O uso do algoritmo shuffle em Java

复制代码代码如下:

/**
* Move cada elemento da Lista para uma nova posição aleatória na lista.
*
* @param lista
* a lista para embaralhar
*
* @throwsUnsupportedOperationException
* ao substituir um elemento na Lista não é suportado
*/
public static void shuffle(Lista<?> lista) {
shuffle(lista, new Random());
}

/**
* Move cada elemento da lista para uma nova posição aleatória na lista
* usando o gerador de números aleatórios especificado.
*
* @param lista
* a lista para embaralhar
* @param aleatório
* o gerador de números aleatórios
*
* @throwsUnsupportedOperationException
* ao substituir um elemento na Lista não é suportado
*/
@SuppressWarnings("desmarcado")
public static void shuffle(Lista<?> lista, Aleatório aleatório) {
if (!(listar instância de RandomAccess)) {
Objeto[] array = list.toArray();
for (int i = array.length - 1; i > 0; i--) {
índice interno = random.nextInt(i + 1);
se (índice <0) {
índice = -índice;
}
Temperatura do objeto = array[i];
matriz[i] = matriz[índice];
matriz[índice] = temp;
}

int eu = 0;
ListIterator<Object> it = (ListIterator<Object>) lista
.listIterator();
enquanto (it.hasNext()) {
it.next();
it.set(matriz[i++]);
}
} outro {
Lista<Objeto> rawList = (Lista<Objeto>) lista;
for (int i = rawList.size() - 1; i > 0; i--) {
índice interno = random.nextInt(i + 1);
se (índice <0) {
índice = -índice;
}
rawList.set(index, rawList.set(i, rawList.get(index)));
}
}
}

复制代码代码如下:

classe pública javaShuffle {
público estático int temp = 0;
início longo estático público;
final longo estático público;

public static void main(string final args[]) {

Mudança de objetoTemp;
List<Integer> numList = new ArrayList<Integer>();
List<Integer> firstList = new ArrayList<Integer>();
List<Integer> secondList = new ArrayList<Integer>();
List<Integer> terceiraLista = new ArrayList<Integer>();
List<Integer> quartaList = new ArrayList<Integer>();

for (int i = 1; i <= 100000; i++) {
numList.add(i);
primeiraLista.add(i);
segundaLista.add(i);
terceiraLista.add(i);
quartaLista.add(i);
}

// primeiro embaralhamento, use changeTemp
getStartTime();
int randInt = 0;
for (int i = 0, comprimento = firstList.size(); i < comprimento; i++) {
randInt = getRandom(i, firstList.size());
changeTemp = firstList.get(i);
firstList.set(i, firstList.get(randInt));
firstList.set(randInt, javaShuffle.temp);
}
getEndTime("tempo de execução do primeiro embaralhamento");

// segundo embaralhamento, lista de troca
getStartTime();
for (int i = 0, comprimento = segundaLista.size(); i < comprimento; i++) {
randInt = getRandom(i, secondList.size());
secondList.set(i, secondList.set(randInt, secondList.get(i)));
}
getEndTime("segundo tempo de execução aleatória");

// terceiro embaralhamento, mudança gera int aleatório
getStartTime();
Object[] tempArray = terceiraList.toArray();
Rand aleatório = new Random();
int j = 0;
for (int i = tempArray.length - 1; i > 0; i--) {
j = rand.nextInt(i + 1);
terceiraLista.set(i, terceiraLista.set(j, terceiraLista.get(i)));
}

getEndTime("terceiro tempo de execução aleatória ");

// quarto shuffle, simula java shuffle
getStartTime();
Aleatório aleatório = new Aleatório();
if (!(fourthList instanceof RandomAccess)) {
Object[] array = quartaList.toArray();
for (int i = array.length - 1; i > 0; i--) {
índice interno = random.nextInt(i + 1);
se (índice <0) {
índice = -índice;
}
Temperatura do objeto = array[i];
matriz[i] = matriz[índice];
matriz[índice] = temp;
}

int eu = 0;
ListIterator<Integer> it = (ListIterator<Integer>) quartaList.listIterator();
enquanto (it.hasNext()) {
it.next();
it.set((Inteiro) array[i++]);
}
} outro {
List<Integer> rawList = (List<Integer>) quartaList;
for (int i = rawList.size() - 1; i > 0; i--) {
índice interno = random.nextInt(i + 1);
se (índice <0) {
índice = -índice;
}
rawList.set(index, rawList.set(i, rawList.get(index)));
}
}
getEndTime("tempo de execução do quarto embaralhamento");

// embaralhamento java
getStartTime();
Coleções.shuffle(numList);
getEndTime("tempo de execução do Java Shuffle");
}

troca estática pública de void(int a, int b) {
javaShuffle.temp = a;
uma =b;
b = javaShuffle.temp;
}

public static int getRandom(final int baixo, final int alto) {
return (int) (Math.random() * (alto - baixo) + baixo);
}

public static void getStartTime() {
javaShuffle.start = System.nanoTime();
}

public static void getEndTime(string final s) {
javaShuffle.end = System.nanoTime();
System.out.println(s + ": " + (javaShuffle.end - javaShuffle.start) + "ns");
}

}

如果数值较小，例如100000级别，则输出大概是：

tempo de execução do primeiro embaralhamento: 85029499ns
tempo de execução do segundo shuffle: 80909474ns
tempo de execução do terceiro shuffle: 71543926ns
tempo de execução do quarto shuffle: 76520595ns
Tempo de execução do Java Shuffle: 61027643ns

tempo de execução do primeiro embaralhamento: 82326239ns
tempo de execução do segundo shuffle: 78575611ns
tempo de execução do terceiro shuffle: 95009632ns
tempo de execução do quarto shuffle: 105946897ns
Tempo de execução do Java Shuffle: 90849302ns

tempo de execução do primeiro embaralhamento: 84539840ns
tempo de execução do segundo shuffle: 85965575ns
tempo de execução do terceiro shuffle: 101814998ns
tempo de execução do quarto shuffle: 113309672ns
Tempo de execução do Java Shuffle: 35089693ns

tempo de execução do primeiro embaralhamento: 87679863ns
tempo de execução do segundo shuffle: 79991814ns
tempo de execução do terceiro shuffle: 73720515ns
tempo de execução do quarto shuffle: 78353061ns
Tempo de execução do Java Shuffle: 64146465ns

tempo de execução do primeiro embaralhamento: 84314386ns
tempo de execução do segundo shuffle: 80074803ns
tempo de execução do terceiro shuffle: 74001283ns
tempo de execução do quarto shuffle: 79931321ns
Tempo de execução do Java Shuffle: 86427540ns

tempo de execução do primeiro embaralhamento: 84315523ns
tempo de execução do segundo shuffle: 81468386ns
tempo de execução do terceiro shuffle: 75052284ns
tempo de execução do quarto shuffle: 79461407ns
Tempo de execução do Java Shuffle: 66607729ns