1. Mencipta Peta untuk Cache Entiti

Caching entiti dalam Peta boleh meningkatkan prestasi dengan mengurangkan keperluan untuk mengambil data berulang kali daripada pangkalan data atau sumber data lain. Dengan Java Streams, anda boleh membuat cache sedemikian dengan mudah.

Contoh Kod

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class User {
    private int id;
    private String name;

    // Constructors, getters, setters
}

public class EntityCacheExample {
    public static void main(String[] args) {
        List<User> users = List.of(
            new User(1, "Alice"),
            new User(2, "Bob"),
            new User(3, "Charlie")
        );

        Map<Integer, User> userCache = users.stream()
            .collect(Collectors.toMap(User::getId, user -> user));

        System.out.println(userCache);
    }
}

Dalam kod di atas, kami menggunakan Collectors.toMap() untuk menukar senarai objek Pengguna kepada Peta yang kuncinya ialah ID pengguna dan nilainya ialah objek Pengguna itu sendiri. Ini berkesan mencipta cache entiti Pengguna.

Keputusan Demo

{1=User{id=1, name='Alice'}, 2=User{id=2, name='Bob'}, 3=User{id=3, name='Charlie'}}

2. Mencipta Peta Bersarang

Peta Bersarang boleh berguna apabila anda perlu mengkategorikan data kepada berbilang peringkat. Sebagai contoh, anda mungkin mahu mengumpulkan pengguna mengikut jabatan mereka dan kemudian mengikut peranan mereka.

Contoh Kod

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class User {
    private String department;
    private String role;
    private String name;

    // Constructors, getters, setters
}

public class NestedMapExample {
    public static void main(String[] args) {
        List<User> users = List.of(
            new User("HR", "Manager", "Alice"),
            new User("IT", "Developer", "Bob"),
            new User("IT", "Manager", "Charlie")
        );

        Map<String, Map<String, List<User>>> nestedMap = users.stream()
            .collect(Collectors.groupingBy(User::getDepartment,
                Collectors.groupingBy(User::getRole)));

        System.out.println(nestedMap);
    }
}

Kod ini menunjukkan cara menggunakan Collectors.groupingBy() untuk membuat Peta bersarang. Peta luar mengumpulkan pengguna mengikut jabatan, manakala Peta dalam mengelompokkan mereka mengikut peranan.

Keputusan Demo

{HR={Manager=[User{name='Alice'}]}, IT={Developer=[User{name='Bob'}], Manager=[User{name='Charlie'}]}}

3. Mencipta Peta dengan Dua Nilai

Kadangkala, anda mungkin mahu menyimpan berbilang atribut untuk satu kunci dalam Peta. Menggunakan Peta
>
boleh menjadi penyelesaian yang berkesan.

Contoh Kod

import java.util.List;
import java.util.Map;
import java.util.AbstractMap.SimpleEntry;
import java.util.stream.Collectors;

class User {
    private int id;
    private String name;
    private int age;

    // Constructors, getters, setters
}

public class MapWithTwoValuesExample {
    public static void main(String[] args) {
        List<User> users = List.of(
            new User(1, "Alice", 30),
            new User(2, "Bob", 25),
            new User(3, "Charlie", 35)
        );

        Map<Integer, Map.Entry<String, Integer>> userMap = users.stream()
            .collect(Collectors.toMap(User::getId, user -> 
                new SimpleEntry<>(user.getName(), user.getAge())));

        System.out.println(userMap);
    }
}

Di sini, kami menggunakan SimpleEntry untuk mencipta Peta dengan dua nilai—nama dan umur—yang dikaitkan dengan setiap ID pengguna.

Keputusan Demo

{1=Alice=30, 2=Bob=25, 3=Charlie=35}

4. Pengelompokan Mengikut dan Pemetaan

Pengumpulan dan pemetaan bersama boleh memudahkan transformasi data yang kompleks, seperti menukar senarai objek kepada Peta berkumpulan di mana setiap kumpulan mengandungi atribut khusus.

Contoh Kod

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class User {
    private String department;
    private String name;

    // Constructors, getters, setters
}

public class GroupingByMappingExample {
    public static void main(String[] args) {
        List<User> users = List.of(
            new User("HR", "Alice"),
            new User("IT", "Bob"),
            new User("HR", "Charlie")
        );

        Map<String, List<String>> groupedMap = users.stream()
            .collect(Collectors.groupingBy(User::getDepartment,
                Collectors.mapping(User::getName, Collectors.toList())));

        System.out.println(groupedMap);
    }
}

Dalam contoh ini, kami mengumpulkan pengguna mengikut jabatan dan kemudian memetakan objek Pengguna kepada nama mereka, mencipta Peta di mana setiap jabatan dikaitkan dengan senarai nama.

Keputusan Demo

{HR=[Alice, Charlie], IT=[Bob]}

5. Pengumpulan Mengikut, Pemetaan, dan Pengurangan

Menggabungkan pengumpulan, pemetaan dan pengurangan membolehkan anda mengagregat data dengan cekap, seperti menjumlahkan nilai atau mencari nilai maksimum dalam setiap kumpulan.

Contoh Kod

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class Transaction {
    private String type;
    private int amount;

    // Constructors, getters, setters
}

public class GroupingByMappingReducingExample {
    public static void main(String[] args) {
        List<Transaction> transactions = List.of(
            new Transaction("Deposit", 100),
            new Transaction("Deposit", 200),
            new Transaction("Withdrawal", 50),
            new Transaction("Withdrawal", 30)
        );

        Map<String, Integer> transactionSums = transactions.stream()
            .collect(Collectors.groupingBy(Transaction::getType,
                Collectors.reducing(0, Transaction::getAmount, Integer::sum)));

        System.out.println(transactionSums);
    }
}

Dalam kod ini, kami mengumpulkan urus niaga mengikut jenis, memetakannya kepada amaunnya, dan kemudian mengurangkan amaun dengan menjumlahkannya. Hasilnya ialah Peta yang menunjukkan jumlah amaun untuk setiap jenis transaksi.

Keputusan Demo

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class User {
    private int id;
    private String name;

    // Constructors, getters, setters
}

public class EntityCacheExample {
    public static void main(String[] args) {
        List<User> users = List.of(
            new User(1, "Alice"),
            new User(2, "Bob"),
            new User(3, "Charlie")
        );

        Map<Integer, User> userCache = users.stream()
            .collect(Collectors.toMap(User::getId, user -> user));

        System.out.println(userCache);
    }
}

6. Kesimpulan

Helah Java Stream termaju ini boleh meningkatkan kecekapan pengekodan dan kebolehbacaan anda dengan ketara. Dengan menguasai teknik ini, anda boleh mengendalikan tugas pemprosesan data yang kompleks dengan mudah. Jika anda mempunyai sebarang pertanyaan atau memerlukan penjelasan lanjut, sila komen di bawah!

Baca siaran lebih lanjut di : 5 Helah Java Stream Lanjutan yang Perlu Anda Tahu

Atas ialah kandungan terperinci Trik Java Stream lanjutan yang Anda Perlu Tahu. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!