黑马程序员——集合（一）

a982541919

于 2015-06-20 09:04:53 发布

阅读量310

点赞数

分类专栏：黑马程序员——集合

本文链接：https://blog.csdn.net/a982541919/article/details/46571969

版权

黑马程序员——集合专栏收录该内容

2 篇文章 0 订阅

订阅专栏

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

集合类的由来：

对象用于封装特有数据，对象多了需要存储，如果对象个数不确定，就使用集合容器进行存储。

集合特点：
1，用于存储对象的容器。
2，集合长度是可变的。
3，集合中不可以存储基本数据类型值。

集合容器因为内部数据结构不同，有多种具体容器。
不断的向上抽取，就形成了集合框架。

框架的顶层Collection接口：

各种集合之间的继承关系

Collection

    |--List  有序（存入和取出顺序一致），元素有索引，元素可以重复
        |--ArrayList  底层是数组数据结构，线程不同步
        |--LinkedList  底层是使用链表数据结构，线程不同步
        |--Vector  底层是数组数据结构，线程同步（已经被ArrayList集合取代）

    |--Set  元素不能重复，无序。Set集合中的方法和Collection中的方法是一致的
        |--HashSet  底层数据结构是哈希表，线程不同步
        |--TreeSet  底层数据结构是二叉树，线程不同步

Collection的特有方法（共性方法）

1，添加
boolean add(Object obj);
boolena addAdd(Collection coll);

2，删除
boolean remove(Object obj);
boolean removeAll(Collection coll);

3，判断
boolean contains(Object obj); 判断集合中是否包含obj元素
boolean containsAll(Collection coll); 判断集合中是否包含另一个集合
boolean isEmpty(); 判断集合是否为空，如果为空，返回true

4，获取
int size(); 获取集合长度
Iterator iterator(); 取出元素的方式：迭代器。
该对象依赖于具体容器，因为每一个容器的数据结构不同。
所以该迭代器对象时在容器中进行内部实现的。
对于使用容器者而言，具体实现不重要，只要通过容器获取到该实现的迭代器对象即可。
也就是iterator方法。

Iterator接口就是对所有的Collection容器进行元素取出的公共接口

5，其他
boolean retainAll(Collection coll); 取集合的交集
Object[] toArray(); 将集合转成数组

代码示例：

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

public class Demo {
    public static void main(String[] args) {
        // method_1();
        // method_2();
        method_get();
    }

    public static void method_1() {
        // 1，添加元素
        ArrayList al = new ArrayList();
        al.add("01");
        al.add("02");
        al.add("03");
        al.add("04");

        // 2，获取个数，既集合长度
        print("集合长度为：" + al.size());// 结果 集合长度为：4

        // 3，打印集合
        print("集合的值为：" + al);// 结果 集合的值为：[01, 02, 03, 04]

        // 4，删除元素
        al.remove("01");
        // al.clear();//此方法清空集合中的所有内容
        print("集合的值为：" + al);// 结果 集合的值为：[02, 03, 04]

        // 5，判断元素
        print("03是否存在：" + al.contains("03"));// 结果 03是否存在：true
        print("集合是否为空：" + al.isEmpty());// 结果 集合是否为空：false

    }

    public static void method_2() {// 获取集合的交集
        ArrayList al_1 = new ArrayList();
        al_1.add("01");
        al_1.add("02");
        al_1.add("03");
        al_1.add("04");

        ArrayList al_2 = new ArrayList();
        al_2.add("01");
        al_2.add("02");
        al_2.add("06");
        al_2.add("07");

        al_1.retainAll(al_2);// 取交集，al_1中只会保留和al_2中相同的元素

        print("al_1集合为：" + al_1);// 结果 al_1集合为：[01, 02]
        print("al_2集合为：" + al_2);// 结果 al_2集合为：[01, 02, 06, 07]
    }

