effectivement, les fichiers binaires étaient encodés en little endian, alors que la jvm ne traite que du big endian, en faisant quelques petits bidouillages, j'ai reussi à résoudre mon probleme
voila ce que ca donne:

        public static final float CoeffP = 0.01f;
    public static final int nbLus = 200;

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        if (args.length > 0) {
            System.out.println("start");
            lireFichierBinaire(args[0]);
            System.out.println("The End");
        } else {
            System.out.println("Not Enough arguments");
        }
    }

    /**
     * fonction test de lecture d'un fichier .dat
     * @param fichierBinaire: l'uri du fichier binaire
     */
    public static void lireFichierBinaire(String fichierBinaire) {
        DataInputStream in = null;

        System.out.println("    lecture du fichier binaire " + fichierBinaire);
        System.out.println("    CoeffP == " + CoeffP);
        
        try {
            // on crée un input stream de bytes
            in = new DataInputStream(new FileInputStream(fichierBinaire));

            byte[] byteArray = new byte[2];

            // le compteur (sert à se reperer dans la liste des capteurs)
            int compteur = 0;

            // on lit les octets 2 par 2
            while (compteur < nbLus && in.read(byteArray) != -1) {
                System.out.println("" + ((double) byteArrayToInt(byteArray) * CoeffP));
                compteur++;
            }
        } catch (IOException ex) {
            System.out.println(ex);
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
            } catch (IOException ex) {
                System.out.println(ex);
            }
        }
    }

    /**
     * extrait la valeur int d'un byte array en little endian
     * @param byteArray: un byte array en ordre little endian
     * @return int
     */
    private static int byteArrayToInt(byte[] byteArray) {
        int total = 0;
        for (int i = 0; i < byteArray.length; i++) {
            total += unsignedByteToInt(byteArray[i]) * ((i*256) == 0 ? 1 : i*256);
        }
        return total;
    }
    
    /**
     * effectue la conversion d'un byte en int en traitant le byte comme s'il était unsigned
     * @param b: le byte
     * @return la valeur int du byte comme s'il était unsigned
     */
    private static int unsignedByteToInt(byte b){
        int res = (int)b;
        if (res < 0){
            res = 256 + res;  // voir complément à deux
        }
        return res;
    }
   

et ici deux (parties de ) traces de l'exectution du programme test en c et de celui ci avec le même fichier binaire en parametre

start
    Lecture du fichier binaire pd04-199409212054.dat
    CoeffP == 0.010000
0.000000
0.000000
0.000000
0.000000
5.040000
5.040000
0.000000
0.000000
0.000000
0.000000

start
    lecture du fichier binaire pd04-199409212054.dat
    CoeffP == 0.01
0.0
0.0
0.0
0.0
5.039999887347221
5.039999887347221
0.0
0.0
0.0
0.0

j'ai un petit décalage de valeur mais ce n'est pas tres genant vu que ce sont des valeurs millimetres