黑马程序员——单列集合 笔记第十篇

单列集合的笔记

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

1集合

1.1集合的概念

存储对象的容器，面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，存储对象，集合是存储对象最常用的一种方式。

集合的出现就是为了持有对象。集合中可以存储任意类型的对象, 而且长度可变。在程序中有可能无法预先知道需要多少个对象, 那么用数组来装对象的话, 长度不好定义, 而集合解决了这样的问题。

 

数组的特点：

1. 只能存储 同一种数据类型数据。

2. 数组一旦初始化，长度固定。

3. 数组中元素与元素之间的内存 地址是连续的。

4.  Object类型的数组对象可以存储任意类型的数据。

 

集合与数组的区别

数组和集合类都是容器

数组长度是固定的，集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象数组中存储数据类型是单一的，集合中可以存储任意类型的对象。

集合类的特点用于存储对象，长度是可变的，可以存储不同类型的对象。

 

1.2集合的分类

集合的框架体系

---|Collection: 单列集合

           ---|List: 有存储顺序, 可重复

              ---|ArrayList:    数组实现, 查找快, 增删慢

                                  由于是数组实现, 在增和删的时候会牵扯到数组

增容, 以及拷贝元素. 所以慢。数组是可以直接

按索引查找, 所以查找时较快

              ---|LinkedList:   链表实现, 增删快, 查找慢

                                  由于链表实现, 增加时只要让前一个元素记住自

己就可以, 删除时让前一个元素记住后一个元

素, 后一个元素记住前一个元素. 这样的增删效

率较高但查询时需要一个一个的遍历, 所以效率

较低

              ---|Vector:   和ArrayList原理相同, 但线程安全, 效率略低

                              和ArrayList实现方式相同, 但考虑了线程安全问

题, 所以效率略低

           ---|Set: 无存储顺序, 不可重复

              ---|HashSet

              ---|TreeSet

              ---|LinkedHashSet

---| Map: 键值对 双列集合

       ---|HashMap

       ---|TreeMap

       ---|HashTable

       ---|LinkedHashMap

 

为什么出现这么多集合容器，因为每一个容器对数据的存储方式不同，这种存储方式称之为数据结构（data structure）

注意 集合和数组中存放的都是对象的引用。

1.3什么时候该使用什么样的集合

Collection

我们需要保存若干个对象的时候使用集合。

 

List

 

 

如果我们需要保留存储顺序, 并且保留重复元素, 使用List.

如果查询较多, 那么使用ArrayList

如果存取较多, 那么使用LinkedList

如果需要线程安全, 那么使用Vector

 

 

Set

 

如果我们不需要保留存储顺序, 并且需要去掉重复元素, 使用Set.

如果我们需要将元素排序, 那么使用TreeSet

如果我们不需要排序, 使用HashSet, HashSet比

TreeSet效率高.

如果我们需要保留存储顺序, 又要过滤重复元素, 那么使用LinkedHashSet

 

2集合接口(Collection)

Collection接口有两个子接口：

List(链表|线性表)

    Set(集)

特点：

Collection中描述的是集合共有的功能(CRUD)

    List可存放重复元素，元素存取是有序的

    Set不可以存放重复元素，元素存取是无序的

java.util.Collection

       ---| Collection      描述所有接口的共性

           ----| List接口    可以有重复元素的集合

           ----| Set  接口   不可以有重复元素的集合

 

 

2：学习集合对象

    学习Collection中的共性方法，多个容器在不断向上抽取就出现了该体系。发现Collection接口中具有所有容器都具备的共性方法。查阅API时，就可以直接看该接口中的方法。并创建其子类对象对集合进行基本应用。当要使用集合对象中特有的方法，在查看子类具体内容。

查看api 文档Collection在在java.util 中（注意是大写Collection）

注意在现阶段遇到的 E T 之类的类型,需要暂时理解为object  因为涉及到了泛型.

3：创建集合对象,使用Collection中的List的具体实现类ArrayList

    1：Collection coll=new Arraylist();

2.1Collection接口的共性方法

增加：

       1：add()   将指定对象存储到容器中

                      add 方法的参数类型是Object 便于接收任意对象

       2：addAll() 将指定集合中的元素添加到调用该方法和集合中

删除：

       3：remove() 将指定的对象从集合中删除

       4：removeAll() 将指定集合中的元素删除

修改

       5：clear() 清空集合中的所有元素

