Lire .fichier txt en Tableau 2D

Il ya un peu de ces sujets là, mais ce problème a une légère torsion qui le rend différent.

Je me concentre seulement sur la moitié d'un problème plus vaste. Je suis sûr que beaucoup d'entre vous sont au courant des carrés magiques problème.

Invite:

Supposons un fichier avec des lignes et des nombres sur chaque ligne, comme la place indiquée. Écrire un programme qui lit les infos dans un tableau à deux dimensions d'entiers. Le programme doit déterminer si la matrice a est un carré magique ou non.

Solution De Travail:

public static int[][] create2DIntMatrixFromFile(String filename) throws Exception {
int[][] matrix = {{1}, {2}};

File inFile = new File(filename);
Scanner in = new Scanner(inFile);

int intLength = 0;
String[] length = in.nextLine().trim().split("\\s+");
  for (int i = 0; i < length.length; i++) {
    intLength++;
  }

in.close();

matrix = new int[intLength][intLength];
in = new Scanner(inFile);

int lineCount = 0;
while (in.hasNextLine()) {
  String[] currentLine = in.nextLine().trim().split("\\s+"); 
     for (int i = 0; i < currentLine.length; i++) {
        matrix[lineCount][i] = Integer.parseInt(currentLine[i]);    
            }
  lineCount++;
 }                                 
 return matrix;
}


public static boolean isMagicSquare(int[][] square) {

  return false;
}

Voici mon (ancien) du code pour lire des informations à partir d'un fichier texte dans un tableau 2D:

public static int[][] create2DIntMatrixFromFile(String filename) throws Exception {
    int[][] matrix = {{1}, {2}};
    File inFile = new File(filename);
    Scanner in = new Scanner(inFile);
    in.useDelimiter("[/n]");

    String line = "";
    int lineCount = 0;

    while (in.hasNextLine()) {
        line = in.nextLine().trim();
        Scanner lineIn = new Scanner(line);
        lineIn.useDelimiter("");

        for (int i = 0; lineIn.hasNext(); i++) {
            matrix[lineCount][i] = Integer.parseInt(lineIn.next());
            lineIn.next();
        }

        lineCount++;
    }

    return matrix;
}

public static boolean isMagicSquare(int[][] square) {
    return false;
}

Et voici le fichier texte que je lis de. Il est en forme de 9x9 tableau 2D, mais le programme doit accueillir un tableau d'ambigu taille.

  37  48  59  70  81   2  13  24  35 
  36  38  49  60  71  73   3  14  25 
  26  28  39  50  61  72  74   4  15 
  16  27  29  40  51  62  64  75   5 
   6  17  19  30  41  52  63  65  76 
  77   7  18  20  31  42  53  55  66 
  67  78   8  10  21  32  43  54  56 
  57  68  79   9  11  22  33  44  46 
  47  58  69  80   1  12  23  34  45

Il y a deux espaces de procéder chaque ligne de but.

Avant que j'ai le problème exact, c'est un des devoirs de modèle afin que la méthode de déclaration et initialisation d'une variable a été pré-déterminé.

Je ne suis pas positif que la méthode même correctement crée un Tableau 2D à partir du fichier parce que je ne peux pas l'exécuter encore. Le problème est que pour une raison "matrix" a été initialisé à 1 colonne et 2 lignes. Pour quelle raison, je ne suis pas sûr, mais dans le but de remplir un tableau avec les numéros à partir du fichier que j'ai besoin de créer un tableau 2D avec des dimensions égal au nombre de valeurs dans une ligne.

J'avais déjà écrit le code pour créer un nouveau tableau 2D

int[line.length()][line.length()]

mais il a créé un 36x36 tableau car c'est le nombre de caractères individuels sont sur une seule ligne. J'ai le sentiment que c'est aussi simple que de boucle à travers la première ligne et d'avoir un compteur de garder une trace de chaque séquence de chiffres séparés par un zéro.

Pour moi, cette solution semble trop inefficace et coûteuse en temps, juste pour trouver les dimensions de la nouvelle matrice. Quelle est la meilleure façon d'accomplir cette? Sans l'aide de ArrayLists que je dois réécrire ce programme après l'utilisation de ArrayLists.

Pour obtenir les nombres sur une ligne, vous pouvez simplement appeler line.split(" ");.

InformationsquelleAutor BimmerM3 | 2014-03-04

J'ai produit la suite de tableau 2D à partir du fichier que vous avez fournies:

 37 | 48 | 59 | 70 | 81 |  2 | 13 | 24 | 35
