string shuffle java,Java中 shuffle 算法的使用

public class javashuffle {

public static int temp = 0;

public static long start;

public static long end;

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

object changetemp;

list numlist = new arraylist();

list firstlist = new arraylist();

list secondlist = new arraylist();

list thirdlist = new arraylist();

list fourthlist = new arraylist();

for (int i = 1; i <= 100000; i++) {

numlist.add(i);

firstlist.add(i);

secondlist.add(i);

thirdlist.add(i);

fourthlist.add(i);

}

// first shuffle,use changetemp

getstarttime();

int randint = 0;

for (int i = 0, length = firstlist.size(); i < length; i++) {

randint = getrandom(i, firstlist.size());

changetemp = firstlist.get(i);

firstlist.set(i, firstlist.get(randint));

firstlist.set(randint, javashuffle.temp);

}

getendtime("first shuffle run time ");

// second shuffle,exchange list

getstarttime();

for (int i = 0, length = secondlist.size(); i < length; i++) {

randint = getrandom(i, secondlist.size());

secondlist.set(i, secondlist.set(randint, secondlist.get(i)));

}

getendtime("second shuffle run time");

// third shuffle, change generate random int

getstarttime();

object[] temparray = thirdlist.toarray();

random rand = new random();

int j = 0;

for (int i = temparray.length - 1; i > 0; i--) {

j = rand.nextint(i + 1);

thirdlist.set(i, thirdlist.set(j, thirdlist.get(i)));

}

getendtime("third shuffle run time ");

// fourth shuffle, simulate java shuffle

getstarttime();

random random = new random();

if (!(fourthlist instanceof randomaccess)) {

object[] array = fourthlist.toarray();

for (int i = array.length - 1; i > 0; i--) {

int index = random.nextint(i + 1);

if (index < 0) {

index = -index;

}

object temp = array[i];

array[i] = array[index];

array[index] = temp;

}

int i = 0;

listiterator it = (listiterator) fourthlist.listiterator();

while (it.hasnext()) {

it.next();

it.set((integer) array[i++]);

}

} else {

list rawlist = (list) fourthlist;

for (int i = rawlist.size() - 1; i > 0; i--) {

int index = random.nextint(i + 1);

if (index < 0) {

index = -index;

}

rawlist.set(index, rawlist.set(i, rawlist.get(index)));

}

}

getendtime("fourth shuffle run time");

// java shuffle

getstarttime();

collections.shuffle(numlist);

getendtime("java shuffle run time  ");

}

public static void swap(int a, int b) {

javashuffle.temp = a;

a = b;

b = javashuffle.temp;

}

public static int getrandom(final int low, final int high) {

return (int) (math.random() * (high - low) + low);

}

public static void getstarttime() {

javashuffle.start = system.nanotime();

}

public static void getendtime(final string s) {

javashuffle.end = system.nanotime();

system.out.println(s + ": " + (javashuffle.end - javashuffle.start) + "ns");

}

}

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

first shuffle run time : 85029499ns

second shuffle run time: 80909474ns

third shuffle run time : 71543926ns

fourth shuffle run time: 76520595ns

java shuffle run time  : 61027643ns

first shuffle run time : 82326239ns

second shuffle run time: 78575611ns

third shuffle run time : 95009632ns

fourth shuffle run time: 105946897ns

java shuffle run time  : 90849302ns

first shuffle run time : 84539840ns

second shuffle run time: 85965575ns

third shuffle run time : 101814998ns

fourth shuffle run time: 113309672ns

java shuffle run time  : 35089693ns

first shuffle run time : 87679863ns

second shuffle run time: 79991814ns

third shuffle run time : 73720515ns

fourth shuffle run time: 78353061ns

java shuffle run time  : 64146465ns

first shuffle run time : 84314386ns

second shuffle run time: 80074803ns

third shuffle run time : 74001283ns

fourth shuffle run time: 79931321ns

java shuffle run time  : 86427540ns

first shuffle run time : 84315523ns

second shuffle run time: 81468386ns

third shuffle run time : 75052284ns

fourth shuffle run time: 79461407ns

java shuffle run time  : 66607729ns