TreeSet：
|——TreeSet：可以對Set集合中的元素進行排序。底層數據結構是二叉樹。
保證元素唯一性的依據：
compareTo方法return 0 。
TreeSet排序的第一種方式：讓元素自身具備比較性。元素需要實現comparable接口，覆蓋compareTo方法。這種方式也稱爲元素的自然順序，或者叫做默認順序。
TreeSet的第二種排序方式：當元素自身不具備比較性時，或者具備的比較性不是所需要的。這時就需要讓集合自身具備比較性。在集合初始化時，就有了比較方式。
定義一個類，實現Comparator接口，覆蓋compare方法。
定義了比較器，將比較器對象作爲參數傳遞給TreeSet集合的構造函數。
當兩種排序都存在時，以比較器爲主。
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class TreeSetDemo
{
/**
* @param args
*/
public static void main(String[] args)
{
TreeSet<Student> ts=new TreeSet<Student>(new MyCompare());//在兩種比較方式都有的情況下，優先比較器。
ts.add(new Student("zhangsan",18));
ts.add(new Student("zhangsan",18));
ts.add(new Student("lisi",18));
ts.add(new Student("lisi",21));
ts.add(new Student("zhangsan",19));
ts.add(new Student("zhangsan",20));
for(Iterator<Student> it=ts.iterator();it.hasNext();)
{
Student s=it.next();
System.out.println(s.getName()+"..."+s.getAge());
}
}
}
class Student implements Comparable<Student>//強制讓Student具備比較性。
{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
Student(String name,int age)
{
this.name=name;
this.age=age;
}
public int compareTo(Student s)//保證元素唯一性的依據。
{
/*if(!(obj instanceof Student))
throw new RuntimeException("不是學生對象");
Student s=(Student) obj;*/
if(this.age>s.age)
return 1;
else if(this.age==s.age)
//return 0;
return this.name.compareTo(s.name);//在比較完主要條件的情況下，還要比較次要條件。
return -1;
}
}
class MyCompare implements Comparator<Student>
{
public int compare(Student s1,Student s2)
{
int num=s1.getName().compareTo(s2.getName());
if(num==0)
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
return num;
}
}泛型：JDK1.5版本以後出現的新特性。用於解決安全問題，是一個類型安全機制。
好處是：
1.將運行時期出現問題ClassCastException，轉移盜了編譯時期。方便程序員解決問題。讓運行時問題減少，安全。
2.避免了強制轉換的麻煩。
泛型格式：通過< >來定義要操作的引用數據類型。
在使用java提供的對象時，什麼時候寫泛型呢？
通常在集合框架中很常見，只要見到< >就要定義泛型。其實< >就是用來接收類型的。
當使用集合時，將集合中要存儲的數據類型作爲參數傳遞到< >中即可。
什麼時候定義泛型類：當類中要操作的引用數據類型不確定的時候，早起定義object來完成擴展。現在定義泛型來完成擴展。
靜態方法不可以訪問類上定義的泛型。如果靜態方法操作的應用數據類型不確定，可以將泛型定義在方法上。
泛型類定義的泛型，在整個類中有效。如果被方法使用，那麼泛型類的對象明確要操作的具體類型後，所有要操作的類型就已經固定了。
爲了讓不同方法可以操作不同類型，而且類型還不確定。那麼可以將泛型定義在方法上。
public class GenericDemo
{
/**
* @泛型類和方法上的泛型的演示 */
public static void main(String[] args)
{
Demo<Integer> d=new Demo<Integer>();
d.show(2);
/*d.show("hah");
d.show('a');
d.show(2.333);*/
d.print("hah");
Demo.methot("hahhh");
}
}
class Demo<T>
{
public void show(T t)
{
System.out.println("show"+t);
}
public <Q> void print(Q q)
{
System.out.println("print"+q);
}
public static <T> void methot(T t)
{
System.out.println("method"+t);
}
}<?>通配符。也可以理解爲佔位符。
泛型的限定：
？extends E：可以接收E類型或者E的子類型，上限。
？ super E ：可以就收E類型或者E的父類型。下限。
注意在定義比較類時comparator<Person>，此處可以傳入類中要比較元素的父類，但是元素所使用的方法也必須是父類所具有的。
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class GenericDemo2
{
/**
* @param args
*/
public static void main(String[] args)
{
ArrayList<Student1> al=new ArrayList<Student1>();
al.add(new Student1("zhangsan",20));
al.add(new Student1("zhangsan1",21));
al.add(new Student1("zhangsan2",22));
printColl(al);
TreeSet<Student1> ts=new TreeSet<Student1>(new Com());
ts.add(new Student1("zhangsan",20));
ts.add(new Student1("lisi",21));
ts.add(new Student1("lisi",18));
printColl2(ts);
}
public static void printColl(ArrayList<? extends Person> al)
{
for(Iterator<? extends Person> it=al.iterator();it.hasNext();)
{
System.out.println(it.next().getAge());
}
}
public static void printColl2(TreeSet<? extends Person> al)
{
for(Iterator<? extends Person> it=al.iterator();it.hasNext();)
{
System.out.println(it.next().getAge());
}
}
}
class Person
{
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
private int age;
Person(String name,int age)
{
this.name=name;
this.age=age;
}
}
class Student1 extends Person
{
Student1(String name,int age)
{
super(name,age);
}
}
class Com implements Comparator<Person>//此處的泛型可以使用指定類的父類。? extends Student;
{
public int compare(Person p1,Person p2)
{
return p1.getName().compareTo(p2.getName());
}
}