Effektiver Austausch von Elementen eines Arrays in Java

Question

Ich frage mich, ob es eine effizientere Art und Weise von Vertauschen zweier Elemente in einem Array ist, als so etwas wie dies zu tun:

String temp = arr[1]; 
arr[1] = arr[2]; 
arr[2] = temp; 

Nun, das ist natürlich nicht schlecht oder sogar falsch, aber ich muss sehr oft tauschen, also bin ich interessiert, ob es irgendwelche Libs gibt oder etwas, das einen effizienteren Weg bietet, dies zu tun?

Answer 1

Nein. Sie könnten eine Funktion haben, die es an jedem Ort präziser macht, aber am Ende wäre die Arbeit die gleiche (plus der Overhead des Funktionsaufrufs, bis/außer HotSpot es inline verschoben   —, um damit zu helfen das, mach das functon static final).

Answer 2

Wenn Sie die Zeichenfolge austauschen möchten. Es ist bereits der effiziente Weg, dies zu tun.

Wenn Sie jedoch integer tauschen möchten, können Sie XOR verwenden zwei ganze Zahlen wie diese effizienter zu tauschen:

int a = 1; int b = 2; a ^= b; b ^= a; a ^= b; 

Answer 3

Dies sollte es nahtlos machen:

public static final <T> void swap (T[] a, int i, int j) { 
    T t = a[i]; 
    a[i] = a[j]; 
    a[j] = t; 
} 

public static final <T> void swap (List<T> l, int i, int j) { 
    Collections.<T>swap(l, i, j); 
} 

private void test() { 
    String [] a = {"Hello", "Goodbye"}; 
    swap(a, 0, 1); 
    System.out.println("a:"+Arrays.toString(a)); 
    List<String> l = new ArrayList<String>(Arrays.asList(a)); 
    swap(l, 0, 1); 
    System.out.println("l:"+l); 
} 

Answer 4

Wenn Sie Tauschen Zahlen und wollen eine prägnante Möglichkeit, den Code zu schreiben, ohne eine separate Funktion zu erstellen oder einen verwirrenden XOR-Hack verwenden, finde ich, dass dies viel einfacher zu verstehen ist und es ist auch ein One-Liner.

Was ich von einigen primitiven Benchmarks gesehen habe, ist, dass der Leistungsunterschied im Grunde auch vernachlässigbar ist.

Answer 5

Unglaublich spät zur Party (meine Entschuldigung), sondern eine allgemeinere Lösung, die hier nicht vorgesehen umgesetzt werden (wird mit Primitiven arbeiten und nicht-Primitiven gleichermaßen):

public static void swap(final Object array, final int i, final int j) { 
    final Object atI = Array.get(array, i); 
    Array.set(array, i, Array.get(array, j)); 
    Array.set(array, j, atI); 
} 

Sie kompilieren Zeit verlieren Sicherheit , aber es sollte den Trick machen.

Hinweis I: Sie erhalten eine NullPointerException, wenn der gegebene arraynull ist, eine IllegalArgumentException wenn die gegebene array ist nicht ein Array und ein ArrayIndexOutOfBoundsException wenn eine der beiden Indizes für die gegebene array nicht gültig sind.

Hinweis II: Mit separaten Methoden für diese für jeden Array-Typ (Object[] und alle primitiven Typen) wäre mehr performant (mit den anderen Ansätzen hier gegeben), da dies einige Boxen/Unboxing erfordert. Aber es wäre auch viel mehr Code zum Schreiben/Pflegen.

Answer 6

Versuchen Sie folgendes:

int lowIndex = 0; 
    int highIndex = elements.length-1; 

    while(lowIndex < highIndex) { 
     T lowVal = elements[lowIndex]; 
     T highVal = elements[highIndex]; 
     elements[lowIndex] = highVal; 
     elements[highIndex] = lowVal; 

     lowIndex += 1; 
     highIndex -=1; 
    } 

Answer 7

Verwenden Collections.swap und Arrays.asList:

Collections.swap(Arrays.asList(arr), i, j);