Moving data in an array to the left

Question

I'm really new to Java and there's something wrong with the code. No errors were detected, but the output is odd. The goal is to move the data in an array to the left. For example: x = {1,2,3} the new array should be {2,3,1}.

Now the code below only gives me {0,0,0}. It'd be nice if you point out the mistake and tell me what to do. Thanks a lot beforehand!

public class Project1 {

public static int[] shiftone(int[]n,boolean left) {
    n = new int[n.length];


    int save,save2;
    if(left = true){
        save = n[0];
        save2 = n[(n.length-1)];
        for (int i = 1; i < n.length-1; i++) {
            n[i-1]=n[i];
        }
        n[n.length-1] = save;
        n[n.length-2] = save2;
    }
    else{
        save = n[n.length-1];
        for (int i=0;i<(n.length-1);i++)
            n[(n.length)-i] = n[(n.length-1)-1];
       n[0] = save; 
    }
    return n;
}

public static void main(String[] args){
    Scanner input = new Scanner(System.in);
    int[] x;
    int k;

    boolean left;
    System.out.print("Masukkan jumlah data yang ingin diinput: ");
    k = input.nextInt();
    System.out.println();
    x = new int[k];

    for (int i = 0; i < k; i++) {
    System.out.print("Input data ke-"+i+": ");
    x[i] = input.nextInt(); 
    }
    System.out.print("Array: "+Arrays.toString(x));
    System.out.println();

    System.out.print("Move to left? (true/false): ");
    left = input.nextBoolean();
    System.out.println();

    int[] y;
    y = new int[k];
    y = shiftone(x,left);
    System.out.print("New array: "+Arrays.toString(y));
    }
}

Answer 1

If we don't want to code the moving on our own, we can use the method Collections.rotate . It takes a List and rotates the elements by a given distance. To use it, we need to convert the int array to a List<Integer>. The rotated list is converted back to an int array.

protected static int[] move(int[] input, int distance) {
    List<Integer> inputList = Arrays.stream(input).boxed().collect(Collectors.toCollection(ArrayList::new));
    Collections.rotate(inputList, distance);
    return inputList.stream().mapToInt(Integer::intValue).toArray();
}

Usage:

public static void main(String[] args) throws Exception {
    int[] input = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    int moveLeftOnce = -1;
    int[] moved = move(input, moveLeftOnce); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
}

Please note:
Since Collections.rotate will move the elements in the given list, the list has to be modifiable. This is the case for an ArrayList. Therefore the code uses Collectors.toCollection(ArrayList::new) since there are (JavaDoc)

no guarantees on the type, mutability ... of the List returned

by Collectors.toList.

Answer 2

There is the very fast method to copy the array elements from one place to another. I don't know if this will be helpful to you since it seems to me your question is homework assignment. Nevertheless, I'll put the code with appropriate comments...

public class Answer {

    public static void main(String[] args) {

        //test case
        int[] input = {1, 2, 3, 4, 5};
        System.out.println(Arrays.toString(input));

        //save the first element in the temporary variable
        int temp = input[0];

        //the fastest way to copy the array elements
        //1st parameter is the source array
        //2nd parameter is the source position (read: from which element to copy)
        //3rd parameter is the destination (in this case the same array)
        //4th parameter is the destination position (read: where to store the 1st element)
        //5th parameter is the length of elements to copy (read: how many)
        System.arraycopy(input, 1, input, 0, input.length - 1);

        //finally store the saved element to the end
        input[input.length - 1] = temp;

        System.out.println(Arrays.toString(input));
    }

}

Answer 3

As a simple solution for your goal, you can use this

public static int[] shiftone(int[] n, boolean left) {
    // you don't need to shift anything if length = 1
    if (n.length < 2) {
        return n;
    }
    if (left) {
        // save first element
        int save = n[0];
        for (int i = 1; i < n.length; i++) {
            // shift from 1 to n
            n[i-1] = n[i];
        }
        // insert saved element to array
        n[n.length - 1] = save;
    } else {
        // the same
        int save = n[n.length - 1];
        for (int i = 1; i < n.length; i++)
            n[n.length - i] = n[(n.length - 1) - i];
        n[0] = save;
    }
    return n;
}