list集合总结

---------

集合框架（TreeSet）
Set：无序，不可以重复元素。
    |---HashSet：数据结构是哈希表。线程是非同步的。保证元素唯一性的原理：判断元素的hashCode值是否相同，如果相同，还会继续判断元素的equals方法，是否为true。
    |---TreeSet：可以对Set集合中的元素进行排序。

import java.util.*;
class TreeSetDemo
{
	public static void main(String []args)
	{
		TreeSet ts = new TreeSet();
		ts.add("cba");
		ts.add("abcd");
		ts.add("aaa");
		ts.add("abcd");
		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}

输出结果：
aaa
abcd
cba

2、集合框架（TreeSet存储自定义对象）
需求：往TreeSet集合中存储自定义对象学生，想按照学生的年龄进行排序。

import java.util.*;
class Student implements Comparable//该接口强制学生具备比较性。
{
	private String name ;
	private int age;
	public Student(String name, int age)
	{
		this.name = name ;
		this.age =age ;
	}
	public String getName()
	{
		return name ;
		
	}
	public int getAge()
	{
		return age ;
	}
	public int compareTo(Object obj)
	{
		if(!(obj instanceof Student ))
		{
			throw new RuntimeException("不是学生对象");
		}
		Student s = (Student ) obj;
		System.out.println(this.name +"...com..."+s.name);
		if(this.age > s.age)
		{
			return 1;
		}
		if(this.age == s.age)
		{
			return this.name.compareTo(s.name);//记住排序时，当主要条件相同时，一定要判断一下次要条件
		}
		return -1;
	}
}
class TreeSetTest
{
	public static void main(String []args)
	{
		TreeSet ts = new TreeSet();
		ts.add(new Student("lisi02",22));//往TreeSet里存的对象必须具备比较性
		ts.add(new Student("lisi007",20));
		ts.add(new Student("lisi09",19));
		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());
		}
		
	}
}

输出：
lisi02...com...lisi02
lisi007...com...lisi02
lisi09...com...lisi02
lisi09...com...lisi007
lisi01...com...lisi007
lisi01...com...lisi02
lisi08...com...lisi007
lisi08...com...lisi09
lisi08....19
lisi09....19
lisi007....20
lisi02....22
lisi01....40

3、集合框架（二叉树）
图：

 现在有一个需求：如何按存进去的顺序取出元素？
解：在接口Comparable中的功能compareTo(Object obj)里只写return 1;这样会导致二叉树会按一下图存储：

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

TreeSet排序的第一种方式：让它自身具备比较性。元素需要实现Comparable接口，覆盖这种方式也成为元素的自然顺序，或叫默认顺序。

4、集合框架（实现Comparator方法排序）
TreeSet的第二种排序方式：当元素自身不具备比较性时，或者具备的比较性不是需要的，这时就需要让集合自身具备比较性，在集合一初始化时，就有了比较方式。

当元素自身不具备比较性时，或者具备的比较性不是所需要的，这时需要让容器自身具备比较性，定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

而当两种排序都存在时，以比较器为主，定义一个类，实现Comparator接口，覆盖compare方法。

以下是测试代码：

import java.util.*;
class Student implements Comparable//该接口强制学生具备比较性。
{
	private String name ;
	private int age;
	public Student(String name, int age)
	{
		this.name = name ;
		this.age =age ;
	}
	public String getName()
	{
		return name ;
		
	}
	public int getAge()
	{
		return age ;
	}
	public int compareTo(Object obj)
	{
		if(!(obj instanceof Student ))
		{
			throw new RuntimeException("不是学生对象");
		}
		Student s = (Student ) obj;
		System.out.println(this.name +"...com..."+s.name);
		if(this.age > s.age)
		{
			return 1;
		}
		if(this.age == s.age)
		{
			return this.name.compareTo(s.name);//记住排序时，当主要条件相同时，一定要判断一下次要条件
		}
		return -1;
	}
}
class TreeSetDemo
{
	public static void main(String []args)
	{
		TreeSet ts = new TreeSet(new MyCompare());
		ts.add(new Student("lisi02",22));
		ts.add(new Student("lisi02",21));
		ts.add(new Student("lisi007",20));
		ts.add(new Student("lisi09",19));
		ts.add(new Student("lisi06",18));
		ts.add(new Student("lisi06",18));
		ts.add(new Student("lisi007",20));
		Iterator it = ts.iterator();
		while (it.hasNext())
		{
			Student s = (Student)it.next();
			System.out.println(s.getName()+"..."+s.getAge());
		}
		
	}
}
class MyCompare 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;
	}
}

输出：

lisi007...20
lisi02...21
lisi02...22
lisi06...18
lisi09...19

5、集合框架（TreeSet练习）

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

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

import java.util.*;
class StrLenComparator 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 ;
	}
}
class TreeSetDemo
{
	public static void main(String []args)
	{
		TreeSet ts = new TreeSet(new StrLenComparator());
		ts.add("abcd");
		ts.add("cc");
		ts.add("cba");
		ts.add("aaa");
		ts.add("zz");
		ts.add("hahaha");
		ts.add("z");
		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
	
}

