Rumah > Java > javaTutorial > Trik Java Stream lanjutan yang Anda Perlu Tahu

Trik Java Stream lanjutan yang Anda Perlu Tahu

Mary-Kate Olsen
Lepaskan: 2024-11-10 16:19:02
asal
715 orang telah melayarinya

dvanced Java Stream Tricks You Need to Know

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);
    }
}
Salin selepas log masuk
Salin selepas log masuk

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'}}
Salin selepas log masuk

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);
    }
}
Salin selepas log masuk

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'}]}}
Salin selepas log masuk

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);
    }
}
Salin selepas log masuk

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}
Salin selepas log masuk

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);
    }
}
Salin selepas log masuk

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]}
Salin selepas log masuk

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);
    }
}
Salin selepas log masuk

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);
    }
}
Salin selepas log masuk
Salin selepas log masuk

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!

Kenyataan Laman Web ini
Kandungan artikel ini disumbangkan secara sukarela oleh netizen, dan hak cipta adalah milik pengarang asal. Laman web ini tidak memikul tanggungjawab undang-undang yang sepadan. Jika anda menemui sebarang kandungan yang disyaki plagiarisme atau pelanggaran, sila hubungi admin@php.cn
Artikel terbaru oleh pengarang
Tutorial Popular
Lagi>
Muat turun terkini
Lagi>
kesan web
Kod sumber laman web
Bahan laman web
Templat hujung hadapan