判断

       6：isEmpty() 判断集合是否为空

       7：contains() 判断集合何中是否包含指定对象

           

       8：containsAll() 判断集合中是否包含指定集合

                            使用equals()判断两个对象是否相等 

获取:   9：int size()    返回集合容器的大小

 

转成数组10： toArray()   集合转换数组

 

 

单例集合:

--------| Collection  单列集合的跟接口。

-------------| List   如果是实现了List接口 的集合类特点： 有序，可重复。

-------------| Set   如果是实现了Set接口的集合类特点； 无序，不可重复。

 

添加

    add( )

    addAll(Collection  c)

   

删除

    clear()       //清除集合中的所有元素

    remove(Object o)//删除指定的元素，删除成功返回true，删除失败返回false.

    removeAll(Collection<?>c)   //删除交集元素

    retainAll(Collection<?>c)   //保留交集元素，其他元素删除。

 

判断

    contains(Objecto)   //判断该集合是否有指定的元素存在，如果有返回true，否则返回false. contains方法底层是依赖于euqals方法做比较的。

    containsAll(Collection<?>c)

    equals(Objecto)    比较两个集合对象中的对应元素是否一致。

    isEmpty()    //判断元素是否为空

 

查看

    size()  //size 查看集合中元素的个数。

 

迭代方法（遍历）：

    toArray();

//遍历集合的元素方式 1：使用toArray() 把集合中的元素存储到一个Object数组中返回。

       Object[] arr = c.toArray();

       for(int i = 0 ; i<arr.length ; i++){

           System.out.println(arr[i]);

       }

 

    iterator()

   

//遍历集合的元素方式 2：可以使用迭代器解决。

       Iterator it = c.iterator(); //获取到的就是一个迭代器，迭代器

       while(it.hasNext()){

           System.out.println(it.next());

       }

 

迭代器的作用就是用于抓取集合中的元素，遍历集合中的元素。  

Iterator存在的方法：

    hasNext()  有没有元素可迭代。

    next()    获取当前游标指向的元素，然后游标向下移动一个单位。

    remove()移除迭代器最后返回的元素

 

NoSuchElementException 没有该元素的异常，使用迭代器最常见的异常。

出现该异常的原因 ： 集合中没有元素可以迭代了，但是继续调用next方法，所以出错。

 

class Person{

    int id;

    String name;

    public Person(intid, String name) {

       super();

       this.id =id;

       this.name =name;

    }

   

    @Override

    public String toString() {//不重写时返回的是该元素的内存地址

       return"{编号："+this.id+" 姓名："+this.name+"}";

    }

   

    @Override

    public boolean equals(Object obj) {

       Person p = (Person)obj;

       return this.id==p.id;

    }

   

    @Override

    public int hashCode() {

       return this.id;

    }

}

 

class Dog{

    @Override

    public boolean equals(Object obj) {

       System.out.println("狗的equals被调用了...");

       return super.equals(obj);

    }

}

 

public class Demo3 {

    public static void main(String[] args) {

       Collection c1 = new ArrayList();

       //往集合类添加自定义的对象

       c1.add(new Person(110,"王林"));

       c1.add(new Person(119,"狗娃"));

       c1.add(new Person(112,"狗剩"));

      

       //如果判断一个人是否存在集合中，要求只要两个人的id号一致，那么就要返回true。

       System.out.println("有狗娃存在吗？"+c1.contains(new Person(119,"狗蛋"))); //contains方法底层是依赖于euqals方法做比较的。

      

       Collection c2 = new ArrayList();

       c2.add(new Person(110,"王林"));

       c2.add(new Person(112,"狗剩"));

       c2.add(new Person(119,"狗娃"));

      

       //System.out.println("c1集合有包含c2集合中的所有元素吗？"+ c1.containsAll(c2));

       System.out.println("两个集合的元素完全一致吗？"+c1.equals(c2));

 

       c1.clear();

       c1.add(null); //null也可以作为一个元素存在。

       System.out.println("判断集合是否为空元素："+c1.isEmpty());

      

       System.out.println("元素的个数："+c1.size()); // size查看集合中元素的个数。

      

       Object[] persons = c1.toArray();   //toArrary() 把集合中元素存储到一个Object数组返回。

       //遍历

       for(inti = 0 ; i<persons.length ;i++){

           Person o  =(Person)persons[i];//多态

           System.out.println(o.id);

       }

    }

}

分析:

1：Person类

    1：姓名和年龄

    2：重写hashCode和equals方法

       1：如果不重写，调用Object类的equals方法，判断内存地址，为false

           1：如果是Person类对象，并且姓名和年龄相同就返回true

       2：如果不重写，调用父类hashCode方法

           1：如果equals方法相同，那么hashCode也要相同，需要重写hashCode方法

       3：重写toString方法

           1：不重写，直接调用Object类的toString方法，打印该对象的内存地址

2.2 List

2.2.1 List 接口特有的方法

1：增加

        void add(int index, E element) 指定位置添加元素           

        boolean addAll(int index, Collection c) 指定位置添加集合 

2：删除

E remove(int index) 删除指定位置元素

 

3：修改

       E set(int index, E element)    返回的是需要替换的集合中的元素

4：查找：

        E get(int index)             注意： IndexOutOfBoundsException

       int indexOf(Object o)         //获取指定元素在集合第一次出现的索引值。找不到返回-1

       lastIndexOf(Object o) //获取指定元素在集合最后一次出现的索引值。找不到会返回-1

5：求子集合

        List<E> subList(int fromIndex, int toIndex) // 不包含toIndex  

 

记住： 操作集合的时候，凡是想用索引值操作集合对象，都需要使用List接口下面的集合类。否则不行。

 

迭代

         listIterator()

List接口特有的迭代器ListIterator：

         hasPrevious()   问是否有上一个元素

         previous()  游标先向上移动一个单位，然后获取游标指向的元素。    

         next()先获取当前游标指向的元素，然后游标向下移动一个单位。

         add(Ee)  把元素插入到当前游标指向的位置上。  

         set(Ee) 使用指定的元素替换迭代器最后一次返回的元素。

 

/*

练习：定义一个List集合，存储一批元素，然后使用三种方式遍历集合中的元素。

    方式1：使用get方法遍历。

    方式2：使用迭代器正顺遍历。

    方式3：使用迭代器逆序遍历。

*/

import java.util.ListIterator;

 

public class Demo4 {

 

    public static void main(String[] args) {

       //创建一个List的集合对象

       List list = new ArrayList();

       //添加元素

       list.add("张三");

       list.add("李四");

       list.add("王五");

      

       //方式1：使用get方法遍历。

       System.out.println("====get遍历方式==========");

       for(inti = 0 ; i<list.size() ;i++){

           System.out.print(list.get(i)+",");

       }

      

       //方式2：使用迭代器正顺遍历。

       System.out.println("\r\n====迭代器正顺遍历方式==========");

       ListIterator it = list.listIterator();

       while(it.hasNext()){

           System.out.print(it.next()+",");

       }

      

      

       //方式3：使用迭代器逆顺遍历。

       System.out.println("\r\n====迭代器逆顺遍历方式==========");

       while(it.hasPrevious()){

           System.out.print(it.previous()+",");

       }

      

       ListIterator it = list.listIterator(); //获取一个迭代器对象。

       while(it.hasNext()){

           System.out.print(it.next()+",");

           //it.add("狗娃");  //这个是迭代器的add方法。

           list.add("狗娃");//  把元素添加集合的末尾处的。

       }

       /*

        在使用迭代器迭代集合的元素的过程中一定记住:不能使用集合对象直接删除或者添加集合中的元素个数(不能改变集合中的元素个数)。否则就会出现:

        .ConcurrentModificationException这个异常。

        */

       System.out.println("集合的元素："+list);

    }

}

 

2.2.2ArrayList

-----| Collection

-----------| List  实现了List接口的集合类，特点： 有序、 可重复。

--------------| ArrayList   特点：ArrayList底层是维护了一个Object数组实现的，查询速度快，增删速度慢。

原因：由于ArrayList是数组实现, 在增和删的时候会牵扯到数组增容, 以及拷贝元素. 所以慢。数组是可以直接按索引查找, 所以查找时较快

可以考虑,假设向数组的0角标未知添加元素,那么原来的角标位置的元素需要整体往后移,并且数组可能还要增容,一旦增容,就需要要将老数组的内容拷贝到新数组中.所以数组的增删的效率是很低的.

ArrayList的应用场景：如果遇到的数据是经常要查询的，增删很少的，这时候你就可以选择使用ArrayList去使用。 比如： 高校里面的图书馆。

 

--------------| LinkedList

--------------| Vector（了解 ）

-----------| Set 

 

