Movimentar elementos

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);

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

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));
        }
    }

}

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;
        }
    }
}