    public static void method_get(){//获取集合中的数据
        ArrayList al = new ArrayList();
        al.add("01");
        al.add("02");
        al.add("03");
        al.add("04");

        Iterator it = al.iterator();//创建一个迭代器，获取集合al的迭代器，用于取出集合中的元素
        while(it.hasNext()){//判断迭代器下一个是否有元素
            print(it.next());//如果有元素则输出迭代器中的元素
        }
    }

    public static void print(Object obj) {
        System.out.println(obj);

    }
}

List集合的特有方法

增
add(index,element);
addAll(index,Collection);
删
remover(index);
改
set(index,element);
查
get(index);
subList(start,end);
listIterator(); List集合特有的迭代器

代码示例：

/*
    List集合的特有方法示例
*/
import java.awt.event.ItemListener;
import java.util.*;

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

        // 在指定位置添加元素
        al.add(1, "java009");
        print(al);// 结果：[java01, java009, java02, java03, java04]

        // 删除指定位置的元素
        al.remove(2);
        print(al);// 结果：[java01, java009, java03, java04]

        // 修改元素
        al.set(0, "java111");
        print(al);// 结果：[java111, java009, java03, java04]

        // 通过角标获取元素
        print(al.get(2));// 结果：java03

        // 获取所有元素
        for (int i = 0; i < al.size(); i++)// 方式一
            print(al.get(i));// 结果：java111 java009 java03 java04

        Iterator it = al.iterator();// 方式二
        while (it.hasNext()) {
            print(it.next());// 结果：java111 java009 java03 java04
        }
        print("index="+al.indexOf("java04"));//index=3  获取java04的角标

        List sub = al.subList(1,3);//获取1~3的子串
        print(sub);//[java009, java03]
    }

    public static void print(Object obj) {
        System.out.println(obj);
    }
}

/*
  List集合特有的迭代器。ListIterator是Iterator的子接口

  在迭代时，不可以通过集合对象的方法操作集合中的元素，
  因为会发生ConcurrentModificationException异常。 并发异常

  所以，在使用迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，
  只能对元素进行判断，取出，删除的操作。
  如果想要其他的操作如添加，修改等，就需要使用其子类的接口ListIterator。

  该接口只能通过List集合的ListIterator方法获取
*/
import java.util.*;

public class Demo {

    // 演示迭代器，普通的迭代器只具备删除方法，没有增加和修改
    public static void demoIterator() {
        ArrayList al = new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        print(al);// 结果：[java01, java02, java03, java04]

        // 在叠加过程中，准备添加或者删除元素
        Iterator it = al.iterator();// 创建一个迭代器，获取集合al的迭代器，用于取出集合中的元素。此时，迭代器已经知道al集合中有4个元素
        while (it.hasNext()) {
            Object obj = it.next();
            if (obj.equals("java02"))
                // al.add("java0003");//此方法错误，因为迭代只知道集合中已有4个元素，而这时al突然添加一个元素，而迭代器不知道已经添加了元素。会导致并发异常
                it.remove();// 将java02删除，此方法可以执行，因为在迭代过程中使用的是迭代器的方法操作集合
            print("obj="+obj);//obj=java01  obj=java02  obj=java03  obj=java04
        }
        print(al);// 结果：[java01, java03, java04]
    }

    // 演示列表迭代器，具有添加和修改
    public static void demoListIterator() {
        ArrayList al = new ArrayList();
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        print(al);// 结果：[java01, java02, java03, java04]

        // 在叠加过程中，准备添加或者删除元素
        ListIterator li = al.listIterator();// 创建一个迭代器，获取集合al的迭代器，用于取出集合中的元素
        while (li.hasNext()) {
            Object obj = li.next();// 每赋值一次，指针后移一次
            if (obj.equals("java02")) {
                // li.remove();// 将java02删除，此方法可以执行，因为在迭代过程中使用的是迭代器的方法操作集合
                // li.add("java0003");//在java02的后边添加java0003
                li.set("java0005");// 将java02修改为java0005
            }
        }
        print(al);// 结果：[java01, java0005, java03, java04]
        print(li.hasNext());// 结果：false。因为迭代器的指针已经指向最后一个元素，当再判断该指针后边是否有元素，则返回false
        print(li.hasPrevious());// 结果：true。因为迭代器的指针已经指向最后一个元素，当再判断该指针前边否有元素，则返回true

        while (li.hasPrevious())
            print(li.previous());// 结果：java04 java03 java0005
                                    // java01。每输出一个，指针前移一次
    }

    public static void main(String[] args) {
         demoIterator();
        demoListIterator();
    }

    public static void print(Object obj) {
        System.out.println(obj);
    }
}

Vector集合

/*
 枚举就是Vector特有的取出方式
 发现枚举和迭代器很像。
 其实枚举和迭代器是一样的。

 因为枚举的名称以及方法的名称都过长。
 所以被迭代器取代了。
 */
import java.util.*;
public class Demo {
    public static void main(String[] args) {
        Vector v = new Vector();

        v.add("abc01");
        v.add("abc02");
        v.add("abc03");
        v.add("abc04");

        Enumeration en = v.elements();//Vector特有的迭代器
        while(en.hasMoreElements()){//Vector特有的判断是否存在下一个元素
            System.out.println(en.nextElement());//特有的取出元素方式
        }
    }

    public static void print(Object obj) {
        System.out.println(obj);
    }
}

LinkedList集合

addFirst(); 往第一个位置添加元素
addLast(); 往第最后位置添加元素

getFist();获取第一个元素
getLast();获取最后一个元素
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException异常–>没有这个元素异常

removeFist();删除第一个元素
removeLast();删除最后一个元素
获取元素，但元素被删除。如果集合中没有元素，会出现NoSuchElementException异常–>没有这个元素异常

在JDK1.6出现了替代方法。

offerFirst();往第一个位置添加元素
offerLast();往第最后位置添加元素

peekFirst();获取第一个元素
peekLast();获取最后一个元素
获取元素，但不删除元素。如果集合中没有元素，会返回null

pollFirst();删除第一个元素
pollLast();删除最后一个元素
获取元素，但元素被删除。如果集合中没有元素，会返回null

代码示例：

import java.util.*;

public class Demo {

    public static void main(String[] args) {
        // function1();
        function2();
    }

    public static void function1() {
        LinkedList link = new LinkedList();
        link.addLast("java01");
        link.addLast("java02");
        link.addLast("java03");
        print(link);// 结果：[java01, java02, java03]

        print(link.getFirst());// 结果：java01
        print(link.getFirst());// 结果：java01注意：这里是java01

        print(link.removeFirst());// 结果：java01
        print(link.removeFirst());// 结果：java02。注意：这里是java02，因为java01已经被删除，于是java02为第一个
    }

    public static void function2() {
        LinkedList link = new LinkedList();
        link.addFirst("java01");
        link.addFirst("java02");
        link.addFirst("java03");
        print(link);// 结果：[java03, java02, java01]

        // 不用迭代器遍历link
        while (!link.isEmpty()) {//如果link不为空
            print(link.removeFirst());// 结果：java03 java02 java01
        }
    }

    public static void print(Object obj) {
        System.out.println(obj);
    }
}

ArrayList集合

ArrayList去除重复元素原理：
ArrayList在执行contains方法判断某元素是否存在于集合中时，
会调用ArrayList中元素的equasl方法，判断equals的返回值是否为true，
如果返回true，就代表两个元素相同，那么就可以选择不存入该元素。

代码示例：

/*
  练习：自定义对象作为元素存到ArrayList集合中，并去除重复元素

  比如：存人对象。同年龄且同姓名，视为同一个人。为重复元素

  思路：
  1，对人描述，将数据封装进人对象
  2，定义容器，将人对象存入
  3，取出

  记住：List集合判断元素是否相同，依据是元素的equals方法
 */
import java.util.*;

class Person {
    public String name;
    public int age;

    public Person() {
    }

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

    public boolean equals(Object obj) {
        if (!(obj instanceof Person))
            return false;
        Person p = (Person) obj;
        return this.name.equals(p.name) && (this.age == p.age);
    }
}

