Cách lặp lại thanh lịch nhất thông qua các bộ sưu tập song song?

Question

Giả sử tôi có 2 bộ sưu tập song song, ví dụ: danh sách tên người trong số List<String> và danh sách tuổi của chúng theo số List<Int> theo cùng thứ tự (để bất kỳ chỉ mục cụ thể nào trong mỗi bộ sưu tập đều đề cập đến cùng một người).

Tôi muốn lặp lại thông qua cả hai bộ sưu tập cùng một lúc và tìm nạp tên và tuổi của mỗi người và làm điều gì đó với nó. Với mảng này có thể dễ dàng thực hiện với:

for (int i = 0; i < names.length; i++) { 
    do something with names[i] .... 
    do something with ages[i]..... 
} 

Cách nào là cách thanh lịch nhất (về khả năng đọc và tốc độ) khi thực hiện việc này với bộ sưu tập?

Answer 1

Tôi sẽ tạo một đối tượng mới đóng gói cả hai. Ném nó vào mảng và lặp lại điều đó.

List<Person> 

đâu

public class Person { 
    public string name; 
    public int age; 
} 

Answer 2

it1 = coll1.iterator(); 
it2 = coll2.iterator(); 
while(it1.hasNext() && it2.hasNext()) { 
    value1 = it1.next(); 
    value2 = it2.next(); 
    do something with it1 and it2; 
} 

Phiên bản này chấm dứt khi bộ sưu tập ngắn hơn bị cạn kiệt; cách khác, bạn có thể tiếp tục cho đến khi cái còn lại cạn kiệt, thiết lập giá trị 1 resp. value2 đến null.

Answer 3

for (int i = 0; i < names.length; ++i) { 
    name = names.get(i); 
    age = ages.get(i); 
    // do your stuff 
} 

Nó không thực sự quan trọng. Mã của bạn sẽ không nhận được điểm cho sự thanh lịch. Chỉ cần làm điều đó để nó hoạt động. Và xin đừng sưng lên.

Answer 4

Bạn có thể tạo một giao diện cho nó:

public interface ZipIterator<T,U> { 
    boolean each(T t, U u); 
} 

public class ZipUtils { 
    public static <T,U> boolean zip(Collection<T> ct, Collection<U> cu, ZipIterator<T,U> each) { 
    Iterator<T> it = ct.iterator(); 
    Iterator<U> iu = cu.iterator(); 
    while (it.hasNext() && iu.hasNext()) { 
     if (!each.each(it.next(), iu.next()) { 
     return false; 
     } 
    } 
    return !it.hasNext() && !iu.hasNext(); 
    } 
} 

Và sau đó bạn có:

Collection<String> c1 = ... 
Collection<Long> c2 = ... 
zip(c1, c2, new ZipIterator<String, Long>() { 
    public boolean each(String s, Long l) { 
    ... 
    } 
}); 

Answer 5

Theo đề nghị của jeef3, mô hình hóa sự thật miền thay vì giữ sepa tỷ lệ, danh sách được ghép đôi hoàn toàn là đúng cách để đi ... khi đây là một tùy chọn.

Có nhiều lý do khiến bạn không thể áp dụng phương pháp này. Nếu vậy ...

A. Bạn có thể sử dụng phương pháp gọi lại, theo đề xuất của cletus.

B. Bạn vẫn có thể chọn để hiển thị Iterator hiển thị phần tử đối tượng miền cho từng trường hợp tổng hợp. Cách tiếp cận này không buộc bạn phải giữ một cấu trúc Danh sách song song xung quanh.

private List<String> _names = ...; 
private List<Integer> _ages = ...; 

Iterator<Person> allPeople() { 
    final Iterator<String> ni = _names.iterator(); 
    final Iterator<Integer> ai = _ages.iterator(); 
    return new Iterator() { 
    public boolean hasNext() { 
     return ni.hasNext(); 
    } 
    public Person next() { 
     return new Person(ni.next(), ai.next()); 
    } 
    public void remove() { 
     ni.remove(); 
     ai.remove(); 
    } 
    }; 
} 

C. Bạn có thể sử dụng biến thể này và sử dụng API con trỏ kiểu RowSet. Giả sử IPerson là giao diện mô tả Người. Sau đó, chúng ta có thể làm:

public interface IPerson { 
    String getName(); 
    void setName(String name); 
    ... 
} 

public interface ICursor<T> { 
    boolean next(); 
    T current(); 
} 

private static class PersonCursor implements IPerson, ICursor<IPerson> { 
    private final List<String> _names; 
    ... 
    private int _index = -1; 

