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("01","zhangsan1"));
        System.out.println("put:"+map.put("01","wnagwu"));
        map.put("02","zhangsan2");
        map.put("03","zhangsan3");

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

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

        map.put("04",null);
        System.out.println("get:"+map.get("04"));
        //可以通过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]
{04=null, 01=wnagwu, 03=zhangsan3}

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

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 秒) - 正常终止