13.集合框架--泛型、工具类

泛型

1.概述：

         泛型是JDK1.5出现的一种安全机制
2.好处：

          a.将运行时期的问题ClassCastException转到了编译时期

          b.避免了强制转换的麻烦

3.特点：

          a.当操作的引用数据类型不确定时，使用<>将要操作的引用数据类型传入其中

          b.泛型用于编译时期，确保类型的安全；

          c.运行时，会将泛型去掉，生成的class文件是不带泛型的，这称为泛型的擦除。

          d.运行时，通过获取元素的类型进行转换动作，不用使用者再进行强制转换，这称为泛型的补偿。

4.泛型在集合中的应用：

代码示例：

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

class ComparatorByName implements Comparator<Person> {// 定义比较器，按照姓名字典顺序排序

	@Override
	public int compare(Person o1, Person o2) {
		int temp = o1.getName().compareTo(o2.getName());

		return temp == 0 ? o1.getAge() - o2.getAge() : temp;
	}

}

class Person implements Comparable {
	private String name;
	private int age;

	Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		age = age;
	}

	 @Override
	 public int compareTo(Object obj) {//重写CompareTo方法，按年龄升序排序
	 Person p=(Person)obj;
	 int temp=this.age-p.age;
	 return temp;
	 }

}

public class GenericDemo {

	public static void main(String[] args) {
		TreeSet<Person> ts = new TreeSet<Person>(new ComparatorByName());

		ts.add(new Person("Michael", 22));
		ts.add(new Person("Tony", 47));
		ts.add(new Person("John", 18));
		ts.add(new Person("Jam", 56));

		Iterator<Person> it = ts.iterator();

		while (it.hasNext()) {
			Person p = it.next();
			System.out.println(p.getName() + ":" + p.getAge());
		}
	}

}

5.泛型类和泛型方法

         a.概述：JDK1.5以后，使用泛型来接收类中药操作的引用数据类型

         b.当类中的操作的引用数据类型不确定时，使用泛型来表示
代码示例：

class Tool<T> {// 泛型类
	private T t;

	public T getT() {
		return t;
	}

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

	public <W> void show(W t) {// 泛型方法,将泛型定义在方法上
		System.out.println("show:" + t);
	}

	public static <X> void method(X x) {// 当方法是静态时，不能访问类上定义的泛型，如果静态方法使用泛型，只能将泛型定义在方法上
		System.out.println("method:" + x);
	}
}

public class Student {
	Student() {
		System.out.println("小学生");
	}
}

public class Worker {

}

public class GenericDefineDemo {
	public static void main(String[] args) {
		// Tool<Worker> tool=new Tool<Worker>();
		//
		// tool.setT(new Student());//传入类型错误，编译失败
		//
		//
		// Worker w=(Worker)tool.getT();

		Tool<String> tool = new Tool<String>();
		tool.show(new Integer(4));

	}
}

6.泛型接口

代码示例：

//泛型接口，将泛型定义在接口上
interface Inter<T>{
	public void show(T t);
}
class InterImp implements Inter<String>{//方式一：在接口中明确泛型具体类型
	public void show(String str){
		System.out.println("show:"+str);
	}
}
class InterImp2<Q> implements Inter<Q>{//方式二：在使用时明确泛型具体类型
	public void show(Q q){
		System.out.println("show:"+q);
	}
}
public class GenericDefineDemo {
	public static void main(String[] args){
		InterImp it=new InterImp();
		it.show("abc");
		
		InterImp2<Integer> it2=new InterImp2<Integer>();
		it2.show(5);
	}
}

7.泛型限定

         a.限定上限： <？ extends E> 表示接收E类型或E的子类型对象

代码示例：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

class Person {
	private int age;
	private String name;

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getName() {
		return name;
	}

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

	public Person(String name, int age) {
		this.age = age;
		this.name = name;
	}

}

class Student extends Person {
	private int age;
	private String name;

	public Student(String name, int age) {
		super(name, age);

	}

	public String toString() {
		return "Student:" + getName() + "-" + getAge();
	}

}

class Worker extends Person {
	private String name;
	private int age;

	public Worker(String name, int age) {
		super(name, age);
	}

	public String toString() {
		return "Worker:" + getName() + "-" + getAge();
	}

}

public class GenericAdvanceDemo {

	public static void main(String[] args) {
		ArrayList<Worker> al = new ArrayList<Worker>();
		al.add(new Worker("Man1", 45));
		al.add(new Worker("Man2", 30));

		ArrayList<Student> al2 = new ArrayList<Student>();
		al2.add(new Student("Child1", 20));
		al2.add(new Student("Child2", 22));

		printCollection(al);
		printCollection(al2);
	}

