java泛型

原文链接: java泛型

上一篇: 常见函数

下一篇: PAT A1047. Student List for Course (25)

package ahao.test1;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

import sun.org.mozilla.javascript.internal.ObjArray;

/*
 * 泛型测试
 * 	泛型是给javac编译器使用的,限定集合输入类型
 * 编译完后会去掉类型信息,提升运行效率
 */
public class GenericTest {

	public static void main(String[] args) throws Exception {
		// test1();
		ArrayList<String> a = new ArrayList<String>();
		a.add("asd");
		a.add("hello");
		print(a);

		ArrayList b = new ArrayList();
		b.add(1);
		b.add("asd");
		b.add(12.1);
		print(b);

		test3();

		// 泛型方法推断,取交集
		Integer i = add(2, 3);
		Number n = add(2, 2.2);
		Object obj = add("a", 1);

		String[] strs = { "a", "b", "c", "d" };
		System.out.println(Arrays.asList(strs));
		swap(strs, 1, 2);
		System.out.println(Arrays.asList(strs));

		Object t = "aa";
		String s = autoConvert(t);
		System.out.println(s);

		test5();
	}

	// 通过反射得到泛型
	public static void test5() throws Exception {
		// 反射获得泛型类型
		ArrayList<String> arr = new ArrayList<String>();
		Method m = GenericTest.class.getMethod("apply", List.class);
		Type[] type = m.getGenericParameterTypes();
		ParameterizedType ptype = (ParameterizedType) type[0];
		System.out.println("原始类型" + ptype.getRawType());
		System.out.println("泛型实际类型"
				+ ptype.getActualTypeArguments()[0]);
	}

	// 辅助方法
	public static void apply(List<Date> list) {

	}

	public static void test1() throws NoSuchMethodException,
			IllegalAccessException, InvocationTargetException {
		ArrayList cols = new ArrayList();
		cols.add(1);
		cols.add("123");
		cols.add(1.2);
		System.out.println(cols.get(2).getClass());
		System.out.println(cols);

		// 保证类型一致
		ArrayList<String> arr = new ArrayList<String>();
		arr.add("ad");
		arr.add("cc");
		System.out.println(arr);

		// 编译后类型信息被消除
		ArrayList<String> arr1 = new ArrayList<String>();
		ArrayList<Integer> arr2 = new ArrayList<Integer>();
		System.out.println(arr1.getClass() == arr2.getClass());

		// 通过反射绕过类型检查
		Class cla = arr1.getClass();
		Method m = cla.getMethod("add", Object.class);
		m.invoke(arr1, 12);
		System.out.println(arr1);

		// 参数化类型不考虑继承关系
		// ArrayList<Object> a = new ArrayList<String>();

		// 数组不能使用参数化类型
		ArrayList bb[] = new ArrayList[10];
		// ArrayList<String> aa[] = new ArrayList<String>[10];
	}

	// 使用通配符打印任意参数化集合 ?表示任意类型
	public static void print(Collection<?> col) {
		// 只能调用与类型无关的方法
		col.size();
		// col.add(new Object());

		for (Object obj : col) {
			System.out.println(obj.getClass().getName() + "-" + obj.toString());
		}

		// ?通配符可引用各种其他参数化类型
		col = new ArrayList<String>();

		// 限定上界,必须是指定类的子类
		ArrayList<? extends Number> t1 = new ArrayList<Integer>();
		// ArrayList<? extends Number> t2 = new ArrayList<String>();

		// 通配符总是包括自己
		// 限定下界,必须是指定类型的父类
		ArrayList<? super Integer> t3 = new ArrayList<Number>();
		// ArrayList<? super Number> t4 = new ArrayList<String>();

	}

	// map
	public static void test3() {
		Map<String, Integer> map = new TreeMap<String, Integer>();
		map.put("ahao", 12);
		map.put("ace", 17);
		Set<Map.Entry<String, Integer>> set = map.entrySet();
		for (Entry<String, Integer> data : set) {
			System.out.println(data.getKey() + "-" + data.getValue());
		}
	}

	public static <T> T add(T x, T y) {
		return null;
	}

	// 交换任意数组元素(非基本类型)
	public static <T> void swap(T[] arr, int x, int y) {
		T t = arr[x];
		arr[x] = arr[y];
		arr[y] = t;
	}

	// 使用泛型自动转换
	public static <T> T autoConvert(Object obj) {
		return (T) obj;
	}

}

// 泛型crud
class GenericMgr<T> {
	public void add(T t) {

	}

	public T findById(String id) {
		return null;
	}

	public void del(T t) {

	}

	public Set<T> findByConditions() {
		return null;
	}

	public static <E> E findByName() {
		return null;
	}
}