Newsgroup: it.comp.java
Titolo: byte[]->string->byte[]

il seguente metodo:
public void stringacarattere() {
		byte[] array1 =  {1,2,4,14,127};
		byte[] array2 = (new String(array1)).getBytes();
		boolean uguali = true;
		int diversodove=1000;
		for (int i=0;i<5;i++) {
			System.out.println(array1[i]+" "+array2[i]);
			if (array1[i]!=(array2[i])){
				uguali=false;
				diversodove=i+1;
			}
		}
		System.out.println("lungezza1 "+array1.length);
		System.out.println("lungezza2 "+array2.length);
		if (array1==array2) System.out.println("uguali con ==");
		if (array1.equals(array2)) System.out.println("uguali con equals");
		if (uguali) System.out.println("uguali uno a uno");
		System.out.println("diverso dove? "+diversodove);
	}
ha come output che i due array di byte sono diversi sia con == che con
equals, mentre pero' hanno la stessa lunghezza e gli elementi, a uno a uno
sono uguali.
Perchč?
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it


perche' con == e equals stai confrontando gli array e non il loro
contenuto

 >

cambio domanda: quando due array si dicono uguali?


 cambio domanda: quando due array si dicono uguali?
definisci "uguali"


comunque devi usare Arrays.equals per fare quello che sembra tu voglia fare

 Perchè?
Per una ragione semplice.
Le String in java sono rappresentate in unicode. Quando tu ne crei una
da un vettore di byte viene fatta una conversione da byte a caratteri
unicode, asumendo che il vettore sia una rappresentazione in byte di
una sequenza di caratteri unicode. Quando tu richiedi i byte con
getBytes() viene fatta una conversione inversa.
Ora, dov'è l'inghippo? L'inghippo sta nel fatto che tu in array1 non
hai una rappresentazione corretta di caratteri unicode, quindi nella
conversione non ottieni la stringa che ti aspetti e di conseguenza
anche getBytes() non ti darà il risultato sperato.
Come minimo, array2 avrà anche un numero di elementi diverso da
array1.

emmeesse ha scritto:



il ragionamento è chiaro e ne avevo anche letto a proposito, infatti se
mettessi dei caratteri tipo '£' array2 avrebbe un numero di elementi
superiore ad array1. Ma non è questo il caso, infatti array contiene solo
valori tra 0 e 127 e ne risulta che array2 ha non solo lo stesso numero di
elementi di array1 ma conforntando gli elementi uno a uno essi sono
uguali, cioè per ogni i risulta che array1[i]==array2[i].
Ergo, indipendentemente da come gli abbiamo prodotti, abbiamo due array di
dimensioni uguali, con elementi ti tipo primitivo uguali per posizioni
corrispondenti,ma cio' nonostante, essi vengono considerati diversi.
Il punto è, come si confrontano allora gli array?


 comunque devi usare Arrays.equals per fare quello che sembra tu voglia fare
giusto ma Arrays.equals vale solo per array di oggetti e no ndi tipi
primitivi.


 definisci "uguali"
Quando se confrontati attraverso equals il responso è true.


 primitivi.
falso.


Un array e' sotto sotto un oggetto come gli altri. L'equals di un array e'
la stessa equals di Object. L'equals di object:
    public boolean equals(Object obj) {
	return (this == obj);
    }
non definisce "uguale" nel senso che intendi tu.
Devi usare Arrays.equals che non fa altro che ciclare su tutti gli
elementi dell'array.
A volte guardare il codice sorgente delle classi standard puo' essere
illuminante.

 Il punto è, come si confrontano allora gli array?
java.util.Arrays.equals(array1, array2);

 Quando se confrontati attraverso equals il responso è true.
Nel caso degli array, il metodo equals non è implementato per cui
prende l'implementazione di Object: ovvero ritorna true se i reference
sono uguali (ovvero solo se sono lo stesso oggetto).

 falso.
hai ragione avevo letto male.
con arrays.equals l'esecuzione è corretta


 java.util.Arrays.equals(array1, array2);
grazie č perfetto.
