Newsgroup: it.comp.java
Titolo: conveersione bit / long

Salve,
il mio problema è che ho un long e lo devo sdoppiare nella sequenza di due
byte che lo rappresenta...in sostatnzza un metodo che in ingresso ha un long
e in uscita un vettore con due byte......qualcuno mi sa dire come fare?
thanx
--
AMS

e in uscita un vettore con due byte......qualcuno mi sa dire come fare?
In ingresso un long, in uscita un vettore di due int (un int č 2 byte,
un long č 4 byte):
public class Cutter
{
	static final long maxInt=(long)Math.pow(2.00,31.00);
 
	public static void main(String[] args)
	{
		int[] cut=Cutter.cut(10000000000000L);
		for(int i=0;i<2;i++)
		{
			System.out.println(cut[i]);
		}
	}
 
	public static int[] cut(long l)
	{
		int[] cut=new int[2];
		cut[0]=(int)(l/maxInt);
		cut[1]=(int)(l-cut[0]*maxInt);
		return cut;
	}
}

 il mio problema č che ho un long e lo devo sdoppiare nella sequenza di due

2 bye? non ne occupa almeno 4? Oppure hai bisogno di rappresentarlo con 2
byte per motivi tuoi?

 byte per motivi tuoi?
il long che ho sono sicuro che ci sta in due byte ......per questo me ne
servono solo 2(è un campo di un header di un protocollo di trasporto)

> int[] cut=Cutter.cut(10000000000000L);
Grazie per l'esempio....mi spieghi la L maiuscola alla fine del numero che
significa?



Equivale ad un cast esplicito: (long)10000000000000

 un long č 4 byte):
[cut]
Finalmente ho qualcosa di utile da dire anch'io! :)
Un int corrisponde a 4 byte e un long a 8:
  int provaInt = Integer.MAX_VALUE;
  System.out.println(provaInt);
  provaInt = Integer.MIN_VALUE;
  System.out.println(provaInt);
  long provaLong = Long.MAX_VALUE;
  System.out.println(provaLong);
  provaLong = Long.MIN_VALUE;
  System.out.println(provaLong);
Output:
 
2147483647
  -
2147483648
  9223372036854775807
  -9223372036854775808
Se l'int fosse a 2 byte non potrebbe contenere valori maggiori a 32767 (o
32768? non ricordo...)
Il tipo di dato che occupa 2 byte č il short.
Ciao!
--
Huan

 ha scritto nel messaggio
news:b80o94$57qkp$1...@ID-191073.news.dfncis.de...

prova a shiftare:
long l = ...;
byte a = (byte)l;
byte b = (byte)(l >> 8);
funziona?


Si funge.....l'ho proprio fatto simile.......

 Equivale ad un cast esplicito: (long)10000000000000
ok grazie della spiegazione......
Sai qualche guida dettagliata per le operazione con i dati primitivi?(con
vari metodi che si possono utilizzare comprese librerie....)

 Equivale ad un cast esplicito: (long)10000000000000
No!
Scrivere
   (long)10000000000000
e' un errore perche' 10000000000000 supera il massimo
intero positivo rappresentabile che e' 
2147483647
.
Infatti se compili il seguente programma:
class A26 {
   public static void main(String args[]) {
     System.out.println("      10000000000000L = "
     +       10000000000000L);
     System.out.println("(long)10000000000000  = "
     + (long)10000000000000);
   }
}
qualsiasi compilatore serio ti dara' un errore del tipo:
   integer number too large: 10000000000000
Se lo compili invece con un compilatore non serio
(tipo il javac di jdk1.1.8) questo te lo compila
(erroneamente!) e quando lo lanci ottieni il seguente risultato:
       10000000000000L = 10000000000000
(long)10000000000000  = 1316134912
OK?
- Dario