JavaFX ObservableList中自定义对象属性计数教程

本教程详细介绍了如何在javafx的`observablelist`中，高效统计自定义对象某个属性（如`id`）的出现次数。文章将演示两种主要方法：传统的迭代结合`hashmap`实现计数，以及更现代、简洁的java stream api结合`collectors.groupingby`和`counting()`进行聚合统计，并提供详细代码示例和解释，帮助开发者选择最适合其场景的解决方案。

在Java应用程序开发中，尤其是在使用JavaFX构建UI时，经常会遇到需要处理包含自定义对象的列表数据。一个常见的需求是统计列表中某个特定属性（例如一个对象的ID）的出现频率。本文将以ObservableList为例，深入探讨如何有效地实现这一目标。

1. 定义自定义类与数据准备

首先，我们需要定义一个简单的自定义类CustomClass，它包含我们将要统计的属性。

public class CustomClass {
    public String id;
    public String name;

    // 建议添加构造函数和getter/setter方法以遵循良好的Java实践
    public CustomClass(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "CustomClass{" +
               "id='" + id + '\'' +
               ", name='" + name + '\'' +
               '}';
    }
}

接下来，我们模拟一个ObservableList的创建和填充过程。这通常涉及到从文件、数据库或其他数据源读取数据并将其封装到自定义对象中。

import javafx.collections.FXCollections;
import javafx.collections.ObservableList;

import java.util.ArrayList;
import java.util.List;

public class DataInitializer {

    public static ObservableList initializeList() {
        ObservableList list = FXCollections.observableArrayList();

        // 模拟从文件读取的行数据
        List rawLines = new ArrayList<>();
        rawLines.add("1/data1");
        rawLines.add("1/data2");
        rawLines.add("1/data3");
        rawLines.add("2/data1");
        rawLines.add("2/data2");
        rawLines.add("3/dataA");
        rawLines.add("1/data4"); // 再次出现id=1

        for (String s : rawLines) {
            String[] parts = s.split("/");
            if (parts.length == 2) {
                list.add(new CustomClass(parts[0], parts[1]));
            }
        }
        return list;
    }

    public static void main(String[] args) {
        ObservableList myCustomList = initializeList();
        System.out.println("初始列表内容:");
        myCustomList.forEach(System.out::println);
        // 预期输出:
        // CustomClass{id='1', name='data1'}
        // CustomClass{id='1', name='data2'}
        // CustomClass{id='1', name='data3'}
        // CustomClass{id='2', name='data1'}
        // CustomClass{id='2', name='data2'}
        // CustomClass{id='3', name='dataA'}
        // CustomClass{id='1', name='data4'}
    }
}

2. 传统迭代方法实现计数

最直观的方法是遍历ObservableList，并使用一个HashMap来存储每个id及其对应的计数。当遍历到每个CustomClass对象时，我们检查其id是否已存在于HashMap中。如果存在，则将其计数加一；如果不存在，则将其添加进去并初始化计数为一。

立即学习“Java免费学习笔记（深入）”；

import javafx.collections.ObservableList;
import java.util.HashMap;
import java.util.Map;

public class CountItemsIterative {

    public static Map countByIdIterative(ObservableList list) {
        Map idCounts = new HashMap<>();
        for (CustomClass item : list) {
            String id = item.getId(); // 使用getter方法获取id
            idCounts.put(id, idCounts.getOrDefault(id, 0) + 1);
        }
        return idCounts;
    }

    public static void main(String[] args) {
        ObservableList myCustomList = DataInitializer.initializeList();
        Map counts = countByIdIterative(myCustomList);

        System.out.println("\n迭代方法计数结果:");
        counts.forEach((id, count) -> System.out.println("id=" + id + ", count=" + count));
        // 预期输出:
        // id=1, count=4
        // id=2, count=2
        // id=3, count=1
    }
}

代码解析：

• HashMap idCounts：用于存储id（键）和其出现次数（值）。
• for (CustomClass item : list)：标准的增强for循环，遍历ObservableList中的每个CustomClass对象。
• item.getId()：获取当前对象的id值。
• idCounts.put(id, idCounts.getOrDefault(id, 0) + 1)：这是核心逻辑。
  • getOrDefault(id, 0)：尝试获取id对应的当前计数。如果id不存在，则返回默认值0。
  • 然后将获取到的值加1，并使用put方法更新或添加id及其新计数。

这种方法简单直观，易于理解，对于中小型数据集而言性能良好。

3. 使用Java Stream API进行高效计数

