Chuyển đổi mảng Java thành Iterable

Tôi có một mảng nguyên thủy, ví dụ cho int, int [] foo. Nó có thể là một kích thước nhỏ, hoặc không.

int foo[] = {1,2,3,4,5,6,7,8,9,0};

Cách tốt nhất để tạo ra một Iterable<Integer>từ nó là gì?

Iterable<Integer> fooBar = convert(foo);

Ghi chú:

Vui lòng không trả lời bằng cách sử dụng các vòng lặp (trừ khi bạn có thể đưa ra lời giải thích tốt về cách trình biên dịch làm điều gì đó thông minh về chúng?)

Cũng lưu ý rằng

int a[] = {1,2,3};
List<Integer> l = Arrays.asList(a);

Thậm chí sẽ không biên dịch

Type mismatch: cannot convert from List<int[]> to List<Integer>

Ngoài ra kiểm tra Tại sao một mảng không thể gán cho Iterable? trước khi trả lời.

Ngoài ra, nếu bạn sử dụng một số thư viện (ví dụ, ổi), vui lòng giải thích lý do tại sao đây là tốt nhất. (Bởi vì từ Google không phải là câu trả lời hoàn chỉnh: P)

Cuối cùng, vì dường như có một bài tập về nhà về điều đó, tránh đăng mã bài tập về nhà.

Integer foo[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };

List<Integer> list = Arrays.asList(foo);
// or
Iterable<Integer> iterable = Arrays.asList(foo);

Mặc dù bạn cần sử dụng một Integermảng (không phải là một intmảng) để làm việc này.

Đối với người nguyên thủy, bạn có thể sử dụng ổi:

Iterable<Integer> fooBar = Ints.asList(foo);

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>15.0</version>
    <type>jar</type>
</dependency>

Dành cho Java8: (từ câu trả lời của Jin Kwon)

final int[] arr = {1, 2, 3};
final PrimitiveIterator.OfInt i1 = Arrays.stream(arr).iterator();
final PrimitiveIterator.OfInt i2 = IntStream.of(arr).iterator();
final Iterator<Integer> i3 = IntStream.of(arr).boxed().iterator();

chỉ 2 xu của tôi:

final int a[] = {1,2,3};

java.lang.Iterable<Integer> aIterable=new Iterable<Integer>() {

    public Iterator<Integer> iterator() {
       return new Iterator<Integer>() {
            private int pos=0;

            public boolean hasNext() {
               return a.length>pos;
            }

            public Integer next() {
               return a[pos++];
            }

            public void remove() {
                throw new UnsupportedOperationException("Cannot remove an element of an array.");
            }
        };
    }
};

Với Java 8, bạn có thể làm điều này.

final int[] arr = {1, 2, 3};
final PrimitiveIterator.OfInt i1 = Arrays.stream(arr).iterator();
final PrimitiveIterator.OfInt i2 = IntStream.of(arr).iterator();
final Iterator<Integer> i3 = IntStream.of(arr).boxed().iterator();

Guava cung cấp bộ điều hợp bạn muốn dưới dạng Int.asList () . Có một loại tương đương cho mỗi loại nguyên thủy trong lớp liên kết, ví dụ, Booleanscho boolean, v.v.

int foo[] = {1,2,3,4,5,6,7,8,9,0};
Iterable<Integer> fooBar = Ints.asList(foo);
for(Integer i : fooBar) {
    System.out.println(i);
}

Các đề xuất ở trên Arrays.asListsẽ không hiệu quả, ngay cả khi chúng được biên dịch vì bạn nhận được Iterator<int[]>thay vì Iterator<Integer>. Điều gì xảy ra là thay vì tạo một danh sách được hỗ trợ bởi mảng của bạn, bạn đã tạo một danh sách 1 phần tử của mảng, có chứa mảng của bạn.

Tôi đã có cùng một vấn đề và giải quyết nó như thế này:

final YourType[] yourArray = ...;
return new Iterable<YourType>() {
  public Iterator<YourType> iterator() {
     return Iterators.forArray(yourArray);   // Iterators is a Google guava utility
  }
}

Bản thân iterator là một kẻ lười biếng UnmodifiableIteratornhưng đó chính xác là những gì tôi cần.

Trong Java 8 trở lên, Iterablelà một giao diện chức năng trả về Iterator. Vì vậy, bạn có thể làm điều này.

int[] array = {1, 2, 3};
Iterable<Integer> iterable = () -> Arrays.stream(array).iterator();
for (int i : iterable)
    System.out.println(i);

->

1
2
3

Trước hết, tôi chỉ có thể đồng ý rằng Arrays.asList(T...)rõ ràng đó là giải pháp tốt nhất cho các kiểu hoặc mảng Wrapper với các kiểu dữ liệu không nguyên thủy. Phương thức này gọi một hàm tạo của một AbstractListtriển khai tĩnh riêng đơn giản trong Arrayslớp, về cơ bản lưu tham chiếu mảng đã cho dưới dạng trường và mô phỏng danh sách bằng cách ghi đè các phương thức cần thiết.

Nếu bạn có thể chọn giữa loại nguyên thủy hoặc loại Wrapper cho mảng của mình, tôi sẽ sử dụng loại Wrapper cho các tình huống như vậy nhưng tất nhiên, nó không phải lúc nào cũng hữu ích hoặc bắt buộc. Sẽ chỉ có hai khả năng bạn có thể làm:

