แปลงชุดเป็นรายการโดยไม่ต้องสร้างรายการใหม่

ฉันใช้รหัสนี้เพื่อแปลง a Setเป็นList:

Map<String, List<String>> mainMap = new HashMap<>();

for (int i=0; i < something.size(); i++) {
  Set<String> set = getSet(...); //returns different result each time
  List<String> listOfNames = new ArrayList<>(set);
  mainMap.put(differentKeyName, listOfNames);
}

ฉันต้องการหลีกเลี่ยงการสร้างรายการใหม่ในการวนซ้ำแต่ละครั้ง เป็นไปได้ไหม

คุณสามารถใช้List.addAll ()วิธีการ ยอมรับการรวบรวมเป็นอาร์กิวเมนต์และชุดของคุณคือการรวบรวม

List<String> mainList = new ArrayList<String>();
mainList.addAll(set);

แก้ไข:ตอบสนองต่อการแก้ไขของคำถาม
มันเป็นเรื่องง่ายที่จะเห็นว่าถ้าคุณต้องการที่จะมีMapด้วยListในฐานะที่เป็นค่านิยมเพื่อให้มีค่าที่แตกต่าง k, คุณจำเป็นต้องสร้าง k รายการที่แตกต่างกัน
ดังนั้น: คุณไม่สามารถหลีกเลี่ยงการสร้างรายการเหล่านี้ได้ทุกรายการจะต้องถูกสร้างขึ้น

การทำงานที่เป็นไปได้:
ประกาศของคุณMapเป็น a Map<String,Set>หรือMap<String,Collection>แทนและเพียงแค่ใส่ชุดของคุณ

ใช้ Constructor เพื่อแปลง:

List<?> list = new ArrayList<?>(set);

นอกจากนี้จากห้องสมุดรวบรวม Guava คุณสามารถใช้newArrayList(Collection):

Lists.newArrayList([your_set])

นี้จะคล้ายกับคำตอบก่อนหน้านี้จากamitยกเว้นว่าคุณไม่จำเป็นต้องประกาศ (หรือ instanciate) listวัตถุใด ๆ

เราสามารถใช้หนึ่งซับในต่อไปนี้ใน Java 8:

List<String> list = set.stream().collect(Collectors.toList());

นี่คือตัวอย่างเล็ก ๆ น้อย ๆ :

public static void main(String[] args) {
        Set<String> set = new TreeSet<>();
        set.add("A");
        set.add("B");
        set.add("C");
        List<String> list = set.stream().collect(Collectors.toList());
}

ทางออกที่ง่ายที่สุด

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

 return new ArrayList<Long>(mySetVariable);

คุณสามารถใช้การเปลี่ยนแปลงหนึ่งบรรทัดนี้: Arrays.asList(set.toArray(new Object[set.size()]))

Map<String, List> mainMap = new HashMap<String, List>();

for(int i=0; i<something.size(); i++){
  Set set = getSet(...); 
  mainMap.put(differentKeyName, Arrays.asList(set.toArray(new Object[set.size()])));
}  

ฉันจะทำ :

Map<String, Collection> mainMap = new HashMap<String, Collection>();

for(int i=0; i<something.size(); i++){
  Set set = getSet(...); //return different result each time
  mainMap.put(differentKeyName,set);
}

เนื่องจากยังไม่ได้รับการกล่าวถึงจนถึงขณะนี้ใน Java 10 คุณสามารถใช้วิธีการใหม่จากcopyOfโรงงาน:

List.copyOf(set);

จากJavadoc :

ส่งคืนรายการที่ไม่สามารถเปลี่ยนแปลงได้ที่มีองค์ประกอบของคอลเล็กชันที่กำหนดตามลำดับการวนซ้ำ

Java 8 มีตัวเลือกในการใช้สตรีมและคุณสามารถรับรายการจากSet<String> setString:

List<String> stringList = setString.stream().collect(Collectors.toList());

แม้ว่าการใช้งานภายใน ณ ตอนนี้จะเป็นตัวอย่างของArrayList:

public static <T>
    Collector<T, ?, List<T>> toList() {
        return new CollectorImpl<>((Supplier<List<T>>) ArrayList::new, List::add,
                                   (left, right) -> { left.addAll(right); return left; },
                                   CH_ID);
    }

แต่ JDK ไม่รับประกัน ดังที่กล่าวไว้ที่นี่ :

ไม่มีการรับประกันเกี่ยวกับประเภทความไม่แน่นอนความต่อเนื่องของอนุกรมหรือความปลอดภัยของเธรดของรายการที่ส่งคืน หากต้องการการควบคุมมากกว่ารายการที่ส่งคืนให้ใช้ toCollection (ซัพพลายเออร์)

ในกรณีที่คุณต้องการให้แน่ใจเสมอคุณสามารถขออินสแตนซ์ได้โดยเฉพาะดังนี้:

List<String> stringArrayList = setString.stream()
                     .collect(Collectors.toCollection(ArrayList::new));

ฉันสร้างstaticวิธีการง่าย ๆ:

public static <U> List<U> convertSetToList(Set<U> set)
{
    return new ArrayList<U>(set);
}

... หรือถ้าคุณต้องการตั้งค่าชนิดของรายการคุณสามารถใช้:

public static <U, L extends List<U>> List<U> convertSetToList(Set<U> set, Class<L> clazz) throws InstantiationException, IllegalAccessException
{
    L list = clazz.newInstance();
    list.addAll(set);
    return list;
}

เมื่อเร็ว ๆ นี้ฉันพบสิ่งนี้:

ArrayList<T> yourList = Collections.list(Collections.enumeration(yourSet<T>));

เพื่อความสมบูรณ์ ...

