Credo che abbia ad a con la substring attuazione prima JDK 7.
Al momento, la dimensione della matrice di caratteri sottostante non è necessariamente la dimensione della stringa. C'erano due campi, offset & count (i un j rispettivamente) che mostravano dove è this stringa nella matrice sottostante, in modo che il metodo era:
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = count;
if (n == anotherString.count) {
char v1[] = value;
char v2[] = anotherString.value;
int i = offset;
int j = anotherString.offset;
while (n-- != 0) {
if (v1[i++] != v2[j++])
return false;
}
return true;
}
}
return false;
}
Dopo il cambio di cui sopra, questo metodo doveva essere anche cambiati, in modo che solo fissati n per essere ora la lunghezza della matrice:
int n = value.length;
e si sono sbarazzati di j (perché non c'è più di offset):
int i = 0;
Ora perché i deve essere incrementato dopo 2 usi, si è incrementato in una dichiarazione separata:
if (v1[i] != v2[i])
return false;
i++;
penso che è tutto, c'è un'implementazione più concisa che è evidente se si tratta di scriverlo da zero, ma dato che si trattava di un cambiamento spinto da un altro cambiamento ... Oracle persone sono persone normali come noi :)
Benchmarking
per quanto riguarda l'analisi comparativa String#equals vs 012.) Penso che dobbiamo confrontare le mele con le mele, così ho messo i due approcci per il confronto di 2 array di caratteri insieme:
public static void main(String[] args) {
final Random random = new Random();
final int arrays = 10000;
final int chars = 1000;
// generate the arrays
char[][] array = new char[arrays][chars];
for (int i = 0; i < arrays; i++) {
for (int j = 0; j < chars; j++) {
array[i][j] = (char)(random.nextInt(94) + 33);
}
}
// compare using Arrays equals
long before = System.nanoTime();
for (int i = 0; i < arrays; i++) {
for (int j = 0; j < chars; j++) {
equals_Arrays(array[i], array[j]);
}
}
System.out.println(System.nanoTime() - before);
// compare using String equals
before = System.nanoTime();
for (int i = 0; i < arrays; i++) {
for (int j = 0; j < chars; j++) {
equals_String(array[i], array[j]);
}
}
System.out.println(System.nanoTime() - before);
}
private static boolean equals_Arrays(char[] a, char[] a2) {
if (a == a2)
return true;
if (a == null || a2 == null)
return false;
int length = a.length;
if (a2.length != length)
return false;
for (int i = 0; i < length; i++)
if (a[i] != a2[i])
return false;
return true;
}
private static boolean equals_String(char[] v1, char[] v2) {
if (v1 == v2)
return true;
if (v1 == null || v2 == null)
return false;
int length = v1.length;
if (length == v2.length) {
int i = 0;
while (length-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
return false;
}
Sulla mia casella non vedo differenza notevole.
* l'attraversamento di array inverso è (in confronto) molto più lento di attraversamento in avanti: * Dove l'hai sentito? – Tunaki
Si intende proestamente che la List Iteration è più lenta. Questo è un array e l'iterazione e non dovrebbe essere più lento. – AlexWien
Huh, mi sembra di averlo sentito da qualche parte. Forse l'ho confuso con l'attraversamento di un array 2D, dove il tuo ciclo interno scorre attraverso l'array esterno. Il mio male, lo modificherò. – Marv