Question

我是新手，我不知道如何合并我的知识部分。我必须让算法寻找最长的数字序列。我的文件有50列，每列都有一些用空格分隔的随机数。

我仍然试图将它们放在Matrix或其他多维数组中，但我不知道如何。

这是我的代码：

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

public class reading {

    public static void main(String[] args) {
        double[][] numbers = new double[101][101];
        int column = 0, row = 0;

        try {
            System.out.print("Enter the file name with extension : ");
            Scanner input = new Scanner(System.in);
            File file = new File(input.nextLine());
            input = new Scanner(file);

            for (int columns = 0; columns < 101; columns++) {
                String input2 = input.nextLine();
                StringTokenizer strToken = new StringTokenizer(input2);
                int count = strToken.countTokens();

                for (int rows = 0; rows < count; rows++) {
                    numbers[columns][rows] = Integer.parseInt((String) strToken.nextElement());// writing values to arrays
                    System.out.println(numbers[columns][rows]);// test 
                }
            }

            input.close();

        } catch (Exception ex) {
            ex.printStackTrace();
        }

        // here someday will be algorithm 

    }
}

**对不起，我的英语很差，我想告诉我想要什么，但这对我来说有点困难。 :(我得到了很多数字文件，我必须找到最长的数字系列，从较小到最大，而不更换数字**

文件“

中的小例子

45 -31 -21 -34 30 -2 12 21 -39 -46 -48 8 15 30 8 -48 29 12 11 -28 40 27 28 -45 2 50 8 28 14 47 -22 -20 27 16 43 -7 35 13 7 15 40 -42 23 -7 7 18 22 13 28 -33 -15 -46 12 -22 31 -33 39 34 -11 45 -25 -25 -50 48 31 -20 -25 -5 5 18 -36 -24 -17 10 24 21 -35 6 19 38 6 44 20 30 -49 -33 -44 9 37 -36 -18 2 -2 35 -2 45 -36 40 26 -42 -17 45 40 -31 -21 33 -4 -50 40 13 -50 11 12 37 -26 38 -31 7 30 4 32 -50 - 7 -40 -12 27 17 -5 -11 41 -1 46 16 16 48 38 -49 10 1 25 39 26 -14 -50“

Answer 1

如果您尝试读取以空格分隔的值，最简单的解决方案可能只是使用Scanner.next或其他next...函数之一（nextLine除外），例如{ {3}}，或您的Scanner.nextInt。）

这些函数使用空格作为分隔符，因此每次后续调用都将返回某些空格之间的下一段文本，并将其转换为适当的类型（如果适用）。

input = new Scanner(file);

for (int rows = 0; rows < numbers.length; rows++){
   for (int columns = 0; columns < numbers[rows].length; columns++){
      numbers[rows][columns] = input.nextDouble(); 
   }
}

如果你希望文件中的每一行都是一行，那么rows循环应该在外面（考虑你要从第0行开始并按照你想要的方式遍历每一列从第0行开始并遍历该行中的每个值。）

这不是特别强大（如果您的数据出现问题，它可能仍然有用，或者可能很难找到问题所在。）

如果你正在寻找更强大的东西，我可能会推荐更像：

for (int rows = 0; rows < numbers.length; rows++){
   String[] split = input.nextLine().split("\\s+"); // \\s+ is 1 or more whitespace characters
   if (split.length != numbers.length) {
      throw new IllegalArgumentException("Line " + rows + " has " + split.length + " columns, but needs " + numbers.length);
   }
   for (int columns = 0; columns < numbers[rows].length; columns++){
      numbers[rows][columns] = Double.parseDouble(split[columns]);
   }
}

在Java 8中，我们可以实现相同的结果：

final int DESIRED_ROW_LENGTH = 101;
for (int rows = 0; rows < numbers.length; rows++){
   numbers[rows] = Arrays.stream(input.nextLine().split("\\s+"))
                       .mapToDouble(Double::parseDouble).toArray();
   if (numbers[rows].length != DESIRED_ROW_LENGTH) {
      throw new IllegalArgumentException("Line " + rows + " has " + numbers[rows].length + " columns, but needs " + DESIRED_ROW_LENGTH);
   }
}

Answer 2

我将为@Dukeling答案提供一个替代*，前提是您实际上正在为最长的数字序列寻找某种算法：

基本上，在读取文件时直接执行，只检查（（列+ 1） - （列）== 1）的每个位置，如果是，则更新字段。

File file = new File("\\\\share\\file\\path\\file.txt");
Scanner sc = new Scanner(file);
int totalCount = 0;
int tempCount = 0;
int tempLineNumber = 1;
int totalLineNumber = 0;
while (sc.hasNextLine()) {
    String[] array = sc.nextLine().split("\\s+");
    for (int i = 0; i < array.length - 1; i++) {
        if (Integer.parseInt(array[i + 1]) - Integer.parseInt(array[i]) == 1) {
            tempCount++;
        }
    }
    if (totalCount < tempCount) {
        totalCount = tempCount;
        totalLineNumber = tempLineNumber;
    }
    tempCount = 0;
    tempLineNumber++;
}
System.out.println("The max longest rising sequence of numbers is: "
        + totalCount + " at line " + totalLineNumber);

_{*我只是快速地将这个例子放在一起，并且很可能有一两个问题，例如缺少边缘情况等}

Answer 3

实际算法发生在一维整数数组上。所以这可以从文件中读取每行。

Path path = Paths.get(input.nextLine());
for (String line : Files.readAllLines(path, Charset.defaultCharset())) {

    // Convert line into numbers:
    String[] words = line.split(" ");
    int[] numbers = new int[words.length];
    for (int i = 0; i < numbers.length; ++i) {
        numbers[i] = Integer.parseInt(words[i]);
    }

    // Find longest sequence in numbers array:
    ...
}

由于此处的其他代码使用文件和扫描程序，我已经给出了Path（文件的新选择），并且文件是一个实用程序类，它有很好的方法，如readAllLines。

虽然你不需要矩阵，但一般不会使用典型的数学排序，而是逐行（按行）：

 for (int row = 0; row < count; rows++) {
     ... read a line
     for (int column = 0; column < 101; column++) {
         numbers[row][column] = ...
         System.out.print(numbers[row][column] + " ");
     }
     System.println();
 }

将文件中的值按空格分隔为多维数组

3 个答案: