Java에서 일반 배열을 만드는 방법은 무엇입니까?

Java 제네릭의 구현으로 인해 다음과 같은 코드를 가질 수 없습니다.

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

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

타입 안전을 유지하면서 이것을 어떻게 구현할 수 있습니까?

Java 포럼에서 다음과 같은 솔루션을 보았습니다.

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;
}

그러나 나는 정말로 무슨 일이 일어나고 있지 않습니다.

당신의 GenSet"체크 된"또는 "체크되지 않은"입니까? 그게 무슨 뜻이야?

• 확인 : 강력한 타이핑 . GenSet포함하는 객체의 유형을 명시 적으로 알고 있습니다 (즉, 생성자가 Class<E>인수 와 함께 명시 적으로 호출되었으며 , 메소드가 유형이 아닌 인수를 전달하면 예외가 발생합니다 E. 참조) Collections.checkedCollection.

  이 경우 다음과 같이 작성해야합니다.

  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];
      }
  }

• 선택하지 않은 경우 : 약한 입력 입니다. 인수로 전달 된 객체에 대해서는 실제로 유형 검사가 수행되지 않습니다.

  이 경우에는

  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;
      }
  }

  배열의 구성 요소 유형은 type 매개 변수 의 삭제 여야합니다 .

  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];
      }
  
      ...
  }

이 모든 것은 Java에서 알려진 고의적이며 제네릭의 약점에서 비롯됩니다. 삭제를 사용하여 구현되었으므로 "일반"클래스는 런타임에 어떤 유형 인수로 작성되었는지 알 수 없으므로 유형을 제공 할 수 없습니다. 명시 적 메커니즘 (유형 검사)이 구현되지 않는 한 안전.

당신은 이것을 할 수 있습니다 :

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

이것은 효과적인 Java 에서 일반 컬렉션을 구현하는 제안 된 방법 중 하나입니다 . 항목 26 . 유형 오류가 없으며 배열을 반복적으로 캐스팅 할 필요가 없습니다. 그러나 이것은 잠재적으로 위험하므로주의해서 사용해야합니다. 주석에 자세히 설명되어 있듯이 이것은 Object[]현재 E[]유형으로 위장되어 ClassCastException안전하지 않은 경우 예기치 않은 오류나 s 가 발생할 수 있습니다 .

일반적으로이 동작은 캐스트 배열이 내부적으로 (예 : 데이터 구조를 백업하기 위해) 사용되고 클라이언트 코드에 반환되거나 노출되지 않는 한 안전합니다. 제네릭 형식의 배열을 다른 코드로 반환해야하는 경우 Array언급 한 리플렉션 클래스가 올바른 방법입니다.

가능한 List경우 제네릭을 사용하는 경우 배열보다는 s로 작업하는 것이 훨씬 행복 합니다. 확실히 선택의 여지가 없지만 컬렉션 프레임 워크를 사용하는 것이 훨씬 강력합니다.

다음은 제네릭을 사용하여 형식 안전을 유지하면서 찾고있는 형식의 배열을 얻는 방법입니다 (다른 답변과 달리 Object배열 을 반환 하거나 컴파일 타임에 경고를 표시 함).

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];  
    }  
}

당신이 볼 수있는 경고없이 컴파일하고, 같은 main당신의 인스턴스 선언 어떤 유형, GenSet등, 당신은 할당 할 수있는 a해당 유형의 배열에, 당신은에서 요소를 할당 할 수 a배열 즉, 해당 유형의 변수 배열의 값이 올바른 유형입니다.

Java Tutorials 에서 설명한 것처럼 클래스 리터럴을 런타임 유형 토큰으로 사용하여 작동합니다 . 클래스 리터럴은 컴파일러에서의 인스턴스로 처리됩니다 java.lang.Class. 하나를 사용하려면으로 클래스 이름을 따르십시오 .class. 따라서 클래스를 나타내는 객체 String.class로 작동 Class합니다 String. 또한 인터페이스, 열거 형, 모든 차원 배열 (예 :) String[].class, 프리미티브 (예 :) int.class및 키워드 void(예 :)에서도 작동합니다 void.class.

