ජාවා 8 ලැයිස්තුව <V> සිතියමට <K, V>

ජාවා 8 හි ධාරාවන් සහ ලැම්බඩාස් භාවිතා කරමින් සිතියමකට වස්තු ලැයිස්තුවක් පරිවර්තනය කිරීමට මට අවශ්‍යය.

ජාවා 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;
}

ජාවා 8 සහ ගුවා භාවිතයෙන් මට මෙය පහසුවෙන් ඉටු කර ගත හැකි නමුත් ගුවා නොමැතිව මෙය කරන්නේ කෙසේදැයි දැන ගැනීමට මම කැමතියි.

ගුවා හි:

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

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

ඔබට 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 හි සයික්ලොප්ස්-ප්‍රතික්‍රියා ලිබ් (මම දායකයෙකු බව අනාවරණය කිරීම) ලැයිස්තු සහ සිතියම ඇතුළුව සියලුම JDK එකතු කිරීමේ වර්ග සඳහා දිගු ඇත .

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

ඔබට IntStream භාවිතයෙන් දර්ශක ප්‍රවාහයක් සාදා ඒවා සිතියමකට පරිවර්තනය කළ හැකිය:

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

මම භාවිතා සිතියම්ගත ලැයිස්තුව පරිවර්තනය කරන ආකාරය ලියන්න ඇත generics හා පාලනය සඳහා ප්රතිලෝම . හුදෙක් විශ්ව ක්රමය!

සමහර විට අපට පූර්ණ සංඛ්‍යා ලැයිස්තුවක් හෝ වස්තු ලැයිස්තුවක් තිබේ . එබැවින් ප්‍රශ්නය පහත දැක්වේ: සිතියමේ යතුර කුමක් විය යුතුද ?

අතුරු මුහුණතක් සාදන්න

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. ලැයිස්තුවේ සරල පුරෝකථනය සහ ලැම්බඩා ප්‍රකාශනය භාවිතා කිරීම

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, toMapසංඛ්‍යානමය වශයෙන් ආනයනය කළ හැකිය (Java ලදායී ජාවා නිර්දේශිත පරිදි, තෙවන සංස්කරණය).

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 භාවිතා කළ හැකිය

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}