J*a处理文本文件：根据首个字段删除重复行并存储

新闻中心 NEWS CENTER

您当前位置：首页 > 新闻中心 > 网络学院

J*a处理文本文件：根据首个字段删除重复行并存储

2025-12-03

浏览次数：次

返回列表

Java处理文本文件：根据首个字段删除重复行并存储

本教程详细介绍了如何使用j*a高效地处理文本文件中的重复行。针对以特定字段（如每行的第一个逗号分隔值）作为重复判断依据的场景，我们将探讨两种基于j*a stream api和`collectors.tomap()`的解决方案：一种直接操作字符串，另一种通过引入领域对象提升代码可读性和可维护性。文章将提供详细的代码示例和实现步骤，帮助开发者准确筛选和存储唯一数据。

在数据处理中，我们经常会遇到需要从文本文件中清除重复记录的场景。与简单的行重复不同，有时重复的定义是基于行内某个特定字段的值。例如，在一个包含公司信息的文本文件中，如果多行记录的第一个字段（如公司ID）相同，即使其他字段不同，我们也可能希望将其视为重复并只保留其中一条。本教程将详细介绍如何使用J*a实现这一功能，并将处理后的唯一记录存储到ArrayList中。

1. 理解问题：基于特定字段的重复删除

考虑以下文本文件内容：

123456,greenwitch street,near dominos store,Opp sandwitch company,Neyork,US,876890
123480,Postwitch street,near KFC store,Opp masala company,Newyork,US,876891
123456,Newyork street,near 100th *enue,King master company,Texas,US,10005

在这个例子中，第一行和第三行的起始值（123456）是相同的。我们的目标是删除第三行，因为它的第一个字段与第一行重复。J*a Stream API的distinct()方法通常用于删除完全相同的对象或字符串，但对于这种基于部分字段的重复判断则无能为力。

2. 解决方案一：使用Stream API的Collectors.toMap()处理字符串

Collectors.toMap()是解决这类问题的强大工具。它允许我们定义如何从流中的每个元素生成一个键（Key），一个值（Value），以及当出现重复键时如何处理（mergeFunction）。

2.1 核心思路

定义键（Key）：将每行的第一个逗号分隔的值作为键。
定义值（Value）：将整行字符串作为值。
处理重复键（Merge Function）：当遇到重复的键时，我们需要决定保留哪个值。在此场景下，通常是保留第一次遇到的值。

2.2 代码实现

假设我们已经将文本文件的所有行读取到一个List中：

import j*a.util.List;
import j*a.util.function.Function;
import j*a.util.stream.Collectors;

public class DeduplicateTextFile {

    public static void main(String[] args) {
        List<String> sourceList = List.of(
            "123456,greenwitch street,near dominos store,Opp sandwitch company,Neyork,US,876890",
            "123480,Postwitch street,near KFC store,Opp masala company,Newyork,US,876891",
            "123456,Newyork street,near 100th *enue,King master company,Texas,US,10005"
        );

        List<String> uniqueList = sourceList.stream()
            .collect(Collectors.toMap(
                str -> str.substring(0, str.indexOf(',')), // keyMapper: 提取第一个逗号前的子字符串作为键
                Function.identity(),                       // valueMapper: 将整个字符串作为值
                (existing, replacement) -> existing        // mergeFunction: 如果键重复，保留已存在的（即第一次遇到的）值
            ))
            .values()                                      // 获取Map中所有的值（即唯一的行字符串）
            .stream()
            .toList();                                     // 将结果收集到List中

        System.out.println("去重后的列表 (字符串):");
        uniqueList.forEach(System.out::println);
    }
}

代码解释：

str -> str.substring(0, str.indexOf(','))：这是一个keyMapper函数，它从当前字符串str中提取第一个逗号之前的部分作为Map的键。
Function.identity()：这是一个valueMapper函数，它表示将流中的当前元素（即整个字符串）作为Map的值。
(existing, replacement) -> existing：这是一个mergeFunction函数，当keyMapper生成了重复的键时，它会被调用。existing是Map中已经存在的值，replacement是新尝试插入的值。这里我们选择保留existing，意味着Map中只会保留第一个具有该键的元素。
.values().stream().toList()：Collectors.toMap()的结果是一个Map。为了得到一个List，我们需要获取Map中所有的值，然后将其转换回流并收集成列表。

3. 解决方案二：结合领域对象提升代码质量

直接操作字符串在简单场景下是可行的，但当数据结构变得复杂或需要对字段进行更多操作时，引入领域对象（Domain Object）会显著提高代码的可读性、可维护性和健壮性。

3.1 定义领域对象

我们可以创建一个Company类来封装每行数据。为了简化代码，这里使用Lombok的@Getter和@Builder注解。

独响

一个轻笔记+角色扮演的app

249 查看详情

import lombok.Builder;
import lombok.Getter;

@Builder
@Getter
public class Company {
    private long id;
    private String street;
    private String locationDescription;
    private String companyName;
    private String state;
    private String country;
    private String zipCode;

