cầu dẹt một bộ sưu tập

Question

Nói rằng tôi có một Map<? extends Object, List<String>>

tôi có thể nhận các giá trị của bản đồ một cách dễ dàng đủ, và lặp trên nó để sản xuất một đơn List<String>.

for (List<String> list : someMap.values()) { 
     someList.addAll(list); 
    } 

Có cách nào để làm phẳng nó trong một cảnh không?

List<String> someList = SomeMap.values().flatten(); 

Answer 1

Nếu bạn đang sử dụng Java 8, bạn có thể làm một cái gì đó như thế này:

someMap.values().forEach(someList::addAll); 

Answer 2

Không, không có phương pháp ngắn hơn. Bạn phải sử dụng một vòng lặp.

Cập nhật tháng 4 năm 2014: Java 8 cuối cùng cũng đã xuất hiện. Trong phiên bản mới, bạn có thể sử dụng phương thức Iterable.forEach để đi bộ qua bộ sưu tập mà không sử dụng vòng lặp rõ ràng.

Cập nhật tháng 11 năm 2017: Tìm thấy câu hỏi này một cách tình cờ khi tìm kiếm giải pháp hiện đại. Kết thúc đi với reduce:

someMap.values().stream().reduce(new ArrayList(), (accum, list) -> { 
    accum.addAll(list); 
    return accum; 
}): 

Điều này tránh phụ thuộc vào trạng thái bên ngoài có thể thay đổi các forEach(someList::addAll) overhead của flatMap(List::stream).

Answer 3

Nếu bạn chỉ muốn lặp qua các giá trị, bạn có thể tránh tất cả những phương pháp addAll.

Tất cả bạn phải làm là viết một lớp mà đóng gói đồ của mình, và điều đó thực hiện các Iterator:

public class ListMap<K,V> implements Iterator<V> 
{ 
    private final Map<K,List<V>> _map; 
    private Iterator<Map.Entry<K,List<V>>> _it1 = null; 
    private Iterator<V> _it2 = null; 

    public ListMap(Map<K,List<V>> map) 
    { 
    _map = map; 
    _it1 = map.entrySet().iterator(); 
    nextList(); 
    } 

    public boolean hasNext() 
    { 
    return _it2!=null && _it2.hasNext(); 
    } 

    public V next() 
    { 
    if(_it2!=null && _it2.hasNext()) 
    { 
     return _it2.next(); 
    } 
    else 
    { 
     throw new NoSuchElementException(); 
    } 
    nextList(); 
    } 

    public void remove() 
    { 
    throw new NotImplementedException(); 
    } 

    private void nextList() 
    { 
    while(_it1.hasNext() && !_it2.hasNext()) 
    { 
     _it2 = _it1.next().value(); 
    } 
    } 
} 

Answer 4

Nếu bạn đang sử dụng Eclipse Collections, bạn có thể sử dụng Iterate.flatten().

MutableMap<String, MutableList<String>> map = Maps.mutable.empty(); 
map.put("Even", Lists.mutable.with("0", "2", "4")); 
map.put("Odd", Lists.mutable.with("1", "3", "5")); 
MutableList<String> flattened = Iterate.flatten(map, Lists.mutable.empty()); 
Assert.assertEquals(
    Lists.immutable.with("0", "1", "2", "3", "4", "5"), 
    flattened.toSortedList()); 

flatten() là trường hợp đặc biệt của tổng quát hơn RichIterable.flatCollect().

MutableList<String> flattened = 
    map.flatCollect(x -> x, Lists.mutable.empty()); 

Lưu ý: Tôi là người cam kết cho Bộ sưu tập Eclipse.

Answer 5

Sử dụng Java 8 và nếu bạn không muốn nhanh chóng một trường hợp List một mình, giống như trong các gợi ý (và được chấp nhận) giải pháp

someMap.values().forEach(someList::addAll); 

Bạn có thể làm tất cả bằng cách truyền với tuyên bố này:

List<String> someList = map.values().stream().flatMap(c -> c.stream()).collect(Collectors.toList()); 

Bằng cách này, điều thú vị cần biết, trên Java 8 phiên bản được chấp nhận có vẻ thực sự là nhanh nhất. Nó có khoảng thời gian giống như

for (List<String> item : someMap.values()) ... 

và nhanh hơn so với giải pháp truyền trực tuyến thuần túy. Đây là mã kiểm tra nhỏ của tôi. Tôi rõ ràng không đặt tên cho nó chuẩn để tránh các cuộc thảo luận kết quả của sai sót điểm chuẩn. ;) Tôi làm tất cả các bài kiểm tra hai lần để hy vọng có được một phiên bản biên dịch đầy đủ.

