Có cách nào tránh vòng lặp khi thêm vào danh sách không?

Question

Tôi đã tự hỏi một mã như sau:

List<String> list = new ArrayList<String>(); 
for(CustomObject co : objects) { 
    list.add(co.getActualText()); 
} 

Có thể viết nó khác đi không? Ý tôi là dĩ nhiên tại một số điểm sẽ có một vòng lặp nhưng tôi tự hỏi nếu có một cách sử dụng API Tôi phớt lờ

Answer 1

Nếu bạn sử dụng Java 8, bạn có thể tận dụng các API Suối:

List<String> list = objects.stream() 
          .map(CustomObject::getActualText) 
          .collect(Collectors.toList()); 

Answer 2

Nếu bạn có Java 8, điều gì về:

objects.forEach(item -> list.add(item.getActualText())); 

Nội bộ vẫn là một vòng lặp.

CHỈNH SỬA một chút Off-Topic: IMO Đây là giải pháp tốt nhất và dễ đọc nhất. Tại sao không chỉ sử dụng một foreach bạn có thể yêu cầu. Câu trả lời: Bởi vì cách này bộ sưu tập chọn cách tốt nhất để lặp qua các mục. Ví dụ, ArrayList không sử dụng một iterator, bởi vì nó biết tốt hơn so với bạn:

@Override 
public void forEach(Consumer<? super E> action) { 
    Objects.requireNonNull(action); 
    final int expectedModCount = modCount; 
    @SuppressWarnings("unchecked") 
    final E[] elementData = (E[]) this.elementData; 
    final int size = this.size; 
    for (int i=0; modCount == expectedModCount && i < size; i++) { 
     action.accept(elementData[i]); 
    } 
    if (modCount != expectedModCount) { 
     throw new ConcurrentModificationException(); 
    } 
} 

Answer 3

Sử dụng con suối sẽ nhiều thành ngữ trong Java 8, nhưng nếu bạn muốn nó sẽ được gần gũi hơn với cách tiếp cận dựa trên vòng lặp thông thường bạn có thể sử dụng forEach:

objects.forEach(co -> list.add(co.getActualText())); 

Answer 4

Mặc dù rõ ràng một chút gợi ý vô lý: bạn có thể tránh các vòng bằng cách thêm chúng một cách đệ quy.

void add(List<? super String> receiver, CustomObject[] objects) { 
    addRec(receiver, toAdd, 0, objects.length()); 
} 

void addRec(List<? super String> receiver, CustomObject[] objects, int start, int end) { 
    if (start + 1 == end) { 
    receiver.add(objects[start].getActualText()); 
    } else if (start != end) { 
    int mid = (start + end)/2; 
    addRec(receiver, objects, start, mid); 
    addRec(receiver, objects, mid, end); 
    } 
} 

Answer 5

Tất nhiên, Apache Commons và ổi cũng cung cấp cách để tránh các vòng lặp mà không sử dụng Java 8.

Commons CollectionUtils.collect:

CollectionUtils.collect(objects, Transformer.invokerTransformer("getActualText"), list); 

Ổi Lists.transform:

List<String> list = Lists.transform(objects, 
    new Function<CustomObject, String>() { 
     public String apply(CustomObject co) { 
      return co.getActualText(); 
     } 
    } 
); 

Answer 6

Nếu bạn sử dụng Eclipse Collections (trước đây là GS Collections), bạn có thể viết như sau trong Java 8:

MutableList<CustomObject> objects = ... 
MutableList<String> result = objects.collect(CustomObject::getActualText); 

Với Java 5-7 bạn có thể sử dụng một lớp bên trong vô danh đại diện cho SAM loại Function với phương pháp thu thập.

MutableList<CustomObject> objects = ... 
MutableList<String> result = objects.collect(new Function<CustomObject, String>() { 
    public String valueOf(CustomObject object){ 
     return object.getActualText(); 
    } 
}); 

Lưu ý: Tôi là một người có duyên cho Eclipse Collections

Answer 7

Để đạt được hiệu quả thực sự tốt khi sao chép một loạt các dữ liệu giữa hai loại danh sách chưa được biết đến nhau, thì phải có một cơ chế theo đó một loại "đáng tin cậy" có thể yêu cầu mỗi để lộ (các) mảng sao lưu được liên kết với một loạt các phần tử, và sau đó sử dụng thao tác sao chép số lượng lớn để di chuyển dữ liệu từ một đến khác. Có thể viết một lớp như vậy hoàn toàn bằng Java, bằng cách có một phương thức GetArraySource truyền cho hàm tạo của lớp ArraySource tin cậy một đối tượng mà nó có thể sử dụng để yêu cầu mảng sao lưu được liên kết với một phần tử cụ thể (trả về sẽ bao gồm mảng sao lưu) và phạm vi các yếu tố được bao gồm trong đó).Mã muốn sao chép sẽ gọi GetArraySource và vượt qua ArraySource được trả về từ đó đến phương thức CopyFromArraySource của danh sách đích, sau đó có thể yêu cầu ArraySource sao chép một hoặc nhiều phạm vi mục vào (các) mảng sao lưu riêng của nó.

Nếu ArraySource là một lớp học được cung cấp với Java, và Oracle ghi nhận chính xác những gì nó sẽ làm gì với mảng mà nó nhận được, sau đó nó sẽ có thể với nhiều loại như ArrayList và String để lộ nội dung của họ như là một ArraySource, hoặc chấp nhận dữ liệu bên ngoài từ một số ArraySource, mà không hiển thị không đúng mảng của chúng với bất kỳ mã nào có thể lạm dụng nó.

Thật không may, trừ khi Oracle kết hợp một thứ như vậy vào bản phân phối Java, hỗ trợ có thể sẽ quá thưa thớt để hữu ích. Nó không tốt để có danh sách nguồn hỗ trợ một lớp như vậy, đích hỗ trợ một lớp khác và mã muốn hoạt động sao chép thứ ba. Tất cả ba lớp cần hỗ trợ cùng lớp tin cậy-array-segment-copy-helper.