Làm thế nào để tạo một mảng chung trong Java?

Do việc triển khai các tổng quát Java, bạn không thể có mã như thế này:

public class GenSet<E> {
    private E a[];

    public GenSet() {
        a = new E[INITIAL_ARRAY_LENGTH]; // error: generic array creation
    }
}

Làm thế nào tôi có thể thực hiện điều này trong khi duy trì an toàn loại?

Tôi thấy một giải pháp trên các diễn đàn Java như thế này:

import java.lang.reflect.Array;

class Stack<T> {
    public Stack(Class<T> clazz, int capacity) {
        array = (T[])Array.newInstance(clazz, capacity);
    }

    private final T[] array;
}

Nhưng tôi thực sự không hiểu chuyện gì đang xảy ra.

Tôi phải hỏi lại một câu hỏi: GenSet"được kiểm tra" hay "không được kiểm tra" của bạn? Điều đó nghĩa là gì?

• Đã kiểm tra : gõ mạnh . GenSetbiết rõ loại đối tượng mà nó chứa (nghĩa là hàm tạo của nó được gọi rõ ràng bằng một Class<E>đối số và các phương thức sẽ đưa ra một ngoại lệ khi chúng được truyền các đối số không thuộc loại E. Xem Collections.checkedCollection.

  -> trong trường hợp đó, bạn nên viết:

  public class GenSet<E> {
  
      private E[] a;
  
      public GenSet(Class<E> c, int s) {
          // Use Array native method to create array
          // of a type only known at run time
          @SuppressWarnings("unchecked")
          final E[] a = (E[]) Array.newInstance(c, s);
          this.a = a;
      }
  
      E get(int i) {
          return a[i];
      }
  }

• Bỏ chọn : gõ yếu . Không có kiểm tra kiểu nào thực sự được thực hiện trên bất kỳ đối tượng nào được truyền dưới dạng đối số.

  -> trong trường hợp đó, bạn nên viết

  public class GenSet<E> {
  
      private Object[] a;
  
      public GenSet(int s) {
          a = new Object[s];
      }
  
      E get(int i) {
          @SuppressWarnings("unchecked")
          final E e = (E) a[i];
          return e;
      }
  }

  Lưu ý rằng loại thành phần của mảng phải là độ xóa của tham số loại:

  public class GenSet<E extends Foo> { // E has an upper bound of Foo
  
      private Foo[] a; // E erases to Foo, so use Foo[]
  
      public GenSet(int s) {
          a = new Foo[s];
      }
  
      ...
  }

Tất cả các kết quả này từ một điểm yếu đã biết và có chủ ý của tính tổng quát trong Java: nó được triển khai bằng cách xóa, vì vậy các lớp "chung" không biết chúng được tạo ra với loại đối số nào trong thời gian chạy và do đó không thể cung cấp loại an toàn trừ khi một số cơ chế rõ ràng (kiểm tra kiểu) được thực hiện.

Bạn có thể làm được việc này:

E[] arr = (E[])new Object[INITIAL_ARRAY_LENGTH];

Đây là một trong những cách được đề xuất để triển khai một bộ sưu tập chung trong Java hiệu quả; Mục 26 . Không có lỗi loại, không cần phải truyền mảng nhiều lần. Tuy nhiên, điều này gây ra một cảnh báo vì nó có khả năng nguy hiểm và nên được sử dụng thận trọng. Như đã nêu chi tiết trong các nhận xét, Object[]hiện tại đây đang giả dạng là E[]loại của chúng tôi và có thể gây ra lỗi hoặc lỗi không mong muốn ClassCastExceptionnếu sử dụng không an toàn.

Theo nguyên tắc thông thường, hành vi này là an toàn miễn là mảng truyền được sử dụng bên trong (ví dụ để sao lưu cấu trúc dữ liệu) và không được trả lại hoặc tiếp xúc với mã máy khách. Nếu bạn cần trả về một mảng kiểu chung cho mã khác, Arraylớp phản chiếu mà bạn đề cập là cách phù hợp.

Đáng nói là bất cứ khi nào có thể, bạn sẽ có thời gian làm việc vui vẻ hơn nhiều Listso với mảng nếu bạn đang sử dụng thuốc generic. Chắc chắn đôi khi bạn không có lựa chọn nào khác, nhưng sử dụng khung bộ sưu tập mạnh mẽ hơn nhiều.

Đây là cách sử dụng thuốc generic để có được một mảng chính xác loại bạn đang tìm kiếm trong khi bảo vệ an toàn loại (trái ngược với các câu trả lời khác, sẽ cung cấp cho bạn một Objectmảng hoặc dẫn đến cảnh báo tại thời điểm biên dịch):

import java.lang.reflect.Array;  

public class GenSet<E> {  
    private E[] a;  

    public GenSet(Class<E[]> clazz, int length) {  
        a = clazz.cast(Array.newInstance(clazz.getComponentType(), length));  
    }  

    public static void main(String[] args) {  
        GenSet<String> foo = new GenSet<String>(String[].class, 1);  
        String[] bar = foo.a;  
        foo.a[0] = "xyzzy";  
        String baz = foo.a[0];  
    }  
}

Nó biên dịch mà không có cảnh báo, và như bạn có thể thấy main, đối với bất kỳ loại nào bạn khai báo một thể hiện GenSetnhư, bạn có thể gán acho một mảng của loại đó và bạn có thể gán một phần tử từ amột biến của loại đó, nghĩa là mảng đó và các giá trị trong mảng là đúng loại.

Nó hoạt động bằng cách sử dụng các chữ theo lớp làm mã thông báo loại thời gian chạy, như được thảo luận trong Hướng dẫn Java . Lớp chữ được trình biên dịch coi là phiên bản của java.lang.Class. Để sử dụng một, chỉ cần làm theo tên của một lớp với .class. Vì vậy, String.classhoạt động như một Classđối tượng đại diện cho lớp String. Điều này cũng hoạt động cho các giao diện, enums, mảng bất kỳ chiều (ví dụ String[].class), nguyên thủy (ví dụ int.class) và từ khóa void(ví dụ void.class).

Classchính nó là chung (khai báo là Class<T>, nơi Tđứng cho các loại hình mà Classđối tượng là đại diện cho), có nghĩa là các loại String.classlà Class<String>.

Vì vậy, bất cứ khi nào bạn gọi các nhà xây dựng cho GenSet, bạn vượt qua trong một chữ lớp cho đối số đầu tiên đại diện cho một mảng của GenSetkiểu được khai báo của ví dụ (ví dụ như String[].classcho GenSet<String>). Lưu ý rằng bạn sẽ không thể có được một loạt các nguyên hàm, vì các nguyên thủy không thể được sử dụng cho các biến loại.

Bên trong hàm tạo, việc gọi phương thức casttrả về Objectđối số đã truyền cho lớp được đại diện bởi Classđối tượng mà phương thức được gọi. Gọi phương thức tĩnh newInstancetrong java.lang.reflect.Arraylợi nhuận như một Objectmột mảng của các loại đại diện bởi các Classđối tượng thông qua như là đối số đầu tiên và chiều dài theo quy định của intthông qua như là đối số thứ hai. Gọi phương thức getComponentTypetrả về một Classđối tượng đại diện cho các loại thành phần của mảng đại diện bởi các Classđối tượng trên mà phương pháp này được gọi là (ví dụ như String.classcho String[].class, nullnếu Classđối tượng không đại diện cho một mảng).

Câu cuối cùng không hoàn toàn chính xác. Gọi String[].class.getComponentType()trả về một Classđối tượng đại diện cho lớp String, nhưng kiểu của nó Class<?>thì không Class<String>, đó là lý do tại sao bạn không thể làm một cái gì đó như sau.

String foo = String[].class.getComponentType().cast("bar"); // won't compile

Tương tự với mọi phương thức trong Classđó trả về một Classđối tượng.

Về nhận xét của Joachimerer về câu trả lời này (tôi không đủ uy tín để tự nhận xét về nó), ví dụ sử dụng diễn viên T[]sẽ dẫn đến cảnh báo vì trình biên dịch không thể đảm bảo an toàn loại trong trường hợp đó.

Chỉnh sửa liên quan đến ý kiến ​​của Ingo:

public static <T> T[] newArray(Class<T[]> type, int size) {
   return type.cast(Array.newInstance(type.getComponentType(), size));
}

Đây là câu trả lời duy nhất là loại an toàn

E[] a;

a = newArray(size);

@SafeVarargs
static <E> E[] newArray(int length, E... array)
{
    return Arrays.copyOf(array, length);
}

Để mở rộng ra nhiều kích thước hơn, chỉ cần thêm []tham số và kích thước vào newInstance()( Tlà tham số loại, clslà một tham sốClass<T> , d1thông qua d5là số nguyên):

T[] array = (T[])Array.newInstance(cls, d1);
T[][] array = (T[][])Array.newInstance(cls, d1, d2);
T[][][] array = (T[][][])Array.newInstance(cls, d1, d2, d3);
T[][][][] array = (T[][][][])Array.newInstance(cls, d1, d2, d3, d4);
T[][][][][] array = (T[][][][][])Array.newInstance(cls, d1, d2, d3, d4, d5);

Xem Array.newInstance()để biết chi tiết.

Trong Java 8, chúng ta có thể thực hiện một kiểu tạo mảng chung bằng cách sử dụng tham chiếu phương thức hoặc lambda. Điều này tương tự như phương pháp phản xạ (vượt qua a Class), nhưng ở đây chúng tôi không sử dụng phản xạ.

@FunctionalInterface
interface ArraySupplier<E> {
    E[] get(int length);
}

class GenericSet<E> {
    private final ArraySupplier<E> supplier;
    private E[] array;

    GenericSet(ArraySupplier<E> supplier) {
        this.supplier = supplier;
        this.array    = supplier.get(10);
    }

    public static void main(String[] args) {
        GenericSet<String> ofString =
            new GenericSet<>(String[]::new);
        GenericSet<Double> ofDouble =
            new GenericSet<>(Double[]::new);
    }
}

Ví dụ, điều này được sử dụng bởi <A> A[] Stream.toArray(IntFunction<A[]>).

Điều này cũng có thể được thực hiện trước Java 8 bằng cách sử dụng các lớp ẩn danh nhưng nó cồng kềnh hơn.

Điều này được trình bày trong Chương 5 (Generics) của Java hiệu quả, Phiên bản 2 , mục 25 ... Ưu tiên danh sách cho mảng

Mã của bạn sẽ hoạt động, mặc dù nó sẽ tạo ra một cảnh báo không được kiểm tra (mà bạn có thể loại bỏ với chú thích sau:

@SuppressWarnings({"unchecked"})

Tuy nhiên, có lẽ tốt hơn là sử dụng Danh sách thay vì Mảng.

Có một cuộc thảo luận thú vị về lỗi / tính năng này trên trang web của dự án OpenJDK .

Bạn không cần truyền đối số Class cho hàm tạo. Thử cái này.

public class GenSet<T> {
    private final T[] array;
    @SuppressWarnings("unchecked")
    public GenSet(int capacity, T... dummy) {
        if (dummy.length > 0)
            throw new IllegalArgumentException(
              "Do not provide values for dummy argument.");
        Class<?> c = dummy.getClass().getComponentType();
        array = (T[])Array.newInstance(c, capacity);
    }
    @Override
    public String toString() {
        return "GenSet of " + array.getClass().getComponentType().getName()
            + "[" + array.length + "]";
    }
}

và

GenSet<Integer> intSet = new GenSet<>(3);
System.out.println(intSet);
System.out.println(new GenSet<String>(2));

kết quả:

GenSet of java.lang.Integer[3]
GenSet of java.lang.String[2]

Tổng quát Java hoạt động bằng cách kiểm tra các loại tại thời gian biên dịch và chèn các phôi phù hợp, nhưng xóa các loại trong các tệp được biên dịch. Điều này làm cho các thư viện chung có thể sử dụng được bằng mã không hiểu khái quát (đó là một quyết định thiết kế có chủ ý) nhưng điều đó có nghĩa là bạn thường không thể tìm ra loại nào trong thời gian chạy.

Công chúng Stack(Class<T> clazz,int capacity)xây dựng đòi hỏi bạn phải vượt qua một đối tượng Class tại thời gian chạy, mà thông tin có nghĩa là lớp là có sẵn trong thời gian chạy để mã mà cần nó. VàClass<T> biểu mẫu có nghĩa là trình biên dịch sẽ kiểm tra xem đối tượng Class mà bạn vượt qua có chính xác là đối tượng Class cho loại T. Không phải là lớp con của T, không phải là siêu lớp của T, mà chính xác là T.

Điều này có nghĩa là bạn có thể tạo một đối tượng mảng thuộc loại thích hợp trong hàm tạo của mình, điều đó có nghĩa là loại đối tượng bạn lưu trữ trong bộ sưu tập của bạn sẽ kiểm tra các loại của chúng tại điểm chúng được thêm vào bộ sưu tập.

Xin chào mặc dù chủ đề đã chết, tôi muốn thu hút sự chú ý của bạn về điều này:

Generics được sử dụng để kiểm tra kiểu trong thời gian biên dịch:

• Do đó, mục đích là để kiểm tra xem những gì đến là những gì bạn cần.
• Những gì bạn trở lại là những gì người tiêu dùng cần.
• Kiểm tra điều này:

Đừng lo lắng về các cảnh báo typecasting khi bạn đang viết lớp chung. Lo lắng khi bạn đang sử dụng nó.

Giải pháp này thì sao?

@SafeVarargs
public static <T> T[] toGenericArray(T ... elems) {
    return elems;
}

Nó hoạt động và trông quá đơn giản để là sự thật. Có bất kỳ nhược điểm?

Cũng xem mã này:

public static <T> T[] toArray(final List<T> obj) {
    if (obj == null || obj.isEmpty()) {
        return null;
    }
    final T t = obj.get(0);
    final T[] res = (T[]) Array.newInstance(t.getClass(), obj.size());
    for (int i = 0; i < obj.size(); i++) {
        res[i] = obj.get(i);
    }
    return res;
}

Nó chuyển đổi một danh sách của bất kỳ loại đối tượng nào thành một mảng cùng loại.

Tôi đã tìm thấy một cách nhanh chóng và dễ dàng mà làm việc cho tôi. Lưu ý rằng tôi chỉ sử dụng cái này trên Java JDK 8. Tôi không biết liệu nó có hoạt động với các phiên bản trước không.

Mặc dù chúng ta không thể khởi tạo một mảng chung của một tham số loại cụ thể, chúng ta có thể chuyển một mảng đã được tạo cho một hàm tạo lớp chung.

class GenArray <T> {
    private T theArray[]; // reference array

    // ...

    GenArray(T[] arr) {
        theArray = arr;
    }

    // Do whatever with the array...
}

Bây giờ trong main chúng ta có thể tạo mảng như vậy:

class GenArrayDemo {
    public static void main(String[] args) {
        int size = 10; // array size
        // Here we can instantiate the array of the type we want, say Character (no primitive types allowed in generics)
        Character[] ar = new Character[size];

        GenArray<Character> = new Character<>(ar); // create the generic Array

        // ...

    }
}

Để linh hoạt hơn với các mảng của bạn, bạn có thể sử dụng một danh sách được liên kết, ví dụ. ArrayList và các phương thức khác được tìm thấy trong lớp Java.util.ArrayList.

Ví dụ này sử dụng phản chiếu Java để tạo một mảng. Làm điều này thường không được khuyến khích, vì nó không an toàn. Thay vào đó, những gì bạn nên làm chỉ là sử dụng Danh sách nội bộ và tránh mảng đó.

Vượt qua danh sách các giá trị ...

public <T> T[] array(T... values) {
    return values;
}

Tôi đã tạo đoạn mã này để khởi tạo một cách phản xạ một lớp được truyền cho một tiện ích kiểm tra tự động đơn giản.

Object attributeValue = null;
try {
    if(clazz.isArray()){
        Class<?> arrayType = clazz.getComponentType();
        attributeValue = Array.newInstance(arrayType, 0);
    }
    else if(!clazz.isInterface()){
        attributeValue = BeanUtils.instantiateClass(clazz);
    }
} catch (Exception e) {
    logger.debug("Cannot instanciate \"{}\"", new Object[]{clazz});
}

Lưu ý phân khúc này:

    if(clazz.isArray()){
        Class<?> arrayType = clazz.getComponentType();
        attributeValue = Array.newInstance(arrayType, 0);
    }

để bắt đầu mảng trong đó Array.newInstance (lớp của mảng, kích thước của mảng) . Lớp có thể là cả nguyên thủy (int. Class) và object (Integer. Class).

BeanUtils là một phần của mùa xuân.

Trên thực tế, một cách dễ dàng hơn để làm như vậy, là tạo một mảng các đối tượng và chuyển nó sang loại mong muốn của bạn như ví dụ sau:

T[] array = (T[])new Object[SIZE];

trong đó SIZElà một hằng số và Tlà một định danh loại

Các diễn viên bị ép buộc được đề xuất bởi những người khác đã không làm việc cho tôi, ném ngoại lệ của việc đúc bất hợp pháp.

Tuy nhiên, dàn diễn viên ngầm này hoạt động tốt:

Item<K>[] array = new Item[SIZE];

Trong đó Item là một lớp tôi xác định có chứa thành viên:

private K value;

Bằng cách này, bạn nhận được một mảng loại K (nếu mục chỉ có giá trị) hoặc bất kỳ loại chung nào bạn muốn xác định trong Mục lớp.

Không ai khác đã trả lời câu hỏi về những gì đang xảy ra trong ví dụ bạn đã đăng.

import java.lang.reflect.Array;

class Stack<T> {
    public Stack(Class<T> clazz, int capacity) {
        array = (T[])Array.newInstance(clazz, capacity);
    }

    private final T[] array;
}

Như những người khác đã nói thuốc generic bị "xóa" trong quá trình biên dịch. Vì vậy, trong thời gian chạy, một thể hiện của một cái chung không biết loại thành phần của nó là gì. Lý do cho điều này là lịch sử, Sun muốn thêm tướng mà không phá vỡ giao diện hiện có (cả nguồn và nhị phân).

Mặt khác, không biết loại thành phần của chúng khi chạy.

Ví dụ này giải quyết vấn đề bằng cách có mã gọi hàm tạo (biết kiểu này) truyền tham số cho lớp biết loại cần thiết.

Vì vậy, ứng dụng sẽ xây dựng lớp với một cái gì đó như

Stack<foo> = new Stack<foo>(foo.class,50)

và hàm tạo bây giờ biết (trong thời gian chạy) loại thành phần là gì và có thể sử dụng thông tin đó để xây dựng mảng thông qua API phản chiếu.

Array.newInstance(clazz, capacity);

Cuối cùng, chúng ta có một kiểu truyền vì trình biên dịch không có cách nào để biết rằng mảng được trả về Array#newInstance()là loại đúng (mặc dù chúng ta biết).

Kiểu này hơi xấu nhưng đôi khi nó có thể là giải pháp kém nhất để tạo các kiểu chung cần biết loại thành phần của chúng khi chạy vì bất kỳ lý do gì (tạo mảng hoặc tạo phiên bản của loại thành phần, v.v.).

Tôi tìm thấy một loại công việc xung quanh vấn đề này.

Dòng bên dưới ném lỗi tạo mảng chung

List<Person>[] personLists=new ArrayList<Person>()[10];

Tuy nhiên nếu tôi gói gọn List<Person>trong một lớp riêng biệt, nó sẽ hoạt động.

import java.util.ArrayList;
import java.util.List;


public class PersonList {

    List<Person> people;

    public PersonList()
    {
        people=new ArrayList<Person>();
    }
}

Bạn có thể hiển thị những người trong lớp PersonList thông qua một getter. Dòng dưới đây sẽ cung cấp cho bạn một mảng, có một List<Person>trong mọi phần tử. Nói cách khác mảng của List<Person>.

PersonList[] personLists=new PersonList[10];

Tôi cần một cái gì đó như thế này trong một số mã tôi đang làm việc và đây là những gì tôi đã làm để làm cho nó hoạt động. Cho đến nay không có vấn đề.

Bạn có thể tạo một mảng Object và truyền nó tới E ở mọi nơi. Vâng, đó không phải là cách rất sạch sẽ để làm điều đó nhưng ít nhất nó nên hoạt động.

thử cái này.

private int m = 0;
private int n = 0;
private Element<T>[][] elements = null;

public MatrixData(int m, int n)
{
    this.m = m;
    this.n = n;

    this.elements = new Element[m][n];
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < n; j++)
        {
            this.elements[i][j] = new Element<T>();
        }
    }
}

