Java lê inteiros em little endian ou big endian?

Eu pergunto porque estou enviando um fluxo de bytes de um processo C para Java. No lado C, o inteiro de 32 bits tem o LSB é o primeiro byte e MSB é o quarto byte.

Portanto, minha pergunta é: no lado do Java, quando lemos o byte conforme ele foi enviado do processo C, o que é endian no lado do Java?

Uma pergunta de acompanhamento: Se o endian no lado Java não for o mesmo que o enviado, como posso converter entre eles?

Use a ordem de bytes da rede (big endian), que é a mesma que o Java usa. Veja man htons para os diferentes tradutores em C.

Tropecei aqui via Google e obtive minha resposta que Java é big endian .

Lendo as respostas, gostaria de salientar que os bytes realmente têm uma ordem endian, embora, felizmente, se você só lidou com microprocessadores "convencionais", é improvável que os tenha encontrado como Intel, Motorola e Zilog todos concordaram na direção de mudança de seus chips UART e que MSB de um byte seria 2**7e LSB 2**0em suas CPUs (usei a notação de potência FORTRAN para enfatizar a idade desse material :)).

Eu tive esse problema com alguns dados de downlink serial de bits do ônibus espacial há mais de 20 anos, quando substituímos um hardware de interface de US $ 10 mil por um computador Mac. Há um resumo técnico da NASA publicado sobre isso há muito tempo. Eu simplesmente usei uma tabela de consulta de 256 elementos com os bits invertidos ( table[0x01]=0x80etc.) depois que cada byte foi deslocado do fluxo de bits.

Não há inteiros sem sinal em Java. Todos os inteiros são assinados e em big endian.

No lado C, cada byte tem o LSB no início à esquerda e o MSB no final.

Parece que você está usando LSB como a parte menos significativa, não é? LSB geralmente significa byte menos significativo. Endianness não é baseado em bits, mas em bytes.

Para converter de um byte sem sinal em um inteiro Java:

int i = (int) b & 0xFF;

Para converter de little-endian de 32 bits não assinado em byte [] para Java long (do topo da minha cabeça, não testado):

long l = (long)b[0] & 0xFF;
l += ((long)b[1] & 0xFF) << 8;
l += ((long)b[2] & 0xFF) << 16;
l += ((long)b[3] & 0xFF) << 24;

Não há como isso influenciar qualquer coisa em Java, uma vez que não há uma maneira (não-API direta) de mapear alguns bytes diretamente em um int em Java.

Cada API que faz isso ou algo semelhante define o comportamento com bastante precisão, portanto, você deve consultar a documentação dessa API.

Eu lia os bytes um por um e os combinava em um valor longo . Dessa forma, você controla o endianismo e o processo de comunicação é transparente.

Se ele se encaixa no protocolo que você usa, considere usar um DataInputStream, onde o comportamento é muito bem definido .

Java é 'Big-endian' conforme observado acima. Isso significa que o MSB de um int está à esquerda se você examinar a memória (pelo menos em uma CPU Intel). O bit de sinal também está no MSB para todos os tipos inteiros Java.
Ler um inteiro sem sinal de 4 bytes de um arquivo binário armazenado por um sistema 'Little-endian' requer um pouco de adaptação em Java. O readInt () de DataInputStream espera o formato Big-endian.
Aqui está um exemplo que lê um valor sem sinal de quatro bytes (conforme exibido pelo HexEdit como 01 00 00 00) em um inteiro com um valor de 1:

 // Declare an array of 4 shorts to hold the four unsigned bytes
 short[] tempShort = new short[4];
 for (int b = 0; b < 4; b++) {
    tempShort[b] = (short)dIStream.readUnsignedByte();           
 }
 int curVal = convToInt(tempShort);

 // Pass an array of four shorts which convert from LSB first 
 public int convToInt(short[] sb)
 {
   int answer = sb[0];
   answer += sb[1] << 8;
   answer += sb[2] << 16;
   answer += sb[3] << 24;
   return answer;        
 }

java realmente força big endian: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-2.html#jvms-2.11