    /**
     * 将一行字符串解析为Company对象
     * @param line 待解析的字符串
     * @return 解析后的Company对象
     */
    public static Company parse(String line) {
        String[] arr = line.split(",");
        if (arr.length < 7) {
            throw new IllegalArgumentException("Invalid line format: " + line);
        }
        return Company.builder()
            .id(Long.parseLong(arr[0]))
            .street(arr[1]) // 补充street字段
            .locationDescription(arr[2])
            .companyName(arr[3])
            .state(arr[4])
            .country(arr[5])
            .zipCode(arr[6])
            .build();
    }

    @Override
    public String toString() {
        return id + "," + street + "," + locationDescription + "," + companyName + "," + state + "," + country + "," + zipCode;
    }
}

注意：

需要添加Lombok依赖到项目中。
parse方法中加入了简单的长度检查，以避免ArrayIndexOutOfBoundsException。
为了方便打印和查看，重写了toString()方法。

3.2 使用领域对象进行去重

有了Company类，去重逻辑将更加清晰：

import j*a.util.List;
import j*a.util.function.Function;
import j*a.util.stream.Collectors;

// 假设Company类已定义如上

public class DeduplicateWithDomainObject {

    public static void main(String[] args) {
        List<String> sourceList = List.of(
            "123456,greenwitch street,near dominos store,Opp sandwitch company,Neyork,US,876890",
            "123480,Postwitch street,near KFC store,Opp masala company,Newyork,US,876891",
            "123456,Newyork street,near 100th *enue,King master company,Texas,US,10005"
        );

        List<Company> uniqueCompanies = sourceList.stream()
            .map(Company::parse)                           // 将每行字符串解析为Company对象
            .collect(Collectors.toMap(
                Company::getId,                            // keyMapper: 使用Company对象的id作为键
                Function.identity(),                       // valueMapper: 将Company对象本身作为值
                (existing, replacement) -> existing        // mergeFunction: 如果id重复，保留已存在的Company对象
            ))
            .values()
            .stream()
            .toList();

        System.out.println("\n去重后的列表 (Company对象):");
        uniqueCompanies.forEach(System.out::println);
    }
}

代码解释：

.map(Company::parse)：将List中的每个字符串通过Company.parse()方法转换为Company对象流。
Company::getId：作为keyMapper，直接使用Company对象的id属性作为键，这比从字符串中截取更加直观和安全。
其余部分与字符串处理方法类似，最终得到的是一个List。

4. 文件读取与错误处理

在实际应用中，sourceList通常是通过读取文件获得的。以下是一个简单的文件读取示例：

import j*a.io.IOException;
import j*a.nio.file.Files;
import j*a.nio.file.Paths;
import j*a.util.List;
import j*a.util.stream.Collectors;

public class FileReaderExample {

    public static List<String> readLinesFromFile(String filePath) throws IOException {
        return Files.lines(Paths.get(filePath))
                    .collect(Collectors.toList());
    }

    public static void main(String[] args) {
        String filePath = "data.txt"; // 替换为你的文件路径
        // 假设data.txt文件内容如示例所示

        try {
            List<String> allLines = readLinesFromFile(filePath);
            // 接下来可以将allLines传递给上述的去重方法
            System.out.println("从文件读取的行数: " + allLines.size());
            // ... 进行去重操作
        } catch (IOException e) {
            System.err.println("读取文件时发生错误: " + e.getMessage());
        }
    }
}

在Company.parse()方法中，Long.parseLong()和line.split(",")都可能抛出异常（如NumberFormatException或ArrayIndexOutOfBoundsException），因此在实际生产代码中，应加入更完善的异常处理机制，例如使用try-catch块捕获并记录错误，或者返回Optional。

5. 总结

本文介绍了两种在J*a中根据特定字段删除文本文件重复行的有效方法。

直接操作字符串：适用于简单的数据结构和快速实现。利用Collectors.toMap()的keyMapper、valueMapper和mergeFunction参数，可以灵活地定义去重逻辑。
结合领域对象：对于复杂的数据结构和需要长期维护的项目，将字符串解析为领域对象是更推荐的做法。它能显著提高代码的可读性、类型安全性和可维护性，并使业务逻辑更加清晰。

无论选择哪种方法，J*a Stream API都提供了强大且简洁的工具来处理这类数据去重任务。在实际应用中，请根据具体需求和项目复杂性选择最合适的方案，并务必考虑文件I/O和潜在的解析错误处理。

以上就是J*a处理文本文件：根据首个字段删除重复行并存储的详细内容，更多请关注其它相关文章！

# 首个 # 大兴区常规网站优化记录 # 东莞快速seo哪家好 # 茂名网站建设的详细策划 # 大马戏团的营销推广方案 # 在局网站作风建设 # 惠州整合营销网络推广 # 单品如何搞营销推广呢 # 谷歌网seo的工作内容 # 高级网站制作推广方案 # seo营销的应用案例 # 详细介绍 # 这类 # 将其 # 两种 # java # 是一个 # 这是一个 # 数据结构 # 文本文件 # 第一个 # 回流 # 代码可读性 # 字符串解析 # java实现 # stream # ai # 工具 # app