疑问： 使用ArrayList无参的构造函数创建一个对象的时候，默认 的初始容量是多少？ 当长度不够使用的时候自动增长多少？

    ArrayList的底层是使用了一个Object数组实现的，使用无参的构造方法时默认的初始化容量是10， 当长度不够使用的时候自动增长0.5倍。

 

ArrayList特有的方法：

    ensureCapacity(intminCapacity) //增加实例的容量，确保能够容纳最小容量参数所指定的元素数

    trimToSize()  //  将此 ArrayList 实例的容量调整为列表的当前大小。

2.2.3 LinkedList

LinkedList:链表实现,增删快, 查找慢

由于LinkedList:在内存中的地址不连续,需要让上一个元素记住下一个元素.所以每个元素中保存的有下一个元素的位置.虽然也有角标,但是查找的时候,需要从头往下找,显然是没有数组查找快的.但是,链表在插入新元素的时候,只需要让前一个元素记住新元素,让新元素记住下一个元素就可以了.所以插入很快.

由于链表实现, 增加时只要让前一个元素记住自己就可以, 删除时让前一个元素记住后一个元素, 后一个元素记住前一个元素. 这样的增删效率较高。

但查询时需要一个一个的遍历, 所以效率较低。

 

LinkedList特有的方法：

1：方法介绍

            addFirst(E e)

addLast(E e)

getFirst()

getLast()

removeFirst()

removeLast()

如果集合中没有元素，获取或者删除元

素抛：NoSuchElementException

2：数据结构

              1：栈 （1.6）

                  先进后出

                  push()

                  pop()

              2：队列（双端队列1.5）

                  先进先出

                  offer()

                  poll()

3：返回逆序的迭代器对象     

descendingIterator()   返回逆序的迭代器对象

 

 

public class Demo7 {

   

    public static void main(String[] args) {

       LinkedList list = new LinkedList();

       //添加元素

       list.add("张三");

       list.add("李四");

       list.add("王五");

 

       list.addFirst("狗娃");//把元素添加到集合的首位置

       list.addLast("狗剩"); //把元素添加到集合的末尾位置

      

       System.out.println("首元素是："+list.getFirst());

       System.out.println("末尾元素是："+list.getLast());

      

       System.out.println("删除首元素，并返回删除的元素:"+list.removeFirst()); 

       System.out.println("删除末尾的元素，并返回删除的元素："+list.removeLast());

      

       list.push("铁蛋");// push 把元素添加到集合的首位置上。

       System.out.println(list.pop() );//删除并返回集合中的第一个元素。

      

       list.offer("黑子");//offer把元素添加到集合的末尾处。

       list.poll();       // poll 删除并返回集合中的第一个元素。

 

       System.out.println("集合的元素："+list);

    }

}

 

ArrayList 和 LinkedList的存储查找的优缺点：

1、ArrayList 是采用动态数组来存储元素的，它允许直接用下标号来直接查找对应的元素。但是，但是插入元素要涉及数组元素移动及内存的操作。总结：查找速度快，插入操作慢。

2、LinkedList 是采用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快

问题：有一批数据要存储，要求存储这批数据不能出现重复数据，ArrayList、LinkedList都没法满足需求。解决办法：使用 set集合。

 

 

//需求：定义一个LinkedList存储一批人的对象，根据人的年龄进行排序。

//人类

class Person{

    String name;  //名字

    int age;  //年龄

    public Person(Stringname, intage) {

       this.name =name;

       this.age =age;

    }

   

    @Override

    public String toString() {

       return"{姓名："+this.name+"年龄："+this.age+"}";

    }

}

 

public class Demo1 {

    public static void main(String[] args) {

       //创建了一个集合对象

       LinkedList list = new LinkedList();

       //存储人

       list.add(new Person("狗娃",12));

       list.add(new Person("狗剩",8));

       list.add(new Person("铁蛋",30));

       list.add(new Person("张三",43));

       list.add(new Person("李四",4));

      

       sort(list);

    }

   

    public static void sort(LinkedList list){

       //直接排序

       for(inti = 0 ; i<list.size()-1 ;i++){

           for(intj = i+1 ; j<list.size() ; j++){

              Person p1 = (Person)list.get(i);

              Person p2 = (Person)list.get(j); 

              if(p1.age>p2.age){

                  //交换位置

                  list.set(i,p2);

                  list.set(j,p1);

              }

           }

       }

      

       //使用迭代器遍历集合的元素，查看效果

       Iterator it = list.iterator();

       while(it.hasNext()){

           System.out.println(it.next());

       }

    }

}

 