----+----+----+----+----+----+----+----+----
36 | 38 | 49 | 60 | 71 | 73 |  3 | 14 | 25
----+----+----+----+----+----+----+----+----
26 | 28 | 39 | 50 | 61 | 72 | 74 |  4 | 15
----+----+----+----+----+----+----+----+----
16 | 27 | 29 | 40 | 51 | 62 | 64 | 75 |  5
----+----+----+----+----+----+----+----+----
6 | 17 | 19 | 30 | 41 | 52 | 63 | 65 | 76
----+----+----+----+----+----+----+----+----
77 |  7 | 18 | 20 | 31 | 42 | 53 | 55 | 66
----+----+----+----+----+----+----+----+----
67 | 78 |  8 | 10 | 21 | 32 | 43 | 54 | 56
----+----+----+----+----+----+----+----+----
57 | 68 | 79 |  9 | 11 | 22 | 33 | 44 | 46
----+----+----+----+----+----+----+----+----
47 | 58 | 69 | 80 |  1 | 12 | 23 | 34 | 45

Le tableau des chiffres de la taille de la place lorsqu'il lit la première ligne du fichier. C'est très dynamique. Sa fonctionne tant que le fichier d'entrée est un carré parfait. Je n'ai pas plus d'erreur de manipulation.

Ici est une approche simple qui devrait adhérer à vos directives.

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
public class ReadMagicSquare {
public static int[][] create2DIntMatrixFromFile(String filename) throws Exception {
int[][] matrix = null;
//If included in an Eclipse project.
InputStream stream = ClassLoader.getSystemResourceAsStream(filename);
BufferedReader buffer = new BufferedReader(new InputStreamReader(stream));
//If in the same directory - Probably in your case...
//Just comment out the 2 lines above this and uncomment the line
//that follows.
//BufferedReader buffer = new BufferedReader(new FileReader(filename));
String line;
int row = 0;
int size = 0;
while ((line = buffer.readLine()) != null) {
String[] vals = line.trim().split("\\s+");
//Lazy instantiation.
if (matrix == null) {
size = vals.length;
matrix = new int[size][size];
}
for (int col = 0; col < size; col++) {
matrix[row][col] = Integer.parseInt(vals[col]);
}
row++;
}
return matrix;
}
public static void printMatrix(int[][] matrix) {
String str = "";
int size = matrix.length;
if (matrix != null) {
for (int row = 0; row < size; row++) {
str += " ";
for (int col = 0; col < size; col++) {
str += String.format("%2d",  matrix[row][col]);
if (col < size - 1) {
str += " | ";
}
}
if (row < size - 1) {
str += "\n";
for (int col = 0; col < size; col++) {
for (int i = 0; i < 4; i++) {
str += "-";
}
if (col < size - 1) {
str += "+";
}
}
str += "\n";
} else {
str += "\n";
}
}
}
System.out.println(str);
}
public static void main(String[] args) {
int[][] matrix = null;
try {
matrix = create2DIntMatrixFromFile("square.txt");
} catch (Exception e) {
e.printStackTrace();
}
printMatrix(matrix);
}
}

Cette approche s'est affiné et optimisé.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
public class ReadMagicSquare {
private int[][] matrix;
private int size = -1;
private int log10 = 0;
private String numberFormat;
public ReadMagicSquare(String filename) {
try {
readFile(filename);
} catch (IOException e) {
e.printStackTrace();
}
}
public void readFile(String filename) throws IOException {
//If included in an Eclipse project.
InputStream stream = ClassLoader.getSystemResourceAsStream(filename);
BufferedReader buffer = new BufferedReader(new InputStreamReader(stream));
//If in the same directory - Probably in your case...
//Just comment out the 2 lines above this and uncomment the line
//that follows.
//BufferedReader buffer = new BufferedReader(new FileReader(filename));
String line;
int row = 0;
while ((line = buffer.readLine()) != null) {
String[] vals = line.trim().split("\\s+");
//Lazy instantiation.
if (matrix == null) {
size = vals.length;
matrix = new int[size][size];
log10 = (int) Math.floor(Math.log10(size * size)) + 1;
numberFormat = String.format("%%%dd", log10);
}
for (int col = 0; col < size; col++) {
matrix[row][col] = Integer.parseInt(vals[col]);
}
row++;
}
}
@Override
public String toString() {
StringBuffer buff = new StringBuffer();
if (matrix != null) {
for (int row = 0; row < size; row++) {
buff.append(" ");
for (int col = 0; col < size; col++) {
buff.append(String.format(numberFormat,  matrix[row][col]));
if (col < size - 1) {
buff.append(" | ");
}
}
if (row < size - 1) {
buff.append("\n");
for (int col = 0; col < size; col++) {
for (int i = 0; i <= log10 + 1; i++) {
buff.append("-");
}
if (col < size - 1) {
buff.append("+");
}
}
buff.append("\n");
} else {
buff.append("\n");
}
}
}
return buff.toString();
}
public static void main(String[] args) {
ReadMagicSquare square = new ReadMagicSquare("square.txt");
System.out.println(square.toString());
}
}

