主页 / 问题 / 711316
Accepted
golubtsoff
Asked:2020-08-28 10:55:18 +0000 UTC2020-08-28 10:55:18 +0000 UTC

从文件中读取数据的通用方法

  • 772

你好。告诉我如何编写一个从文件中读取数据的通用方法。例如，在一种情况下，您需要计算字符串，在另一种情况下需要计算整数。如何编写这样的方法：

    public static <T> List<T> readFromFile(Path pathIn, TypeValue typeValue){...};

此代码是否正确：

public static List readFromFile(Path pathIn, TypeValue typeValue){
        try(Scanner in = new Scanner(pathIn)) {
            if (typeValue == TypeValue.typeInt) {
                List<Integer> list = new ArrayList<>();
                while (in.hasNextInt()) {
                    list.add(in.nextInt());
                }
                return list;
            } else {
                List<String> list = Files.readAllLines(pathIn);
                return list;
            }
        } catch (IOException e){ 
            return null;
        }
    }

这里pathIn- 数据文件的路径，typeValue- 指定数据的标志（Integer等String）。令人困惑的是它返回一个未参数化的List. 如果数据格式可以不同 - Integer，等Double，通常如何解决从文件读取的任务String？还是应该编写自己的代码来读取每种数据类型？那就有点麻烦了。

java

2 个回答

  1. Best Answer

    Java 8 Stream 和 Lambda 的功能允许您将功能接口传递给方法，该方法将应用于数据流：

    public void start() throws IOException {
    Path path = Paths.get("test");
    List<String> resultStringList = readFile(path, Function.identity());
    List<Integer> resultIntList = readFile(path, Integer::parseInt);
}

public <T> List<T> readFile(Path path, Function<String, T> func) throws IOException {
    return Files.lines(path)
            .map(func)
            .collect(Collectors.toList());
}

    }

    • 4

  2. 还是应该编写自己的代码来读取每种数据类型？

    不是最糟糕的选择：为每种类型编写单独的方法（Scanner例如，他们这样做了）。

    那就有点麻烦了。

    在您的版本中，使用一种而不是几个短方法，其中一个大if方法将包含所有这些方法的代码。

    选择

    您可以将方法包装在接口中并应用多态性：

    //интерфейс
interface ListReader<T> {
    List<T> read(String path);
}

//все общие функции вынесем в отдельный базовый класс
abstract class BaseListReader<T> implements ListReader<T> {
    @Override
    public List<T> read(String path) {
        try (Scanner in = new Scanner(path)) {
            List<T> list = new ArrayList<>();
            while (hasNext(in)) {
                list.add(next(in));
            }
            return list;
        } catch (IOException e) {
            return null;
        }
    }

    abstract boolean hasNext(Scanner in) throws IOException;
    abstract T next(Scanner in) throws IOException;
}

class IntListReader extends BaseListReader<Integer> {
    @Override
    boolean hasNext(Scanner in) throws IOException {
        return in.hasNextInt();
    }
    @Override
    Integer next(Scanner in) throws IOException {
        return in.nextInt();
    }
}

class StringListReader extends BaseListReader<String> {
    @Override
    boolean hasNext(Scanner in) throws IOException {
        return in.hasNext();
    }
    @Override
    String next(Scanner in) throws IOException {
        return in.nextLine();
    }
}

    然后创建一个工厂：

    //Метод для создания
public ListReader createReader(Class clazz) {
    if (clazz == Integer.class) {
        return new IntListReader();
    } else if (clazz == String.class) {
        return new StringListReader();
    }
    throw new IllegalArgumentException("clazz");
}

    在这样的实现中，不同类型的处理将相互分离并与客户端类分离（只有一个接口可以是 public ListReader）。这将允许您将它们与其他应用程序类/重用类分开测试。

    这是否合理需要根据情况来决定。如果代码使用一次，对它的要求不会改变，并且没有严格的质量要求（测试覆盖率，限制方法的复杂性），那么简单地将其分解为单独的方法就足够了。

    返回非参数化列表令人困惑

    此问题未解决（返回 unparameterized ListReader）。解决方案取决于如何使用该方法的结果。如果结果列表被这样处理List<Object>，则该方法可以不进行参数化。如果将来列表中的对象被强制转换为一种类型，那么值得考虑参数化工厂和客户端代码的可能性。

    • 2

相关问题