java----集合类

集合类

一、TreeSet集合

Set：无序，元素不可重复。

|——HashSet：数组结构是哈希表，线程是非同步的。

保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同还会继续判断元素的equals方法是否为true。

|——TreeSet：可以对Set集合进行排序。底层数据结构是二叉树。保证元素唯一性的依据compareTo方法return 0。

TreeSet排序的第一种方式：

让元素自身具备比较性，元素需要实现Comparable接口。覆盖compareTo方法。这种方式也称为元素的自然顺序，或者叫做默认顺序。

练习：存储自定义对象，需要往TreeSet集合中存储自定义对象。想按照学生的年龄进行排序。

import java.util.*;
//建立学生对象，属性：姓名，年龄
class Student
{
	private String name;
	private int age;
	Student(String name,int age){
		this.name = name;
		this.age = age;
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
	//判断学生对象是否重复
	public boolean equals(Object obj){
		if(!(obj instanceof Student))
			throw new ClassCastException("不是学生类");
		Student s = (Student)obj;
		return name.equals(s.name)&&age==s.age;
	}
	//针对性的复写hashCode，减少判断次数，提高效率
	public int hashCode(){
		return name.hashCode()+age*11;
	}
}
class Demo
{
	public static void main(String []args){
		TreeSet ts = new TreeSet();
		ts.add(new Student("lisi02",22));
		ts.add(new Student("lisi09",20));
		ts.add(new Student("lisi01",40));
		ts.add(new Student("lisi08",19));
		
		Iterator it = ts.iterator();
		while(it.hasNext()){
			Student s = (Student)it.next();
			System.out.println(s.getName()+"..."+s.getAge());
		}
	}
}

分析：出现了ClassCastException异常，提示“Student cannot be cast to java.lang.Comparable”，大概意思是说：学生类不能转换为Comparable。原因就是：TreeSet是要对对象进行排序的，而自定义对象没有说明自己的排序方式，TreeSet就无法对对象排序。所以在存入集合前，要使对象强行具备可比性，也就是实现Comparable接口。

import java.util.*;
//建立学生对象，属性：姓名，年龄
//令学生具备比较性，就可以存储在TreeSet当中，要复写compareTo方法
class Student implements Comparable<Student>
{
	private String name;
	private int age;
	Student(String name,int age){
		this.name = name;
		this.age = age;
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
	public int compareTo(Student s){
		int num = new Integer(age).compareTo(new Integer(s.age));
		if(num==0)
			return name.compareTo(s.name);
		return num;
	}
	//判断学生对象是否重复
	public boolean equals(Object obj){
		if(!(obj instanceof Student))
			throw new ClassCastException("不是学生类");
		Student s = (Student)obj;
		return name.equals(s.name)&&age==s.age;
	}
	//针对性的复写hashCode，减少判断次数，提高效率
	public int hashCode(){
		return name.hashCode()+age*11;
	}
}
class Demo
{
	public static void main(String []args){
		TreeSet ts = new TreeSet();
		ts.add(new Student("lisi02",22));
		ts.add(new Student("lisi09",20));
		ts.add(new Student("lisi01",40));
		ts.add(new Student("lisi08",19));
		
		Iterator it = ts.iterator();
		while(it.hasNext()){
			Student s = (Student)it.next();
			System.out.println(s.getName()+"..."+s.getAge());
		}
	}
}

注：排序时，当主要条件相同时，一定要判断次要条件。

神马是二叉树？

答：二叉树存储方式图示

TreeSet排序的第二种方式：

当元素自身不具备比较性时，或者具备的比较性不是所需要的，这时就需要让集合自身具备比较性。在集合初始化时就有了比较方式。

TreeMap(Comparator<? super K> comparator)构造一个新的、空的树映射，该映射根据给定比较器进行排序。

比较器Comparator：当元素自身不具备比较性，或者具备的比较性不是所需要的，这时就需要让容器自身具备比较性。定义一个比较器，吧比较器对象作为参数传递给TreeSet集合的构造函数。
练习：按照学生的姓名进行排序

import java.util.*;
//建立学生对象，属性：姓名，年龄
//令学生具备比较性，就可以存储在TreeSet当中，要复写compareTo方法
class Student implements Comparable<Student>
{
	private String name;
	private int age;
	Student(String name,int age){
		this.name = name;
		this.age = age;
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
	public int compareTo(Student s){
		int num = new Integer(age).compareTo(new Integer(s.age));
		if(num==0)
			return name.compareTo(s.name);
		return num;
	}
	//判断学生对象是否重复
	public boolean equals(Object obj){
		if(!(obj instanceof Student))
			throw new ClassCastException("不是学生类");
		Student s = (Student)obj;
		return name.equals(s.name)&&age==s.age;
	}
	//针对性的复写hashCode，减少判断次数，提高效率
	public int hashCode(){
		return name.hashCode()+age*11;
	}
}
//定义比较器,需要继承Comparator接口，并复写里面的方法
class myCom implements Comparator
{
	public int compare(Object o1,Object o2){
		Student s1 = (Student)o1;
		Student s2 = (Student)o2;
		int num = s1.getName().compareTo(s2.getName());
		if(num==0){
			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
		}
		return num;
	}
	//因为Object中已经有了equals方法，所以可以不用复写。
}
class Demo
{
	public static void main(String []args){
		TreeSet ts = new TreeSet(new myCom());
		ts.add(new Student("lisi02",22));
		ts.add(new Student("lisi09",20));
		ts.add(new Student("lisi01",40));
		ts.add(new Student("lisi08",19));
		
		Iterator it = ts.iterator();
		while(it.hasNext()){
			Student s = (Student)it.next();
			System.out.println(s.getName()+"..."+s.getAge());
		}
	}
}

注：当两种排序都存在时，议比较器为主。

练习：按照字符串长度排序。

字符串本身具备比较性，但它的比较性不是所需要的。这时就只能使用比较器。

import java.util.*;
class Demo
{
	public static void main(String []args){
		TreeSet ts = new TreeSet(new myCom());
		ts.add("sacdxzw");
		ts.add("abc");
		ts.add("k");
		ts.add("ax");
		ts.add("afcgaw");
		
		Iterator it = ts.iterator();
		while(it.hasNext()){
			String s = (String)it.next();
			System.out.println(s);
		}
	}
}
class myCom implements Comparator
{
	public int compare(Object o1,Object o2){
		String s1 = (String)o1;
		String s2 = (String)o2;
		int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
		if(num==0)
			return s1.compareTo(s2);
		return num;
	}
}

二、泛型

例：

import java.util.*;
class Demo
{
	public static void main(String []args){
		ArrayList al = new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add(4);

		Iterator it = al.iterator();
		while(it.hasNext()){
			String s = (String)it.next();
			System.out.println(s+":"+s.length());
		}
	}
}

分析：编译没有问题，运行跑出类型转换异常。应为在集合中有两种类型String和整型。若何避免错误发生呢？

泛型：JDK1.5版本以后出现的新特性，用于解决安全，是一个类型安全机制。

解决：

import java.util.*;
class Demo
{
	public static void main(String []args){
		ArrayList<String> al = new ArrayList<String>();
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add(4);

		Iterator<String> it = al.iterator();
		while(it.hasNext()){
			String s = it.next();
			System.out.println(s+":"+s.length());
		}
	}
}

编译不通过。

好处：

1.将运行时期出现的出现的问题转移到了编译时期，方便程序员解决问题，让运行时期问题减少。安全。

2.避免了强制转换的麻烦。

泛型格式：通过"<>"来定义要操作的引用数据类型。

在使用Java提供的对象时，什么时候写泛型呢？

答：通常在集合框架很常见。只要看到"<>"就要定义泛型。其实"<>"就是用来接收类型的。当使用集合时，将集合中要存储的数据类型作为参数传递到"<>"中即可。

例：按照字符串长度排序。

import java.util.*;
class Demo
{
	public static void main(String []args){
		TreeSet<String> al = new TreeSet<String>(new myCom());
		al.add("abcd");
		al.add("cc");
		al.add("cba");
		al.add("aaa");
		al.add("z");
		al.add("hahaha");

		Iterator<String> it = al.iterator();
		while(it.hasNext()){
			String s = it.next();
			System.out.println(s);
		}
	}
}
class myCom implements Comparator<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;
	}
}

如果需要降序排列，则只要将s1和s2位置对调就可以了。

泛型应用：

没有泛型前：

class Student
{
	public void show(){
		System.out.println("Student");
	}
}
class Woker
{
	public void show(){
		System.out.println("Woker");
	}
}
class Tool
{
	private Object obj;
	public void setObject(Object obj){
		this.obj = obj;
	}
	public Object getObject(){
		return obj;
	}
}
class Demo
{
	public static void main(String []args){
		Tool t = new Tool();
		t.setObject(new Student());
		Student s = (Student)t.getObject();
		s.show();
	}
}

缺点：容易发生转换异常，必须明确对象。

有了泛型以后：

class Student
{
	public void show(){
		System.out.println("Student");
	}
}
class Woker
{
	public void show(){
		System.out.println("Woker");
	}
}
class Tool<QQ>
{
	private QQ q;
	public void setObject(QQ q){
		this.q = q;
	}
	public QQ getObject(){
		return q;
	}
}
class Demo
{
	public static void main(String []args){
		Tool<Student> t = new Tool<Student>();
		t.setObject(new Student());
		Student s = t.getObject();
		s.show();
	}
}

神马时候定义泛型？

答：当类型中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展，现在定义泛型来完成扩展。

泛型的定义：

1.泛型定义在类上。

class Test<T>
{
	public void show(T t){
		System.out.println("show:"+t);
	}
}
class Demo
{
	public static void main(String []args){
		int a = 100;
		new Test<Integer>().show(a);
	}
}

分析：泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

2.泛型定义在方法上，可以让不同方法操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。

class Test<T>
{
	public void show(T t){
		System.out.println("show:"+t);
	}
	public <E> void print(E e){
		System.out.println("print:"+e);
	}
}
class Demo
{
	public static void main(String []args){
		Test<Integer> t = new Test<Integer>();
		int a = 100;
		t.show(a);
		String s = "hello";
		t.print(s);
	}
}

特殊之处：静态方法不可以访问类上定义的泛型，如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。

class Test<T>
{
	public void show(T t){
		System.out.println("show:"+t);
	}
	public <E> void print(E e){
		System.out.println("print:"+e);
	}
	public static <W> void method(W w){
		System.out.println("method:"+w);
	}
}
class Demo
{
	public static void main(String []args){
		Test<Integer> t = new Test<Integer>();
		int a = 100;
		t.show(a);
		String s = "hello";
		t.print(s);
		char c = 'a';
		Test.method(c);
	}
}

注：泛型定义在方法上时，要放在返回类型前。

3.泛型定义在接口上

interface Inter<T>
{
	void show(T t);
}
class Interimpl implements Inter<String>
{
	public void show(String s){
		System.out.println("show:"+s);
	}
}
class Demo
{
	public static void main(String []args){
		String s = "hello";
		Interimpl in = new Interimpl();
		in.show(s);
	}
}

如果实现时也不明确类型：

interface Inter<T>
{
	void show(T t);
}
class Interimpl<T> implements Inter<T>
{
	public void show(T t){
		System.out.println("show:"+t);
	}
}
class Demo
{
	public static void main(String []args){
		String s = "hello";
		Interimpl<String> in = new Interimpl<String>();
		in.show(s);
	}
}

泛型的高级应用：

使用"<?>"通配符：

import java.util.*;
class Test
{
	public static void printColl(ArrayList<?> al){
		Iterator<?> it = al.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}
}
class Demo
{
	public static void main(String []args){
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc1");
		al.add("abc2");
		al.add("abc3");

		ArrayList<Integer> al1 = new ArrayList<Integer>();
		al1.add(4);
		al1.add(7);
		al1.add(1);

		Test.printColl(al);
		Test.printColl(al1);
	}
}

使用泛型"<T>"：

import java.util.*;
class Test
{
	public static <T> void printColl(ArrayList<T> al){
		Iterator<T> it = al.iterator();
		while(it.hasNext()){
			T t = it.next();
			System.out.println(t);
		}
	}
}
class Demo
{
	public static void main(String []args){
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc1");
		al.add("abc2");
		al.add("abc3");

		ArrayList<Integer> al1 = new ArrayList<Integer>();
		al1.add(4);
		al1.add(7);
		al1.add(1);

		Test.printColl(al);
		Test.printColl(al1);
	}
}

定义"<T>"和"<?>"的区别：

<T>：代表具体类型。

<?>：代表占位符，说明这有泛型。

泛型限定（重点）：

? extends E：可以接收E类型或者E类型的子类。上限。

? super E：可以接收E类型或者E类型的父类。下限。

注：使用泛型不能使用类的特有方法。

练习：将学生和工人存集合

import java.util.*;
class Person
{
	private String name;
	Person(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
}
class Student extends Person
{
	Student(String name){
		super(name);
	}
}
class Worker extends Person
{
	Worker(String name){
		super(name);
	}
}
class Test
{
	public static void printColl(ArrayList<? extends Person> al){
		Iterator<? extends Person> it = al.iterator();
		while(it.hasNext()){
			System.out.println(it.next().getName());
		}
	}
}
class Demo
{
	public static void main(String []args){
		ArrayList<Student> al = new ArrayList<Student>();
		al.add(new Student("zhangsan01"));
		al.add(new Student("zhangsan02"));
		al.add(new Student("zhangsan03"));

		ArrayList<Worker> al1 = new ArrayList<Worker>();
		al1.add(new Worker("lisi01"));
		al1.add(new Worker("lisi02"));
		al1.add(new Worker("lisi03"));

		Test.printColl(al);
		Test.printColl(al1);
	}
}