Generics

Java

public class MyClass<T> { }

new MyClass<string>()

Map<K, V>

public <T> void method(T t){ }

String s = obj.<String>method();

制約

なし

T extends <baseclass name>

T extends <interface name>

T extends U

同じパッケージ内に共存できない

MyClass, MyClass<T>, MyClass<T,U>

java.lang.Throwable の子孫クラスをジェネリックにすることはできない

オーバーロードできない

public class MyClass {

public void method() { }

public <T> void method() { }

public <T,U> void method() { }

}

this.<String>get(); OK

<String>get(); NG

ジェネリックなコンストラクタは宣言できる

class MyClass {

<T> MyClass() {

}

}

new <String>MyClass();

class MyClass<T> {

<U> MyClass() {

}

}

<String>MyClass<Integer>();

ジェネリックなクラスの静的メンバ (フィールド・メソッド) NG

static T staticField; // 不可

static class MyNestedClass<U extends T> { // 不可

}

class MyClass<T> {

static {

System.out.println("Initialized."); //一回だけ出力される

}

public static void main(String[] args) {

new MyClass<Object>();

new MyClass<String>();

}

}

class MyGenericClass<T extends MyClass> extends Object { }

class MyGenericClass

<T extends MyClass & MyInterface1 & MyInterface2> { }

// インタフェースの制約でも implements ではなく extends と書く

class MyGenericClass

<T extends MyClass, U extends T> { }

メソッド

<T extends MyClass> T method() { }

Tは参照型のみ

int、char や double などの原始型はそのままでは扱えないので

Integer、Char や Double などのラッパークラスを使う必要がある

ジェネリックな型の配列

List[] a1 = new List[3]; // OK (非推奨)

List[] a2 = new List<?>[3]; // OK (非推奨)

List[] a3 = new List<String>[3]; // エラー

List<?>[] a4 = new List[3]; // OK (非推奨)

List<?>[] a5 = new List<?>[3]; // OK

List<?>[] a6 = new List<String>[3]; // エラー

List<String>[] a7 = new List[3]; // 警告 (非推奨)

List<String>[] a8 = new List<?>[3]; // エラー

List<String>[] a9 = new List<String>[3]; // エラー

List<String>[] a10 = (List<String>[]) new List<?>[3]; // 警告

@SuppressWarnings("unchecked")

List<String>[] a11 = (List<String>[]) new List<?>[3]; // OK

ワイルドカード

List<?> list = new ArrayList<String>();

List<?> list = new ArrayList<Object>();

List<?> list = new LinkedList<Number>();

List<?> list = new ArrayList<ArrayList<Object>>();

ワイルドカードの境界には、 extends と super が指定できる

List<? extends Number> list1 = new ArrayList<Integer>();

List<? super Number> list2 = new ArrayList<Object>();

class MyClass1<T> {

List<T> list;

void copy(List<? super T> list2) {

for (T t : list)

list2.add(t);

}

}

class MyClass2<T> {

List<T> list;

void copy(Iterable<? extends T> list2) {

for (T t : list2)

list.add(t);

}

}

サンプル

public static void method(List<? extends Number> list) {

for (Number number : list) {

System.out.println(number);

}

}

List<Integer> list = new ArrayList<Integer>(){

{

add(1);

add(2);

add(3);

}

};

Util.method(list);

List<Object> も List<String> も List<Integer> も結局は単なる List として扱われる

リフレクションにおいて実際のオブジェクトの型を扱えない

instanceof 演算子で型を判別できない

実行時にジェネリックの機能を使用できないため、パフォーマンスの面で不利

★Genericの注意点

JavaのGeneric情報はコンパイル後削除されるため、Generic化されてもBoxingを避けない

public void method(List<String> list)

public void method(List<Integer> list)

※OverLoadできず、コンパイルエラー

List<String>, List<Integer>, List<T> ⇒ List

List<String>[] ⇒ List[]

List<? extends E>, List<? super E> ⇒ List<E>

List<T extends Serializable & Cloneable> ⇒ List<Serializable & Cloneable>

List<String> list1 = new ArrayList<String>();

List<Integer> list2 = new ArrayList<Integer>();

boolean b = list1.getClass() == list2.getClass(); true

boolean b = list1 instanceof List<String>); × コンパイルエラー

boolean b = list1 instanceof List); true

boolean b = list1 instanceof ArrayList); true

List<String> list = new ArrayList<String>(); 〇

List<String>[] listArray1 = new List[6]; 〇 警告

List<String>[] listArray2 = new List<String>[6]; × コンパイルエラー

List<String>[] listArray3 = new ArrayList[6]; 〇 警告

List<String>[] listArray4 = new ArrayList<String>[6]; × コンパイルエラー

改良前