    PersonCursor(List<String> names, List<Integer> ages) { 
    _names = names; 
    ... 
    } 

    public boolean next() { 
    return ++_index < _names.size(); 
    } 

    public Person current() { 
    return this; 
    } 

    public String getName() { 
    return _names.get(_index); 
    } 

    public void setName(String name) { 
    _names.set(0, name); 
    } 

    ... 
} 

private List<String> _names = ...; 
private List<Integer> _ages = ...; 

Cursor<Person> allPeople() { 
    return new PersonCursor(_names, _ages); 
} 

Lưu ý rằng phương pháp B cũng được thực hiện để hỗ trợ cập nhật vào danh sách bằng cách giới thiệu một giao diện Domain, và có sự trở lại Iterator 'sống' đối tượng.

Answer 6

Tôi chỉ đăng tải chức năng này trong similar question này (mà @Nils von Barth khẳng định không phải là một bản sao;)), nhưng nó không kém phần áp dụng ở đây:

public static <L,R,M> List<M> zipLists(
    BiFunction<L,R,M> factory, Iterable<L> left, Iterable<R> right) { 
    Iterator<L> lIter = left.iterator(); 
    Iterator<R> rIter = right.iterator(); 
    ImmutableList.Builder<M> builder = ImmutableList.builder(); 

    while (lIter.hasNext() && rIter.hasNext()) { 
    builder.add(factory.apply(lIter.next(), rIter.next())); 
    } 

    // Most of the existing solutions fail to enforce that the lists are the same 
    // size. That is a *classic* source of bugs. Always enforce your invariants! 
    checkArgument(!lIter.hasNext(), 
     "Unexpected extra left elements: %s", ImmutableList.copyOf(lIter)); 
    checkArgument(!rIter.hasNext(), 
     "Unexpected extra right elements: %s", ImmutableList.copyOf(rIter)); 
    return builder.build(); 
} 

Sau đó, bạn có thể cung cấp một hoạt động nhà máy cho BiFunction , chẳng hạn như một giá trị kiểu của constructor:

List<Person> people = zipLists(Person::new, names, ages); 

Nếu bạn thực sự chỉ muốn để lặp qua họ và làm một số hoạt động, chứ không phải là xây dựng một bộ sưu tập mới, bạn có thể hoán đổi số BiFunction cho số BiConsumer và có chức năng trả về void.

Answer 7

tôi đã bình luận @cletus và cải tiến nó ABIT, Và đó là những gì tôi sử dụng:

public static <T,U> void zip(Collection<T> ct, Collection<U> cu, BiConsumer<T, U> consumer) { 
    Iterator<T> it = ct.iterator(); 
    Iterator<U> iu = cu.iterator(); 
    while (it.hasNext() && iu.hasNext()) { 
     consumer.accept(it.next(), iu.next()); 
    } 
} 

Cách sử dụng:

zip(list1, list2, (v1, v2) -> { 
    // Do stuff 
}); 

Answer 8

Trong khi các giải pháp gửi là chính xác tôi thích một sau vì nó sau hướng dẫn từ mục java hiệu quả 57: giảm thiểu phạm vi biến cục bộ:

for (Iterator<String> i = lst1.iterator(), ii = lst2.iterator(); i.hasNext() && ii.hasNext();) { 
     String e1 = i.next(); 
     String e2 = ii.next(); 
     .... 
    }