public class Demo {
    public static void main(String[] args) {
        //定义容器，将人对象存入
        ArrayList al = new ArrayList();
        al.add(new Person("zhangsan", 20));// al.add(Object obj);//Object obj = new Person("zhangsan",20);
        al.add(new Person("lisi", 30));
        al.add(new Person("zhangsan", 20));
        al.add(new Person("lisi", 30));
        al.add(new Person("wangwu", 40));
        al.add(new Person("wangwu", 45));

        al = function(al);

        Iterator it = al.iterator();
        while (it.hasNext()) {
            Object obj = it.next();
            Person p = (Person) obj;
            print(p.name + "..." + p.age);
        }
    }

    public static ArrayList function(ArrayList al) {
        ArrayList newal = new ArrayList();

        Iterator it = al.iterator();
        while (it.hasNext()) {
            Object obj = it.next();
            if (!newal.contains(obj)) {//List集合判断元素是否相同，依据是元素的equals方法。如果Person中的equals返回true，则代表包含元素
                        //注意：List集合是在执行contains时，才去判断equals方法
                newal.add(obj);     
            }
        }
        return newal;
    }

    public static void print(Object obj) {
        System.out.println(obj);
    }
}

HashSet集合

保证唯一性原理： HashSet集合在存入元素时，
先调用hashCode判断返回值是否相同（注意：存入时就已经开始判断，第一个元素存入除外），
如果元素的hashCode值相同，才会判断equals是否为true，
如果equals的返回值为true，则不将该元素存入。
如果元素的hashCode值不同，不会调用equals

代码示例：

/*
 * 练习：自定义对象作为元素存到HashSet集合中，并去除重复元素
 * 
 * 比如：存人对象。同年龄同姓名，视为同一个人。为重复元素
 */     
import java.util.*;
class Person{
    public String name;
    public int age;
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public boolean equals(Object obj){//为了保证对象唯一，一般都需要复写equals和hashCode
        if(!(obj instanceof Person))
            return false;
        Person p = (Person)obj;
        return this.name.equals(p.name)&&this.age==p.age;
    }
    public int hashCode(){//为了保证对象唯一，一需要复写equals和hashCode
        return name.hashCode()+age;
    }
}
public class Demo {
    public static void main(String[] args) {
        HashSet hs = new HashSet();
        //HashSet集合在存入元素之前，先调用hashCode判断返回值是否相同（注意：存入之前就判断，第一个元素存入除外），
        //如果元素的hashCode值相同，才会判断equals是否为true，如果equals的值为true，则不将该元素存入。
        //如果元素的hashCode值不同，不会调用equals
        hs.add(new Person("zhangsan",20));
        hs.add(new Person("lisi",21));
        hs.add(new Person("wangwu",22));
        hs.add(new Person("zhaoliu",23));
        hs.add(new Person("zhaoliu",23));

        System.out.println(hs.contains(new Person("zhangsan",20)));//true  contains判断是否包含也依据hashCode和equals方法
        //System.out.println(hs.remove(new Person("zhangsan",20)));//true  remove删除元素也依据hashCode和equals方法

        Iterator it = hs.iterator();
        while(it.hasNext()){
            Person p = (Person)it.next();
            print(p.name+"..."+p.age);

            /*
            结果：
            true
            wangwu...22
            zhaoliu...23
            zhangsan...20
            lisi...21

             */
        }
    }

    public static void print(Object obj) {
        System.out.println(obj);
    }
}

TreeSet集合

TreeSet第一种排序方式：
让元素自身具备比较性。元素要实现Comparable接口，覆盖ComparTo方法，
如果本类对象大于比较类，则返回正数。小于返回负数。等于返回0。
这种方式也称为元素的自然顺序，或者叫做默认顺序。
TreeSet第二种排序方式：
当元素自身不具备比较性时，或者具备的比较性不是所需要的。
这时就需要让集合具备比较性。
在集合初始化时，就有了比较方式

代码示例：

/*
  TreeSet集合的  常见错误示例：
*/
import java.util.*;