Je comprends que c'est vraiment la seule réponse qui résout le problème, mais nous n'avons jamais été introduit aux tampons et n'ont pas encore écrire des classes avec des méthodes d'assistance. Je suis conscient que je cela va produire la bonne réponse, mais je pense que j'ai besoin qu'il a accompli en une plus de manière rudimentaire.
que faire si l'entrée a plus de colonnes (9) que les lignes (1) ? vous initialiser la matrice à 1 ligne et 1 colonne et à la fin, avec arrayindexoutofbound exception.
Avez-vous lu ce que j'ai dit? "C'est très dynamique. Sa fonctionne tant que le fichier d'entrée est un carré parfait. je n'ai pas plus d'erreur de manipulation."
Je me permet de "stupide" vers le bas si vous voulez... je vais garder ma présentation originale ci-dessous la "nouvelle" réponse, quand j'ai fini.
Ce serait très apprécié. Si je n'ai pas de bâton avec une telle base de code, je ne pense pas que j'aurais un problème avec elle. J'ai passé tellement de temps sur cette simple question que mon cerveau ne veut même pas essayer de continuer à ressasser sur elle.
Je voudrais utiliser BufferedReader par opposition à Scanner. Non seulement il a été autour de plus de temps, mais c'est synchronisé! 🙂 Il suffit de suivre les commentaires où je créer le BufferedReader en fonction de vos besoins.
"un carré parfait": qu'est Ce qu'un "non-préfet" carré ?

InformationsquelleAutor Mr. Polywhirl

Vous êtes proche, mais le changement de votre boucle while pour ressembler à la suivante:

while (in.hasNextLine()) {
Scanner lineIn = new Scanner(line);
//The initial case - this first line is used to determine the size of the array
if(lineIn.hasNext()) {
//Create a String array by splitting by spaces
String[] s = lineIn.nextLine().split(" ");
//Reinitialize the array to hold all of your subarrays
matrix = new int[s.length];
for (int i = 0; i < s.length; i++) {
//Reinitialize each subarray to hold the numbers
matrix[i] = new int[i];
//Finally, parse your data from the String array
matrix[0][i] = Integer.parseInt(s[i]);
}
}
//Repeat the steps now that all of your arrays have been initialized
for (int j = 1; j < matrix.length; j++) {
String[] s = lineIn.nextLine().split(" ");
for (int i = 0; i < s.length; i++) {
matrix[j][i] = Integer.parseInt(s[i]);
}
}
}

Le changement le plus important que vous pouvez faire pour rendre cela plus facile sur vous-même est d'obtenir vos numéros de ligne-par-ligne. Avec chaque ligne que vous obtenez, il est facile de diviser ensuite dans un tableau de chaînes, de sorte que vous pouvez analyser chaque chiffre séparément. Le faire de cette façon, vous pouvez obtenir la longueur totale de la matrice de tous à la fois sans avoir à avoir de fâcheuses compteurs.

J'ai mis en place cette boucle, mais je suis une "Aucun Élément" erreur '.nextLine()' et je ne sais pas exactement à quel point il est d'atteindre la fin du fichier.

InformationsquelleAutor David Kopczyk

0

D'abord, tester le Scanner résultats. Je ne pense pas que ces délimiteurs fonctionne. (BTW, Scanner nextInt() méthode est à portée de main.)

Si vous pouvez supposer que l'entrée est une matrice carrée, de la numérisation de la première ligne de révéler combien de nombres entiers qu'il contient. Ensuite, vous pouvez (re)allouer les tableaux. Puis de traiter toutes les lignes, y compris la première ligne que vous avez déjà numérisées.

Puis vous pouvez définir matrix = new int[n][n];

InformationsquelleAutor Jerry101

Avec Java 8 et c'est Flux:

  static public int[][] create2DIntMatrixFromFile(Path path) throws IOException {
return Files.lines(path)
.map((l)->l.trim().split("\\s+"))
.map((sa)->Stream.of(sa).mapToInt(Integer::parseInt).toArray())
.toArray(int[][]::new);
}

C'est juste pour la "lecture" d'une partie de la question.

InformationsquelleAutor YoYo

Vous devez vous connecter pour publier un commentaire.