Class자체는 일반적입니다 (로 선언 Class<T>, 여기서 객체가 나타내는 T유형을 Class나타냄) . 의 유형은 String.class입니다 Class<String>.

따라서에 대한 생성자를 호출 할 때마다 인스턴스의 선언 된 유형의 GenSet배열을 나타내는 첫 번째 인수에 대해 클래스 리터럴을 전달 GenSet합니다 (예 : String[].classfor GenSet<String>). 프리미티브는 유형 변수에 사용할 수 없기 때문에 프리미티브 배열을 얻을 수 없습니다.

생성자 내에서 메서드를 호출하면 메서드 cast가 호출 Object된 Class객체가 나타내는 클래스로 전달 된 인수가 반환 됩니다. 정적 메소드 newInstance를 호출하면 첫 번째 인수로 전달 된 객체와 두 번째 인수로 전달 된 길이로 표시되는 유형의 배열이 java.lang.reflect.Array반환됩니다 . 메소드 호출 복귀 어레이의 구성 형태를 나타내는 객체에 의해 표현 (예를 들어 메소드가 호출되는 객체 에 대해 , 경우 생성 객체 배열을 나타내지 않음).ObjectClassintgetComponentTypeClassClassString.classString[].classnullClass

마지막 문장은 완전히 정확하지 않습니다. 호출 String[].class.getComponentType()반환 Class클래스를 나타내는 객체 String, 그러나 그것의 유형입니다 Class<?>하지, Class<String>당신은 다음과 같은 일을 할 수없는 이유이다.

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

객체 Class를 반환하는 모든 메소드에 동일하게 적용됩니다 Class.

이 답변에 대한 Joachim Sauer의 의견에 대해 (나는 스스로 의견을 제시 할만큼 평판이 충분하지 않습니다), 캐스트를 사용하는 예제 T[]는 컴파일러가 유형 안전을 보장 할 수 없기 때문에 경고를 표시합니다.

Ingo의 의견에 관한 편집 :

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

이것은 안전한 유형의 유일한 답변입니다

E[] a;

a = newArray(size);

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

더 많은 차원으로 확장하려면에 []및 차원 매개 변수를 추가하십시오 newInstance()( T유형 매개 변수, cls는이며 Class<T>, d1관통 d5하는 정수임).

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);

자세한 내용 Array.newInstance()을 참조하십시오.

Java 8에서는 람다 또는 메서드 참조를 사용하여 일종의 일반 배열을 만들 수 있습니다. 이것은 (을 전달하는 Class) 반사 방식과 유사 하지만 여기서는 반사를 사용하지 않습니다.

@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);
    }
}

예를 들어 이것은에 의해 사용됩니다 <A> A[] Stream.toArray(IntFunction<A[]>).

이 수 익명 클래스를 사용하여 사전에 자바 (8)을 수행 할 수 있지만, 더 복잡합니다.

이것은 효과적인 Java, 제 2 판 , 항목 25 의 5 장 (Generics)에서 다룹니다 . 배열 목록 선호

코드는 확인되지 않은 경고를 생성하지만 다음 주석으로 억제 할 수는 있지만 작동합니다.

@SuppressWarnings({"unchecked"})

그러나 Array 대신 List를 사용하는 것이 좋습니다.

OpenJDK 프로젝트 사이트 에서이 버그 / 기능에 대한 흥미로운 토론이 있습니다 .

Class 인수를 생성자에 전달할 필요는 없습니다. 이 시도.

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 + "]";
    }
}

과

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

결과:

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

Java 제네릭은 컴파일 타임에 유형을 확인하고 적절한 캐스트를 삽입하지만 컴파일 된 파일에서 유형을 지우는 방식으로 작동합니다. 이로 인해 제네릭을 이해하지 못하는 (고의적 인 디자인 결정) 코드로 제네릭 라이브러리를 사용할 수 있지만 런타임시 유형이 무엇인지 일반적으로 알 수 없습니다.