Một cách giải quyết dễ dàng, mặc dù lộn xộn cho việc này sẽ là lồng một lớp "người giữ" thứ hai bên trong lớp chính của bạn và sử dụng nó để giữ dữ liệu của bạn.

public class Whatever<Thing>{
    private class Holder<OtherThing>{
        OtherThing thing;
    }
    public Holder<Thing>[] arrayOfHolders = new Holder<Thing>[10]
}

Có thể không liên quan đến câu hỏi này nhưng trong khi tôi generic array creationgặp lỗi "" khi sử dụng

Tuple<Long,String>[] tupleArray = new Tuple<Long,String>[10];

Tôi tìm ra các tác phẩm sau (và làm việc cho tôi) với @SuppressWarnings({"unchecked"}):

 Tuple<Long, String>[] tupleArray = new Tuple[10];

Tôi đang tự hỏi nếu mã này sẽ tạo ra một mảng chung hiệu quả?

public T [] createArray(int desiredSize){
    ArrayList<T> builder = new ArrayList<T>();
    for(int x=0;x<desiredSize;x++){
        builder.add(null);
    }
    return builder.toArray(zeroArray());
}

//zeroArray should, in theory, create a zero-sized array of T
//when it is not given any parameters.

private T [] zeroArray(T... i){
    return i;
}

