Java: movendo itens no array

Eu estou olhando para mover as coisas dentro de uma matriz.

Eu quero ser capaz de mover o último item dentro da determinada matriz para um ponto, enquanto mova os itens da localização atual para a direita. Eu quero que ele se mova do primeiro lugar para o segundo, etc, sem replace o item que está lá.

ex)

a,b,c,d,e 

Digamos que eu queira mudar para “3” – isso se tornaria

 a,b,c,e,d 

Atualmente tenho o seguinte:

 public static void moveLastup(String[] stuff, int position) { String y = stuff[stuff.length-1]; for (int x = stuff.length-1; x > position; x--) list[x] = list[x-1]; stuff[position] = y; } 

Edit: desculpe, eu não acho que eu estava claro o suficiente. O que eu quero ser capaz de fazer é usar esse método, eu deveria ser capaz de mover a última peça para qualquer lugar.

 for (int pos = 0; pos < stuff.length; pos++) { moveLastup(list,pos); showList(list); } 

Agora, quando eu executo isso, ele simplesmente pega o último item na próxima lista no loop for ex)

 e,a,b,c,d e,d,a,b,c e,d,c,b,a 

eu gostaria que mostrasse

 e,a,b,c,d a,e,b,c,d a,b,e,c,d 

Aqui está uma solução mais eficiente e concisa, contando com o System.arraycopy implementado nativamente:

 public static void moveLastup(String[] arr, int pos) { String last = arr[arr.length-1]; // Copy sub-array starting at pos to pos+1 System.arraycopy(arr, pos, arr, pos + 1, arr.length - pos - 1); arr[pos] = last; } 

E algum código de teste:

 public static void main(String[] args) { String[] test = { "one", "two", "three", "four", "five" }; // Move "five" to index 2 moveLastup(test, 2); // [one, two, five, three, four] System.out.println(Arrays.toString(test)); } 

Em relação à sua edição: você está trabalhando com e modificando a matriz original. Se você quiser “começar de novo” em cada moveLastup você precisa trabalhar em uma cópia. Este snippet imprime o que você deseja:

 String[] list = { "a", "b", "c", "d", "e" }; for (int pos = 0; pos < list.length; pos++) { String[] tmpCopy = list.clone(); moveLastup(tmpCopy, pos); showList(tmpCopy); } 

Saída:

[ e , a, b, c, d]
[a, e , b, c, d]
[a, b, e , c, d]
[a, b, c, e , d]
[a, b, c, d, e ]

Eu sei que a questão é sobre Arrays – não quero começar uma discussão sobre questões de desempenho “versus” e “por que estou usando array puro” – mas para aqueles que usam o List , acho que isso pode ser útil.

método java.util.Collections.rotate . Sim, o nome é estranho, confira uma parte do javadoc:

Observe que esse método pode ser aplicado a sub-listas para mover um ou mais elementos em uma lista, preservando a ordem dos elementos restantes. Por exemplo, o idioma a seguir move o elemento no índice j para a posição k (que deve ser maior ou igual a j):

     Collections.rotate (list.subList (j, k + 1), -1);

Para tornar isso concreto, suponha que a lista inclua [a, b, c, d, e]. Para mover o elemento no índice 1 (b) para frente duas posições, execute a seguinte chamada:

     Collections.rotate (l.subList (1, 4), -1);

A lista resultante é [a, c, d, b, e].

Para mover mais de um elemento para frente, aumente o valor absoluto da distância de rotação. Para mover os elementos para trás, use uma distância de deslocamento positiva.

 public void moveElement(List list, int a, int b) { // forward or backward int direction = a > b ? 1 : -1; // always from minor to major to subList int minor = a < b ? a : b; int major = b > a ? b : a; Collections.rotate(list.subList(minor, major + 1), direction); } 

Primeiro de tudo, no seu código você faz

 for (int x = stuff.length-1; x > pos; x--) 

onde pos não está sequer definido, sugiro alterá-lo para posição. Em segundo lugar, mude a “lista” para “coisas”.

Código de trabalho modificado:

 public static void moveLastup(String[] stuff, int position) { String y = stuff[stuff.length-1]; for (int x = stuff.length-1; x > position; x--) stuff[x] = stuff[x-1]; stuff[position] = y; } 

Qualquer razão em particular que você não está usando uma List vez de String[] ? Isso facilitará esse tipo de operação. Com um ArrayList , tudo que você precisa é:

 list.add(3, list.remove(list.size() - 1)); 

Ou ainda mais curto, se você usou um LinkedList :

 list.add(3, list.removeLast()); 

Aqui está um exemplo mais completo baseado no seu:

 LinkedList list = new LinkedList(); list.addAll(Arrays.asList("a", "b", "c", "d", "e")); list.add(3, list.removeLast()); System.out.println(list); // prints "[a, b, c, e, d]" 

Outra solução rápida e rápida baseada em System.arraycopy :

 System.arraycopy(array, insert, array, insert+1, array.length-insert-1); 

O conteúdo da matriz é “empurrado para a direita” do índice “insert”.

Aqui está um código de demonstração:

 int[] array = {1,2,3,4,5}; int insert = 2; int last = array[array.length-1]; System.arraycopy(array, insert, array, insert+1, array.length-insert-1); array[insert] = last; for (int value:array) System.out.println(value); 

você poderia fazer assim:

 char arr1[]=new arr1[5]; // arr1 contains a,b,c,d,e in order char arr2[]=new arr2[5]; for(int i=0;i