Rotate array to the left
Your class has 4 methods:


int[] LeftRotate(int, int[], int[])
int[] LeftRotate(int, int[])
int[] printArray(int[])
void main(String[])


The second method is never called, and can be removed.

The first and third methods (and the second) all return an int[], the a parameter, but the returned values are never assigned to anything.  This return value can be removed, and the methods declared to return void.

In the first method, you are looping over increasing i values, decrementing n1, and assigning to a[a.length - n1].  This “double negative” makes the code harder to understand; decrementing n1 increases the destination index value.  You already have a i index which in incrementing.  You could instead:

for(int i = 0; i &lt; numberOfLeftRotations; i++) {
    a[a.length - numberOfLeftRotations + i] = b[i];
}


This is a little easier to understand; you are only changing i, increasing it, and adding it to a starting point for the destination.  We can make it a little clearer:

int dest_start = a.length - numberOfLeftRotations;
for(int i = 0; i &lt; numberOfLeftRotations; i++) {
    a[dest_start + i] = b[i];
}


That is much more understandable.  Do the same for the second loop.



The above is just a cleanup of your existing code.  We can restructure / refactor the code to make it better and easier to use.

When you want to left-rotate an array, you always need to create a new array for the destination.  You can make the left-rotate function create the destination array for the caller.

int[] LeftRotate(int numberOfLeftRotations, int[] source) {
    int[] dest = new int[source.length];
    // ... copy rotated version from dest into source
    return dest;
}


And use it as:

int[] b = LeftRotation(l, a);


In fact, this is probably what was intended for your second method.  The code to copy the rotated version from dest to source could just be a call of the first “helper” method:

int[] LeftRotate(int numberOfLeftRotations, int[] source) {
    int[] dest = new int[source.length];
    LeftRotate(numberOfLeftRotations, dest, source);
    return dest;
}


Your first method should still be void, as it is not returning anything that wasn’t just passed to it.



Copying sequential elements from one array to another is a common operation, and Java provides a method which does just that: System.arraycopy().  Using this, your left rotation can be performed very efficiently in two statements:

System.arraycopy(source, 0, dest, dest.length - numberOfLeftRotations, numberOfLeftRotations);
System.arraycopy(source, numberOfLeftRotations, dest, 0, dest.length - numberOfLeftRotations);




Use better variable names.  a and b are unclear; source and dest give context to the reader.  numberOfLeftRotations is a very descriptive, but it is perhaps a little long.  numLeftRotations is just as clear and doesn’t result in lines becoming excessively long.  numRotations or rotations might be even better; the reader would know they are left rotations, because the variables are contained within a “left rotate” function.

Convention is for only Class names to begin with upper case letters; method names should not.  You should name the method leftRotate, not LeftRotate.