class Example<T>{

※具体的な型が確定できないため

private T t = new T(); × コンパイルエラー

private T[] tArray = new T[6]; × コンパイルエラー

private List<T> list = new ArrayList<T>(); 〇

※private List<Object> list = new ArrayList<Object>()と同じ

}

改良後

class Example<T>{

private T t;

private T[] tArray;

private List<T> list = new ArrayList<T>();

public Example() {

try{

Class<?> type = Class.forName("xxx");

t = (T)type.newInstance();

tArray = (T[])Array.newInstance(type, 6);

}catch(Exception e){

e.printStackTrace();

}

}

}

補足

public static <E> void append(List<E> list, Class<E> cls)

throws InstantiationException, IllegalAccessException {

//E elem = new E(); // NG

E elem = cls.newInstance(); // OK

list.add(elem);

}

★Wildcardの注意点

・read処理のみの場合、上限を設定、親クラスに対する操作

public static <E> void read(List<? extends E> list){

for(E e : list){

// do something

}

}

・write処理のみの場合、下限を設定、子クラスに対する操作

public static void write(List<? super Number> list){

list.add(12);

list.add(3.6);

}

・read処理とwrite処理の場合

List<E>

サンプル(Collections.copy)

public static <T> void copy(List<? super T> dest, List<? extends T> src){

...

for(int i = 0; i < src.size(); i++){

dest.set(i, src.get(i)); // srcはreadのみ、destはwriteのみ

}

...

}

PECS(producer-extends, consumer-super)

public void pushAll(Iterable<? extends E> src) {

for (E e : src) {

push(e);

}

}

public void popAll(Collection<? super E> dst) {

while (!isEmpty()) {

dst.add(pop());

}

}

<? extends T> Retrieve objects from a collection.

<? super T> Put objects in a collection.

class Apple extends Fruit { ... }

List<Apple> apples = new ArrayList<>();

apples.add(new Apple());

List<? extends Fruit> basket = apples;

basket.add(new Apple()); //Compile error

basket.add(new Fruit()); //Compile error

List<? super Apple> basket = apples;

basket.add(new Apple()); //OK

basket.add(new Fruit()); //Compile error

★Generic中のcovarianceとcontravariance

covariance 子クラスで親クラスを替える

contravariance 親クラスで子クラスを替える

class Base{

public Number method(){

// do something

}

public void method(Integer i){

// do something

}

}

class Sub extends Base{

@Override

public Integer method(){ ←covarianceの例 Overrideできる

// do something

}

public void method(Number n){ ←contravarianceの例 Overloadと相当

// do something

}

}

・Genericはcovarianceなし

Number[] n = new Integer[6]; 〇

List<Number> list = new ArrayList<Integer>(); ×

List<? extends Number> list = new ArrayList<Integer>(); 〇 真似できる

・Genericはcontravarianceなし

Integer[] n = new Number[6]; ×

List<Integer> list = new ArrayList<Number>(); ×

List<? super Integer> list = new ArrayList<Number>(); 〇 真似できる

★List<T>とList<?>

List<T> add, removeなど使える

List<?> add使えないが、remove, clear使える

★サンプル

例1

static <E> E reduce(List<E> list, Function<E> func, E initVal) {

List<E> innerList = new ArrayList<E>(list);

E result = initVal;

for (E e : innerList) {

result = func.apply(result, e);

}

return result;

}

interface Function<E> {

E apply(E arg1, E arg2);

}

例2

//public static <T extends Comparable<? super T>> T max(List<? extends T> l) {

public static <T extends Comparable<T>> T max(List<T> list) {

Iterator<T> i = list.iterator();

T result = i.next();

while (i.hasNext()) {

T t = i.next();

if (t.compareTo(result) > 0) {

result = t;

}

}

return result;

}

例3

public static <E> Set<E> union(Set<E> s1, Set<E> s2) {

Set<E> result = new HashSet<E>(s1);

result.addAll(s2);

return result;

}

↓

public static <E> Set<E> union(Set<? extends E> s1, Set<? extends E> s2) {

...

}

Set<Integer> integers = new HashSet<Integer>();

Set<Double> doubles = new HashSet<Double>();

//Set<Number> numbers = union(integers, doubles); ×

Set<Number> numbers = Xxx.<Number>union(integers, doubles);

★Map Distinct Value Types (typesafe heterogeneous container)

public class Context {

private final Map<Class<?>, Object> values = new HashMap<>();

public <T> void put(Class<T> key, T value) {

if (key == null) {

throw new NullPointerException("key is null");

}

values.put(key, key.cast(value));

}

public <T> T get(Class<T> key) {

return key.cast(values.get(key));

}

}

context.put(Runnable.class, runnable);

context.put(Executor.class, executor);

Runnable value = context.get(Runnable.class);

Runnable[] value = context.get(Runnable[].class);

List<Runnable> value = context.get(List.class); // NG