/*

需求：定义一个LinkedList存储一副扑克牌(52张)，编写一个洗牌功能。

*/

 

//扑克类

class Poker{

    String color; //花色

    String num;  //点数

    public Poker(Stringcolor, String num) {

       this.color =color;

       this.num =num;

    }

    @Override

    public String toString() {

       returncolor+num;

    }

}

 

public class Demo2 {

    public static void main(String[] args) {

       //生成了一副扑克牌

       LinkedList list = createPoker();

       //洗牌

    //  shuffPoker(list);

       showPoker(list);

    }

   

    //洗牌的功能

    public static LinkedList shuffPoker(LinkedList list){

       //创建一个随机数对象

       Random random = new Random();

       for(inti =  0 ; i<100 ;i++){

           //先随机生成两个随机索引值

           intindex1 = random.nextInt(list.size());

           intindex2 = random.nextInt(list.size());

           //交换这个两个索引值的对应的扑克牌

           Poker poker1 = (Poker)list.get(index1);

           Poker poker2 = (Poker)list.get(index2);

           //交换位置

           list.set(index2,poker1);

           list.set(index1,poker2);

       }

       returnlist;

    }

   

    //显示扑克牌的方法

    public static void showPoker(LinkedListlist){

       for(inti = 0 ; i< list.size() ; i++){

           if(i%10==9){

              System.out.println(list.get(i));

           }else{

              System.out.print(list.get(i)+"\t");

           }

          

       }     

    }

   

    //生成一副扑克牌

    public static LinkedList createPoker(){

       //定义一个集合存储扑克类

       LinkedList list = new LinkedList();

       //所有的花色

       String[] colors = {"方块","梅花","红桃","黑桃"};

       //存储所有的点数

       String[] nums =  {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};

      

       for(inti = 0 ; i<nums.length ;i++){

           for(intj = 0 ; j<colors.length ;j++){

              list.add(new Poker(colors[j],nums[i]));

           }

       }

       returnlist;

    }

}

 

2.2.4 Vector

Vector: 描述的是一个线程安全的ArrayList。  底层也是维护了一个Object的数组实现的， 与ArrayList的实现完全一致，但是ArrayList已经取代这个类了。      

ArrayList： 单线程效率高

Vector  ：多线程安全的，所以效率低

特有的方法：

 

 void addElement(E obj)  在集合末尾添加元素

 E elementAt( int index) 返回指定角标的元素

 Enumeration elements()  返回集合中的所有元素，封装到Enumeration对象中

 

 Enumeration 接口：

  boolean hasMoreElements()

          测试此枚举是否包含更多的元素。

  E nextElement()

          如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。

 

疑问： 说出ArrayList与Vector区别：

    相同点： ArrayList  与 Vector 内部都是维护了一个Obejct数组实现的。   

    不同点：

       1. ArrayList是线程不安全的，操作效率高，Vector是线程安全的，操作效率低。

       2. ArrayList 是jdk1.2的时候出现的，Vector是jdk1.0的时候出现的。

 

 

2.3 Set

---| Itreable      接口 实现该接口可以使用增强for循环

              ---| Collection      描述所有集合共性的接口

                  ---| List接口     有序，可以重复，有角标的集合

                            ---| ArrayList  

                            ---|  LinkedList

                  ---| Set接口      无序，不可以重复的集合

                            ---| HashSet  线程不安全，存取速度快。底层是依赖哈希表表实现的。

                            ---| TreeSet  红-黑树的数据结构，默认对元素进行自然排序（String）。如果在比较的时候两个对象返回值为0，那么元素重复。

2.3.1 HashSet

HashSet的存储原理：

往HashSet添加元素的时候，HashSet首先会调用元素的HashCode方法得到这个元素的哈希码值，然后通过哈希码值计算出该元素在哈希表存储的位置。

情况1：如果通过元素哈希码算出的位置没有任何元素存储，那该元素可以直接存储到哈希表中，不用调用equals方法进行比较。

情况2：如果通过元素哈希码算出的位置目前已经有其他的元素存储了，那么会调用该元素的equals方法与该位置的元素再比较一次，如果equals方法返回的是true，那么视为重复元素，不允许添加到哈希表，如果equals方法返回的是false，那么该元素允许存储。

 

HashSet 和ArrayList集合都有判断元素是否相同的方法，

