[Java]泛型总结

1.泛型与泛型擦除的概念

JDK5以前，对象保存到集合中就会失去其特性，取出时通常要程序员手工进行类型的强制转换，这样不可避免就会引发程序的一些安全性问题。

JDK5中的泛形允许程序员在编写集合代码时，就限制集合的处理类型， 从而把原来程序运行时可能发生问题，转变为编译时的问题，以此提高程序的可读性和稳定性(尤其在大型程序中更为突出)。

注意：泛型是提供给javac编译器使用的，它用于限定集合的输入类型，让编译器在源代码级别上，即挡住向集合中插入非法数据。但编译器编译完带有泛形的java程序后，生成的class文件中将不再带有泛形信息，以此使程序运行效率不受到影响，这个过程称之为“擦除”。

泛形的基本术语，以ArrayList<E>为例：<>念 typeof

ArrayList<E>中的 E称为类型参数变量

ArrayList<Integer>中的Integer称为 实际类型参数

整个 ArrayList<E>称为泛型类型

整个 ArrayList<Integer>称为 参数化的类型ParameterizedType( 注意这是一个类，以后反射会用到！)

2.自定义泛型

<pre name="code" class="java">//自定义带泛型的方法
public class Demo2 {
	// 先声明后使用，所以方法前先声明，参数中再用
	public <T> T a(T t) {
		return t;

	}

	// 多个泛型类型
	public <T, E, K> void b(T t, E e, K k) {

	}
}

//自定义类上的泛型
public class Demo3<T, E, K> {

	public T a(T t) {// 类上声明泛型，这里就不用再声明，直接用
		return t;
	}

	public void b(T t, E e, K k) {

	}

	// 但自定义类上的泛型不能作用于静态方法，静态方法要使用泛型只能单独声明
	public static <T> void c(T t) {// 注意声明在static关键字之后

	}
}

编写一个泛型方法，接收任意数组，颠倒数组中所有元素

代码：

public class Demo4 {

	// 编写一个泛型方法，实现指定位置上数组元素的交换
	public <T> void swap(T arr[], int pos1, int pos2) {
		T temp = arr[pos1];
		arr[pos1] = arr[pos2];
		arr[pos2] = temp;
	}

	// 编写一个泛型方法，接收任意数组，颠倒数组中所有元素
	public <T> void reverse(T arr[]) {
		// 去看算法！！！
		int start = 0;// 定义指针分别指向第一个和最后一个元素
		int end = arr.length - 1;

		while (true) {
			if (start >= end) {
				break;
			}
			T temp = arr[start];
			arr[start] = arr[end];
			arr[end] = temp;

			start++;
			end--;
		}
	}
}

3.算法书中的泛型例子（待更新）

dfs

4.泛型集合排序

自然排序：

class GenericDemo 
{
	public static void main(String[] args) 
	{
		TreeSet<String> ts=new TreeSet<String>();
		ts.add("fsldfsl");
		ts.add("Aslf");
		ts.add("A");
		ts.add("a");
		ts.add("1wel");
		ts.add("Bdls");
		ts.add("b3");

		for(Iterator<String> it=ts.iterator();it.hasNext();)
		{
			System.out.println(it.next());
		}

		
	}
}

结果：

D:\java\practice5>javac GenericDemo.java

D:\java\practice5>java GenericDemo
1wel
A
Aslf
Bdls
a
b3
fsldfsl

按照字符串长度排序：实现自定义比较器初始化集合

import java.util.*;

//实现按照字符串长度排序
class MyComparator implements Comparator<String>//只接收String类型元素
{
	public int compare(String s1,String s2)
	{
		int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));//主要排序

		if(num==0)
			return s1.compareTo(s2);//次要排序

		return num;
	}
}
class GenericDemo 
{
	public static void main(String[] args) 
	{
		TreeSet<String> ts=new TreeSet<String>(new MyComparator());
		ts.add("fsldfsl");
		ts.add("Aslf");
		ts.add("A");
		ts.add("a");
		ts.add("1wel");
		ts.add("Bdls");
		ts.add("b3");

		for(Iterator<String> it=ts.iterator();it.hasNext();)
		{
			System.out.println(it.next());
		}

		
	}
}

结果：

D:\java\practice5>javac GenericDemo.java

D:\java\practice5>java GenericDemo
A
a
b3
1wel
Aslf
Bdls
fsldfsl

如果需要按长度降序，只需在比较器中将s1和s2互换位置：比较器比较s1和s2的结果与自然比较相反而不是相同，比如s1.length()<s2.length()时返回正数，则相当于把s2排在s1前面，这样实现降序。

修改比较器：

//降序实现：内部比较将s1与s2互换位置，获得与自然排序相反的结果，即降序
class MyComparator implements Comparator<String>//只接收String类型元素
{
	public int compare(String s1,String s2)
	{
		int num=new Integer(s2.length()).compareTo(new Integer(s1.length()));//主要排序

		if(num==0)
			return s2.compareTo(s1);//次要排序

		return num;
	}
}

主程序不变，测试结果：

D:\java\practice5>javac GenericDemo.java

D:\java\practice5>java GenericDemo
fsldfsl
Bdls
Aslf
1wel
b3
a
A