class Person {
    public String name;
    public int age;

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

public class Demo {
    /*
        会出现异常的原因是，Person类没有实现Comparable接口中的 int comparaTo(Object obj)方法。
        TreeSet是用来排序的，而一个对象要进行排序，必须覆盖comparaTo方法才可以排序，否则出现异常
     */
    public static void main(String[] args) {
        TreeSet ts = new TreeSet();//定义一个TreeSet集合

        ts.add(new Person("lisi", 20));// 当只有一个元素时，可以输出结果
        // ts.add(new Person("lisi",22));//当添加第二个元素时，出现类型转换异常 ClassCaseException

        Iterator it = ts.iterator();
        while (it.hasNext()) {
            Person p = (Person) it.next();
            print(p.name + "..." + p.age);
        }
    }

    public static void print(Object obj) {
        System.out.println(obj);
    }
}

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 o) {//此方法为实现Comparable接口的方法
                        //如果本类对象大于比较对象，则返回整数。小于则返回负数。等于返回0
        if(!(o instanceof Student))
            throw new RuntimeException();
        Student stu = (Student)o;
        if(this.age>stu.age)
            return 1;
        if(this.age == stu.age){//如果年龄相等，则再判断姓名是否相等。等主要条件相同时，要判断次要条件。
                        //如果姓名相等，返回0。如果本类姓名大于比较对象姓名，返回正数。如果小于，返回负数。
            return this.name.compareTo(stu.name);
        }
        return -1;
    }
}
public class Demo {
    public static void main(String[] args) {
        TreeSet ts = new TreeSet(); 
        //TreeSet集合在存之前，就调用Person实现Comparable的compareTo方法（注意：存入之前就已经调用，第一个元素存入除外），
        //判断Person对象中的年龄是否相同，如果年龄相同，再判断姓名是否相同，如果姓名和年龄都相同，那么compareTo方法会返回0，
        //如果compareTo返回值为0，则不存入TreeSet集合中
        ts.add(new Student("zhangsan01",22));
        ts.add(new Student("zhangsan01",22));//此结果不会输出，因为姓名年龄相同
        ts.add(new Student("zhangsan03",22));//会输出，因为姓名不同！并且姓名还按照排序输出
        ts.add(new Student("lisi08",21));
        ts.add(new Student("lisi08",22));
        ts.add(new Student("wangwu",20));

        Iterator it = ts.iterator();
        while(it.hasNext()){
            Student stu = (Student)it.next();
            print(stu.getName()+"..."+stu.getAge());

            /*结果：
            wangwu...20
            lisi08...21
            lisi08...22
            zhangsan01...22
            zhangsan03...22
            */
        }
    }
    public static void print(Object obj) {
        System.out.println(obj);
    }
}

TreeSet集合的第二种排序：

/*
 当元素自身不具备比较性，或者具备的比较性不是所需要的。
 这时需要让容器自身具备比较性。

 定义一个比较器Comparator，将比较器对象作为参数传递给TreeSet集合构造函数。

 当两者排序都存在时，以比较器为主。

 定义一个类，实现Comparator接口，覆盖compare方法

 需求：
        往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 o) {//此方法为实现Comparable接口的方法，此方法按照学生的  年龄  排序
                    //如果本类对象大于比较对象，则返回整数。小于则返回负数。等于返回0
        if(!(o instanceof Student))
            throw new RuntimeException();
        Student stu = (Student)o;
        if(this.age>stu.age)
            return 1;
        if(this.age == stu.age){//如果年龄相等，则再判断姓名是否相等。等主要条件相同时，要判断次要条件。
                        //如果姓名相等，返回0。如果本类姓名大于比较对象姓名，返回正数。如果小于，返回负数。
            return this.name.compareTo(stu.name);
        }
        return -1;
    }
}
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){//如果姓名相同，则要判断年龄是否也相同。否则姓名相同，年龄不同的没有存入
//                  //当主要条件相同时，需要判断次要条件
//          if(s1.getAge()>s2.getAge())
//              return 1;
//          if(s1.getAge()<s2.getAge())
//              return -1;
//          return 0;
//      }

        if(num==0){//此方法和上面的注释方法相同。当主要条件相同时，需要判断次要条件
            return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
        }
        return num;
    }
}
public class Demo {
    public static void main(String[] args) {
        TreeSet ts = new TreeSet(new Mycompare()); 
        ts.add(new Student("zhangsan01",22));
        ts.add(new Student("zhangsan01",22));
        ts.add(new Student("lisi08",21));
        ts.add(new Student("asan",20));
        ts.add(new Student("csan",20));
        ts.add(new Student("csan",21));

        Iterator it = ts.iterator();
        while(it.hasNext()){
            Student stu = (Student)it.next();
            print(stu.getName()+"..."+stu.getAge());

            /*
             结果：
             asan...20
             csan...20
             csan...21
             lisi08...21
             zhangsan01...22
             */
        }
    }
    public static void print(Object obj) {
        System.out.println(obj);
    }
}

