Remplir un tableau à partir d'un fichier texte

J'ai un fichier texte avec les décimales de pi en binaire (environ 3000) je doit écrire un programme qui va chercher ce fichier puis lit ce qu'il y a dans le fichier et enfin stocke tout cela dans un tableau int.
Je me demande si le probleme ne vient pas de la manière dont j'indique le chemin de mon fichier
voici se que j'ai deja trouvé (javascool m'indique une erreur à la ligne ou il y à bufferedreader):

import java.io.*;

void main(){
    BufferedReader fichier2  = new BufferedReader(new FileReader(
        "C:\\Users\\wellenreiter\\Documents\\travail\\.travail ts\\ISN\\pi\\binairepi.txt"));
    String ligne;
    ligne = fichier2.readLine();
    while(ligne != null) {
        println(ligne);
        ligne = fichier2.readLine();
    }
    fichier2.close();
}

Donc chaque ligne de ton fichier comprend une décimale codée en binaire et tu veux récupérer chaque ligne dans un tableau de int ?

Si c'est le cas vu je passera plutôt par un ArrayList<Integer> pour avoir un taille dynamique.
Aprés à premiére vu ton code semble correct, seule question, pourquoi un des répertoires commence par un point ?
Et au passage les double simples slash (//) fonctionne aussi pour indiquer un chemin d'accés en java sous windows :)

EDIT: Autant pour moi j'avais pas bien lu ton code. Sauf erreur de ma part il ne faut pas passer par un FileReader pour ton fichier mais un FileInputReader qui appel ton fichier et que tu passes en paramétre dans un InputStreamReader

Voici un expemple simple :

import java.io.*;

public class ReadFile {
 public static void main(String[] args){
  String fichier ="fichiertexte.txt";
  
  //lecture du fichier texte 
  try{
   InputStream ips=new FileInputStream(fichier); 
   InputStreamReader ipsr=new InputStreamReader(ips);
   BufferedReader br=new BufferedReader(ipsr);
   String ligne;
   while ((ligne=br.readLine())!=null){
    System.out.println(ligne);
   }
   br.close(); 
  }  
  catch (Exception e){
   System.out.println(e.toString());
  }
         }
}

Donc si on adapte pour toi il suffit de déclarer ton ArrayList<Integer> puis d'ajouter la ligne dans le while à chaque fois.

import java.io.*;
import java.util.ArrayList;

public class ReadFile {
 public static void main(String[] args){
  String fichier ="fichiertexte.txt";
  ArrayList<Integer> decimale = new ArrayList<Integer>();
  
  //lecture du fichier texte 
  try{
   InputStream ips=new FileInputStream(fichier); 
   InputStreamReader ipsr=new InputStreamReader(ips);
   BufferedReader br=new BufferedReader(ipsr);
   String ligne;
   while ((ligne=br.readLine())!=null){
   int piBinaire = Integer.parseInt(ligne);
   decimale.add(piBinaire);
   }
   br.close(); 
  }  
  catch (Exception e){
   System.out.println(e.toString());
  }
         }
}

EDIT 2 : D'ailleurs en faisant ta méthode ton nombre binaire ne sera pas considéré comme tel mais comme un entier. Je ne connais pas la suite de ton programme mais autrement dit si ta décimale est 1000 en base 2 = 8 en base 10 mais ton programme l'interprétera comme un entier donc 1000 en base 10. En fonction de ce que tu veux faire il serait peut être plus référable pour toi de récupérer des Strings dans le tableau et de te faire une petite méthode de conversion String to Binary :)

Merci pour tes explications je commence à y voir plus claire.
Le point dans le dossier est normal (mon dossier s'appelle bien .travail ts ^^)
Cependant mon fichier texte comprend plusieurs nombres (en binaire) par ligne.
Mon programme à pour but de demander un message à l'utilisateur, ce message sera converti d'abord en ASCII puis en binaire (par exemple un A sera 01000001)
Nous devons additionner, avec un Xor, chaque nombre binaire de ce message avec les décimales de pi elles mêmes en binaire pour finalement avoir un message codé qui devra être décodé par la suite. (je t'explique cela car je ne suis pas sur d'avoir bien compris ton EDIT 2).
Je pense avoir compris ton programme bien qu'il y ai un problème avec le "public class ReadFile" (cela doit être un problème en rapport avec javascool car j'ai déjà eu ce problème avec d'autres programmes qui utilisaient aussi "public class ReadFile" ou n'importe quel "public ........"
Merci encore de ton aide qui nous avance fortement :)

