Movimentar elementos

Programação Java
#1

Estou com um problema para implementar uma lógica, eu quero movimentar meus elementos uma posição para direita de dentro do meu array.
Esse é meu código.

String alfabeto;

List<Character> letras ;


public Teste(){
	
	letras = new ArrayList<Character>();
	alfabeto = ("abcdefghijklmnopqrstuvwxyz");
}

public void trocaPosicaoAlfabeto(){
	
	for(int i=0; i<alfabeto.length(); i++){
		letras.add(alfabeto.charAt(i));
	}
	
	char aux;
	
	for(int i=1; i<letras.size()-2; i++){			
		aux = letras.get(i-1);
		letras.set(i, aux);		
	}
	alfabeto="";
	for(int i=0; i<letras.size(); i++){
		alfabeto +=letras.get(i);
	}
	
	System.out.println(alfabeto);
}

e a saída é essa: aaaaaaaaaaaaaaaaaaaaaaaayz

a minha intenção é que a saída fique: zabcdefghijklmnopqrstuvwxy

alguém pode me ajudar?

#2

É difícil de entender o que cada laço (for) está fazendo, recomendo que insra um comentário:

public void trocaPosicaoAlfabeto(){

	// adiciona na lista de 'a' - 'y'
	for(int i = 0; i < alfabeto.length - 1; i++){
		letras.add(alfabeto.charAt(i));
	}

	// adiciona 'z' no inicio
	letras.add(0, alfabeto.charAt(alfabeto.length - 1));

	// copia a lista para a string
	alfabeto="";
	for(int i=0; i<letras.size(); i++){
		alfabeto +=letras.get(i);
	}

	System.out.println(alfabeto);

Pode ser feito também, usando o substring:

alfabeto = "" + alfabeto.charAt(alfabeto.length - 1) + alfabeto.substring(0, alfabeto.length - 1);
#3

Uma abordagem orientada a objetos:

import java.util.Arrays;

class PalavraRotatoria {

    enum Direcao {
        ESQUERDA, DIREITA;
    }

    final private char[] palavra;

    PalavraRotatoria(char[] palavra) {
        this.palavra = Arrays.copyOf(palavra, palavra.length);
    }

    PalavraRotatoria(String palavra) {
        this.palavra = palavra.toCharArray();
    }

    String getPalavra() {
        return new String(palavra);
    }

    PalavraRotatoria rotacionada(int quantidade, Direcao direcao) {
        char[] resultado = new char[palavra.length];
        int base = direcao == Direcao.DIREITA ? quantidade : palavra.length - quantidade;
        for (int i = 0; i < palavra.length; i++) {
            int novoIndice = (base + i) % palavra.length;
            resultado[novoIndice] = palavra[i];
        }
        return new PalavraRotatoria(resultado);
    }

    @Override
    public String toString() {
        return getPalavra();
    }
}

public class Main {
    public static void main(String[] args) {
        String alfabeto = "abcdefghijklmnopqrstuvwxyz";
        PalavraRotatoria pl = new PalavraRotatoria(alfabeto);
        for (int i = 0; i < 10; i++) {
            System.out.println(pl.rotacionada(i, PalavraRotatoria.Direcao.DIREITA));
        }
        System.out.println();
        for (int i = 0; i < 10; i++) {
            System.out.println(pl.rotacionada(i, PalavraRotatoria.Direcao.ESQUERDA));
        }
    }

}
#4

Outra codificação alternativa, considerando a diferencia de tempo de acordo com cada tipo de implementação na codificação a seguir.

import java.util.Arrays;


public class Teste {

    public static void main(String[] args) {
        String txt = "123456789";
        int ciclo = 1000000;//extressando a codificação para encontrar, se livrar de um ArrayIndexOutOfBoundsException
        char[] vetor = txt.toCharArray();
        for (int i = 0; i < 10; i++) {
            System.out.println("Diferença: " + String.format("%.2f", 100 - 100f * teste(vetor, ciclo, true) / teste(vetor, ciclo, false)) + "%\n");
        }
    }
    //verifica o tempo de processamento em nano
    private static long teste(char[] vetor, int ciclo, boolean giro1) {
        long tempoGiroVetor = -System.nanoTime();
        if (giro1) {
            giroVetor(vetor, ciclo, true);
        } else {
            giroVetor2(vetor, ciclo, false);
        }
        tempoGiroVetor += System.nanoTime();
        System.out.println(Arrays.toString(vetor) + " TempoGiro" + (giro1 ? 1 : 2) + ": " + +tempoGiroVetor);
        return tempoGiroVetor;
    }

    
    //eficiência geralmente maior que o método giroVetor2
    private static void giroVetor(char[] vetor, int len, boolean giroCanhoto) {
        int limite = vetor.length - 1;
        char auxiliar;
        if (giroCanhoto) {
            for (int i = 0; i < len; i++) {
                auxiliar = vetor[0];
                System.arraycopy(vetor, 1, vetor, 0, limite);
                vetor[limite] = auxiliar;
            }
        } else {
            for (int i = 0; i < len; i++) {
                auxiliar = vetor[limite];
                System.arraycopy(vetor, 0, vetor, 1, limite);
                vetor[0] = auxiliar;
            }
        }
    }
    //alternativo, com mais peso ciclomático e menos linhas
    private static void giroVetor2(char[] vetor, int len, boolean giroCanhoto) {

        for (int i = 0; i < len; i++) {
            char auxiliar = vetor[giroCanhoto ? 0 : vetor.length - 1];
            System.arraycopy(vetor, giroCanhoto ? 1 : 0, vetor, giroCanhoto ? 0 : 1, vetor.length - 1);
            vetor[giroCanhoto ? vetor.length - 1 : 0] = auxiliar;
        }
    }
}