Java 填充多个数组'；使用.txt文件中的标准输入

我一直在努力用文本文件中不同类型的数据填充数组。此文本文件如下所示：

N字符串
双倍双倍
双倍双倍
等N行双打
N字符串
冲洗并重复

例如：

  120 Chicago Illinois  
  34.457832 78.294756  
  34.452948 78.198347
  etc.  

这是我到目前为止的代码，它是原始的，都在主体中。A=17，B=10632。因为总共有10649行，其中17行是整数字符串，其余的x和y坐标

//    Read over entire file
    while (!StdIn.isEmpty()){

      String line = StdIn.readLine();
      String[] split = line.split(" ");
//      System.out.print(split.length);
//      if (Character.isDigit(line.charAt(0))){  // Didnt work as to both the integer N and double are a digit 0-9
      if (split.length >= 3){
        for(int i = 0; i < A;i++){
          intArray1[i] = Integer.parseInt(split[0]);
          stringArray1[i] = split[1];
          stringArray2[i] = split[2];
        }
      } else{
        for(int i = 0;i < B; i++){
          xcoords[i] = Double.parseDouble(split[0]);
          ycoords[i] = Double.parseDouble(split[1]);
        }}  
      }

//读取整个文件
而（！StdIn.isEmpty（））{
String line=StdIn.readLine（）；
String[]split=line.split（“”）；
//系统输出打印（拆分长度）；
//如果（Character.isDigit（line.charAt（0））{//不起作用，因为整数N和double都是数字0-9
如果（拆分长度>=3）{
for（int i=0；i

其思想是，如果StdI.readLine和split创建的行的长度为3，则它必须是.txt文件中的一行，以整数N开头，后跟两个字符串。
然后，我们应该将这些3'值存储在匹配类型的3个数组中

---

否则，行的长度应为2，仅包含2个双倍值，并分别存储这些值。

我想知道您的数组和索引的用途，它将仅保存最新的一个，除非您在外部有其他索引并使用它

//Read over entire file
while (!StdIn.isEmpty()){
    String line = StdIn.readLine();
    String[] split = line.split(" ");
    if (line.contains(".")) {       
        //It is the double double lines
        for(int i = 0; i < 3; i++){
            intArray1[i] = Integer.parseInt(split[0]);
            stringArray1[i] = split[1];
            stringArray2[i] = split[2];
        }
    }else {
        //It is the int String String lines
        for(int i = 0;i < B; i++){
            xcoords[i] = Double.parseDouble(split[0]);
            ycoords[i] = Double.parseDouble(split[1]);
        }
    }
}

//读取整个文件
而（！StdIn.isEmpty（））{
String line=StdIn.readLine（）；
String[]split=line.split（“”）；
如果（第行包含（“.”）{
//这是双行
对于（int i=0；i<3；i++）{
intArray1[i]=Integer.parseInt（拆分[0]）；
stringArray1[i]=拆分[1]；
stringArray2[i]=拆分[2]；
}
}否则{
//它是整数字符串行
对于（int i=0；i

---

我将向您展示我这样做的方法：

//Create List to store all the useful information
List<IntStringObj> intStrList = new ArrayList<IntStringObj>;
List<DoubleObj> doubleList = new ArrayList<DoubleObj>;

//Read over entire file
while (!StdIn.isEmpty()){
    String line = StdIn.readLine();
    String[] split = line.split(" ");
    if (line.contains(".")) {       
        //It is the double double lines
        for(int i = 0; i < 3; i++){
            IntStringObj tempIntStrObj = new IntStringObj();
            tempIntStrObj.setInterger(Integer.parseInt(split[0]));
            tempIntStrObj.setStr1(split[1]);
            tempIntStrObj.setStr2(split[2]);
            intStrList.add(tempIntStrObj);
        }
    }else {
        //It is the int String String lines
        for(int i = 0;i < B; i++){
            DoubleObj tmpDoubleObj = new DoubleObj();
            tmpDoubleObj.setDouble1(Double.parseDouble(split[0]));
            tmpDoubleObj.setDouble2(Double.parseDouble(split[1]));
            doubleList.add(tmpDoubleObj);
        }
    }
}

//The classes can be stored outside/inside depends on your usage
class IntStringObj {
    private int interger;
    private String str1;
    private String str2;

    public int getInterger() {
        return interger;
    }

    public void setInterger(int interger) {
        this.interger = interger;
    }

    public String getStr1() {
        return str1;
    }

    public void setStr1(String str1) {
        this.str1 = str1;
    }

    public String getStr2() {
        return str2;
    }

    public void setStr2(String str2) {
        this.str2 = str2;
    }

}

class DoubleObj {
    private double double1;
    private double double2;

    public double getDouble1() {
        return double1;
    }

    public void setDouble1(double double1) {
        this.double1 = double1;
    }

    public double getDouble2() {
        return double2;
    }

    public void setDouble2(double double2) {
        this.double2 = double2;
    }

}

//创建列表以存储所有有用信息
List intStrList=新建ArrayList；
List doubleList=新的ArrayList；
//读取整个文件
而（！StdIn.isEmpty（））{
String line=StdIn.readLine（）；
String[]split=line.split（“”）；
如果（第行包含（“.”）{
//这是双行
对于（int i=0；i<3；i++）{
IntStringObj tempIntStrObj=新的IntStringObj（）；
tempIntStrObj.setinteger（Integer.parseInt（split[0]）；
tempIntStrObj.setStr1（拆分[1]）；
tempIntStrObj.setStr2（拆分[2]）；
intStrList.add（tempIntStrObj）；
}
}否则{
//它是整数字符串行
对于（int i=0；i

由于数据库看起来相当一致，您应该能够对大部分数据库进行硬处理。我会这样处理：

    List<City> cities =  new ArrayList<>();

    while (!StdIn.isEmpty()){

        String line1 = StdIn.readLine();
        String line2 = StdIn.readLine();
        String line3 = StdIn.readLine();

        String[] arr1 = line1.split(" ");
        String[] arr2 = line1.split(" ");
        String[] arr3 = line1.split(" ");

        int cityNum = arr1[0];
        String cityName = arr1[1] + " " + arr1[2];

        double[] xcoords = new double[2];
        double[] ycoords = new double[2];

        xcoords[0] = Double.parseDouble(arr2[0]);
        xcoords[1] = Double.parseDouble(arr3[0]);

        ycoords[0] = Double.parseDouble(arr2[1]);
        ycoords[1] = Double.parseDouble(arr3[1]);

        City city = new City();
        //build city with info

        cities.add(city);
    }

List cities=new ArrayList（）；
而（！StdIn.isEmpty（））{
字符串line1=StdIn.readLine（）；
字符串line2=StdIn.readLine（）；
字符串line3=StdIn.readLine（）；
字符串[]arr1=line1.split（“”）；
字符串[]arr2=line1.split（“”）；
字符串[]arr3=line1.split（“”）；
int cityNum=arr1[0]；
字符串cityName=arr1[1]+“”+arr1[2]；
double[]xcoords=新的double[2]；
double[]ycoords=新的double[2]；
xcoords[0]=Double.parseDouble（arr2[0]）；
xcoords[1]=Double.parseDouble（arr3[0]）；
ycoords[0]=Double.parseDouble（arr2[1]）；
ycoords[1]=Double.parseDouble（arr3[1]）；
城市=新城（）；
//用信息建设城市
城市。添加（城市）；
}

---

我认为做任何类型的测试来查看格式是什么都是多余的工作，只要你合理地确定格式将保持不变。

看看代码在做什么……while循环已经在所有行中循环，那么for循环的目的是什么呢？你在while循环中读取一行，然后e for循环用同一行的副本填充所有数组元素。然后重复下一行，以此类推，直到到达最后一行，然后数组用最后一行的副本填充

1） 如果您想要维护该结构，那么除了我将把一个

DoubleObj

数组作为

IntStringObj

类的成员和

// Create List to store all the useful information
List<IntStringObj> intStrList = new ArrayList<>();

IntStringObj tempIntStrObj = null;
int index = 0;
// Read over entire file
while (!StdIn.isEmpty()) {
    String line = StdIn.readLine();
    String[] split = line.split(" ");
    if (!line.contains(".")) {
        tempIntStrObj = new IntStringObj();
        index = 0;
        tempIntStrObj.setInteger(Integer.parseInt(split[0]));
        tempIntStrObj.setStr1(split[1]);
        tempIntStrObj.setStr2(split[2]);
        intStrList.add(tempIntStrObj);
    } else {
        DoubleObj tmpDoubleObj = new DoubleObj();
        tmpDoubleObj.setX(Double.parseDouble(split[0]));
        tmpDoubleObj.setY(Double.parseDouble(split[1]));
        tempIntStrObj.setCoords(index++, tmpDoubleObj);
    }
}
// print to console
/*
for (IntStringObj iso : intStrList) {
    System.out.println(iso.getInteger() + " " + iso.getStr1() + " " + iso.getStr2());
    for (int i = 0; i < iso.getInteger(); i++) {
        System.out.println(iso.getCoords(i).getX() + ", " + iso.getCoords(i).getY());
    }
}
*/

// The classes can be stored outside/inside depends on your usage
class IntStringObj {
    private int integer;
    private String str1;
    private String str2;
    private DoubleObj[] coords;

    public int getInteger() {
        return integer;
    }

    public void setInteger(int integer) {
        this.integer = integer;
        coords = new DoubleObj[integer];
    }

    public String getStr1() {
        return str1;
    }

    public void setStr1(String str1) {
        this.str1 = str1;
    }

    public String getStr2() {
        return str2;
    }

    public void setStr2(String str2) {
        this.str2 = str2;
    }

    public DoubleObj getCoords(int index) {
        return coords[index];
    }

    public void setCoords(int index, DoubleObj coords) {
        this.coords[index] = coords;
    }
}

class DoubleObj {
    private double x;
    private double y;

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }

}

ArrayList<Double> xcoords = new ArrayList<>();
ArrayList<Double> ycoords = new ArrayList<>();
ArrayList<String> strArray1 = new ArrayList<>();
ArrayList<String> strArray2 = new ArrayList<>();
ArrayList<Integer> intArray1 = new ArrayList<>();

// Read over entire file
while (!StdIn.isEmpty()) {
    String line = StdIn.readLine();
    String[] split = line.split(" ");

    if (split.length >= 3) {
        intArray1.add(Integer.parseInt(split[0]));
        strArray1.add(split[1]);
        strArray2.add(split[2]);
    } else {
        xcoords.add(Double.parseDouble(split[0]));
        ycoords.add(Double.parseDouble(split[1]));
    }
}
// print to console
/*
// print N city state
for (int i = 0; i < intArray1.size(); i++) {
    System.out.println(intArray1.get(i) + " " + strArray1.get(i) + " " + strArray2.get(i));
}
// print x, y coords
for (int i = 0; i < xcoords.size(); i++) {
    System.out.println(xcoords.get(i) + ", " + ycoords.get(i));
}
*/