集合框架__【泛型】

---------------------------------------- android培训、java培训、期待与您交流！ ------------------------------------

泛型：

JDK1.5版本的新特性，用于解决安全问题，是一个类型安全机制
泛型的好处
1，将运行时期出现的问题ClassCastException转移到了编译时期；便于程序员解决问题，减小安全隐患
2，避免了强转的麻烦，

使用场景：
格式：通过<>来定义要操作的引用数据类型
在集合框架中比较常见，见到<>就定义了泛型，<>就是用来接收类型的；在迭代器，比较器，容器中使用
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可

 

例如描述学生类时复写hashCode()、equals()、compare()方法。HashSet、TreeSet中都可以存入

泛型使用示例

package collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListTest {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();//使用泛型，只能传入String类型的数据
		list.add("abc");
		list.add("bbc");
		list.add("cbc");
		list.add("cbc");
		List<String> list2 = new ArrayList<String>();
		for (int i = 0; i < list.size(); i++) {
			if (!list2.contains(list.get(i))) {
				list2.add(list.get(i));
			}
		}
		Iterator<String> it = list.iterator();//迭代器中使用泛型，如果it.next是Object类型，如果不使用泛型还需要强转
		while (it.hasNext()) {
			String str = it.next();
			if (!list2.contains(str)) {
				list2.add(str);
			}
			System.out.println(list2);
		}

	}

}

比较器中定义泛型：

/**
 * 比较器中定义泛型
 * 
 * @author lWX207643
 * 
 */
class myCompare implements Comparator<String> {

	// 传入类型限制为String,不需要在向下转型
	@Override
	public int compare(String o1, String o2) {
		// 比较长度
		int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
		if (num == 0) {
			return o1.compareTo(o2);	//如果长度相同，则进行正常的比较
		}
		return num;		//如果换位将o1、o2换位即可
	}

}

 

泛型类

当类中要操作的引用数据不确定时：早期定义Object完成扩展，而且会在运行时引发安全隐患；需要类型强转
现在定义泛型来完成扩展，将错误转移到编译时期，安全隐患会在编译时就排除；而且不用强转类型

 

示例：

 

package collection;

class Utils<T> {// 泛型类，作为获取不同对象的工具

	private T t;

	public T getT() {
		return t;
	}

	public void setT(T t) {
		this.t = t;
	}
}

public class GenericDemo {
	public static void main(String[] args) {
		Utils<String> u = new Utils<String>();
		u.setT("abc"); // 定义泛型為String，传入其他类型则编译出错
		String str = u.getT();
		System.out.println(str);
	}
}

泛型类的优点 ：
强大之处在于可以传入任何类型的对象引用，而不需要再定义多个重载函数
泛型类的局限性：
泛型类定义的泛型在整个类中都有效，被方法调用泛型类的对象要操作的类型一旦确定，就固定了，如下示例：

                   Utils<String> u = new Utils<String>();// 只能操作String类型
		u.setT("abc"); // 定义泛型為String，传入其他类型则编译出错
		String str = u.getT();
		System.out.println(str);

		Utils<Integer> u2 = new Utils<Integer>();// 只能操作Integer类型
		u2.setT(5);
		System.out.println(u2.getT());

泛型方法

为了让让不同方法可以操作不同的类型，且类型不确定，可以将泛型定义在方法上；打破了泛型类的局限性
在泛型类中可以同时存在泛型方法；
该类中的方法如果不自定义泛型就与类的泛型一致，
而如果该类中的方法也定义了泛型，该方法就不受类泛型的限制，可以传入任意对象。
特殊之处：静态方法不可以访问类上的泛型，如果静态方法操作的应用数据类型不确定，就将泛型定义在方法上

package collection;

class Demo<T> { // 泛型类
	public <T> void show(T t) {
		System.out.println("show :" + t);
	}

	public <Q> void print(Q q) {
		System.out.println("print:" + q);
	}

	// 静态方法不能访问类的泛型，泛型类中必须将泛型定义在方法上
	public static <S> void method(S s) {
		System.out.println("static method:" + s);
	}
}

public class GenericDemo2 {
	public static void main(String[] args) {
		Demo<String> d = new Demo<String>();
		d.show("haha");
		d.print(123);
		d.print(false);
		Demo.method(456);
	}
}

泛型接口

泛型定义在接口上，作为了解

package collection;

interface Inter<T> {
	void show(T t);
}

class Demo2<T> implements Inter<T> {

	@Override
	public void show(T t) {
		System.out.println("show:" + t);

	}

}

public class GenericDemo3 {
	public static void main(String[] args) {
		Demo2<Integer> d = new Demo2<Integer>();
		d.show(123);
	}
}

 

泛型限定

高级应用

? 通配符，也可理解为占位符，可以传入任意类型
？extends E：可以接受E类型或E的子类型。 上限 <? extends Person>
？ super E ：可以接收E类型或者E的父类型。下限<? super Student>

上限实例：

package collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

class Person3 {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Person3(String name) {
		super();
		this.name = name;
	}

	public Person3() {
		super();
		// TODO Auto-generated constructor stub
	}
}

class Student3 extends Person3 {
	public Student3(String name) {
		super(name);
	}
}

public class GenericDemo4 {
	public static void main(String[] args) {
		List<Person3> list = new ArrayList<Person3>();
		list.add(new Person3("Person1"));
		list.add(new Person3("Person2"));
		list.add(new Person3("Person3"));
		print(list);

		List<Student3> list2 = new ArrayList<Student3>();
		list2.add(new Student3("Student1"));
		list2.add(new Student3("Student2"));
		list2.add(new Student3("Student3"));
		print(list2);
	}

	public static void print(List<? extends Person3> list) {
		Iterator<? extends Person3> it = list.iterator();
		while (it.hasNext()) {
			System.out.println(it.next().getName());
		}
	}
}

下限实例：

class Student implements Comparable<Student>//<? super E>
{
	public int compareTo(Person s)
	{
		this.getName();
	}
}
class Comp implements Comparator<Person>//下限
{
	public int compare(Person s1,Person s2)
	{
		//Person s1 = new Student("hahha");
		return s1.getName().compareTo(s2.getName());
	}
}
//在主函数中的操作中：
	TreeSet<Student> ts = new TreeSet<Student>(new Comp());//下限可以接收Person及其子类Student
	ts.add(new Student("aaa1"));
	ts.add(new Student("aaa2"));
	ts.add(new Student("aaa3"));

  ---------------------------------------- android培训、java培训、期待与您交流！ ------------------------------------