Danh sách Java 8 <V> vào Bản đồ <K, V>

Tôi muốn dịch Danh sách các đối tượng thành Bản đồ bằng cách sử dụng các luồng và lambd của Java 8.

Đây là cách tôi sẽ viết nó trong Java 7 trở xuống.

private Map<String, Choice> nameMap(List<Choice> choices) {
        final Map<String, Choice> hashMap = new HashMap<>();
        for (final Choice choice : choices) {
            hashMap.put(choice.getName(), choice);
        }
        return hashMap;
}

Tôi có thể thực hiện điều này một cách dễ dàng bằng cách sử dụng Java 8 và ổi nhưng tôi muốn biết làm thế nào để làm điều này mà không có ổi.

Ở ổi:

private Map<String, Choice> nameMap(List<Choice> choices) {
    return Maps.uniqueIndex(choices, new Function<Choice, String>() {

        @Override
        public String apply(final Choice input) {
            return input.getName();
        }
    });
}

Và ổi với Java 8 lambdas.

private Map<String, Choice> nameMap(List<Choice> choices) {
    return Maps.uniqueIndex(choices, Choice::getName);
}

Dựa trên Collectorstài liệu, nó đơn giản như:

Map<String, Choice> result =
    choices.stream().collect(Collectors.toMap(Choice::getName,
                                              Function.identity()));

Nếu khóa của bạn KHÔNG được đảm bảo là duy nhất cho tất cả các thành phần trong danh sách, bạn nên chuyển đổi nó thành một Map<String, List<Choice>>thay vìMap<String, Choice>

Map<String, List<Choice>> result =
 choices.stream().collect(Collectors.groupingBy(Choice::getName));

Sử dụng getName()làm khóa và Choicechính nó là giá trị của bản đồ:

Map<String, Choice> result =
    choices.stream().collect(Collectors.toMap(Choice::getName, c -> c));

Đây là một cái khác trong trường hợp bạn không muốn sử dụng Collector.toMap ()

Map<String, Choice> result =
   choices.stream().collect(HashMap<String, Choice>::new, 
                           (m, c) -> m.put(c.getName(), c),
                           (m, u) -> {});

Hầu hết các câu trả lời được liệt kê, bỏ lỡ một trường hợp khi danh sách có các mục trùng lặp . Trong trường hợp đó có câu trả lời sẽ ném IllegalStateException. Tham khảo mã dưới đây để xử lý trùng lặp danh sách :

public Map<String, Choice> convertListToMap(List<Choice> choices) {
    return choices.stream()
        .collect(Collectors.toMap(Choice::getName, choice -> choice,
            (oldValue, newValue) -> newValue));
  }

Thêm một lựa chọn theo cách đơn giản

Map<String,Choice> map = new HashMap<>();
choices.forEach(e->map.put(e.getName(),e));

Ví dụ: nếu bạn muốn chuyển đổi các trường đối tượng thành bản đồ:

Đối tượng ví dụ:

class Item{
        private String code;
        private String name;

        public Item(String code, String name) {
            this.code = code;
            this.name = name;
        }

        //getters and setters
    }

Và hoạt động chuyển đổi danh sách sang bản đồ:

List<Item> list = new ArrayList<>();
list.add(new Item("code1", "name1"));
list.add(new Item("code2", "name2"));

Map<String,String> map = list.stream()
     .collect(Collectors.toMap(Item::getCode, Item::getName));

Nếu bạn không phiền khi sử dụng các thư viện của bên thứ 3, lib của cyclop- Reac (tiết lộ tôi là cộng tác viên) có các phần mở rộng cho tất cả các loại Bộ sưu tập JDK , bao gồm Danh sách và Bản đồ .

ListX<Choices> choices;
Map<String, Choice> map = choices.toMap(c-> c.getName(),c->c);

Tôi đã cố gắng thực hiện điều này và thấy rằng, bằng cách sử dụng các câu trả lời ở trên, khi sử dụng Functions.identity()khóa cho Bản đồ, sau đó tôi gặp vấn đề với việc sử dụng một phương thức cục bộ như this::localMethodNamethực sự hoạt động vì vấn đề gõ.

Functions.identity()thực sự làm một cái gì đó để gõ trong trường hợp này vì vậy phương thức sẽ chỉ hoạt động bằng cách trả về Objectvà chấp nhận một tham sốObject

Để giải quyết điều này, cuối cùng tôi đã bỏ qua Functions.identity()và sử dụng s->s.

Vì vậy, mã của tôi, trong trường hợp của tôi để liệt kê tất cả các thư mục trong một thư mục và cho mỗi thư mục sử dụng tên của thư mục làm chìa khóa cho bản đồ và sau đó gọi một phương thức với tên thư mục và trả về một bộ sưu tập các mục, trông giống như:

Map<String, Collection<ItemType>> items = Arrays.stream(itemFilesDir.listFiles(File::isDirectory))
.map(File::getName)
.collect(Collectors.toMap(s->s, this::retrieveBrandItems));