Comparable接口中的compareTo方法原理：

/*
 演示 TreeSet集合   
    1，按存放顺序取出。
    2，存放顺序的倒序取出
    3，将所有元素视为相同元素
 */
import java.util.*;

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

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

    public int compareTo(Object obj) {
        return 1;// 返回1是因为，TreeSet集合是二叉树结构，存数据时数据都往树的右边存放，所以输出时，是存放的顺序取出；
        // return -1;//返回-1是因为，存放数据时，数据往数的左边存放，那么输出的结果是 存放顺序的倒序
        // return 0;//由于返回值是0，所以二叉树只存放了第一个元素，其它的元素都视为和第一个元素相同，所以没有存放进去

    }
}

public class Demo {
    public static void main(String[] args) {
        TreeSet ts = new TreeSet();

        ts.add(new Person("lisi", 22));
        ts.add(new Person("lisi", 20));
        ts.add(new Person("lisi", 24));
        ts.add(new Person("lisi", 22));

        Iterator it = ts.iterator();
        while (it.hasNext()) {
            Person p = (Person) it.next();
            System.out.println(p.name + "..." + p.age);
        }
    }
}

总结：

|--Collection
    |--List：有序（存入和取出的顺序一致），元素都有索引（角标），元素可以重复
        |--ArrayList：底层是数组数据结构。特点：查询速度很快，增删稍慢。线程不同步
            保证唯一性原理：ArrayList在执行contains方法判断某元素是否存在于集合中时，
            会调用ArrayList中元素的equasl方法，判断equals的返回值是否为true，
            如果返回true，就代表两个元素相同，那么就可以选择不存入该元素。
        |--LinkedList：底层是使用链表数据结构。特点：增删速度很快，查询稍慢。线程不同步
        |--Vector：底层是数组数据结构。现在基本不用，因为已经被ArrayList代替。
                   增删，查询都很慢。线程同步。

    |--Set：元素不能重复，无序。Set集合中的方法和Collection中的方法是一致的
        |--HashSet：底层数据结构是哈希表，线程是不同步的
            保证唯一性原理：HashSet集合在存入元素时，先调用hashCode判断返回值是否相同
            （注意：存入时就已经开始判断，第一个元素存入除外），如果元素的hashCode值相同，
            才会判断equals是否为true，如果equals的返回值为true，
            则不将该元素存入。如果元素的hashCode值不同，不会调用equals
        |--TreeSet：底层数据结构是二叉树，可以对Set集合中的元素进行排序。线程不同步
            TreeSet第一种排序方式：
                TreeSet集合在存入元素时，就调用Person实现Comparable接口的compareTo方法
                （注意：存入时就已经调用，第一个元素存入除外），
                如果姓名和年龄都相同，那么compareTo方法会返回0，
                如果compareTo返回值为0，则不存入TreeSet集合中
            TreeSet第二种排序方式：
                定义一个比较器Comparator，将比较器对象作为参数传递给TreeSet集合构造函数。
                在TreeSet集合在存入元素时，
                （注意：存入时就已经调用，第一个元素存入除外），
                如果姓名和年龄都相同，那么compare方法会返回0，
                如果compare返回值为0，则不存入TreeSet集合中