บอกว่าคุณจริงๆไม่ต้องการที่จะรักษาMapค่าเป็นLists แต่คุณต้องการที่จะหลีกเลี่ยงการคัดลอกSetลงในListแต่ละครั้ง

ยกตัวอย่างเช่นบางทีคุณอาจจะเรียกฟังก์ชันหนึ่งที่สร้างSetแต่คุณจะผ่านของคุณMap<String, List<String>>ผลไป (ไม่ดีการออกแบบ แต่ออกมาจากมือของคุณ) ฟังก์ชั่นห้องสมุดที่ใช้เวลาเพียงMap<String, List<String>>แม้อย่างใดที่คุณจะรู้ว่าการดำเนินการมันไม่ด้วยLists เท่าเทียมกันบังคับใด ๆCollection(เช่นใด ๆSet) และด้วยเหตุผลบางอย่างคุณจำเป็นต้องหลีกเลี่ยงค่าใช้จ่ายความเร็ว / หน่วยความจำในการคัดลอกแต่ละชุดเป็นรายการ

ในกรณีพิเศษนี้ขึ้นอยู่กับพฤติกรรม (อาจไม่รู้) ฟังก์ชั่นห้องสมุดต้องการออกจากคุณListคุณอาจจะสามารถสร้างList มุมมองในแต่ละชุด โปรดทราบว่านี่ไม่ปลอดภัยโดยเนื้อแท้ (เนื่องจากความต้องการของฟังก์ชั่นห้องสมุดจากแต่ละคนListอาจเปลี่ยนแปลงได้โดยที่คุณไม่ทราบ) ดังนั้นจึงควรเลือกใช้โซลูชันอื่น แต่นี่คือวิธีที่คุณทำ

คุณจะสร้างคลาสที่ใช้Listอินเทอร์เฟซรับSetตัวสร้างและกำหนดให้กับเขตข้อมูลจากนั้นใช้ภายในนั้นSetเพื่อใช้ListAPI (เท่าที่เป็นไปได้และต้องการ)

โปรดทราบว่าพฤติกรรมบางอย่างของรายการคุณจะไม่สามารถเลียนแบบได้โดยไม่ต้องเก็บองค์ประกอบไว้เป็น a Listและพฤติกรรมบางอย่างที่คุณจะเลียนแบบได้เพียงบางส่วนเท่านั้น อีกครั้งคลาสนี้ไม่ใช่การแทนที่ดร็อปดาวน์อย่างปลอดภัยสำหรับLists โดยทั่วไป โดยเฉพาะอย่างยิ่งถ้าคุณรู้ว่ากรณีการใช้งานต้องการการดำเนินการที่เกี่ยวข้องกับดัชนีหรือการตัดทอนListวิธีนี้จะไปทางทิศใต้อย่างรวดเร็ว

public class ListViewOfSet<U> implements List<U> {
    private final Set<U> wrappedSet;
    public ListViewOfSet(Set<U> setToWrap) { this.wrappedSet = setToWrap; }

    @Override public int size() { return this.wrappedSet.size(); }
    @Override public boolean isEmpty() { return this.wrappedSet.isEmpty(); }
    @Override public boolean contains(Object o) { return this.wrappedSet.contains(o); }
    @Override public java.util.Iterator<U> iterator() { return this.wrappedSet.iterator(); }
    @Override public Object[] toArray() { return this.wrappedSet.toArray(); }
    @Override public <T> T[] toArray(T[] ts) { return this.wrappedSet.toArray(ts); }
    @Override public boolean add(U e) { return this.wrappedSet.add(e); }
    @Override public boolean remove(Object o) { return this.wrappedSet.remove(o); }
    @Override public boolean containsAll(Collection<?> clctn) { return this.wrappedSet.containsAll(clctn); }
    @Override public boolean addAll(Collection<? extends U> clctn) { return this.wrappedSet.addAll(clctn); }
    @Override public boolean addAll(int i, Collection<? extends U> clctn) { throw new UnsupportedOperationException(); }
    @Override public boolean removeAll(Collection<?> clctn) { return this.wrappedSet.removeAll(clctn); }
    @Override public boolean retainAll(Collection<?> clctn) { return this.wrappedSet.retainAll(clctn); }
    @Override public void clear() { this.wrappedSet.clear(); }
    @Override public U get(int i) { throw new UnsupportedOperationException(); }
    @Override public U set(int i, U e) { throw new UnsupportedOperationException(); }
    @Override public void add(int i, U e) { throw new UnsupportedOperationException(); }
    @Override public U remove(int i) { throw new UnsupportedOperationException(); }
    @Override public int indexOf(Object o) { throw new UnsupportedOperationException(); }
    @Override public int lastIndexOf(Object o) { throw new UnsupportedOperationException(); }
    @Override public ListIterator<U> listIterator() { throw new UnsupportedOperationException(); }
    @Override public ListIterator<U> listIterator(int i) { throw new UnsupportedOperationException(); }
    @Override public List<U> subList(int i, int i1) { throw new UnsupportedOperationException(); }
}

...
Set<String> set = getSet(...);
ListViewOfSet<String> listOfNames = new ListViewOfSet<>(set);
...

ฉันพบว่ามันใช้งานได้ดีและมีประโยชน์ในการสร้างรายการจากชุด

ArrayList < String > L1 = new ArrayList < String > ();
L1.addAll(ActualMap.keySet());
for (String x: L1) {
    System.out.println(x.toString());
}

Map<String, List> mainMap = new HashMap<String, List>();

for(int i=0; i<something.size(); i++){
  Set set = getSet(...); //return different result each time
  mainMap.put(differentKeyName, new ArrayList(set));
}