Java 8引入的Stream API提供了一种更函数式、更简洁的方式来处理集合数据。对于计数和分组这类操作，Stream API结合Collectors类提供了非常强大的工具。我们可以使用groupingBy收集器来根据id对对象进行分组，然后使用counting()作为下游收集器来统计每个组的大小。

Powtoon

AI创建令人惊叹的动画短片及简报

下载

import javafx.collections.ObservableList;
import java.util.Map;
import java.util.stream.Collectors;

public class CountItemsStream {

    public static Map countByIdStream(ObservableList list) {
        return list.stream()
                   .collect(Collectors.groupingBy(
                       CustomClass::getId, // 根据CustomClass对象的getId方法返回值进行分组
                       Collectors.counting() // 对每个分组中的元素进行计数
                   ));
    }

    public static void main(String[] args) {
        ObservableList myCustomList = DataInitializer.initializeList();
        Map counts = countByIdStream(myCustomList);

        System.out.println("\nStream API方法计数结果:");
        counts.forEach((id, count) -> System.out.println("id=" + id + ", count=" + count));
        // 预期输出与迭代方法相同:
        // id=1, count=4
        // id=2, count=2
        // id=3, count=1
    }
}

代码解析：

• list.stream()：将ObservableList转换为一个Stream。
• .collect(Collectors.groupingBy(classifier, downstreamCollector))：这是Stream API中用于分组和聚合的核心方法。
  • CustomClass::getId：这是一个方法引用，作为classifier（分类器）。它告诉groupingBy如何从每个CustomClass对象中提取用于分组的键（即id）。groupingBy会根据这个键将所有具有相同id的对象收集到一个列表中。
  • Collectors.counting()：这是downstreamCollector（下游收集器）。它应用于每个分组后的列表，对列表中的元素进行计数，并返回一个Long类型的结果。 最终，collect方法会返回一个Map，其中键是id，值是该id出现的总次数。

Stream API的优势：

• 简洁性： 代码更紧凑，意图更明确。
• 可读性： 对于熟悉函数式编程的开发者来说，其流程更易于理解。
• 并行化： Stream API可以很容易地通过.parallelStream()实现并行处理，对于大规模数据集可以提升性能。

4. 结果展示与注意事项

无论采用哪种方法，最终都会得到一个Map，其中键是id，值是对应的计数。我们可以通过遍历这个Map来打印或进一步处理结果。

// 假设 counts 是通过上述任一方法获得的 Map 或 Map
public static void printCounts(Map counts) {
    System.out.println("最终统计结果:");
    counts.forEach((id, count) -> {
        System.out.println("id=" + id + ", count=" + count);
    });
}

// 示例调用
// Map iterativeCounts = CountItemsIterative.countByIdIterative(DataInitializer.initializeList());
// printCounts(iterativeCounts);

// Map streamCounts = CountItemsStream.countByIdStream(DataInitializer.initializeList());
// printCounts(streamCounts);

注意事项：

1. JavaFX无关性： 值得注意的是，本文讨论的计数逻辑是纯粹的Java集合操作，与JavaFX的UI组件或生命周期本身并无直接关联。ObservableList在此处仅仅作为一个普通的List来使用。如果你需要在UI中实时显示这些计数并响应列表变化，那么可能需要进一步结合JavaFX的绑定和监听机制。
2. 性能考量： 对于小型到中型数据集，迭代方法和Stream API方法的性能差异通常可以忽略不计。但对于非常大的数据集，Stream API在并行处理方面的潜力可能会带来显著的性能优势。
3. 可读性与团队熟悉度： 选择哪种方法也应考虑团队对Java 8 Stream API的熟悉程度。传统迭代方法对于所有Java开发者都易于理解，而Stream API可能需要一定的学习曲线。
4. 自定义类的equals()和hashCode()： 如果你的计数逻辑不仅仅是基于单个属性（如id），而是基于整个CustomClass对象的相等性，那么务必在CustomClass中正确重写equals()和hashCode()方法。然而，对于本教程中基于特定属性id的计数，则无需重写这两个方法。

总结

本教程详细展示了如何在Java中，特别是处理ObservableList时，统计自定义对象中特定属性的出现次数。我们探讨了两种主要方法：

1. 传统迭代方法：利用HashMap手动遍历列表，根据id进行增量计数。这种方法直观易懂，适用于各种场景。
2. Java Stream API方法：利用stream().collect(Collectors.groupingBy(classifier, downstreamCollector))，以更声明式和简洁的方式实现分组和计数。这种方法在代码简洁性和处理大规模数据时的并行化潜力方面具有优势。

根据你的项目需求、团队熟悉度以及性能要求，可以选择最适合的方法来实现你的计数逻辑。