Java 8 รายการ <V> ลงในแผนที่ <K, V>

ฉันต้องการแปลรายการวัตถุเป็นแผนที่โดยใช้สตรีมและแลมบ์ดาของ Java 8

นี่คือวิธีที่ฉันจะเขียนใน Java 7 และด้านล่าง

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;
}

ฉันสามารถทำได้โดยใช้ Java 8 และ Guava แต่ฉันอยากรู้วิธีการทำสิ่งนี้โดยไม่ใช้ Guava

ในฝรั่ง

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();
        }
    });
}

และฝรั่งกับ Java 8 lambdas

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

ตามCollectorsเอกสารมันง่ายเหมือน:

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

หากคีย์ของคุณไม่รับประกันว่าจะไม่ซ้ำกันสำหรับองค์ประกอบทั้งหมดในรายการคุณควรแปลงเป็น a Map<String, List<Choice>>แทนMap<String, Choice>

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

ใช้getName()เป็นกุญแจสำคัญและChoiceเป็นค่าของแผนที่:

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

นี่คืออีกกรณีหนึ่งในกรณีที่คุณไม่ต้องการใช้ Collector.toMap ()

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

ส่วนใหญ่ของคำตอบที่ระบุไว้พลาดกรณีเมื่อรายการมีรายการที่ซ้ำกัน IllegalStateExceptionในกรณีที่มีคำตอบที่จะโยน อ้างอิงรหัสด้านล่างเพื่อจัดการรายการที่ซ้ำกันเช่นกัน:

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

อีกหนึ่งตัวเลือกในวิธีที่ง่าย

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

ตัวอย่างเช่นหากคุณต้องการแปลงฟิลด์วัตถุเป็นแผนที่:

วัตถุตัวอย่าง:

class Item{
        private String code;
        private String name;

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

        //getters and setters
    }

และการดำเนินการแปลง List To Map:

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));

หากคุณไม่ทราบใช้ห้องสมุดของบุคคลที่ 3 ของ AOL ไซคลอปส์ทำปฏิกิริยา lib (เปิดเผยผมมีส่วนร่วม) มีส่วนขยายสำหรับทุกJDK เก็บประเภทรวมทั้งรายการและแผนที่

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

ฉันพยายามทำสิ่งนี้และพบว่าการใช้คำตอบข้างต้นเมื่อใช้Functions.identity()สำหรับกุญแจไปยังแผนที่จากนั้นฉันมีปัญหาเกี่ยวกับการใช้วิธีการในท้องถิ่นที่ต้องการthis::localMethodNameใช้งานได้จริงเนื่องจากปัญหาการพิมพ์

Functions.identity()จริง ๆ แล้วทำอะไรบางอย่างกับการพิมพ์ในกรณีนี้ดังนั้นวิธีการจะทำงานโดยกลับมาObjectและยอมรับพารามิเตอร์ของObject

เพื่อแก้ปัญหานี้ฉันลงเอยด้วยการทิ้งFunctions.identity()และใช้s->sแทน

ดังนั้นรหัสของฉันในรายการของฉันไดเรกทอรีทั้งหมดภายในไดเรกทอรีและสำหรับแต่ละคนใช้ชื่อของไดเรกทอรีเป็นกุญแจสำคัญในแผนที่แล้วเรียกวิธีการที่มีชื่อไดเรกทอรีและส่งกลับคอลเลกชันของรายการดูเหมือนว่า:

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

คุณสามารถสร้างสตรีมของดัชนีโดยใช้ IntStream แล้วแปลงเป็นแผนที่:

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

ฉันจะเขียนวิธีการแปลงรายการเพื่อทำแผนที่โดยใช้ยาชื่อสามัญและผกผันของการควบคุม เพียงแค่วิธีการสากล!

บางทีเราอาจมีรายชื่อจำนวนเต็มหรือรายชื่อวัตถุ ดังนั้นคำถามต่อไปนี้: สิ่งที่ควรเป็นกุญแจสำคัญของแผนที่?

สร้างส่วนต่อประสาน

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

ตอนนี้ใช้การควบคุมแบบผกผัน:

  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));
    }

ตัวอย่างเช่นถ้าเรามีวัตถุของหนังสือคลาสนี้คือการเลือกคีย์สำหรับแผนที่

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

ฉันใช้ไวยากรณ์นี้

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())));

สามารถทำได้ 2 วิธี ให้คนเป็นคลาสที่เราจะใช้เพื่อแสดงให้เห็น

public class Person {

    private String name;
    private int age;

    public String getAge() {
        return age;
    }
}

ให้บุคคลเป็นรายชื่อบุคคลที่จะถูกแปลงเป็นแผนที่

1. การใช้งาน foreach แบบง่ายและการแสดงออกของแลมบ์ดาในรายการ

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

2. การใช้ Collector บนสตรีมที่กำหนดในรายการที่กำหนด

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

เป็นไปได้ที่จะใช้สตรีมเพื่อทำสิ่งนี้ ในการลบความต้องการที่จะใช้อย่างชัดเจนCollectorsเป็นไปได้ที่จะนำเข้าtoMapแบบคงที่ (ตามที่แนะนำโดย Effective Java, edition ที่สาม)

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));
}

นี่คือทางออกโดยStreamEx

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

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

ทำหน้าที่นี้ให้ฉันด้วย

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

หากค่าใหม่สำหรับชื่อคีย์เดียวกันจะต้องถูกแทนที่:

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

หากตัวเลือกทั้งหมดต้องถูกจัดกลุ่มในรายการชื่อ:

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.

ทางเลือกguavaหนึ่งสามารถใช้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);

เผยแพร่คีย์ AA = 12 = ASDFASDFASDF, 7 = EEDDDAD, 4 = CCCC, 3 = BBB, 2 = AA}