	public static void printCollection(Collection<? extends Person> al) {// 限定上限，指定集合中的部分集合类型
																			// 指定集合中的部分集合类型
		Iterator<? extends Person> it = al.iterator();

		while (it.hasNext()) {
			System.out.println(it.next());
		}

	}

}

           b.限定下限： <? super E> 表示接收E类型或E类型的父类型

代码示例：

	public static void printCollection(Collection<? super Student> al) {// 限定下限
																			// 指定集合中的部分集合类型
		Iterator<? super Student> it = al.iterator();
 
		while (it.hasNext()) {
			System.out.println(it.next());
		}

	}

工具类

1.Collections:

           a.概述：此类完全由在 collection 上进行操作或返回 collection 的静态方法组成

           b.常用方法：

代码示例：

import java.awt.List;
import java.util.ArrayList;
import java.util.Collections;
import java.util.TreeSet;

public class CollectionsDemo {

	public static void main(String[] args) {
//		mySort();         排序
//		myBinarySearch(); 二分查找
//		myMax();          获取最大值
//		myReverseOrder(); 逆序
//	    myReplace();	       替换
//		myShuffle();      随机置换元素位置
	}

	private static void myShuffle() {
		ArrayList<String> list = new ArrayList<String>();

		list.add("a");
		list.add("c");
		list.add("d");
		list.add("b");
		
		Collections.shuffle(list);
		System.out.println(list);
		
	}

	private static void myReplace() {
		ArrayList<String> list = new ArrayList<String>();

		list.add("a");
		list.add("c");
		list.add("d");
		list.add("b");
		System.out.println(list);
		//static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)使用另一个值替换列表中出现的所有某一指定值。 
		Collections.replaceAll(list, "b", "bbbbbbbb");
		System.out.println(list);
		//static <T> void fill(List<? super T> list, T obj) 使用指定元素替换指定列表中的所有元素。 
		Collections.fill(list, "haha");
		System.out.println(list);
		
	}

	private static void myReverseOrder() {
		//static <T> Comparator<T> reverseOrder(Comparator<T> cmp) 返回一个比较器，它强行逆转指定比较器的顺序。
		TreeSet ts=new TreeSet(Collections.reverseOrder());
		
		ts.add("a");
		ts.add("d");
		ts.add("b");
		ts.add("c");
		
		System.out.println(ts);
		 
	
	}

	private static void myMax() {
		ArrayList<String> list = new ArrayList<String>();

		list.add("a");
		list.add("c");
		list.add("d");
		list.add("b");
		
		//static <T extends Object & Comparable<? super T>> T  max(Collection<? extends T> coll) 根据元素的自然顺序，返回给定 collection 的最大元素。 
		String max=Collections.max(list);
		System.out.println(max);
	}

	private static void myBinarySearch() {
		ArrayList<String> list = new ArrayList<String>();

		list.add("a");
		list.add("c");
		list.add("d");
		list.add("b");
		Collections.sort(list);
		System.out.println(list);
		
		//static <T> int  binarySearch(List<? extends Comparable<? super T>> list, T key) 使用二分搜索法搜索指定列表，以获得指定对象。 
		int index=Collections.binarySearch(list, "b");
		System.out.println("index:"+index);
		
		
	}

	public static void mySort() {
		ArrayList<String> list = new ArrayList<String>();

		list.add("a");
		list.add("c");
		list.add("d");
		list.add("b");
		System.out.println(list);

		//static <T extends Comparable<? super T>> void sort(List<T> list) 根据元素的自然顺序 对指定列表按升序进行排序。  对list集合进行指定顺序的排序
		// Collections.sort(list);
		meSort(list);
		System.out.println(list);
	}

	private static <T extends Comparable<? super T>> void meSort(ArrayList <T> list) {
		for (int i = 0; i < list.size() - 1; i++) {
			for (int j = i + 1; j < list.size(); j++) {
				if (list.get(i).compareTo(list.get(j)) > 0) {
//					T temp = list.get(i);
//					list.set(i, list.get(j));
//					list.set(j, temp);
					Collections.swap(list, i, j);//static void swap(List<?> list, int i, int j)  在指定列表的指定位置处交换元素。 
				}
			}
		}
	}

}

2.Arrays

          a.概述：此类包含用来操作数组（比如排序和搜索）的各种方法，方法都是静态的。

          b.常用方法：

代码示例：

import java.util.Arrays;
import java.util.List;

public class ArraysDemo {

	public static void main(String[] args) {
//		myAsList();将数组转换成集合
		
	}



	private static void myAsList() {
		String[] arr={"abc","haha","xixi"};
		// static <T> List<T> asList(T... a) 将数组转换成集合
		//注意:如果数组中的元素是对象，那么转换成集合时，直接将数组中的元素作为集合中的元素进行存储；如果数组中的元素是基本数据类型，会将数组作为集合的元素进行存储
		List<String> list=Arrays.asList(arr);
		
		boolean b=list.contains("xixi");
		System.out.println("b="+b);
	}

}