InputStream is = new FileInputStream("file/name.txt");
byte[] data = new byte[12];
is.read(data);

That reads 12 bytes of data into data. Alternatively, you can grab
byte-by-byte or use only part of the buffer. See the JavaDocs for
java.io.InputStream for more information.

On Aug 29, 3:52 pm, Windsor.Lo...@gmail.com wrote:

It's never a good idea portability-wise to write structs in binary
format (e.g. how do you deal with packing, different CPU
architectures, etc.?), but ignoring that for now you could naively do
something like the following. Note that this only works on big-endian
machines, and is probably unreliable there anyway.

jc@soyuz:~/tmp/binrw$ cat main.cpp
#include <stdio.h>

int main(int /*argc*/, char **argv) {
 struct SOME_DATA {
   unsigned long data1 ;
   unsigned short data2 ;
   unsigned short data3 ;
   unsigned long data4 ;
 } ;

 SOME_DATA someData = { 1, 2, 3, 4 } ;

 FILE *fh = fopen(argv[1], "wb") ;
 fwrite(&someData, sizeof(someData), 1, fh) ;
 fclose(fh) ;

 return 0 ;
}
jc@soyuz:~/tmp/binrw$ g++ -W -Wall -pedantic -o test main.cpp
jc@soyuz:~/tmp/binrw$ ./test test2.file
jc@soyuz:~/tmp/binrw$ cat test.java
public class test {
 public static void main(String [] args)
   throws java.io.IOException {
   java.io.DataInputStream dis
      = new java.io.DataInputStream(
          new java.io.FileInputStream(
            new java.io.File(
              args[0]
            )
          )
        ) ;
   System.out.println("data1: " + dis.readInt()) ;
   System.out.println("data2: " + dis.readShort()) ;
   System.out.println("data3: " + dis.readShort()) ;
   System.out.println("data4: " + dis.readInt()) ;
 }
}
jc@soyuz:~/tmp/binrw$ javac test.java
jc@soyuz:~/tmp/binrw$ java -classpath . test test2.file
data1: 1
data2: 2
data3: 3
data4: 4

For reference, duplicating the above on an Intel box yields:
jc@jc-ubuntu:~/tmp/binrw$ java test test.file
data1: 16777216
data2: 512
data3: 768
data4: 67108864

Java doesn't allow you to read into (or write from) a structure this way.
Say you create a Java class:

class SomeData
{
long data1;
short data2;
short data3;
long data4;
}

Unlike in C or C++, there's really no defined order for the fields, and thus
no way to issue one read that fills all of them.  You need to read into each
one individually.  See java.io.DataInoutStream for how to do this.

On Aug 29, 9:52 pm, Windsor.Lo...@gmail.com wrote:

This is already a stupid idea in C++, since there is no guarantee that
sizeof(SOME_DATA) == 12. Since this is a Java group I'd like to
recommend that you consult some C++ resource regarding struct
alignment and padding, data type size, and (network) byte order.

In Java (assuming you have fixed you C++ problem), one would read this
e.g. with a DataInputStream:

/*
* Read data using network byte-order, aka big-endian
* byte-order (MSB first), and no padding/alignment
* between the data.
*/
class Data {
  /*
   * Note, Java has no unsigned data types.
   * Therefore in this example I store the unsigned short
   * in a (signed) int, and the unsigned long in a BigInteger
   * Typically, in a carefully designed application this
   * can be avoided, but I do it here to avoid discussion
   * of using signed data types to handle unsigned types.
   */
  private BigInteger data1; // data format: unsigned long64
  private int data2;        // data format: unsigned short16
  private int data3;        // data format: unsigned short16
  private BigInteger data4; // data format: unsigned long64

  public void read(DataInputStream in) throws IOException {
     byte ulong2big[] = new byte[5];
     ulong2big[0] = 0;  // ensure MSB is always zero, so
                        // we get an unsigned interpretation
                        // of the following 4 byte data
                        // when converting the array to a
                        // BigInteger

     // Read four bytes and convert them to a BigInteger
     // In carefully designed applications a
     // data1 = in.readLong() would do.
     in.read(ulong2big, 1, 4); // TODO: check return value
     data1 = new BigInteger(ulong2big);

     // Read the unsigned short into an int
     data2 = in.readUnisgnedShort();
     // in.skipByte(...) in case padding needs to be skipped

     data3 = in.readUnsignedShort();
     // in.skipByte(...) in case padding needs to be skipped

     // Read four bytes and convert them to a BigInteger
     // In carefully designed applications a
     // data4 = in.readLong() would do.
     in.read(ulong2big, 1, 4); // TODO: check return value
     data4 = new BigInteger(ulong2big);
 }
}

see http://mindprod.com/applet/fileio.html

It will show you how to read big and little endian binary data.

On Aug 29, 2:52 pm, Windsor.Lo...@gmail.com wrote:

Thank you for all who tried to help. I got it working and in the
interest of future programmers here is how I did it.

Of course this is my crappy program with crappy variable names etc,
which I am going to rewrite. Also, the
arr2long function is from here

http://www.captain.at/howto-java-convert-binary-data.php

public class Convert {

        public static void main(String [] args) {

            int crap = 0, doublecrap = 0, counter = 0;

            try {
                String file =  "/opt/workspace/blahblah/binary.file";
                      FileInputStream fis = new FileInputStream(file);
                DataInputStream dis = new DataInputStream(fis);

               int numberBytes = 4;
               byte data1[] = new byte[numberBytes];
               byte data2 [] = new byte[2];
               byte data3 [] = new byte[2];
               byte data4 [] = new byte[numberBytes];

               while (true) {

                   int retval = dis.read(data1);
                   dis.read(data2);
                   dis.read(data3);
                   dis.read(data4);

                   if(retval == -1)
                       break;

                   long stuff = arr2long(data1, 0);
                   long stuff1 = arr2long(data4, 0);
                   System.out.println(stuff + " : " + stuff1);
                   counter ++;

               }

           //    fis.close();
            }
            catch (IOException ioex) {

            }
            finally {
                System.out.println("number of records read : " + counter);
            }
        }

        public static long arr2long (byte[] arr, int start) {
            int i = 0;
            int len = 4;
            int cnt = 0;
            byte[] tmp = new byte[len];
            for (i = start; i < (start + len); i++) {
                tmp[cnt] = arr[i];
                cnt++;
            }
            long accum = 0;
            i = 0;
            for ( int shiftBy = 0; shiftBy < 32; shiftBy += 8 ) {
                accum |= ( (long)( tmp[i] & 0xff ) ) << shiftBy;
                i++;
            }
            return accum;
        }
}