공용 Stack(Class<T> clazz,int capacity)생성자는 런타임에 Class 객체를 전달 해야합니다. 즉, 런타임시 클래스 정보 를 사용하여 필요한 클래스 정보 를 사용할 수 있습니다. 그리고Class<T> 형식은 컴파일러가 전달한 Class 객체가 T 유형의 Class 객체인지 정확하게 확인한다는 의미입니다. T의 하위 클래스가 아니라 T의 수퍼 클래스가 아니라 정확하게 T입니다.

따라서 생성자에서 적절한 유형의 배열 객체를 만들 수 있습니다. 즉, 컬렉션에 저장 한 객체의 유형에 따라 컬렉션에 추가 된 시점에서 유형이 확인됩니다.

안녕하세요 스레드가 죽었지 만 이것에주의를 기울이고 싶습니다.

제네릭은 컴파일 시간 동안 유형 검사에 사용됩니다.

• 따라서 목적은 들어오는 것이 필요한 것인지 확인하는 것입니다.
• 당신이 돌려주는 것은 소비자에게 필요한 것입니다.
• 이것을 확인하십시오 :

제네릭 클래스를 작성할 때 타입 캐스팅 경고에 대해 걱정하지 마십시오. 사용할 때 걱정하십시오.

이 솔루션은 어떻습니까?

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

작동하고 너무 단순 해 보이지 않습니다. 단점이 있습니까?

이 코드를보십시오 :

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;
}

모든 종류의 객체 목록을 동일한 유형의 배열로 변환합니다.

나는 나를 위해 빠르고 쉬운 방법을 찾았습니다. Java JDK 8에서만 이것을 사용했습니다. 이전 버전에서 작동하는지 모르겠습니다.

특정 형식 매개 변수의 제네릭 배열을 인스턴스화 할 수는 없지만 이미 생성 된 배열을 제네릭 클래스 생성자에 전달할 수 있습니다.

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

    // ...

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

    // Do whatever with the array...
}

이제 메인에서 다음과 같이 배열을 만들 수 있습니다.

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

        // ...

    }
}

배열의 유연성을 높이기 위해 링크 된 목록을 사용할 수 있습니다. Java.util.ArrayList 클래스에있는 ArrayList 및 기타 메소드

예는 Java 리플렉션을 사용하여 배열을 만드는 것입니다. 형식 안전하지 않으므로 일반적으로 권장하지 않습니다. 대신 내부 List를 사용하고 배열을 피하십시오.

값 목록 전달 중 ...

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

이 코드 스 니펫을 작성하여 간단한 자동 테스트 유틸리티를 위해 전달되는 클래스를 반사적으로 인스턴스화했습니다.

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});
}

이 세그먼트를 참고하십시오.

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

여기서 Array.newInstance (클래스의 클래스, 배열의 크기)를 시작하는 배열 . 클래스는 기본 (int.class) 및 객체 (Integer.class) 둘 다일 수 있습니다.

BeanUtils는 Spring의 일부입니다.

실제로 더 쉬운 방법은 객체 배열을 만들고 다음 예제와 같이 원하는 유형으로 캐스팅하는 것입니다.

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

여기서 SIZE상수 T는 유형 식별자입니다.

다른 사람들이 제안한 강요된 캐스트는 저에게 효과적이지 않아 불법적 인 캐스트를 예외로합니다.

그러나이 암시 적 캐스트는 정상적으로 작동했습니다.

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

여기서 Item은 멤버를 포함하여 정의한 클래스입니다.

private K value;

이 방법으로 K 유형의 배열 (항목에 값만있는 경우) 또는 항목 클래스에 정의하려는 일반 유형의 배열을 얻을 수 있습니다.

귀하가 게시 한 예에서 무슨 일이 일어나고 있는지에 대한 아무도 대답하지 않았습니다.

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;
}

다른 사람들이 말했듯이 컴파일 중에 제네릭이 "지워졌습니다". 따라서 런타임에 제네릭 인스턴스는 구성 요소 유형이 무엇인지 알지 못합니다. 그 이유는 역사적으로, Sun은 기존 인터페이스 (소스 및 이진 모두)를 손상시키지 않고 제네릭을 추가하려고했습니다.