 输出：
z
cc
zz
aaa
cba
abcd
hahaha

6、集合框架（泛型概述）
泛型：JDK1.5版本后出现了新特性，用于解决安全问题，是一个安全机制。
好处：1、将运行时期出现的问题ClassCastException转移到了编译时期，方便于程序员解决问题。让运行时期问题减少，安全。
            2、避免了强制转换麻烦。

import java.util.*;
class GenericDemo
{
	public static void main(String []args)
	{
		ArrayList <String>  al = new ArrayList<String>();
		al.add("abc01");
		al.add("abc2121");
		al.add("abcasd");
		//al.add(4);
		//al.add(new Integer(4));
		//以上注释掉的代码是不允许的，编译失败，是由泛型限制导致的
		
		Iterator<String> it = al.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}

输出：
abc01
abc2121
abcasd

7、集合框架（泛型使用）
泛型格式：通过<>来定义要操作的引用数据结构。
在使用Java提供的对象时，什么时候使用泛型？
通常在集合框架中很常见，只要见到<>就是用来定义泛型，其实<>就是用来接收类型的，当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

import java.util.*;
class GenericDemo2
{
	public static void main(String []args)
	{
		TreeSet ts = new TreeSet(new StrLenComparator());
		ts.add("abcd");
		ts.add("cc");
		ts.add("cba");
		ts.add("aaa");
		ts.add("zz");
		ts.add("hahaha");
		ts.add("z");
		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
}
class StrLenComparator implements Comparator<String>//使用泛型
{
	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 ;
	}
}

输出：
z
cc
zz
aaa
cba
abcd
hahaha

8、泛型框架（泛型类）
什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，早期定义Oject来完成扩展，现在 定义泛型来完成扩展。

测试代码

import java.util.*;
class GenericDemo3_1
{
	public static void main(String []args)
	{
		/*
		Tool t = new Tool();
		t.setObject(new Student());
		Worker w = (Worker)t.getObject();
		//Exception in thread "main" java.lang.ClassCastException: Student cannot be cast to Worker at GenericDemo3.main(GenericDemo3.java:8)
		*/
		//以上代码出现异常。
		Utils u = new Utils();
		u.setObject(new Student());
		Worker w = (Worker)u.getObject();
		//以上代码在编译时期就有提醒风险。
	}
}
class Worker
{}
class Student
{
}
class Tool
{
	private Object obj;
	public void setObject(Object obj)
	{
		this.obj = obj ;
	}
	public Object getObject()
	{
		return obj;
	}
}
class Utils<QQ>
{
	public QQ q;
	public void setObject(QQ q)
	{
		this.q = q;
	}
	public QQ getObject()
	{
		return q ;
	}
}

输出：

 
9、集合框架（泛型方法）
泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有操作的类型就已经固定了，为了让不同方法可以操作不同类型，而且类型还不能确定，那么可以将泛型定义在方法上。

import java.util.*;
class GenericMethodTest
{
	public static void main(String []	args)
	{
		GenericMethod d = new GenericMethod()	;
		d.show("asadsada");
		d.show(4);
		d.print("asadfasda");
		d.print(212);
	}
}
class GenericMethod
{
	public <T> void show(T t)
	{
		System.out.println("show:"+t);
	}
	public <Q> void print (Q q)
	{
		System.out.println("print:"+q);
	}

}

输出：

10、集合框架（静态方法泛型）
特殊之处：静态方法不可以访问类上定义的泛型，如果静态方法操作的应用数据不确定，可以将泛型定义在方法上：格式

public <W> static void method(W w){}//正确
public static <W> void method(W w){}//错误，<W>的位置要注意，位置是固定的。

11、集合框架（泛型接口）

import java.util.*;
//泛型定义在接口上
interface Inter<T>
{
	void show(T t);

}
/*//这样可以，注释了为了令另外的代码运行
class InterImpl implements Inter<String >
{
	public void show(String t)
	{
		System.out.println("show:"+t);
	}
}
*/

class InterImpl<T> implements Inter<T>
{
	public void show(T t )
	{
		System.out.println("show:"+t);
	}
}
class GenericDemo1
{
	public static void main(String []args)
	{
		//InterImp i = new InterImpl ();
		//i.show("haha");
		InterImpl<Integer> i = new InterImpl<Integer> ();
		i.show(4);
	}
}

输出：

 
12、集合框架（泛型限定）
? ：通配符，也可以理解为占位符。
泛型的限定：? 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 GenericDemo6
{
	public static void main(String []	args)
	{
		ArrayList<Person> al = new ArrayList<Person>();
		al.add(new Person("abc1"));
		al.add(new Person("abc2"));
		al.add(new Person("abc3"));
		al.add(new Person("abc4"));

		ArrayList<Student> al2 = new ArrayList<Student>();
		al2.add(new Student("abc--1"));
		al2.add(new Student("abc--2"));
		al2.add(new Student("abc--3"));
		printColl(al);
		printColl(al2);
	}
	public static void printColl(ArrayList<? extends Person>al)//泛型限定
	{
		Iterator<? extends Person> it = al.iterator()	;
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
	}

}

输出结果：