Java 8如何用Streams替代循环处理列表对象并转换分类？

Absolutely! Java 8 Streams are perfect for replacing this kind of iterative logic with cleaner, more declarative code. Let's break this down with concrete examples tailored to your needs.

First, Let's Define Our Example POJOs #

Since you didn't share your exact class structures, I'll use realistic placeholder classes that match your description:

// Enum to represent the category of each object
enum Category { PERSON, CHILDREN }

// Our target Person class
class Person {
    private String name;
    private Category category;

    // Constructor, getters, setters
    public Person(String name, Category category) {
        this.name = name;
        this.category = category;
    }

    // Getter for category (needed for grouping)
    public Category getCategory() {
        return category;
    }

    // Other getters/setters as needed
}

// The Children class we need to convert to Person
class Children {
    private String name;
    private int age;

    // Constructor, getters
    public Children(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Method to convert a Children instance to Person
    public Person toPerson() {
        // Map Children fields to Person; set category to PERSON
        return new Person(this.name, Category.PERSON);
    }
}

Your Original For-Loop Logic (For Reference) #

Let's assume your existing code looks something like this:

List<Object> originalList = // Your list containing Person and Children objects
Map<Category, List<Person>> groupedResults = new HashMap<>();

for (Object obj : originalList) {
    Person person;
    if (obj instanceof Children) {
        // Convert Children to Person
        person = ((Children) obj).toPerson();
    } else if (obj instanceof Person) {
        // Keep Person as-is
        person = (Person) obj;
    } else {
        // Skip or handle other types as needed
        continue;
    }

    // Add to the appropriate group in the map
    groupedResults.computeIfAbsent(person.getCategory(), k -> new ArrayList<>()).add(person);
}

// Get the final list of Person objects (including converted Children)
List<Person> personList = groupedResults.getOrDefault(Category.PERSON, Collections.emptyList());

Stream-Based Alternative #

Here's how to rewrite this with Java 8 Streams, making the code more concise and readable:

import java.util.*;
import java.util.stream.Collectors;

List<Object> originalList = // Your input list

// Step 1: Convert all valid objects to Person, then group by Category
Map<Category, List<Person>> groupedMap = originalList.stream()
    // Convert each object to Person (or null for unhandled types)
    .map(obj -> {
        if (obj instanceof Children) {
            return ((Children) obj).toPerson();
        } else if (obj instanceof Person) {
            return (Person) obj;
        }
        // Return null for types we don't want to process
        return null;
    })
    // Filter out any null values (unhandled types)
    .filter(Objects::nonNull)
    // Group the Person objects by their Category
    .collect(Collectors.groupingBy(Person::getCategory));

// If you need just the list of Person-category objects (including converted Children)
List<Person> finalPersonList = groupedMap.getOrDefault(Category.PERSON, Collections.emptyList());

Key Explanations #

Let's break down what each part of the Stream does:

• stream(): Converts your input list into a Stream, enabling declarative operations.
• map(): Transforms each element—converting Children to Person and passing through Person objects directly. Unhandled types return null.
• filter(Objects::nonNull): Removes any null values from the stream to avoid polluting our final groups.
• collect(Collectors.groupingBy(Person::getCategory)): Groups the processed Person objects into a Map<Category, List<Person>>, which is perfect for your UI grouping requirement.

Bonus: Ordered Grouping (If Needed) #

If you need the groups to maintain the order of elements from the original list, use a LinkedHashMap for grouping:

Map<Category, List<Person>> orderedGroupedMap = originalList.stream()
    .map(...) // Same as before
    .filter(...) // Same as before
    .collect(Collectors.groupingBy(
        Person::getCategory,
        LinkedHashMap::new, // Preserve insertion order
        Collectors.toList()
    ));

内容的提问来源于stack exchange，提问作者Srinivas Lakshman