booleancontains(Object o)

HashSet使用hashCode和equals方法，ArrayList使用了equals方法

public class Demo3 {

    public static void main(String[] args) {

       String str1 = "abc";

       String str2 = new String("abc");

       System.out.println("两个字符串是同一个对象吗？"+ (str1 == str2)); //false

      

       System.out.println("str1哈希码："+str1.hashCode());// hashCode码在默认情况下代表的是一个对象的内存地址。 

                                                     //String 类是已经重写了hahsCode方法，是通过字符串的字符内容算出来一个数字的。

      

       System.out.println("str2哈希码："+str2.hashCode());// 如果两个字符串的内容一致，那么hashcode的值也肯定一致。

    }

}

 

2.3.2 TreeSet

TreeSet的实现原理：

1、  往TreeSet添加元素时，如果元素具备自然顺序的特性，那么TreeSet会按照元素的自然顺序的特性进行排序存储。

2、  如果元素不具备自然顺序的特性，那么元素所属的类必须要去实现Comparable接口，把该元素的比较规则定义在CompareTo方法上。

3、  如果元素不具备自然顺序的特性，而且元素所属的类也没有实现Comparable接口，那么在创建TreeSet对象时必须传入一个比较器对象。

 

注意：

    1.TreeSet判断是否为重复元素的依据是根据CompareTo方法的，如果CompareTo方法返回0，那么就视为重复元素，不允许添加。

    2. 如果往treeSet添加元素 的时候，元素所属的类实现了Compareble接口，在创建treeSet对象的时候又传入了比较器对象，   那么是以比较器的比较规则优先。

class Book implements Comparable{

    int id;

    String name;

    int price;

    public Book(intid,  String name,int price) {

       this.id =id;

       this.name =name;

       this.price =price;

    }

    @Override

    public String toString() {

       return"{ 编号 "+this.id+"书名："+this.name+"价格："+this.price+"}";

    }

    //把元素的比较规则定义在compareTo方法上。

    // 如果this对象小于、等于或大于指定对象，则分别返回负整数、零或正整数

    @Override

    public int compareTo(Object o) {

       Book b = (Book)o;

       System.out.println(this.name+"<----->"+b.name);

       return this.price - b.price;

    }

}

 

//自定义一个比较器类

class IdComparaTorimplements Comparator{

 

    //元素与元素的比较规则是定义在compare方法。

    //根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数

    @Override 

    public int compare(Object o1, Object o2) {

       Book b1 = (Book)o1;

       Book b2 = (Book)o2;

       returnb1.id- b2.id;

    }

}

 

public class Demo6 {

    public static void main(String[] args) {

      

       //创建一个比较器,在Treeset对象传入一个比较器对象

       IdComparaTor comparaTor =new IdComparaTor();

       TreeSet tree = new TreeSet(comparaTor );

      

//     TreeSet tree = new TreeSet( );

       //添加元素

       tree.add(new Book(120,"西游记",100));

       tree.add(new Book(110,"三国演义",200));

       tree.add(new Book(101,"水浒传",300));

       tree.add(new Book(108,"红楼梦",500));

      

       System.out.println(tree);

    }

}

 

字符串的比较规则:  

    情况一：  两个字符串找到了对应的不同字符，那么比较的就是第一次出现的不同字符。   

    情况二： 两个字符串找不到不同的字符，那么就比较字符串的长度。

 

/*

例如String str="8 10 15 5 2 7";    "2 5 7 8 10 15"

*/

public class Demo8 {

    public static void main(String[] args) {

       String str="8 10 15 5 2 7"; 

       String[] datas = str.split(" ");

       //创建treeSet对象    

       TreeSet tree = new TreeSet();

       for (inti = 0; i < datas.length; i++) {

           tree.add(Integer.parseInt(datas[i]));//注意：把字符串转成Int类型的数据是使用Integer.parseInt()

       }                

       //遍历TreeSet集合，拼装成一个字符串对象 

       Iterator it = tree.iterator();

       StringBuilder sb = new StringBuilder();

       while(it.hasNext()){

           sb.append(it.next()+" ");         

       }     

       System.out.println(sb);    

    }

}

2.3.3 LinkedHashSet

会保存插入的顺序。

 

看到array，就要想到角标。

看到link，就要想到first，last。

看到hash，就要想到hashCode,equals.

看到tree，就要想到两个接口。Comparable，Comparator。