Sorun kaynağı Arrays.copyOf kod anlayış var.

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

1. bu satırı kontrol nedir?

   (Object)newType == (Object)Object[].class
   

2. Ne (T[]) new Object[newLength] (T[]) Array.newInstance(newType.getComponentType(), newLength) arasında farklılıklar vardır. neden 12* *her iki durumda da yeterince iyi değil mi?

3. Bu aşağıdaki satırı derler, ama çalışma zamanında beklendiği gibi çöküyor. Bu yöntemi kullanmam gerekir mi?

   Integer[] nums = Arrays.copyOf(new String[]{"a", "b"}, 2, Integer[].class) 
   

Bu satırı kontrol nedir? (Object)newType == (Object)Object[].class

Basit eşitlik (mikro-optimizasyon amacıyla büyük olasılıkla, ama daha sonra daha fazla) kontrol ediyor.

Sıradışı döküm Class<Object[]> (Object[].class) ve Class<? extends T[]> eşsiz türleri için gereklidir. == eşitlik karşılaştırma derlemek için temel olarak, Taraflardan biri diğerinin alt veya bir supertype olmalı.

I. e. yapamayız:

// doesn't compile
// this expression can never evaluate to true
(new Integer(0) == new Float(0f))

Genel türler için kurallar biraz daha karmaşık ve bir karşılaştırma derleme olmayan birkaç durum vardır, ama yine de doğru değerlendirmek olabilir.

Class<Object[]> Object[] tüm nesne dizisi tür bir supertype olmasına rağmen Class<? extends T[]> Bir supertype değil neden bir joker varlığı olmadan Java generics are invariant.

Karşılaştırma yapmak için başka bir yol olacaktır:

(newType == (Class<? extends Object[]>)Object[].class)

Ne (T[]) new Object[newLength] (T[]) Array.newInstance(newType.getComponentType(), newLength) arasındaki farklar?

• new Object[...] bir dizi normal şekilde, statik olarak bilinen bir tür oluşturur. Unutmayın, bu kodu sadece T[] Object[] olduğunu kontrol etti.
• Array.newInstance(...) dinamik Class tipi geçirilen bir dizi oluşturmak için yansıma kullanır.

Neden 21* *Her iki durumda da yeterince iyi değil mi?

Bir işlemi kullanarak yansıma yansıtıcı olmayan meslektaşı daha generally slower.

reflection tutorial diyor ki:

Yansıma dinamik olarak çözümlenir bu tür hattınızda belli Java sanal makinesi iyileştirmeler yapılabilir. Sonuç olarak, yansıtıcı işlemleri yansıtıcı olmayan akranlarına göre daha düşük performans, sık sık performans-hassas uygulamalar olarak adlandırılan kod bölümlerde kaçınılmalıdır.

Mikro-optimizasyon ile dolu bu gibi Java SE. SE yazarlar dışında her şeyi sığdırmak için deneyin.

Ama bir performans bu durumda vurmak hakkında endişeli olmam: newInstance and copyOf HotSpot intrinsics. Bu yöntem için ideal aramalar makine-özel derleme ile değiştirilmesi anlamına gelir. Sistemli bir şekilde, bazı testler yaptım ve new Object[...] Array.newInstance(...) arasındaki fark önemsiz bulunmuştur. Soru kodu hala iyi donanımlı az Jvm'ler üzerinde yararlı olabilir, ancak muhtemelen bir kalıntı olduğunu.

Yansıma da normal bir masaüstü uygulaması için sıkı güvenlik (bir uygulama gibi) ile belirli bağlamlarda, ancak devre dışı bırakılabilir.

Bu yöntemi kullanmam gerekir mi?

Genel olarak, muhtemelen asla bu aşırı kullanacaksınız. Bu aşırı eğer dizinin türünü değiştirmek isterseniz, sadece yararlıdır.

• Genişletme:

  Object[] a = Arrays.copyOf(
      new String[] { "hello", "world" }, 3, Object[].class);
  a[2] = Character.valueOf('!');
  System.out.println(Arrays.toString(a));
  

• Daralma:

  String[] a = Arrays.copyOf(
      new Object[] { "hello", "world" }, 2, String[].class);
  System.out.println(String.join(" ", a));
  

Daha tipik Arrays.copyOf(T[], int) kullanmak için.