泛型

应用：

1. 类型安全检查

2. 编写通用Java程序

类型安全检查

JDK5 之前集合对象使用问题：

（1）向集合添加任何类型对象。

（2）从集合取出对象时，数据类型丢失，使用与类型相关方法，强制类型转换。

泛型语法： List<泛型类型> 规定 List集合中元素类型

泛型技术：只是编译器阶段技术，为javac命令，起到类型安全检查作用，生成.class文件后，泛型信息将会被擦除。

List— 参数化模型

例：

public void demo1() {
// 应用泛型集合
List<String> list = new ArrayList<String>();// 这个集合只能添加String类型数据
list.add("泛型集合");
list.add("指定数据类型");
for (int i = 0; i < list.size(); i++) {
String s = list.get(i);// 取出数据
System.out.println(s);
}
}

可以利用泛型技术对 Map、Set、List进行类型安全检查

List: ArrayList和LinkedList

对List遍历存在三种方法：

（1）list是有序的可以通过size 和get（index）方法进行遍历

（2）因为List继承collection接口，可以通过Collection 的iterator进行遍历。

（3）JDK5引入 foreach循环结构

例：

@Test
public void demo2() {
// 使用类型安全list
List<String> list = new LinkedList<String>();
// 使用泛型，只能向list添加 String类型
list.add("aaa");
list.add("bbb");
list.add("ccc");

// 遍历list 三种方法
// 1. 由于list是有序的 通过 size和get方法进行遍历
for (int i = 0; i < list.size(); i++) {
String s = list.get(i);
System.out.println(s);
}
System.out.println("----------");
// 2. 由于list继承collection接口 通过collection的iterator方法 进行遍历
Iterator<String> iterator = list.iterator();
// 遍历iterator 通过迭代器hasNext 和next方法进行遍历
while (iterator.hasNext()) {
String s = iterator.next();
System.out.println(s);
}
System.out.println("----------");
// 3.jdk5 引入foreach循环
for (String s : list) {
System.out.println(s);
}
System.out.println("----------");
}

Set: HashSet 使用hashCode和equals 进行排重

TreeSet使用compareable中的compareTo进行排重和排序

对 Set取出遍历有两种方法（因为是无序的，比list少一种方法）

（1）继承Collection 使用Iterator遍历

（2）JDK5foreach循环结构

@Test
public void demo3() {
// 使用类型安全的set
Set<String> set = new TreeSet<String>();
set.add("abc");
set.add("def");
set.add("cef");

// 由于 set是无序的 因此 比list 少了一种方法
// 1.set继承collection 使用 Iterator进行遍历
Iterator<String> iterator = set.iterator();
while (iterator.hasNext()) {
String s = iterator.next();
System.out.println(s);
}

// 2.JDK5 引入foreach循环
for (String s : set) {
System.out.println(s);
}
}

Map: 是一个键值对结构 执行两个类型的泛型

遍历方法两种：

（1）通过keySet

（2）通过 EntrySet取出每一个键值对，getKey和getValue

@Test
public void demo5() {
// 使用类型安全的map map 是一个键值对结构 执行两个类型的泛型
Map<String, String> map = new HashMap<String, String>();
map.put("111", "aaa");
map.put("222", "bbb");
// 取出map 两种方法，
// 1.通过 keyset
Set<String> keys = map.keySet();
for (String s : keys) {
System.out.println(s + ":" + map.get(s));
}

// 2.通过map entrySet 获得每一个键值对
Set<Map.Entry<String, String>> entrySet = map.entrySet();
for (Entry<String, String> entry2 : entrySet) {
System.out.println(entry2.getKey() + ": " + entry2.getValue());

}

}

使用泛型对象进行类型转换时，等号两端对象使用泛型的类型必须一致

2. 编写通用java程序

通常是结合反射技术一起使用

自定义泛型方法

（1）定义泛型方法，必须在方法的返回值前进行泛型类型声明<泛型类型>

使用泛型方法，参数必须是对象类型

@Test
public void demo7() {
// 将数组元素进行倒序排列
Integer[] arr1 = new Integer[] { 1, 2, 3, 4, 5, 6 };
reverce(arr1);
System.out.println(Arrays.toString(arr1));
String[] arr2 = new String[] { "aa", "bb", "cc", "dd", "ee", "ff" };
reverce(arr2);
System.out.println(Arrays.toString(arr2));

}

// 属于引用传递 不需要返回值
public <T> void reverce(T[] arr) {
/**
* 只需要遍历数组的前一半的元素，然后和后一半元素进行交换
*
* */
for (int i = 0; i < arr.length / 2; i++) {
T temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
}
}

@Test
// 交换数组的位置
public void demo6() {
Integer[] arr1 = new Integer[] { 1, 2, 3, 4, 5 };
ChangePosition(arr1, 1, 3);
System.out.println(Arrays.toString(arr1));
String[] arr2 = new String[] { "aa", "bb", "cc", "dd", "ee" };
ChangePosition(arr2, 1, 3);
System.out.println(Arrays.toString(arr2));
}

// 使用泛型交换数组的通用方法
public <T> void ChangePosition(T[] arr, int index1, int index2) {
T temp = arr[index1];
arr[index1] = arr[index2];
arr[index2] = temp;
}

（2）在类名后声明类的泛型，当类使用泛型后，该类中的所有方法都可以使用泛型—在类名后<泛型类型> 不对static方法生效。

public class ArrayUtils<T> {

public void reverce(T[] arr) {
/**
* 只需要遍历数组的前一半的元素，然后和后一半元素进行交换
*
* */
for (int i = 0; i < arr.length / 2; i++) {
T temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
}
}

// 使用泛型交换数组的通用方法
public void ChangePosition(T[] arr, int index1, int index2) {
T temp = arr[index1];
arr[index1] = arr[index2];
arr[index2] = temp;
}

}

@Test
public void demo8() {
// 测试 泛型类 使用
/*
* 在创建工具类对象时，使用泛型String, 这个工具类对象完成对String数组 倒序和 交换
*/
ArrayUtils<String> arrayutils = new ArrayUtils<String>();
String[] arr1 = new String[] { "aa", "bb", "cc", "dd" };
arrayutils.ChangePosition(arr1, 1, 3);
System.out.println(Arrays.toString(arr1));
arrayutils.reverce(arr1);
System.out.println(Arrays.toString(arr1));
}

3.泛型的高级应用–泛型通配符

？：任意的泛型类型

@Test
public void demo9() {
List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
print(list);

List<Integer> list2 = new ArrayList<Integer>();
list2.add(111);
list2.add(222);
list2.add(333);
print(list2);
}

public void print(List<?> list) {// 泛型类型可以是任意类型 --泛型通配符
for (Object string : list) {
System.out.println(string);
}
}