Chỉnh sửa: Có lẽ một cách khác để tạo ra một mảng như vậy, nếu kích thước bạn yêu cầu được biết và nhỏ, sẽ chỉ đơn giản là cung cấp số lượng "null" cần thiết vào lệnh zeroArray?

Mặc dù rõ ràng điều này không linh hoạt bằng việc sử dụng mã createArray.

Bạn có thể sử dụng một diễn viên:

public class GenSet<Item> {
    private Item[] a;

    public GenSet(int s) {
        a = (Item[]) new Object[s];
    }
}

Tôi thực sự tìm thấy một giải pháp khá độc đáo để bỏ qua việc không thể bắt đầu một mảng chung. Những gì bạn phải làm là tạo một lớp có trong biến chung T như vậy:

class GenericInvoker <T> {
    T variable;
    public GenericInvoker(T variable){
        this.variable = variable;
    }
}

và sau đó trong lớp mảng của bạn chỉ cần bắt đầu như vậy:

GenericInvoker<T>[] array;
public MyArray(){
    array = new GenericInvoker[];
}

bắt đầu new Generic Invoker[]sẽ gây ra sự cố không được kiểm soát nhưng thực tế không nên có bất kỳ vấn đề nào.

Để lấy từ mảng, bạn nên gọi mảng [i] .variable như vậy:

public T get(int index){
    return array[index].variable;
}

Phần còn lại, chẳng hạn như thay đổi kích thước mảng có thể được thực hiện với Arrays.copyOf () như vậy:

public void resize(int newSize){
    array = Arrays.copyOf(array, newSize);
}

Và chức năng thêm có thể được thêm vào như vậy:

public boolean add(T element){
    // the variable size below is equal to how many times the add function has been called 
    // and is used to keep track of where to put the next variable in the array
    arrays[size] = new GenericInvoker(element);
    size++;
}

Theo vnportnoy cú pháp

GenSet<Integer> intSet[] = new GenSet[3];

tạo ra một loạt các tham chiếu null, được điền vào như

for (int i = 0; i < 3; i++)
{
   intSet[i] = new GenSet<Integer>();
}

Đó là loại an toàn.

private E a[];
private int size;

public GenSet(int elem)
{
    size = elem;
    a = (E[]) new E[size];
}

Tạo mảng chung không được phép trong java nhưng bạn có thể làm như thế

class Stack<T> {
private final T[] array;
public Stack(int capacity) {
    array = (T[]) new Object[capacity];
 }
}