java-集合类

框架图

集合类

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。
数组和集合类同是容器，有何不同？
数组存储同一类型的基本数据类型和对象；集合可以存储不同类型的对象。数组的长度是固定的；集合的长度是可变的。

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

collection接口

Collection定义了集合框架的共性功能。
1，添加
    add(e);
    addAll(collection);

2，删除
    remove(e);
    removeAll(collection);
    clear();

3，判断。
    contains(e);
    isEmpty();

4，获取
    iterator();
    size();

5，获取交集。
    retainAll();

6，集合变数组。
    toArray();

 import java.util.*;
 class  CollectionDemo
 {
     public static void main(String[] args)
     {
         base_method();
         method_2();
     }
     public static void method_2()
     {
         ArrayList al1 = new ArrayList();

         al1.add("java01");
         al1.add("java02");
         al1.add("java03");
         al1.add("java04");

         ArrayList al2 = new ArrayList();

         al2.add("java01");
         al2.add("java02");
         al2.add("java07");
         al2.add("java08");

         al1.retainAll(al2);//5，取交集，无交集为空
         sop(al1);
         sop(al2);
     }
     public static void base_method()
     {
         //创建一个集合容器。使用Collection接口的子类。ArrayList
         ArrayList al = new ArrayList();

         //1，添加元素。
         al.add("java01");//add(Object obj);
         al.add("java02");
         al.add("java03");
         al.add("java04");

         //打印原集合。
         sop("原集合:"+al);

         //3，删除元素。
         al.remove("java03");
         al.clear();//清空集合。

         //4，判断元素。
         sop("java03是否存在:"+al.contains("java03"));
         sop("集合是否为空？"+al.isEmpty());

         //2，获取个数。集合长度。
         sop("集合长度:"+al.size());

         //打印改变后的集合。
         sop(al);

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

Iterator接口

Iterator接口可以建立引用，指向子类的对象；这个对象不是通过new建立的，而是通过iterator方法建立的。

Iterator it = arr.iterator();获取迭代器，用于取出集合中的元素。迭代器是取出方式，会直接访问集合中的元素，所以将迭代器通过内部类的形式来进行描述，通过容器的iterator()方法获取该内部类的对象。

如何获取集合的对象？每个集合都通过对外提供的一个方法，iteretor()。接口提供引用，集合提供对象，配合在一起使用，降低了使用者和取出动作的耦合性。例如，夹娃娃的机器。

 //1，代码阅读性好。
 Iterator it = arr.iterator();

 while(it.hasNext())
 {
     System.out.println(it.next());
 }
 //2，常用写法，将it作为局部变量，节省内存资源。
 for(Iterator it = arr.iterator();it.hasNext(); )
 {
     System.out.println(it.next());
 }

注意：

迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。
迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。
迭代器的next方法返回值类型是Object，所以要记得类型转换。

List接口

Collection接口有两个子接口：
List（列表），Set（集）
List：可存放重复元素，元素存取是有序的。
Set：不可以存放重复元素，元素存取是无序的。

List
   |--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
   |--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
   |--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。

List：
    特有方法。凡是可以操作角标的方法都是该体系特有的方法。

增
    add(index,element);
    addAll(index,Collection);

删
    remove(index);

改
    set(index,element);
查
    get(index):
    subList(from,to);
    listIterator();
    int indexOf(obj):获取指定元素的位置。
    ListIterator listIterator();

 import java.util.*;
 class ListDemo
 {
     public static void sop(Object obj)
     {
         System.out.println(obj);
     }
     public static void main(String[] args)
     {
         ArrayList al = new ArrayList();

         //添加元素
         al.add("java01");
         al.add("java02");
         al.add("java03");

         sop("原集合是："+al);
         //在指定位置添加元素。
         al.add(1,"java09");

         //删除指定位置的元素。
         //al.remove(2);

         //修改元素。
         //al.set(2,"java007");

         //通过角标获取元素。
         sop("get(1):"+al.get(1));
         sop(al);

         //for循环获取所有元素。
         for(int x=0; x<al.size(); x++)
         {
             System.out.println("al("+x+")="+al.get(x));
         }
         //迭代器获取所有元素
         Iterator it = al.iterator();
         while(it.hasNext())
         {
             sop("next:"+it.next());
         }

         //通过indexOf获取对象的位置。
         sop("index="+al.indexOf("java02"));
         List sub = al.subList(1,3);//获取子列表
         sop("sub="+sub);
     }
 }

在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException并发修改异常。所以，在迭代器时，只能用迭代器的方法操作元素，但是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作，如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。该接口只能通过List集合的listIterator方法获取。

 import java.util.*;
 class ListDemo
 {
     public static void sop(Object obj)
     {
         System.out.println(obj);
     }

     public static void main(String[] args)
     {
         ArrayList al = new ArrayList();

         al.add("java01");
         al.add("java02");
         al.add("java03");

         sop(al);

         ListIterator li = al.listIterator();

         sop("hasPrevious():"+li.hasPrevious());

         while(li.hasNext())
         {
             Object obj = li.next();

             if(obj.equals("java02"))
                 //li.add("java009");
                 li.set("java006");
         }
         sop("hasNext():"+li.hasNext());
         sop("hasPrevious():"+li.hasPrevious());
         while(li.hasPrevious())//逆向遍历
         {
             sop("pre::"+li.previous());
         }

         sop(al);
      }
 }
 ---------- java ----------
 [java01, java02, java03]
 hasPrevious():false
 hasNext():false
 hasPrevious():true
 pre::java03
 pre::java006
 pre::java01
 [java01, java006, java03]

 输出完成 (耗时 0 秒) - 正常终止

LinkedList特有方法

 import java.util.*;
 /*
 LinkedList:特有方法：
 addFirst();
 addLast();

 getFirst();
 getLast();
 获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

 removeFirst();
 removeLast();
 获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException

 在JDK1.6出现了替代方法。
 offerFirst();
 offerLast();

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

 pollFirst();
 pollLast();
 获取元素，但是元素被删除。如果集合中没有元素，会返回null。
 */
 class LinkedListDemo
 {
     public static void main(String[] args)
     {
         LinkedList link = new LinkedList();

         link.offerFirst("java01");
         link.offerFirst("java02");
         link.offerFirst("java03");
         link.offerFirst("java04");

         sop(link);
         sop(link.peekFirst());
         sop(link.peekLast());
         //sop(link.removeFirst());
         //sop(link.removeFirst());

         sop("size="+link.size());

         while(!link.isEmpty())
         {
             sop(link.pollLast());
         }
         sop("size="+link.size());
     }

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

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

由于数据结构不同，某些方法依赖的底层方法也不同，ArrayList和LinkedList中的contains、remove依赖的都是底层的equals方法。默认的equals方法依据对象的内存地址值来比较对象是否相同，可以根据对象的属性自定义equals方法。

 import java.util.*;
 /*
 将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
 比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。
 思路：
 1，对人描述，将数据封装进人对象。
 2，定义容器，将人存入。
 3，取出。
 List集合判断元素是否相同，依据是元素的equals方法。
 */
 class Person
 {
     private String name;
     private int age;
     Person(String name,int age)
     {
         this.name = name;
         this.age = age;
     }

     public boolean equals(Object obj)//复写equals方法
     {

         if(!(obj instanceof Person))//判断是否属于该类对象
             return false;

         Person p = (Person)obj;
         System.out.println(this.name+"和"+p.name+"比一下");

         return this.name.equals(p.name) && this.age == p.age;
     }
     public String getName()
     {
         return name;
     }
     public int getAge()
     {
         return age;
     }
 }
 class ArrayListTest
 {
     public static void sop(Object obj)
     {
         System.out.println(obj);
     }
     public static void main(String[] args)
     {
         ArrayList al = new ArrayList();

         al.add(new Person("lisi01",30));//al.add(Object obj);//Object obj = new Person("lisi01",30);
         al.add(new Person("lisi02",32));
         al.add(new Person("lisi02",32));
         al.add(new Person("lisi03",33));
         al.add(new Person("lisi04",35));

         al = singleElement(al);

         //sop("remove 03 :"+al.remove(new Person("lisi03",33)));//remove方法底层也是依赖于元素的equals方法。

         Iterator it = al.iterator();
         while(it.hasNext())
         {   //Object obj=it。next();
             //Person p = (Person)obj;
             Person p = (Person)it.next();//多态调用子类特有方法向下转型
             sop(p.getName()+"::"+p.getAge());
         }
     }
     public static ArrayList singleElement(ArrayList al)
     {
         //定义一个临时容器。
         ArrayList newAl = new ArrayList();

         Iterator it = al.iterator();

         while(it.hasNext())
         {
             Object obj = it.next();

             if(!newAl.contains(obj))//底层调用元素equals方法。
                 newAl.add(obj);

         }
         return newAl;
     }
 }
 ---------- java ----------
 lisi02和lisi01比一下
 lisi02和lisi01比一下
 lisi02和lisi02比一下
 lisi03和lisi01比一下
 lisi03和lisi02比一下
 lisi04和lisi01比一下
 lisi04和lisi02比一下
 lisi04和lisi03比一下
 lisi01::30
 lisi02::32
 lisi03::33
 lisi04::35

 输出完成 (耗时 0 秒) - 正常终止

Set接口

Set:元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。
    |--HashSet：底层数据结构是哈希表。线程是非同步的。
                保证元素唯一性的原理：
                通过元素的两个方法，hashCode和equals来完成。
                先判断元素的hashCode值是否相同。如果相同，继续判断元素的equals方法，是否为true。如果元素的hashcode值不同，则不会调用equals。

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

TreeSet排序的第一种方式：
                让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。也种方式也成为元素的自然顺序，或者叫做默认顺序。
                TreeSet的第二种排序方式：
                当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。

 HashSet练习，往HashSet集合中存入自定对象人，姓名和年龄相同为重复元素，演示了判断元素唯一性的原理。

 import java.util.*;
 class HashSetTest
 {
     public static void main(String[] args)
     {
         HashSet hs = new HashSet();

         hs.add(new Person("a1",11));
         hs.add(new Person("a2",12));
         hs.add(new Person("a3",13));
         hs.add(new Person("a2",12));
         hs.add(new Person("a4",14));

         hs.remove(new Person("a4",14));    

         Iterator it = hs.iterator();

         while(it.hasNext())
         {
             Person p = (Person)it.next();
             System.out.println(p.getName()+"::"+p.getAge());
         }

     }
 }
 class Person
 {
     private String name;
     private int age;
     Person(String name,int age)
     {
         this.name = name;
         this.age = age;
     }
     //为了获得对象独特的哈希值，避免equals判断，提高效率，创建对象时复写hashCode和equals方法
     public int hashCode()
     {
         System.out.println(this.name+"....hashCode");
         return name.hashCode()+age*37;
     }

     public boolean equals(Object obj)
     {

         if(!(obj instanceof Person))
             return false;

         Person p = (Person)obj;
         System.out.println(this.name+"...equals.."+p.name);

         return this.name.equals(p.name) && this.age == p.age;
     }
     public String getName()
     {
         return name;
     }
     public int getAge()
     {
         return age;
     }
 }
 ---------- java ----------
 a1....hashCode
 a2....hashCode
 a3....hashCode//a1，a2，a3算完哈希值没有相同的存入HashSet
 a2....hashCode
 a2...equals..a2//重复的a2算完哈希值发现相同，调用equals比较内容，发现相同视为重复元素未存。
 a4....hashCode
 a4....hashCode
 a4...equals..a4//remove方法同样调用hashCode和equals方法
 a1::11
 a3::13
 a2::12//元素是无序的。

 输出完成 (耗时 0 秒) - 正常终止

TreeSet练习，往TreeSet集合中存储自定义对象人。按人的年龄进行排序。

TreeSet排序的第一种方式：
                让元素自身具备比较性。元素实现Comparable接口，覆盖compareTo方法。

 import java.util.*;
 class TreeSetDemo1
 {
     public static void main(String[] args)
     {
         TreeSet ts = new TreeSet();

         ts.add(new Person("lisi02",22));
         ts.add(new Person("lisi007",20));
         ts.add(new Person("lisi09",19));
         ts.add(new Person("lisi08",19));
         ts.add(new Person("lisi007",20));

         Iterator it = ts.iterator();
         while(it.hasNext())
         {
             Person p = (Person)it.next();
             System.out.println(p.getName()+"..."+p.getAge());
         }
     }
 }
 class Person implements Comparable//该接口强制让Person具备比较性。
 {
     private String name;
     private int age;

     Person(String name,int age)
     {
         this.name = name;
         this.age = age;
     }
     public int compareTo(Object obj)
     {
         //return 1;//存取顺序一致
         if(!(obj instanceof Person))
             throw new RuntimeException("不是人这一类的对象");
         Person p = (Person)obj;

         System.out.println(this.name+"....compareto....."+p.name);
         if(this.age>p.age)
             return 1;
         if(this.age==p.age)
         {
             return this.name.compareTo(p.name);//String类已经实现了Comparable接口
         }
         return -1;

     }
     public String getName()
     {
         return name;

     }
     public int getAge()
     {
         return age;
     }
 }
 ---------- java ----------
 lisi02....compareto.....lisi02
 lisi007....compareto.....lisi02
 lisi09....compareto.....lisi02
 lisi09....compareto.....lisi007
 lisi08....compareto.....lisi007
 lisi08....compareto.....lisi09
 lisi08...19
 lisi09...19
 lisi007...20
 lisi02...22

 输出完成 (耗时 0 秒) - 正常终止

TreeSet的第二种排序方式：
                当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。定义一个比较器，实现Comparator接口，覆盖compare()方法（返回值是正数、负数和0），将比较器对象作为参数传递给TreeSet集合的构造函数。

 import java.util.*;
 //当两种排序都存在时，以比较器为主。主要条件判断完了判断次要条件，防止元素丢失。
 class Person implements Comparable
 {
     private String name;
     private int age;

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

     public int compareTo(Object obj)
     {

         if(!(obj instanceof Person))
             throw new RuntimeException("不是人这一类的对象");
         Person p = (Person)obj;

         if(this.age>p.age)
             return 1;
         if(this.age==p.age)
         {
             return this.name.compareTo(p.name);
         }
         return -1;

     }

     public String getName()
     {
         return name;

     }
     public int getAge()
     {
         return age;
     }
 }
 class TreeSetDemo2
 {
     public static void main(String[] args)
     {
         TreeSet ts = new TreeSet(new MyCompare());//TreeSet集合的构造函数接收比较器对象

         ts.add(new Person("lisi02",22));
         ts.add(new Person("lisi02",21));
         ts.add(new Person("lisi007",20));
         ts.add(new Person("lisi09",19));
         ts.add(new Person("lisi06",18));
         ts.add(new Person("lisi06",18));
         ts.add(new Person("lisi007",29));

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

 class MyCompare implements Comparator//定义一个比较器，实现Comparator接口，覆盖compare()方法
 {
     public int compare(Object o1,Object o2)
     {
         Person p1 = (Person)o1;
         Person p2 = (Person)o2;

         int num = p1.getName().compareTo(p2.getName());
         if(num==0)
         {

             return new Integer(p1.getAge()).compareTo(new Integer(p2.getAge()));//封装Integer对象调用compareTo方法
             /*
             if(p1.getAge()>p2.getAge())
                 return 1;
             if(p1.getAge()==p2.getAge())
                 return 0;
             return -1;
             */
         }
         return num;
     }
 }
 ---------- java ----------
 lisi007...20
 lisi007...29
 lisi02...21
 lisi02...22
 lisi06...18
 lisi09...19

 输出完成 (耗时 0 秒) - 正常终止

二叉树排序示例

创建排序二叉树的步骤，也就是不断地向排序二叉树添加节点的过程，向排序二叉树添加节点的步骤如下：

1. 以根节点当前节点开始搜索。
2. 拿新节点的值和当前节点的值比较。
3. 如果新节点的值更大，则以当前节点的右子节点作为新的当前节点；如果新节点的值更小，则以当前节点的左子节点作为新的当前节点。
4. 重复 2、3 两个步骤，直到搜索到合适的叶子节点为止。
5. 将新节点添加为第 4 步找到的叶子节点的子节点；如果新节点更大，则添加为右子节点；否则添加为左子节点。

Map

Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。一个映射不能包含重复的键，每个键最多只能映射到一个值。Collection是单列集合(“单身汉”)，Map是双列集合(“夫妻”)。

Map
    |--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。
    |--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。用作键的对象必须实现hashCode方法和equals方法。将Hashtable替代，jdk1.2.效率高。
    |--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。

Map和Set很像，其实Set底层就是使用了Map集合。

1，添加。
        put(K key, V value)
        putAll(Map<? extends K,? extends V> m)

2，删除。
        clear()
        remove(Object key)

3，判断。
        containsValue(Object value)
        containsKey(Object key)
        isEmpty()

4，获取。
        get(Object key)
        size()
        values()
        entrySet()
        keySet()

 import java.util.*;
 class  MapDemo
 {
     public static void main(String[] args)
     {
         Map<String,String> map = new HashMap<String,String>();

         //添加元素,添加元素，如果出现添加时，相同的键。那么后添加的值会覆盖原有键对应值。
         //并put方法会返回被覆盖的值。
         System.out.println("put:"+map.put("","zhangsan1"));
         System.out.println("put:"+map.put("","wnagwu"));
         map.put("","zhangsan2");
         map.put("","zhangsan3");

         System.out.println("containsKey:"+map.containsKey(""));
         System.out.println("remove:"+map.remove(""));

         System.out.println("get:"+map.get(""));

         map.put("",null);
         System.out.println("get:"+map.get(""));
         //可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。

         //获取map集合中所有的值。
         Collection<String> coll = map.values();

         System.out.println(coll);
         System.out.println(map);
     }
 }
 ---------- java ----------
 put:null
 put:zhangsan1
 containsKey:true
 remove:zhangsan2
 get:wnagwu
 get:null
 [null, wnagwu, zhangsan3]
 {=null, =wnagwu, =zhangsan3}

 输出完成 (耗时  秒) - 正常终止

Map集合的两种取出方式：
1，Set<k> keySet：

将map中所有的键存入到Set集合。因为set具备迭代器。所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。

 import java.util.*;
 class MapDemo1
 {
     public static void main(String[] args)
     {
         Map<String,String> map = new HashMap<String,String>();

         map.put("02","zhangsan2");
         map.put("03","zhangsan3");
         map.put("01","zhangsan1");
         map.put("04","zhangsan4");

         //先获取map集合的所有键的Set集合,keySet();
         Set<String> keySet= map.keySet();

         //有了Set集合。就可以获取其迭代器。
         Iterator<String> it = keySet.iterator();

         while(it.hasNext())
         {
             String key = it.next();
             //有了键可以通过map集合的get方法获取其对应的值。
             String value  = map.get(key);
             System.out.println(key+":"+value);
         }
      }
 }

2，Set<Map.Entry<k,v>> entrySet：

将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry。Entry其实就是Map中的一个static内部接口。为什么要定义在内部呢？因为只有有了Map集合，有了键值对，才会有键值的映射关系。关系属于Map集合中的一个内部事物。而且该事物在直接访问Map集合中的元素。

 import java.util.*;
 class MapDemo2
 {
     public static void main(String[] args)
     {
         Map<String,String> map = new HashMap<String,String>();

         map.put("02","zhangsan2");
         map.put("03","zhangsan3");
         map.put("01","zhangsan1");
         map.put("04","zhangsan4");

         //将Map集合中的映射关系取出。存入到Set集合中。
         Set<Map.Entry<String,String>> entrySet = map.entrySet();

         Iterator<Map.Entry<String,String>> it = entrySet.iterator();

         while(it.hasNext())
         {
             Map.Entry<String,String> me = it.next();//Map.Entry也是一个接口，它是Map接口中的一个内部接口。
             String key = me.getKey();
             String value = me.getValue();

             System.out.println(key+":"+value);
         }
      }
 } 

练习。获取字符串中的字母出现的次数。打印结果：a(1)c(2).....

通过结果发现，每一个字母都有对应的次数。说明字母和次数之间都有映射关系，可以选择map集合，因为map集合中存放就是映射关系。
思路：
1，将字符串转换成字符数组。因为要对每一个字母进行操作。
2，定义一个map集合，因为打印结果的字母有顺序，所以使用Treemap集合。
3，遍历字符数组。
    将每一个字母作为键去查map集合。如果返回null，将该字母和1存入到map集合中。如果返回不是null，说明该字母在map集合已经存在并有对应次数。那么就获取该次数并进行自增。然后将该字母和自增后的次数存入到map集合中。覆盖掉原来键所对应的值。
4，将map集合中的数据变成指定的字符串形式返回。

 import java.util.*;
 class  MapTest
 {
     public static void main(String[] args)
     {
         String s= charCount("sddf—g+AzxBc,.CCTVxcvdf");
         System.out.println(s);
     }

     public static String charCount(String str)
     {
         char[] chs = str.toCharArray();//将字符串转换成字符数组

         TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
         //定义一个map集合，因为打印结果的字母有顺序，所以使用Treemap集合

         int count = 0;
         for(int x=0; x<chs.length; x++)
         {
             if(!(chs[x]>='a' && chs[x]<='z' || chs[x]>='A' && chs[x]<='Z'))
                 continue;//如果范围不在字母之间，继续循环。

             Integer value = tm.get(chs[x]);//将每一个字母作为键去查map集合

             //如果返回null，将该字母和0自增后的1存入到map集合中。
             //如果返回不是null，说明该字母在map集合已经存在并有对应次数。那么就获取该次数并进行自增，然后将该字母和自增后的次数存入到map集合中。覆盖掉原来键所对应的值。
             if(value!=null)
                 count = value;
             count++;
             tm.put(chs[x],count);//直接往集合中存储字符和数字，为什么可以，因为自动装箱。

             count = 0;//遍历完一个字母后计数器清零。
         }

         StringBuilder sb = new StringBuilder();
         //Map集合取出
         //将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry
         Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();
         Iterator<Map.Entry<Character,Integer>>  it = entrySet.iterator();

         while(it.hasNext())
         {
             Map.Entry<Character,Integer> me = it.next();
             Character ch = me.getKey();
             Integer value = me.getValue();
             sb.append(ch+"("+value+")");
         }
         return sb.toString();
     }
 }
 ---------- java ----------
 A(1)B(1)C(2)T(1)V(1)c(2)d(3)f(2)g(1)s(1)v(1)x(2)z(1)
 //Character类实现了Comparable，默认自然顺序排列
 输出完成 (耗时 0 秒) - 正常终止

Map扩展

例如一个学校有多个教室。每一个教室都有名称。一个教室很多学生。学生封装成对象。

映射关系：

key                value
"yureban"-----》 yure    Student("01" "zhangsan");  //List集合
                                   Student("02" "lisi");

"jiuyeban"-----》jiuye    Student("01" "zhaoliu");
                                   Student("02" "wangwu");

 /*
 map扩展知识。
 map集合被使用是因为具备映射关系。
 一个学校有多个教室。每一个教室都有名称。一个教室很多学生。学生封装成对象。
 */
 import java.util.*;
 class Student
 {
     private String id;
     private String name;
     Student(String id,String name)
     {
         this.id = id;
         this.name = name;
     }
     public String toString()
     {
         return id+":::"+name;
     }
 }
 class  MapDemo3
 {
     public static void main(String[] args)
     {
          demo();
     }

     public static void demo()
     {
         HashMap<String,List<Student>> czbk = new HashMap<String,List<Student>>();
         //学生对象封装到List集合中
         List<Student> yure = new ArrayList<Student>();
         List<Student> jiuye = new ArrayList<Student>();

         czbk.put("yureban",yure);
         czbk.put("jiuyeban",jiuye);

         yure.add(new Student("01","zhangsan"));
         yure.add(new Student("02","lisi"));
         jiuye.add(new Student("01","zhaoliu"));
         jiuye.add(new Student("02","wangwu"));

         Iterator<String> it = czbk.keySet().iterator();

         while(it.hasNext())
         {
             String roomName = it.next();
             List<Student> room = czbk.get(roomName);//班级房间返回List集合

             System.out.println(roomName);
             getInfos(room);//拿到房间名调用getInfos()取出封装的学生集合
         }

 }
     public static void getInfos(List<Student> list)
     {
             Iterator<Student> it = list.iterator();
             while(it.hasNext())
             {
             Student s = it.next();
             System.out.println(s);
             }
     }
 }
 ---------- java ----------
 jiuyeban
 01:::zhaoliu
 02:::wangwu
 yureban
 01:::zhangsan
 02:::lisi

 输出完成 (耗时 0 秒) - 正常终止

集合工具类

Collections:集合框架的工具类。里面定义的都是静态方法。提供的方法中有可以对list集合进行排序，二分查找等方法。因为要提高效率，通常常用的集合都是线程不安全的。如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

static <T extends Comparable<? super T>> void	sort(List<T> list) 根据元素的自然顺序 对指定列表按升序进行排序。
static <T> void	sort(List<T> list, Comparator<? super T> c) 根据指定比较器产生的顺序对指定列表进行排序

 /*
 Collections:sort
 list集合排序演示
 */
 import java.util.*;
 class  CollectionsSortDemo
 {
     public static void main(String[] args)
     {
         sortDemo();

     }
     public static void sortDemo()
     {
         List<String> list = new ArrayList<String>();

         list.add("abcd");
         list.add("aaa");
         list.add("zz");
         list.add("kkkkk");
         list.add("qq");
         list.add("z");

         System.out.println("原集合..."+list);

         Collections.sort(list);
         System.out.println("自然排序..."+list);
         Collections.sort(list,new StrLenComparator());
         System.out.println("长度排序..."+list);
     }
 }
 class StrLenComparator implements Comparator<String>
 {
     public int compare(String s1,String s2)
     {
         if(s1.length()>s2.length())
             return 1;
         if(s1.length()<s2.length())
             return -1;
         return s1.compareTo(s2);
     }
 }
 ---------- java ----------
 原集合...[abcd, aaa, zz, kkkkk, qq, z]
 自然排序...[aaa, abcd, kkkkk, qq, z, zz]//调用Collections的sort方法给list集合按自然顺序排序
 长度排序...[z, qq, zz, aaa, abcd, kkkkk]//调用Collections的sort方法接收一个list集合和自定义的比较器，给list集合按字符串长度排序。

 输出完成 (耗时 0 秒) - 正常终止

static void

swap(List<?> list, int i, int j) 在指定列表的指定位置处交换元素。

static <T extends Object & Comparable<? super T>> T	max(Collection<? extends T> coll) 根据元素的自然顺序，返回给定 collection 的最大元素。
static <T> T	max(Collection<? extends T> coll, Comparator<? super T> comp) 根据指定比较器产生的顺序，返回给定 collection 的最大元素。
static <T extends Object & Comparable<? super T>> T	min(Collection<? extends T> coll) 根据元素的自然顺序 返回给定 collection 的最小元素。
static <T> T	min(Collection<? extends T> coll, Comparator<? super T> comp) 根据指定比较器产生的顺序，返回给定 collection 的最小元素。

 /*
 集合框架的工具类。
 Collections:max min swap
 */
 import java.util.*;
 class  CollectionsMaxMinDemo
 {
     public static void main(String[] args)
     {
         maxDemo();
     }
     public static void maxDemo()
     {
         List<String> list = new ArrayList<String>();

         list.add("abcd");
         list.add("aaa");
         list.add("zz");
         list.add("kkkkk");
         list.add("qq");
         list.add("z");
         Collections.sort(list);
         sop(list);
         String max = Collections.max(list);
         sop("Max="+max);
         String min = Collections.min(list);
         sop("Min="+min);

         Collections.sort(list,new StrLenComparator());
         sop(list);
         String max1 = Collections.max(list,new StrLenComparator());
         sop("Max1="+max1);
         String min1 = Collections.min(list,new StrLenComparator());
         sop("Min1="+min1);

         Collections.swap(list,0,list.size()-1);//头尾交换
         sop("swap......"+list);
     }

     public static void sop(Object obj)
     {
         System.out.println(obj);
     }
 }
 class StrLenComparator implements Comparator<String>
 {
     public int compare(String s1,String s2)
     {
         if(s1.length()>s2.length())
             return 1;
         if(s1.length()<s2.length())
             return -1;
         return s1.compareTo(s2);
     }
 }
 ---------- java ----------
 [aaa, abcd, kkkkk, qq, z, zz]
 Max=zz
 Min=aaa
 [z, qq, zz, aaa, abcd, kkkkk]
 Max1=kkkkk
 Min1=z
 swap......[kkkkk, qq, zz, aaa, abcd, z]

 输出完成 (耗时 0 秒) - 正常终止

static <T> int	binarySearch(List<? extends Comparable<? super T>> list, T key) 使用二分搜索法搜索指定列表，以获得指定对象。
static <T> int	binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 使用二分搜索法搜索指定列表，以获得指定对象。

 /*
 集合框架的工具类。
 Collections:
 binarySearch二分查找
 */
 import java.util.*;
 class  CollectionsBinarySearchDemo
 {
     public static void main(String[] args)
     {
         binarySearchDemo();

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

     public static void binarySearchDemo()
     {
         List<String> list = new ArrayList<String>();

         list.add("abcd");
         list.add("aaa");
         list.add("zz");
         list.add("kkkkk");
         list.add("qq");
         list.add("z");
         Collections.sort(list);
         sop(list);
         int index = Collections.binarySearch(list,"WW");
         sop("index="+index);
         Collections.sort(list,new StrLenComparator());
         sop(list);
         int index1 = Collections.binarySearch(list,"ww",new StrLenComparator());
         sop("index1="+index1);
     }
 }
 class StrLenComparator implements Comparator<String>
 {
     public int compare(String s1,String s2)
     {
         if(s1.length()>s2.length())
             return 1;
         if(s1.length()<s2.length())
             return -1;
         return s1.compareTo(s2);
     }
 }
 ---------- java ----------
 [aaa, abcd, kkkkk, qq, z, zz]
 index=-1//如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
 [z, qq, zz, aaa, abcd, kkkkk]
 index1=-3

 输出完成 (耗时 0 秒) - 正常终止

static <T> void

fill(List<? super T> list, T obj) 使用指定元素替换指定列表中的所有元素。

 /*Collections:
 fill使用指定元素替换指定列表中的所有元素。
 自定义fill替换部分元素
 */
 import java.util.*;
 class CollectionsFillDemo
 {
     public static void sop(Object obj)
     {
     System.out.println(obj);
     }
     public static void main(String[] args)
     {
     List<String> list = new ArrayList<String>();
     list.add("abcd");
     list.add("aaa");
     list.add("zz");
     list.add("kkkkk");
     list.add("z");
     sop(list);
     Collections.fill(list,"xx");//使用指定元素替换指定列表中的所有元素。
     sop(list);
     fillDemo(list,"qq",1,3);
     }

     //自定义方法将list集合中部分元素替换。
     public static void fillDemo(List<String> list,String str,int index_s,int index_e)
     {
     //调用list的subList方法取得子集合
     List<String> newlist = list.subList(index_s,index_e);
     //把子集合中对象全部替换为str。
     Collections.fill(newlist,str);
     sop(list);
     }
 }
 ---------- java ----------
 [abcd, aaa, zz, kkkkk, z]
 [xx, xx, xx, xx, xx]
 [xx, qq, qq, xx, xx]

 输出完成 (耗时 0 秒) - 正常终止 

static <T> boolean

replaceAll(List<T> list, T oldVal, T newVal) 使用另一个值替换列表中出现的所有某一指定值。

 import java.util.*;
 class CollectionsReplaceAllDemo
 {   public static void sop(Object obj)
     {
         System.out.println(obj);
     }
     public static void main(String[] args)
     {
         replaceAllDemo();
     }

     public static void replaceAllDemo()
     {
         List<String> list = new ArrayList<String>();

         list.add("abcd");
         list.add("aaa");
         list.add("aaa");
         list.add("aaa");
         list.add("zz");
         list.add("kkkkk");
         sop("原集合"+list);

         Collections.replaceAll(list,"aaa","pp");
         sop(list);
     }
 }
 ---------- java ----------
 原集合[abcd, aaa, aaa, aaa, zz, kkkkk]
 [abcd, pp, pp, pp, zz, kkkkk]

 输出完成 (耗时 0 秒) - 正常终止 

static void	reverse(List<?> list) 反转指定列表中元素的顺序。
static <T> Comparator<T>	reverseOrder() 返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
static <T> Comparator<T>	reverseOrder(Comparator<T> cmp) 返回一个比较器，它强行逆转指定比较器的顺序。

 import java.util.*;
 class StrLenComparator implements Comparator<String>
 {
     public int compare(String s1,String s2)
     {
         if(s1.length()>s2.length())
             return 1;
         if(s1.length()<s2.length())
             return -1;
         return s1.compareTo(s2);
     }
 }
 class CollectionsReverseOrderDemo
 {
     public static void main(String[] args)
     {
         orderDemo();
     }

     public static void orderDemo()
     {
         TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));
                                                  //返回一个比较器，它强行逆转指定比较器的顺序。TreeSet构造函数接收这一比较器进行排序。
         ts.add("abcde");
         ts.add("aaa");
         ts.add("k");
         ts.add("cc");

         Iterator it = ts.iterator();
         while(it.hasNext())
         {
             System.out.println(it.next());
         }
     }
 }
 ---------- java ----------
 abcde
 aaa
 cc
 k

 输出完成 (耗时 0 秒) - 正常终止

static void	shuffle(List<?> list) 使用默认随机源对指定列表进行置换。
static void	shuffle(List<?> list, Random rnd) 使用指定的随机源对指定列表进行置换。

 import java.util.*;
 class CollectionsShuffleDemo
 {
     public static void main(String[] args)
     {
         shuffleDemo();
     }
     public static void shuffleDemo()
     {
         List<String> list = new ArrayList<String>();

         list.add("abcd");
         list.add("aaa");
         list.add("zz");
         list.add("kkkkk");
         list.add("qq");
         list.add("z");

         System.out.println(list);
         Collections.shuffle(list);
         System.out.println(list);
     }
 }
 ---------- java ----------
 [abcd, aaa, zz, kkkkk, qq, z]
 [kkkkk, qq, z, abcd, aaa, zz]

 输出完成 (耗时 0 秒) - 正常终止

Collections中返回线程安全的集合的方法

static <T> Collection<T>	synchronizedCollection(Collection<T> c) 返回指定 collection 支持的同步（线程安全的）collection。
static <T> List<T>	synchronizedList(List<T> list) 返回指定列表支持的同步（线程安全的）列表。
static <K,V> Map<K,V>	synchronizedMap(Map<K,V> m) 返回由指定映射支持的同步（线程安全的）映射。
static <T> Set<T>	synchronizedSet(Set<T> s) 返回指定 set 支持的同步（线程安全的）set。

Arrays:此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

数组变集合

 /*
 Arrays:用于操作数组的工具类。
 里面都是静态方法。
 asList:将数组变成list集合
 把数组变成list集合有什么好处？可以使用集合的思想和方法来操作数组中的元素。

 注意：将数组变成集合，不可以使用集合的增删方法。因为数组的长度是固定。如果你增删。那么会反生UnsupportedOperationException.
         contains。
         get
         indexOf()
         subList();
 */
 import java.util.*;
 class  ArraysDemo
 {
     public static void main(String[] args)
     {

         String[] arr = {"abc","cc","kkkk"};

         List<String> list = Arrays.asList(arr);
         //list.add("qq");  //异常UnsupportedOperationException
         System.out.println(list);

         int[] nums1 = {2,4,5};
         List<int[]> list1 = Arrays.asList(nums1);
         System.out.println(list1);

         Integer[] nums2 = {2,4,5};
         List<Integer> list2 = Arrays.asList(nums2);
         System.out.println(list2);

         /*
         如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
         如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
         */
     }
 }
 ---------- java ----------
 [abc, cc, kkkk]
 [[I@3e0ebb]
 [2, 4, 5]

 输出完成 (耗时 0 秒) - 正常终止

集合变数组

Collection接口中的toArray方法。

 /*
 集合变数组。
 Collection接口中的toArray方法。
 */
 import java.util.*;
 class  CollectionToArray
 {
     public static void main(String[] args)
     {
         ArrayList<String> al = new ArrayList<String>();

         al.add("abc1");
         al.add("abc2");
         al.add("abc3");

         /*
         1,指定类型的数组到底要定义多长呢？
         当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
         当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。
         所以创建一个刚刚好的数组最优。

         2,为什么要将集合变数组？
         为了限定对元素的操作。不需要进行增删了。
         */

         String[] arr = al.toArray(new String[al.size()]);

         System.out.println(Arrays.toString(arr));
       }
 }
 ---------- java ----------
 [abc1, abc2, abc3]

 输出完成 (耗时 0 秒) - 正常终止