Map<String, List<String>> map = new HashMap<>(); 
    long millis; 

    map.put("test", Arrays.asList("1", "2", "3", "4")); 
    map.put("test2", Arrays.asList("10", "20", "30", "40")); 
    map.put("test3", Arrays.asList("100", "200", "300", "400")); 

    int maxcounter = 1000000; 

    System.out.println("1 stream flatmap"); 
    millis = System.currentTimeMillis(); 
    for (int i = 0; i < maxcounter; i++) { 
     List<String> someList = map.values().stream().flatMap(c -> c.stream()).collect(Collectors.toList()); 
    } 
    System.out.println(System.currentTimeMillis() - millis); 

    System.out.println("1 parallel stream flatmap"); 
    millis = System.currentTimeMillis(); 
    for (int i = 0; i < maxcounter; i++) { 
     List<String> someList = map.values().parallelStream().flatMap(c -> c.stream()).collect(Collectors.toList()); 
    } 
    System.out.println(System.currentTimeMillis() - millis); 

    System.out.println("1 foreach"); 
    millis = System.currentTimeMillis(); 
    for (int i = 0; i < maxcounter; i++) { 
     List<String> mylist = new ArrayList<String>(); 
     map.values().forEach(mylist::addAll); 
    } 
    System.out.println(System.currentTimeMillis() - millis);   

    System.out.println("1 for"); 
    millis = System.currentTimeMillis(); 
    for (int i = 0; i < maxcounter; i++) { 
     List<String> mylist = new ArrayList<String>(); 
     for (List<String> item : map.values()) { 
      mylist.addAll(item); 
     } 
    } 
    System.out.println(System.currentTimeMillis() - millis); 


    System.out.println("2 stream flatmap"); 
    millis = System.currentTimeMillis(); 
    for (int i = 0; i < maxcounter; i++) { 
     List<String> someList = map.values().stream().flatMap(c -> c.stream()).collect(Collectors.toList()); 
    } 
    System.out.println(System.currentTimeMillis() - millis); 

    System.out.println("2 parallel stream flatmap"); 
    millis = System.currentTimeMillis(); 
    for (int i = 0; i < maxcounter; i++) { 
     List<String> someList = map.values().parallelStream().flatMap(c -> c.stream()).collect(Collectors.toList()); 
    } 
    System.out.println(System.currentTimeMillis() - millis); 

    System.out.println("2 foreach"); 
    millis = System.currentTimeMillis(); 
    for (int i = 0; i < maxcounter; i++) { 
     List<String> mylist = new ArrayList<String>(); 
     map.values().forEach(mylist::addAll); 
    } 
    System.out.println(System.currentTimeMillis() - millis);   

    System.out.println("2 for"); 
    millis = System.currentTimeMillis(); 
    for (int i = 0; i < maxcounter; i++) { 
     List<String> mylist = new ArrayList<String>(); 
     for (List<String> item : map.values()) { 
      mylist.addAll(item); 
     } 
    } 
    System.out.println(System.currentTimeMillis() - millis); 

Và đây là kết quả:

1 stream flatmap 
468 
1 parallel stream flatmap 
1529 
1 foreach 
140 
1 for 
172 
2 stream flatmap 
296 
2 parallel stream flatmap 
1482 
2 foreach 
156 
2 for 
141 

Sửa 2016/05/24 (hai năm sau):

Chạy thử nghiệm tương tự sử dụng một phiên bản thực tế Java 8 (U92) trên cùng một máy:

1 stream flatmap 
313 
1 parallel stream flatmap 
3257 
1 foreach 
109 
1 for 
141 
2 stream flatmap 
219 
2 parallel stream flatmap 
3830 
2 foreach 
125 
2 for 
140 

Có vẻ như có một spee dup để xử lý tuần tự các luồng và chi phí lớn hơn cho các luồng song song.

Answer 6

Khi tìm kiếm "java 8 flatten", đây chỉ là đề cập đến. Và nó cũng không phải về luồng phẳng. Vì vậy, đối tốt tuyệt vời, tôi chỉ để lại nó ở đây

.flatMap(Collection::stream) 

Tôi cũng ngạc nhiên không ai đã cho java đồng thời 8 câu trả lời cho câu hỏi ban đầu là

.collect(ArrayList::new, ArrayList::addAll, ArrayList::addAll); 

Answer 7

Một giải pháp tốt đẹp cho các subcase của một bản đồ của Maps là lưu trữ, nếu có thể, dữ liệu trong số Table của ổi.

https://github.com/google/guava/wiki/NewCollectionTypesExplained#table

Vì vậy, ví dụ một Map<String,Map<String,String>> được thay thế bằng Table<String,String,String> vốn đã flattend. Trong thực tế, các tài liệu nói rằng HashBasedTable, Table 's thực hiện Hash, được về cơ bản được hỗ trợ bởi một HashMap<R, HashMap<C, V>>

Answer 8

đề nghị bởi một đồng nghiệp:

listOfLists.stream().flatMap(e -> e.stream()).collect(Lists.toList()) 

Tôi muốn nó tốt hơn foreach().