Java 8의 맵 목록

Java 8의 맵 목록

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

그리고 자바8 람다를 곁들인 과바.

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

문서에 따르면 다음과 같이 단순합니다.

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

키가 목록의 모든 요소에 대해 고유하다고 보장되지 않는 경우 키를 다음과 같이 변환해야 합니다.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));

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

서드파티 라이브러리를 사용해도 괜찮으시다면 AOL의 cyclops-react lib(I am inclosure I am a contributor)에는 목록 및 맵을 포함한 모든 JDK 컬렉션 유형에 대한 확장 기능이 있습니다.

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

IntStream을 사용하여 인덱스의 스트림을 작성한 후 Map으로 변환할 수 있습니다.

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

이 작업을 수행하려고 했는데 위의 답변을 사용하여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));

제네릭스와 컨트롤의 반전을 사용하여 리스트를 맵으로 변환하는 방법을 씁니다.범용적인 방법!

정수 목록이나 객체 목록이 있을 수 있습니다.그래서 질문은 다음과 같습니다. 지도의 열쇠는 무엇입니까?

인터페이스 생성

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

예를 들어 book 객체가 있는 경우 이 클래스는 맵의 키를 선택합니다.

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

이것은 두 가지 방법으로 할 수 있습니다.우리가 그것을 시연하기 위해 사용하는 수업으로 사람을 두어라.

public class Person {

    private String name;
    private int age;

    public String getAge() {
        return age;
    }
}

사람을 지도에 변환하는 사람의 리스트로 합니다.

1. 목록의 단순 포어치 및 람다 표현식 사용

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

2. 지정된 목록에 정의된 스트림에서 수집기를 사용합니다.

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

스트림을 사용하여 이 작업을 수행할 수 있습니다.으로 「」를 사용할 .Collectors, Import가 합니다.toMap(유효한 Java, 3★★★★)

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

또 다른 가능성은 아직 댓글에 있습니다.

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

하위 객체의 매개 변수를 Key로 사용하는 경우 유용합니다.

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

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.

「 」의 guavakotlin-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}

언급URL : https://stackoverflow.com/questions/20363719/java-8-listv-into-mapk-v