1) Bạn có thể tạo một lớp với một phương thức tĩnh cho mỗi mảng kiểu dữ liệu nguyên thủy ( boolean, byte, short, int, long, char, float, doubletrả về một Iterable<WrapperType >. Các phương thức này sẽ sử dụng các lớp ẩn danh của Iterator(bên cạnh đóIterable) được phép chứa tham chiếu của đối số của phương thức bao gồm (ví dụ an int[]) dưới dạng trường để triển khai các phương thức.

-> Cách tiếp cận này là hiệu quả và giúp bạn tiết kiệm bộ nhớ (ngoại trừ bộ nhớ của các phương thức mới được tạo, mặc dù, việc sử dụng Arrays.asList()sẽ lấy bộ nhớ theo cùng một cách)

2) Vì các mảng không có phương thức (như được đọc ở bên cạnh bạn đã liên kết) họ cũng không thể cung cấp một Iteratorví dụ. Nếu bạn thực sự quá lười biếng để viết các lớp mới, bạn phải sử dụng một thể hiện của một lớp đã có sẵn để thực hiện Iterablebởi vì không có cách nào khác ngoài việc khởi tạo Iterablehoặc một kiểu con.
Cách DUY NHẤT để tạo triển khai phái sinh Bộ sưu tập hiện cóIterablelà sử dụng một vòng lặp (ngoại trừ bạn sử dụng các lớp ẩn danh như được mô tả ở trên) hoặc bạn khởi tạo một Iterablelớp triển khai có hàm tạo cho phép một Object[]mảng kiểu nguyên thủy (vì không cho phép các mảng có các phần tử kiểu nguyên thủy) nhưng theo như tôi biết, API Java không có một lớp học như thế.

Lý do của vòng lặp có thể được giải thích dễ dàng:
đối với mỗi Bộ sưu tập, bạn cần các đối tượng và kiểu dữ liệu nguyên thủy không phải là đối tượng. Các đối tượng lớn hơn nhiều so với các kiểu nguyên thủy để chúng yêu cầu dữ liệu bổ sung phải được tạo cho từng phần tử của mảng kiểu nguyên thủy. Điều đó có nghĩa là nếu hai cách của ba (sử dụng Arrays.asList(T...)hoặc sử dụng Bộ sưu tập hiện tại) yêu cầu tổng hợp các đối tượng, bạn cần tạo cho mỗi giá trị nguyên thủy củaint[]mảng đối tượng bao bọc. Cách thứ ba sẽ sử dụng mảng như hiện tại và sử dụng nó trong một lớp ẩn danh vì tôi nghĩ nó thích hợp hơn do hiệu suất nhanh.

Ngoài ra còn có một chiến lược thứ ba sử dụng một Objectđối số làm phương thức cho phương thức mà bạn muốn sử dụng mảng hoặc Iterablenó sẽ yêu cầu kiểm tra kiểu để tìm ra loại đối số nào, tuy nhiên tôi sẽ không đề xuất nó như bạn thường cần xem xét rằng Đối tượng không phải luôn luôn là loại được yêu cầu và bạn cần mã riêng cho các trường hợp nhất định.

Tóm lại, đó là lỗi của hệ thống Kiểu chung có vấn đề của Java, không cho phép sử dụng các kiểu nguyên thủy làm kiểu chung sẽ tiết kiệm rất nhiều mã bằng cách sử dụng đơn giảnArrays.asList(T...). Vì vậy, bạn cần lập trình cho từng mảng kiểu nguyên thủy, bạn cần một phương thức như vậy (về cơ bản không có sự khác biệt nào đối với bộ nhớ được sử dụng bởi chương trình C ++ sẽ tạo cho mỗi đối số kiểu được sử dụng một phương thức riêng biệt.

Bạn có thể sử dụng IterableOftừ Cactoos :

Iterable<String> names = new IterableOf<>(
  "Scott Fitzgerald", "Fyodor Dostoyevsky"
);

Sau đó, bạn có thể biến nó thành một danh sách bằng cách sử dụng ListOf:

List<String> names = new ListOf<>(
  new IterableOf<>(
    "Scott Fitzgerald", "Fyodor Dostoyevsky"
  )
);

Hoặc đơn giản là thế này:

List<String> names = new ListOf<>(
  "Scott Fitzgerald", "Fyodor Dostoyevsky"
);

Trong khi một câu trả lời tương tự đã được đăng, tôi nghĩ lý do để sử dụng PrimitiveIterator.OfInt mới không rõ ràng. Một giải pháp tốt là sử dụng Java 8 PrimitiveIterator vì nó chuyên dùng cho các kiểu int nguyên thủy (và tránh hình phạt đấm bốc / bỏ hộp bổ sung):

    int[] arr = {1,2,3};
    // If you use Iterator<Integer> here as type then you can't get the actual benefit of being able to use nextInt() later
    PrimitiveIterator.OfInt iterator = Arrays.stream(arr).iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.nextInt());
        // Use nextInt() instead of next() here to avoid extra boxing penalty
    }

Tham chiếu: https://doc.bccnsoft.com/docs/jdk8u12-docs/api/java/util/PrimitiveIterator.OfInt.html

Trong java8 IntSteam, luồng có thể được đóng hộp cho luồng Số nguyên.

public static Iterable<Integer> toIterable(int[] ints) {
    return IntStream.of(ints).boxed().collect(Collectors.toList());
}

Tôi nghĩ vấn đề hiệu suất dựa trên kích thước của mảng.