Apakah mungkin untuk menyelesaikan peringatan kompiler "Array generik T dibuat untuk parameter varargs"?

Ini adalah versi sederhana dari kode yang dipermasalahkan, satu kelas generik menggunakan kelas lain dengan parameter tipe generik dan perlu meneruskan salah satu tipe generik ke metode dengan parameter varargs:

class Assembler<X, Y> {
    void assemble(X container, Y... args) { ... }
}

class Component<T> {
    void useAssembler(T something) {

        Assembler<String, T> assembler = new Assembler<String, T>();

        //generates warning:
        // Type safety : A generic array of T is
        // created for a varargs parameter
        assembler.assemble("hello", something);
    }

}

Apakah ada cara yang benar untuk meneruskan parameter generik ke metode varargs tanpa menemui peringatan ini?

Tentu saja seperti itu

assembler.assemble("hello", new T[] { something });

tidak berfungsi karena Anda tidak dapat membuat array generik.

Selain menambahkan @SuppressWarnings("unchecked"), saya rasa tidak.

Laporan bug ini memiliki lebih banyak informasi tetapi bermuara pada kompiler yang tidak menyukai array tipe generik.

Tom Hawtin menunjukkan ini dalam komentar, tetapi untuk lebih eksplisit: ya, Anda dapat menyelesaikan ini di situs deklarasi (daripada situs panggilan (berpotensi banyak)): beralih ke JDK7.

Seperti yang dapat Anda lihat di posting blog Joseph Darcy , latihan Project Coin untuk memilih beberapa peningkatan bahasa tambahan kecil untuk Java 7 menerima proposal Bob Lee untuk memungkinkan sesuatu seperti@SuppressWarnings("varargs") di sisi metode untuk membuat peringatan ini hilang dalam situasi di mana ia dikenal sebagai aman.

Ini telah diterapkan di OpenJDK dengan komit ini .

Ini mungkin atau mungkin tidak berguna untuk proyek Anda (banyak orang tidak akan senang beralih ke versi JVM pra-rilis yang tidak stabil!) Tetapi mungkin itu - atau mungkin seseorang yang menemukan pertanyaan ini nanti (setelah JDK7 keluar ) akan bermanfaat.

Jika Anda mencari antarmuka tipe fasih, Anda bisa mencoba pola builder. Tidak sesingkat varargs tetapi jenisnya aman.

Metode statis yang diketik secara umum dapat menghilangkan beberapa pelat ketel saat menggunakan pembangun, sembari tetap mempertahankan keamanan jenisnya.

Pembangun

public class ArgBuilder<T> implements Iterable<T> {

    private final List<T> args = new ArrayList<T>();

    public ArgBuilder<T> and(T arg) {
        args.add(arg);
        return this;
    }

    @Override
    public Iterator<T> iterator() {
        return args.iterator();
    }

    public static <T> ArgBuilder<T> with(T firstArgument) {
        return new ArgBuilder<T>().and(firstArgument);
    }
}

Menggunakannya

import static com.example.ArgBuilder.*;

public class VarargsTest {

    public static void main(String[] args) {
        doSomething(new ArgBuilder<String>().and("foo").and("bar").and("baz"));
        // or
        doSomething(with("foo").and("bar").and("baz"));
    }

    static void doSomething(Iterable<String> args) {
        for (String arg : args) {
            System.out.println(arg);
        }
    }
}

Pengecoran parameter secara eksplisit ke Object dalam pemanggilan metode vararg akan membuat kompiler senang tanpa beralih ke @SuppressWarnings.

public static <T> List<T> list( final T... items )
{
    return Arrays.asList( items );
}

// This will produce a warning.
list( "1", 2, new BigDecimal( "3.5" ) )

// This will not produce a warning.
list( (Object) "1", (Object) 2, (Object) new BigDecimal( "3.5" ) )

// This will not produce a warning either. Casting just the first parameter to 
// Object appears to be sufficient.
list( (Object) "1", 2, new BigDecimal( "3.5" ) )

Saya percaya masalah di sini adalah bahwa kompiler perlu mencari tahu apa jenis konkret array untuk dibuat. Jika metode ini tidak generik, kompiler dapat menggunakan informasi tipe dari metode. Jika metode ini generik, ia mencoba mencari tahu tipe array berdasarkan parameter yang digunakan saat doa. Jika tipe parameternya homogenik, tugas itu mudah. Jika mereka berbeda, kompiler mencoba menjadi terlalu pintar menurut saya dan membuat array generik tipe-serikat. Maka terasa wajib untuk memperingatkan Anda tentang hal itu. Solusi yang lebih sederhana adalah membuat Object [] ketika tipe tidak dapat dipersempit dengan lebih baik. Solusi di atas hanya memaksakan hal itu.

Untuk memahami ini lebih baik, bermain-main dengan doa ke metode daftar di atas dibandingkan dengan metode list2 berikut.

public static List<Object> list2( final Object... items )
{
    return Arrays.asList( items );
}

Anda dapat menambahkan @SafeVarargs ke metode sejak Java 7, dan Anda tidak perlu membuat catatan pada kode klien.

class Assembler<X, Y> {

    @SafeVarargs
    final void assemble(X container, Y... args) {
        //has to be final...
    }
}

Anda dapat memiliki kelebihan metode. Ini tidak menyelesaikan masalah Anda tetapi meminimalkan jumlah peringatan (dan ya, ini peretasan!)

class Assembler<X, Y> {
  void assemble(X container, Y a1) { ... }
  void assemble(X container, Y a1, Y a2) { ... }
  void assemble(X container, Y a1, Y a2, Y a3) { ... }
  void assemble(X container, Y a1, Y a2, Y a3, Y a4) { ... }
  void assemble(X container, Y... args) { ... }
}

Ini adalah masalah yang sangat mudah untuk dipecahkan: Gunakan List<T>!

Susunan jenis referensi harus dihindari.

Dalam versi Java saat ini (1.7), Anda dapat menandai metode @SafeVargsyang akan menghapus peringatan dari pemanggil. Hati-hati dengan itu, dan Anda masih lebih baik tanpa array warisan.

Lihat juga Peringatan Kompiler yang Ditingkatkan dan Kesalahan Saat Menggunakan Parameter Formal yang Tidak Dapat Diperbaiki dengan catatan teknis Metode Varargs .

Ketika bekerja dengan array tipe generik, saya terpaksa memberikan referensi ke tipe generik. Dengan itu, saya benar-benar dapat melakukan kode generik, menggunakan java.lang.reflect.Array.

http://java.sun.com/javase/6/docs/api/java/lang/reflect/Array.html