Java：如何通过ArrayList中的新行读取和存储它们？_Java_Arraylist_Java.util.scanner_Toarray

Java：如何通过ArrayList中的新行读取和存储它们？

java

Java：如何通过ArrayList中的新行读取和存储它们？,java,arraylist,java.util.scanner,toarray,Java,Arraylist,Java.util.scanner,Toarray,下面是my.txt文件的外观（但每行超过100个元素，超过100行）：我想做的是读取这个.txt文件并将它们存储在ArryList中。问题是，当我读取和存储这些数据时，它们将所有这些数据放在同一个数组中（我希望它们存储在一行分割的两个数组中）这是我的密码： public class ReadStore { public static void main(String[] args) throws IOException { Scanner inFile = new Scan

下面是my.txt文件的外观（但每行超过100个元素，超过100行）：

我想做的是读取这个.txt文件并将它们存储在ArryList中。问题是，当我读取和存储这些数据时，它们将所有这些数据放在同一个数组中（我希望它们存储在一行分割的两个数组中）

这是我的密码：

public class ReadStore {
    public static void main(String[] args) throws IOException {

    Scanner inFile = new Scanner(new File("Untitled.txt")).useDelimiter("\\s");
    ArrayList<Float> temps = new ArrayList<Float>();

    while (inFile.hasNextFloat()) {
      // find next line
      float token = inFile.nextFloat();
      temps.add(token);

    }

    inFile1.close();

    Float [] tempsArray = temps.toArray(new Float[0]);
    for (Float s : tempsArray) {
      System.out.println(s);
    } 
  }

公共类ReadStore{
公共静态void main（字符串[]args）引发IOException{
扫描仪填充=新扫描仪（新文件（“Untitled.txt”））。使用分隔符（\\s”）；
ArrayList temps=新的ArrayList（）；
while（infle.hasNextFloat（））{
//查找下一行
float-token=infle.nextFloat（）；
临时添加（令牌）；
}
inFile1.close（）；
Float[]tempsArray=temps.toArray（新的Float[0]）；
用于（浮动s:tempsArray）{
系统输出打印项次；
} 
}

对此有什么建议吗？

我可以这样做，只需读取每一行的全部内容，然后在空格上拆分以访问每个浮点数。这样就避免了必须区分空格和行分隔符的问题

public class ReadStore {
    public static void main(String[] args) throws IOException {
        Scanner inFile = new Scanner(new File("Untitled.txt"));
        ArrayList<Float> temps = new ArrayList<Float>();

        while (inFile.hasNextLine()) {
            String line = inFile.nextLine();
            String[] nums = line.trim().split("\\s+");
            for (String num : nums) {
                float token = Float.parseFloat(num);
                temps.add(token);
            }
            Float [] tempsArray = temps.toArray(new Float[0]);
            for (Float s : tempsArray) {
                System.out.println(s);
            }
        }

        inFile.close();
    }
}

公共类ReadStore{
公共静态void main（字符串[]args）引发IOException{
扫描仪内嵌=新扫描仪（新文件（“Untitled.txt”）；
ArrayList temps=新的ArrayList（）；
while（infle.hasNextLine（））{
字符串行=infle.nextLine（）；
字符串[]nums=line.trim（）.split（\\s+）；
用于（字符串编号：nums）{
浮点标记=float.parseFloat（num）；
临时添加（令牌）；
}
Float[]tempsArray=temps.toArray（新的Float[0]）；
用于（浮动s:tempsArray）{
系统输出打印项次；
}
}
infle.close（）；
}
}

下面是一个演示，演示了该逻辑对输入文件的一行起作用。请注意，在拆分前，我会在每一行上调用

String#trim（）

，以防出现我们不需要的任何前导或尾随空格

首先逐行读取，然后每行读取每个浮点。

试试这个：

public static void main(String[] args) throws IOException {
    Scanner inFile = new Scanner(new File("Untitled.txt"));
    List<List<Float>> temps = new ArrayList<>();

    while (inFile.hasNextLine()) {
        List<Float> data = new ArrayList<>();

        Scanner inLine = new Scanner(inFile.nextLine());
        while (inLine.hasNextFloat()) {
            data.add(inLine.nextFloat());
        }
        inLine.close();

        temps.add(data);
    }

    inFile.close();

    Float[][] dataArray = new Float[temps.size()][];

    for (int i = 0; i < dataArray.length; i++) {
        dataArray[i] = temps.get(i).toArray(new Float[temps.get(i).size()]);
    }

    System.out.println(Arrays.deepToString(dataArray));
}

您可以逐行读取并按空格拆分。正在使用和测试的代码：

public static void main(String[] args) throws IOException {

        Scanner inFile = new Scanner(new File("C:\\Untitled.txt"));
        ArrayList<String[]> temps = new ArrayList<>();

        while (inFile.hasNextLine()) {
            // find next line
            String line = inFile.nextLine();
            String[] floats = line.split("\\s+");
            temps.add(floats);
        }

        inFile.close();

        temps.forEach(arr -> {
            System.out.println(Arrays.toString(arr));
        });
    }

publicstaticvoidmain（字符串[]args）引发IOException{
扫描仪填充=新扫描仪（新文件（“C:\\Untitled.txt”）；
ArrayList temps=新的ArrayList（）；
while（infle.hasNextLine（））{
//查找下一行
字符串行=infle.nextLine（）；
字符串[]floats=line.split（\\s+）；
临时添加（浮动）；
}
infle.close（）；
临时外汇（arr->{
System.out.println（Arrays.toString（arr））；
});
}

您还可以通过正则表达式读取浮点值

Scanner inFile = new Scanner(new File("C:\\Untitled.txt"));
        ArrayList<Float> temps = new ArrayList<>();

        while (inFile.hasNext("-\\d\\.\\d+")) {
            // find next line
            String line = inFile.next();
            temps.add(Float.valueOf(line));
        }

        inFile.close();

Scanner infle=新扫描仪（新文件（“C:\\Untitled.txt”）；
ArrayList temps=新的ArrayList（）；
while（infle.hasNext（“-\\d\\.\\d+”）{
//查找下一行
字符串行=infle.next（）；
临时添加（浮动值（行））；
}
infle.close（）；

使用Files.readAllLines方法读取文件一次，然后按空格分隔

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.stream.Collectors;

public class Test {
    public static void main(String[] args) {
        String readFileContent = readFileContent(new File("Test.txt"));
        ArrayList<Float> temps = new ArrayList<Float>();
        String[] split = readFileContent.split("\\s+");
        for (String num : split) {
             float token = Float.parseFloat(num.trim());
             temps.add(token);
        }

        Float [] tempsArray = temps.toArray(new Float[0]);
        for (Float s : tempsArray) {
            System.out.println(s);
        }
    }

    private static String readFileContent(File file) {
        try {
            return Files.readAllLines(file.toPath()).stream().collect(Collectors.joining("\n"));
        } catch (IOException e) {
            System.out.println("Error while reading file " + file.getAbsolutePath());
        }
        return "";
    }
}

导入java.io.File；
导入java.io.IOException；
导入java.nio.file.Files；
导入java.util.ArrayList；
导入java.util.stream.collector；
公开课考试{
公共静态void main（字符串[]args）{
字符串readFileContent=readFileContent（新文件（“Test.txt”）；
ArrayList temps=新的ArrayList（）；
String[]split=readFileContent.split（\\s+）；
用于（字符串编号：拆分）{
float-token=float.parseFloat（num.trim（））；
临时添加（令牌）；
}
Float[]tempsArray=temps.toArray（新的Float[0]）；
用于（浮动s:tempsArray）{
系统输出打印项次；
}
}
私有静态字符串readFileContent（文件）{
试一试{
返回文件.readAllLines（file.toPath（））.stream（）.collect（Collectors.joining（“\n”）；
}捕获（IOE异常）{
System.out.println（“读取文件时出错”+file.getAbsolutePath（））；
}
返回“”；
}
}

每一行都可以存储为一个数组列表，并且每一个数组列表都可以存储在另一个数组列表中，从而创建一个浮动类型的二维数组列表。使用java.util.Scanner.nextLine（）读取每一行，然后分析每一行的浮点值。我已经使用另一个扫描仪分析每一行的浮点值。解析后，将浮点值存储到tmp ArrayList中，并将该列表添加到主列表中。确保关闭while自身内部的本地扫描程序。

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

public class ReadStore {
    public static void main(String[] args) throws IOException {
        //Input File
        Scanner inFile =new Scanner(new File("Untitled1.txt")).useDelimiter("\\s");
        //Major List (2-D ArrayList)
        ArrayList<ArrayList<Float>> list = new ArrayList<ArrayList<Float>>();
        //Reading Each Line
        while (inFile.hasNextLine()) {
            //tmp ArrayList
            ArrayList<Float> arr = new ArrayList<Float>();

            String line = inFile.nextLine();
            //local scanner to be used for parsing
            Scanner local = new Scanner(line);
            //Parsing line for flat values
            while(local.hasNext()){
                if(local.hasNextFloat()){
                    float token = local.nextFloat();
                    arr.add(token); 
                }   
            }
            //closing local Scanner
            local.close();
            //Adding to major List
            list.add(arr);
        }
        inFile.close();
        //Display List values
        for(ArrayList<Float> arrList:list){

            for(Float f : arrList){
                System.out.print(f + " ");
            }
            System.out.println();
        }        
    }
}

导入java.io.File；
导入java.io.IOException；
导入java.util.ArrayList；
导入java.util.Scanner；
公共类读库{
公共静态void main（字符串[]args）引发IOException{
//输入文件
Scanner infle=new Scanner（新文件（“Untitled1.txt”）。使用分隔符（\\s”）；
//主要列表（二维阵列列表）
ArrayList=新建ArrayList（）；
//读每行
while（infle.hasNextLine（））{
//tmp阵列列表
ArrayList arr=新的ArrayList（）；
字符串行=infle.nextLine（）；
//用于解析的本地扫描程序
扫描仪本地=新扫描仪（行）；
//分析行的平面值
while（local.hasNext（））{
if（local.hasNextFloat（））{
float-token=local.nextFloat（）；
arr.add（令牌）；
}   
}
//关闭本地扫描仪
local.close（）；
//加入主要名单
列表。添加（arr）；
}
infle.close（）；
//显示列表值
对于（ArrayList arrList:list）{
用于（浮动f:arrList）{
系统输出(
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.stream.Collectors;

public class Test {
    public static void main(String[] args) {
        String readFileContent = readFileContent(new File("Test.txt"));
        ArrayList<Float> temps = new ArrayList<Float>();
        String[] split = readFileContent.split("\\s+");
        for (String num : split) {
             float token = Float.parseFloat(num.trim());
             temps.add(token);
        }

        Float [] tempsArray = temps.toArray(new Float[0]);
        for (Float s : tempsArray) {
            System.out.println(s);
        }
    }

    private static String readFileContent(File file) {
        try {
            return Files.readAllLines(file.toPath()).stream().collect(Collectors.joining("\n"));
        } catch (IOException e) {
            System.out.println("Error while reading file " + file.getAbsolutePath());
        }
        return "";
    }
}

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

public class ReadStore {
    public static void main(String[] args) throws IOException {
        //Input File
        Scanner inFile =new Scanner(new File("Untitled1.txt")).useDelimiter("\\s");
        //Major List (2-D ArrayList)
        ArrayList<ArrayList<Float>> list = new ArrayList<ArrayList<Float>>();
        //Reading Each Line
        while (inFile.hasNextLine()) {
            //tmp ArrayList
            ArrayList<Float> arr = new ArrayList<Float>();

            String line = inFile.nextLine();
            //local scanner to be used for parsing
            Scanner local = new Scanner(line);
            //Parsing line for flat values
            while(local.hasNext()){
                if(local.hasNextFloat()){
                    float token = local.nextFloat();
                    arr.add(token); 
                }   
            }
            //closing local Scanner
            local.close();
            //Adding to major List
            list.add(arr);
        }
        inFile.close();
        //Display List values
        for(ArrayList<Float> arrList:list){

            for(Float f : arrList){
                System.out.print(f + " ");
            }
            System.out.println();
        }        
    }
}

static List<List<Float>> readData() throws IOException {
    Pattern pat = Pattern.compile("\\s+");
    try (Stream<String> allLines = Files.lines(Paths.get(filename))) {
        return allLines.map(line -> pat.splitAsStream(line)
                                       .map(Float::parseFloat)
                                       .collect(Collectors.toList()))
                       .collect(Collectors.toList());
    }
}

static List<List<Float>> readData9() throws IOException {
    try (Stream<String> allLines = Files.lines(Paths.get(filename))) {
        return allLines.map(Scanner::new)
                       .map(sc -> sc.tokens()
                                    .map(Float::parseFloat)
                                    .collect(Collectors.toList()))
                       .collect(Collectors.toList());
    }
}