반면에 배열은 할 런타임에 자신의 구성 요소 유형을 알고있다.

이 예제는 생성자를 호출하는 코드 (유형을 아는)가 클래스에 필요한 유형을 알려주는 매개 변수를 전달함으로써 문제를 해결합니다.

따라서 응용 프로그램은 다음과 같은 클래스를 구성합니다.

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

그리고 생성자는 이제 컴포넌트 타입이 무엇인지 (런타임에서) 알고 있으며 그 정보를 사용하여 리플렉션 API를 통해 배열을 구성 할 수 있습니다.

Array.newInstance(clazz, capacity);

마지막으로 컴파일러는 반환 된 배열 Array#newInstance()이 올바른 유형 임을 알 수있는 방법이 없기 때문에 유형 캐스트가 있습니다 (아직 알고 있지만).

이 스타일은 약간 추악하지만 때로는 어떤 이유로 든 런타임에 구성 요소 유형을 알아야하는 일반 형식을 만드는 방법 (배열 생성 또는 구성 요소 유형의 인스턴스 생성 등)에있어 가장 나쁜 해결책이 될 수 있습니다.

이 문제에 대한 일종의 해결 방법을 찾았습니다.

아래 줄은 일반 배열 생성 오류를 발생시킵니다

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

그러나 List<Person>별도의 클래스로 캡슐화 하면 작동합니다.

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


public class PersonList {

    List<Person> people;

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

게터를 통해 PersonList 클래스의 사람들을 노출시킬 수 있습니다. 아래 줄 List<Person>은 모든 요소에 배열을 제공합니다 . 즉,의 배열입니다 List<Person>.

PersonList[] personLists=new PersonList[10];

내가 작업하고있는 일부 코드에서 이와 같은 것이 필요했으며 이것이 작동하도록하는 것입니다. 지금까지 아무런 문제가 없습니다.

Object 배열을 만들어 어디서나 E로 캐스트 할 수 있습니다. 예, 그렇게하는 것이 깨끗하지는 않지만 적어도 작동해야합니다.

이 시도.

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>();
        }
    }
}

이것에 대한 쉬운 해결 방법은 주 클래스 내부에 두 번째 "홀더"클래스를 중첩시키고이를 사용하여 데이터를 보유하는 것입니다.

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

이 질문과 관련이 없지만 generic array creation사용하기 위해 " "오류가 발생하는 동안

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

나는 다음과 같은 작품을 발견했다 @SuppressWarnings({"unchecked"}).

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

이 코드가 효과적인 제네릭 배열을 만들지 궁금합니다.

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;
}

편집 : 아마도 필요한 크기가 알려져 있고 작은 경우 이러한 배열을 만드는 다른 방법은 필요한 수의 "null"을 zeroArray 명령에 공급하는 것입니까?

분명히 이것은 createArray 코드를 사용하는 것만 큼 다재다능하지는 않습니다.

캐스트를 사용할 수 있습니다.

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

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

실제로 제네릭 배열을 시작할 수 없다는 우회 할 수있는 매우 독특한 솔루션을 찾았습니다. 당신이해야 할 일은 다음과 같이 일반 변수 T를 취하는 클래스를 만드는 것입니다.

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

그런 다음 배열 클래스에서 다음과 같이 시작하십시오.

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

를 시작하면 new Generic Invoker[]체크되지 않은 상태로 문제가 발생하지만 실제로는 문제가되지 않습니다.

배열에서 얻으려면 다음과 같이 array [i] .variable을 호출해야합니다.

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

배열 크기 조정과 같은 나머지는 Arrays.copyOf ()를 사용하여 다음과 같이 수행 할 수 있습니다.

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

그리고 add 함수는 다음과 같이 추가 될 수 있습니다 :

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++;
}

vnportnoy에 따르면 구문

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

다음과 같이 채워질 null 참조 배열을 만듭니다.

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

안전한 타입입니다.

private E a[];
private int size;

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

일반 배열 생성은 Java에서 허용되지 않지만 다음과 같이 할 수 있습니다

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