Java, Elemente in einem Array verschieben

Logisch funktioniert es nicht und Sie sollten Ihre Schleife umkehren:

for (int i = position-1; i >= 0; i--) {                
    array[i+1] = array[i];
}

Alternativ können Sie verwenden

System.arraycopy(array, 0, array, 1, position);

Sie können einfach Collections.rotate(List<?> list, int distance) verwenden.

Verwenden Sie Arrays.asList(array) zum Konvertieren in List 

weitere Informationen unter: https://docs.Oracle.com/javase/7/docs/api/Java/util/Collections.html#rotate(Java.util.List,%20int)

Das Manipulieren von Arrays auf diese Weise ist fehleranfällig, wie Sie festgestellt haben. Eine bessere Option kann die Verwendung einer LinkedList in Ihrer Situation sein. Mit einer verknüpften Liste und allen Java-Sammlungen wird die Arrayverwaltung intern verwaltet, sodass Sie sich keine Gedanken darüber machen müssen, ob Elemente verschoben werden. Mit einer LinkedList rufen Sie einfach remove und dann addLast auf und fertig. 

Nur zur Vollständigkeit: Stream-Lösung seit Java 8.

final String[] shiftedArray = Arrays.stream(array)
        .skip(1)
        .toArray(String[]::new);

Ich glaube, ich habe mich an die System.arraycopy() in Ihrer Situation gehalten. Aber die beste langfristige Lösung könnte sein, alles in unveränderliche Sammlungen ( Guava , Vavr ) umzuwandeln, sofern diese Sammlungen nur von kurzer Dauer sind.

Versuche dies:

Object temp = pool[position];

for (int i = position-1; i >= 0; i--) {                
    array[i+1] = array[i];
}

array[0] = temp;

Schauen Sie hier, um zu sehen, wie es funktioniert: http://www.ideone.com/5JfAg

Eine Linksdrehung in einem Array der Größe n verschiebt jede Elementeinheit des Arrays nach links, überprüfen Sie dies heraus !!!!!!

public class Solution {
    private static final Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {
        String[] nd = scanner.nextLine().split(" ");

        int n = Integer.parseInt(nd[0]);  //no. of elements in the array

        int d = Integer.parseInt(nd[1]);  //number of left rotations

        int[] a = new int[n]; 

      for(int i=0;i<n;i++){
          a[i]=scanner.nextInt();
      }

        Solution s= new Solution();     
//number of left rotations
        for(int j=0;j<d;j++){
              s.rotate(a,n);
        }
   //print the shifted array  
        for(int i:a){System.out.print(i+" ");}
    }

//shift each elements to the left by one 
   public static void rotate(int a[],int n){
            int  temp=a[0];
        for(int i=0;i<n;i++){
            if(i<n-1){a[i]=a[i+1];}
            else{a[i]=temp;}
      }}
}

public class Test1 {

    public static void main(String[] args) {

        int[] x = { 1, 2, 3, 4, 5, 6 };
        Test1 test = new Test1();
        x = test.shiftArray(x, 2);
        for (int i = 0; i < x.length; i++) {
            System.out.print(x[i] + " ");
        }
    }

    public int[] pushFirstElementToLast(int[] x, int position) {
        int temp = x[0];
        for (int i = 0; i < x.length - 1; i++) {
            x[i] = x[i + 1];
        }
        x[x.length - 1] = temp;
        return x;
    }

    public int[] shiftArray(int[] x, int position) {
        for (int i = position - 1; i >= 0; i--) {
            x = pushFirstElementToLast(x, position);
        }
        return x;
    }
}

Eine weitere Variante, wenn Sie die Array-Daten als Java-Liste haben

    listOfStuff.add( 
            0, 
            listOfStuff.remove(listOfStuff.size() - 1) );

Ich teile einfach eine andere Option mit, die ich für dieses Thema getroffen habe, aber ich denke, die Antwort von @Murat Mustafin ist der Weg, um mit einer Liste zu gehen

Anstatt um eine Position zu verschieben, können Sie diese Funktion mit einem solchen Modul allgemeiner machen.

int[] original = { 1, 2, 3, 4, 5, 6 };
int[] reordered = new int[original.length];
int shift = 1;

for(int i=0; i<original.length;i++)
     reordered[i] = original[(shift+i)%original.length];

static void pushZerosToEnd(int arr[])
    {   int n = arr.length;
        int count = 0;  // Count of non-zero elements
        // Traverse the array. If element encountered is non-zero, then
        // replace the element at index 'count' with this element
        for (int i = 0; i < n; i++){
            if (arr[i] != 0)`enter code here`
               // arr[count++] = arr[i]; // here count is incremented
                swapNumbers(arr,count++,i);
        }
        for (int j = 0; j < n; j++){
            System.out.print(arr[j]+",");
        }
     }

    public static void swapNumbers(int [] arr, int pos1, int pos2){
        int temp  = arr[pos2];
        arr[pos2] = arr[pos1];
        arr[pos1] = temp;
    }

In der ersten Iteration Ihrer Schleife überschreiben Sie den Wert in array[1]. Sie sollten die Angaben in umgekehrter Reihenfolge durchgehen.

Sie können die folgenden Codes verwenden, um nicht zu drehen:

    int []arr = {1,2,3,4,5,6,7,8,9,10,11,12};
            int n = arr.length;
            int d = 3;

Programm zum Verschieben des Arrays der Größe n um d Elemente nach links:

    Input : {1,2,3,4,5,6,7,8,9,10,11,12}
    Output: {4,5,6,7,8,9,10,11,12,10,11,12}

        public void shiftLeft(int []arr,int d,int n) {
            for(int i=0;i<n-d;i++) {
                arr[i] = arr[i+d];
            }
        }

Programm zum Verschieben des Arrays der Größe n um d Elemente nach rechts:

    Input : {1,2,3,4,5,6,7,8,9,10,11,12}
    Output: {1,2,3,1,2,3,4,5,6,7,8,9}

        public void shiftRight(int []arr,int d,int n) {

            for(int i=n-1;i>=d;i--) {
                arr[i] = arr[i-d];
            }
        }