Bạn có thể tạo Luồng chỉ mục bằng IntStream và sau đó chuyển đổi chúng thành Bản đồ:

Map<Integer,Item> map = 
IntStream.range(0,items.size())
         .boxed()
         .collect(Collectors.toMap (i -> i, i -> items.get(i)));

Tôi sẽ viết cách chuyển đổi danh sách thành bản đồ bằng cách sử dụng tổng quát và đảo ngược điều khiển . Chỉ là phương pháp phổ quát!

Có lẽ chúng ta có danh sách các số nguyên hoặc danh sách các đối tượng. Vì vậy, câu hỏi là như sau: những gì nên là chìa khóa của bản đồ?

tạo giao diện

public interface KeyFinder<K, E> {
    K getKey(E e);
}

hiện đang sử dụng đảo ngược điều khiển:

  static <K, E> Map<K, E> listToMap(List<E> list, KeyFinder<K, E> finder) {
        return  list.stream().collect(Collectors.toMap(e -> finder.getKey(e) , e -> e));
    }

Ví dụ: nếu chúng ta có các đối tượng của cuốn sách, lớp này là chọn khóa cho bản đồ

public class BookKeyFinder implements KeyFinder<Long, Book> {
    @Override
    public Long getKey(Book e) {
        return e.getPrice()
    }
}

Tôi sử dụng cú pháp này

Map<Integer, List<Choice>> choiceMap = 
choices.stream().collect(Collectors.groupingBy(choice -> choice.getName()));

Map<String, Set<String>> collect = Arrays.asList(Locale.getAvailableLocales()).stream().collect(Collectors
                .toMap(l -> l.getDisplayCountry(), l -> Collections.singleton(l.getDisplayLanguage())));

Điều này có thể được thực hiện theo 2 cách. Hãy để người đó là lớp chúng ta sẽ sử dụng để chứng minh điều đó.

public class Person {

    private String name;
    private int age;

    public String getAge() {
        return age;
    }
}

Hãy để mọi người là danh sách những người được chuyển đổi thành bản đồ

1. Sử dụng foreach đơn giản và biểu thức Lambda trong danh sách

Map<Integer,List<Person>> mapPersons = new HashMap<>();
persons.forEach(p->mapPersons.put(p.getAge(),p));

2.Sử dụng Bộ sưu tập trên Luồng được xác định trong Danh sách đã cho.

 Map<Integer,List<Person>> mapPersons = 
           persons.stream().collect(Collectors.groupingBy(Person::getAge));

Có thể sử dụng các luồng để làm điều này. Để loại bỏ nhu cầu sử dụng rõ ràng Collectors, có thể nhập toMaptĩnh (theo khuyến nghị của Java hiệu quả, phiên bản thứ ba).

import static java.util.stream.Collectors.toMap;

private static Map<String, Choice> nameMap(List<Choice> choices) {
    return choices.stream().collect(toMap(Choice::getName, it -> it));
}

Đây là giải pháp của StreamEx

StreamEx.of(choices).toMap(Choice::getName, c -> c);

Map<String,Choice> map=list.stream().collect(Collectors.toMap(Choice::getName, s->s));

Thậm chí phục vụ mục đích này cho tôi,

Map<String,Choice> map=  list1.stream().collect(()-> new HashMap<String,Choice>(), 
            (r,s) -> r.put(s.getString(),s),(r,s) -> r.putAll(s));

Nếu mọi giá trị mới cho cùng một tên khóa phải được ghi đè:

public Map < String, Choice > convertListToMap(List < Choice > choices) {
    return choices.stream()
        .collect(Collectors.toMap(Choice::getName,
            Function.identity(),
            (oldValue, newValue) - > newValue));
}

Nếu tất cả các lựa chọn phải được nhóm trong một danh sách cho một tên:

public Map < String, Choice > convertListToMap(List < Choice > choices) {
    return choices.stream().collect(Collectors.groupingBy(Choice::getName));
}

List<V> choices; // your list
Map<K,V> result = choices.stream().collect(Collectors.toMap(choice::getKey(),choice));
//assuming class "V" has a method to get the key, this method must handle case of duplicates too and provide a unique key.

Thay thế cho guavamột người có thể sử dụng kotlin-stdlib

private Map<String, Choice> nameMap(List<Choice> choices) {
    return CollectionsKt.associateBy(choices, Choice::getName);
}

String array[] = {"ASDFASDFASDF","AA", "BBB", "CCCC", "DD", "EEDDDAD"};
    List<String> list = Arrays.asList(array);
    Map<Integer, String> map = list.stream()
            .collect(Collectors.toMap(s -> s.length(), s -> s, (x, y) -> {
                System.out.println("Dublicate key" + x);
                return x;
            },()-> new TreeMap<>((s1,s2)->s2.compareTo(s1))));
    System.out.println(map);

Khóa công khai AA {12 = ASDFASDFASDF, 7 = EEDDDAD, 4 = CCCC, 3 = BBB, 2 = AA}