J'ai réussi à faire compiler le programme en remplacent :public class ReadFile {
public static void main(String[] args){
par void main (){
je ne sais pas si cela impact sur le programme (en javascool il n'y a qu'une seul class qui est void main).
Cependant quand j'exécute le programme il m'affiche cela : java.lang.NumberFormatException: For input string: ""
Cela viendrait du fait que le string soit "null" à un moment donné.

Dans mon code, je t'ai fait une m"thode toute prête à être éxécuter donc j'ai écrit une classe ReadFile avec une méthode main(String args[])
En java la méthode main est la méthode exécuté par convention lors du lancement du programme. Autrement dit tu peux copier le contenu de la méthode et la mettre dans ton code qui lui contient déjà une classe main (d'où les erreurs).

Pour ton message d'erreur, c'est qu'a un moment la méthode parseInt est appellée pour un String null ou valant "". Donc pas d'entier d'où l'exception qui est levé. Il faut que tu vérifies que ton fichier texte ne contient pas de ligne vide.

00100100 00111111 01101010 10001000 10000101 10100011 00001000 11010011 
00010011 00011001 10001010 00101110 00000011 01110000 01110011 01000100 
10100100 00001001 00111000 00100010 00101001 10011111 00110001 11010000 
00001000 00101110 11111010 10011000 11101100 01001110 01101100 10001001 

<256>

01000101 00101000 00100001 11100110 00111000 11010000 00010011 01110111 
10111110 01010100 01100110 11001111 00110100 11101001 00001100 01101100 
11000000 10101100 00101001 10110111 11001001 01111100 01010000 11011101 
00111111 10000100 11010101 10110101 10110101 01000111 00001001 00010111 

<512>

10010010 00010110 11010101 11011001 10001001 01111001 11111011 00011011 
11010001 00110001 00001011 10100110 10011000 11011111 10110101 10101100 
00101111 11111101 01110010 11011011 11010000 00011010 11011111 10110111 
10111000 11100001 10101111 11101101 01101010 00100110 01111110 10010110 

Voila ce que j'ai dans mon fichier. Notre professeur nous à conseillé de faire un tableau pour chaque décimale et pour chaque lettre du message à coder (cela reste un conseille) donc notre premiers tableau serait composé de 8 cases avec dedans 00100100 (pour pi ) et dans un autre tab 01000001 (par exemple si la première lettre du message est A). Ensuite nous devons additionner ces 2 tab pour obtenir la première lettre du message mais codé, puis il faut la décoder et faire cela pour toutes les lettres de notre message.
Je met ce que nous avons déjà (même si tout ne fonctionne pas )
Avec cela on transforme des mots en binaire (on n'obtient malheureusement pas 8 bytes pour chaque lettre et pour l'instant tout est dans un seul tableau)

int z =0;

int r;


void main() {
 
String mot = readString("Entrez votre message");
int k = mot.length();
    for (int i = 0; i < mot.length(); i ++) {
      int q = (int)mot.charAt(i);
      while (q > 0) {
         q = q /2;
         //tant que q>0 : q se divise par 2 
          r = q %2;
         z = z +1;
         //permet de remplir le tableau case par case (a chaque fois que while  se fait)
          int [] tableau = new int[k *8];
         tableau [ z ] = r;
         print(tableau[z]);
         // le rang z du tableau prend la valeur r a chaque while  print(mot[z]);
          //affiche le tableau
       }
   }
}

Ce programme permet d'additionner 2 tab (de les codés puis décoder) (ici encore nous n'avons que un grand tableau).

//permet de sauter des lignes en mettant print(""+newLine+"");
String newLine = System.getProperty("line.separator");

void main() {
   //valeurs de pi
    int [] cle = new int[1000];
   for (int i = 0; i < 1000; i = i +1) {
      cle [ i ] = random(0, 2);
   }
   // valeurs du message à coder
    int [] tab = new int[1000];
   for (int i = 0; i < 1000; i = i +1) {
      tab [ i ] = random(0, 2);
   }
   //tableau du message codé
    int [] messagecrypte = new int [1000];
   for (int i =0; i <1000; i = i +1) {
      messagecrypte [i] = cle[i] ^ tab[i];
   }
   println("votre message codé est : ");
   for (int i = 0; i < 1000; i = i +1) {
      print(messagecrypte[i]);
   }
   print("" + newLine+"");
   //permet de mettre la réponse à la ligne
    boolean x = readBoolean("voulez vous le decoder? ");
   if (x) {
      //décodation du message
       for (int i = 0; i < 1000; i = i +1) {
         print(messagecrypte[i] ^ cle[i]);
      }
   } else {
      print("tant pis");
   }
}

Après la manière dont cela est fait importe peu tant que le programme n'est pas trop compliqué et qu'il respecte le cahier des chagres (passer un message en ascii puis binaire, additionner ce message (Xor) avec les décimales de pi en binaire issue d'un fichier test puis décoder ce message).

Pour la lecture de ton fichier, ce qui est un peu pénible ce sont les <256> <512> si le fichier avait été uniforme ça se serait bien passé, là il faut jongler un peu pour passer outre ces cas particuliers (NB. je n'ai pas testé sous Java's Cool)

import java.io.File;
import java.util.ArrayList;
import java.util.Scanner;

void main() throws Exception 
{
    ArrayList<Integer> list = new ArrayList<Integer>();
    Scanner sc = new Scanner(new File("C:/pi.txt"));
    
    boolean loop = true;
    while (loop)
    {
        // lecture des bits
        while (sc.hasNextBigInteger(2))
            list.add(sc.nextBigInteger(2).intValue());
        
        // gestion des lignes sans bits
        while (!sc.hasNextBigInteger(2) && loop) 
        {
            if (sc.hasNextLine())
                println("Ignore ligne : "+sc.nextLine());
            else
                loop = false;
        }
    }    
    
    sc.close();
    
    println(list);
    
    int[] tab = new int[list.size()];
    for (int i=0; i<tab.length; i++)
        tab[i] = list.get(i);
}

Remarque : quelques écritures alternatives :

    boolean loop = true;
    while (loop)
    {

Peut être remplacé par

    for (boolean loop = true; loop; )
    {

Ce qui évite d'exposer la variable loop en dehors du scope de la boucle.

On peut même se passer de la variable loop, avec des labels (plus technique) :

x:  while (true) // x est un label pour identifier la boucle
    {
        // lecture des bits
        while (sc.hasNextBigInteger(2))
            list.add(sc.nextBigInteger(2).intValue());
        
        // gestion des lignes sans bits
        while (!sc.hasNextBigInteger(2) && loop) 
        {
            if (sc.hasNextLine())
                println("Ignore ligne : "+sc.nextLine());
            else
                break x; // arrête la boucle identifiée par le label x
        }
    }

Bref, dans tous les cas tu lis tes bits blocs par blocs et tu les rajoutes à la liste en passant par une conversion des BigInteger en base 2 vers les int.
Ton tableau devrait donc correspondre à ce que tu veux...