Java基础：集合框架

最新推荐文章于 2022-09-03 18:04:32 发布

转载最新推荐文章于 2022-09-03 18:04:32 发布 · 408 阅读

文章标签：

#java

java 专栏收录该内容

19 篇文章

订阅专栏

1.集合框架概述及其特点

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

数组和集合都是容器，相较于数组有以下特点：

(1).集合的长度是可变的；数组的长度是固定的；

(2).集合只能存储对象，即引用数据类型，存放的都是对象的引用/地址；数组可以存储基本数据类型；

(3).集合可以存储不同类型的对象；数组存储的是同一类型的数据或对象；

2.Java中的集合体系

每一个容器对数据的存储方式都有不同，这样的存储方式称之为：数据结构；

Interface Collection

|--Interface List：元素是有序的，有序的意思是按什么顺序存储就按什么顺序读取，元素可以重复，因为集合List体系有索引；

|--ArrayList：底层数据结构是数组结构，查找速度快，增删操作复杂，线程不同步；

|--LinkedList：底层数据结构是链表结构，查找速度较慢，增删操作快；

|--Vector：底层数据结构是数组结构，线程同步的，集合框架出现后被ArrayList取代；

|--Interface Set：元素是无序的(存入和取出的顺序不一致)，元素不可以重复；

|--HashSet：底层数据结构是哈希表，保证元素惟一性通过hashCode()和equals()方法；

|--TreeSet：底层数据结构是二叉树，可以对Set集合中的元素进行排序；

Interface Map：该集合存储键值对，保证键的唯一性；

|--Hashtable：底层数据结构是哈希表，不可以存入null的键和值，线程同步的，元素间无序；

|--HashMap：底层数据结构是哈希表，允许使用null的键和值，线程不同步，效率高，元素间无序；

|--TreeMap：底层数据结构是二叉树，线程不同步，可以用于给Map集合中的键排序；

3.共性的Collection集合

(1).添加元素：

boolean add (Object obj)：添加某个元素，操作成功返回true；

boolean addAll(Collection c)：添加某个集合，相当于并集；

(2).删除元素：

void clear()：移除此Collection中的所有元素；

boolean remove(Object obj)：从该Collection中移除指定元素的单个实例；删除成功返回true；

boolean removeAll(Collection c)：移除在该Collection中那些也包含在指定c中的所有元素，相当于取差集；

(3).获取操作：

int size()：返回元素个数；

boolean retainAll(Collection c)：仅保留此Collection中那些也包含在指定c中的元素，相当于取交集；

(4).判断操作：

boolean contains(Object obj)：判断是否包含指定元素；

boolean containsAll(Collection c)：此Collection中包含指定c中的所有元素时，返回true；

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

(5).转换操作：

Object[ ] toArray()：集合转换为数组；

(6).获取元素：

Iterator iterator()：返回在此Collection的元素上进行迭代的迭代器；

迭代器：集合的取出元素方式；

其产生：每个集合中都有取出操作，当简单的方法不足以完成取出动作时，就将取出的动作封装成一个对象，又由于不同数据结构的集合的取出操作各有差异，但是取出的动作通常是共性的(判断+取出)，于是向上抽取定义取出集合元素操作的内部类；之所以定义为内部类，是因为取出的操作需要操作的是集合中的元素，因此定义为内部类来直接访问集合中的元素最为方便；

将这些内部类符合的规则定义为Iterator；

联系：夹娃娃机；整个机器相当于容器集合，保存的元素是娃娃；内部类相当于夹子，定义在机器内部；外部的操纵杆相当于集合对外提供的方法；

集合的迭代操作：

[java] view plain copy

package com.zr.day14;

import java.util.*;

class IteratorDemo
{
    public static void main(String[] args)
    {
        Collection c = new ArrayList();//定义一个集合
        c.add("Messi");<span style="white-space:pre">     </span>//添加一些元素
        c.add("Ronaldo");
        c.add("kaka");
        c.add(100);

        Iterator it = c.iterator();//迭代获取
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
        System.out.println("------------");

        //for循环对资源的释放处理更优化；
        for(Iterator iter = c.iterator();iter.hasNext();)
        {
            System.out.println(iter.next());
        }
    }
}

4.List集合

4.1 List集合中的特有方法

因为List集合是有序的，所以相较于Collection，带有角标的方法都是List集合的特有方法；

(1).增

void add(int index, Object obj)：在指定位置添加元素；

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

(2).删

Object remove(int index)：移除列表中指定位置的元素，返回以前再此位置的元素；

(3).改

Object set(int index, Object obj)：用指定元素替换列表中指定位置的元素，返回之前的元素；

(4).查

Object get(int index)：返回列表中指定位置的元素；

List subList(int fromindex, int toindex)：返回子列表，包含头不包含尾；

int indexOf(Object obj)：返回列表中第一次出现的指定元素的索引，没有则返回-1；

int lastIndexOf(Object obj)：反向索引；

(5).特有的获取元素迭代器

ListIterator listIterator()：迭代

ListIterator listIterator(int index)：从指定位置开始迭代

(6).迭代器Iterator和列表迭代器ListIterator

ListIterator继承了Iterator，是其子接口；

在迭代集合时，使用Iterator中操作元素的方法有限；

Iterator：hasNext()，next()，remove()；

ListIterator：hasNext()，next()，nextIndex()，remove()，add()，set()，hasPrevious()，PreviousIndex()，Previous()；

并发操作异常：迭代器操作和集合操作同时处理集合中的元素；ConcurrentModificationException；

(7).多种获取List集合元素的方式；

[java] view plain copy

package com.zr.day14;

import java.util.*;

class IteratorDemo
{
    public static void main(String[] args)
    {
        ArrayList al = new ArrayList();
        al.add("Messi");
        al.add("Ronaldo");
        al.add("kaka");
        al.add(100);

        //方式一：使用角标操作，循环遍历；
        for(int x=0; x<al.size(); x++)
        {
            System.out.println(al.get(x));
        }
        System.out.println("------------");

        //方式二：使用集合迭代器Iterator；
        Iterator it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
        System.out.println("------------");

        //方式三：使用列表迭代器ListIterator；
        //在迭代操作时还可以对集合中元素进行多种操作；
        ListIterator lit = al.listIterator();
        while(lit.hasNext())
        {
            System.out.println(lit.next());
        }
    }
}

4.2 List：ArrayList

ArrayList底层数据结构是数组，大多数方法都和List接口一致；

特有方法：protected void removeRange(int fromIndex, int toIndex)：移除索引范围内的元素；包含头不包含尾

(1).去除ArrayList集合中的重复字符串元素；

[java] view plain copy

//定义一个功能用来去除列表中的重复字符串元素；
package com.zr.day14;

import java.util.*;

class ArrayListDemo
{
    public static void main(String[] args)
    {
        //新建一个列表，添加元素；
        ArrayList al = new ArrayList();
        al.add("Messi");
        al.add("Ronaldo");
        al.add("Bale");
        al.add("kaka");
        al.add("Ronaldo");
        //ArrayList中复写了toString方法；
        System.out.println(al);
        //去除重复字符串；
        al = removeOther(al);
        System.out.println(al);
    }

    //返回值类型：可以将新的ArrayList赋值给原ArrayList；
    //参数列表：原ArrayList；
    public static ArrayList removeOther(ArrayList al)
    {
        ArrayList newAl = new ArrayList();
        Iterator it = al.iterator();
        //迭代
        while(it.hasNext())
        {
            Object obj = it.next();
            //判断新列表中是否已经存在该对象；
            if(!newAl.contains(obj))
            {
                //如果不存在则将该对象添加到新列表
                newAl.add(obj);
            }
        }
        //返回新列表
        return newAl;
    }
}

(2).将自定义对象作为元素存储到ArrayList集合中，并去除重复元素；

[java] view plain copy

//定义一个功能用来去除自定义对象中的重复元素；
//自定义的是Student对象，当两个Student对象的name属性和age属性都相同时，判定这两个对象是重复元素；
package com.zr.day14;

import java.util.*;

class ArrayListDemo
{
    public static void main(String[] args)
    {
        //新建一个列表，添加元素；
        ArrayList al = new ArrayList();
        al.add(new Student("Messi",26));
        al.add(new Student("Ronaldo",27));
        al.add(new Student("Bale",28));
        al.add(new Student("kaka",29));
        al.add(new Student("Ronaldo",27));
        al.add(new Student("Ronaldo",30));
        //ArrayList中复写了toString方法；
        System.out.println("处理前："+al);
        //去除重复字符串；
        al = removeOther(al);
        System.out.println("处理后："+al);
    }

    //返回值类型：可以将新的ArrayList赋值给原ArrayList；
    //参数列表：原ArrayList；
    public static ArrayList removeOther(ArrayList al)
    {
        ArrayList newAl = new ArrayList();
        Iterator it = al.iterator();
        //迭代
        while(it.hasNext())
        {
            Object obj = it.next();
            //判断新列表中是否已经存在该对象；
            if(!newAl.contains(obj))
            {
                //如果不存在则将该对象添加到新列表
                newAl.add(obj);
            }
        }
        //返回新列表
        return newAl;
    }
}
//自定义的Student对象；
class Student
{
    private String name;
    private int age;
    Student(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    //覆盖toString()方法；
    public String toString()
    {
        return name+":::::"+age;
    }
    //覆盖equals()方法；
    public boolean equals(Object obj)
    {
        if(!(obj instanceof Student))
            return false;
        Student stu = (Student)obj;
        boolean b = this.name.equals(stu.name) && this.age == stu.age;
        //添加的打印语句分析比较过程
        System.out.println(this.name + "--比较--" + stu.name + "--结果--::" +b);
        return b;
    }
}

输出结果：

分析打印结果发现，ArrayList的contains()方法底层是通过调用equals方法来比较各个元素是否是重复元素；

4.3 List：Vector

Vector是集合框架之前的体系，底层数据结构也是数组，集合框架出现后被ArrayList所替代；

Vector中的获取元素方法：角标，迭代器，枚举；

其中枚举是Vector的特有方式，因为枚举的名称和方法名称都过长，最后被迭代器所取代；

Enumeration elements()：相当于集合中的iterator方法；

Interface Enumeration中封装的方法：

boolean hasMoreElements()：使用时相当于Iterator中的hasNext()方法；

Object nextElement()：使用时相当于Iterator中的next()方法；

4.4 List：LinkedList

LinkedList底层数据结构是链表结构，相较于数组结构的ArrayList有其特有的方法；

(1).添加：

void addFirst(Object obj)

void addLast(Object obj)

boolean offer(Object obj)

boolean offerFirst(Object obj)

boolean offerLast(Object obj)

(2).删除：

Object removeFirst()

Object removeLast()

Object poll()

Object pollFirst()

Object pollLast()

(3).获取：

Object getFirst()

Object getLast()

Object peek()

Object peekFirst()

Object peekLast()

(4).逆向迭代

Iterator descendingIterator()

上述方法中，offer，peek，poll方法是JDK6.0之后出现的，当集合中没有元素时不会抛出异常，直接返回null；

但是get和remove方法会出现异常：NoSuchElementException；

(5).练习：使用LinkedList创建栈和队列数据结构；

[java] view plain copy

/*
* 使用LinkedList构建栈和队列数据结构；
*/
package com.zr.day14;

import java.util.LinkedList;

class LinkedListDemo
{
    public static void main(String[] args)
    {
        MyQue mq = new MyQue();
        mq.myAdd("messi");
        mq.myAdd("ronaldo");
        mq.myAdd("kaka");
        System.out.println(mq);
        System.out.println(mq.myDel());
        System.out.println(mq);
    }
}
//队列的存储规律：先进先出
//使用LinkedList实现具体是实现在其一端进行元素的添加，在另一端进行元素的删除
class MyQue
{
    private LinkedList ll;
    MyQue()
    {
        this.ll = new LinkedList();
    }
    //添加元素
    public void myAdd(Object obj)
    {
        ll.addFirst(obj);
    }
    //删除元素
    public Object myDel()
    {
        return ll.removeLast();
    }
    //打印输出
    public String toString()
    {
        return ll.toString();
    }
}

//栈的存储规律：先进后出
//使用LinkedList实现具体步骤是封装只在某一端进行添加和删除元素的方法；
class MyStack
{
    private LinkedList ll ;
    MyStack()
    {
        this.ll = new LinkedList();
    }
    //添加元素的方法
    public void myAdd(Object obj)
    {
        ll.addFirst(obj);
    }
    //删除元素的方法，删除后同时返回被删除的元素；
    public Object myDel()
    {
        return ll.removeFirst();
    }
    //打印输出的复写
    public String toString()
    {
        return ll.toString();
    }
}

5.Set集合

Set作为Collection集合的子类，其中的操作基本同Collection集合一致，相较于List集合，其存取是无序的；

5.1 HashSet

分析HashSet中如何保证元素的惟一性：

首先，因为HashSet底层数据结构是哈希表，所以对于添加的元素，会计算该对象的哈希值，即hashCode()方法，当哈希值不一样时，就根据哈希表为元素分配不同的地址空间；当哈希值一样时，再通过比较equals()方法确定对象是不是同一对象，如果是则为了保证唯一性，只保留一个元素，如果不是则在该哈希值对应的地址域再分配空间存储元素；

说明：

(1).基类Object：

hashCode()：根据地址值返回一个整数；

equals()：当两个引用指向同一个对象时，返回true；

toString()：obj.getClass().getName() + "@" +hashCode()；

(2).String类：该类中复写了上述方法；

hashCode()：根据字符串的内容返回一个整数；

equals()：当两个字符串序列一致时，返回true；

toString()：返回字符串本身；

(3).其他自定义类，当需要存储到HashSet集合中的时候应尽量覆盖hashCode()和equals()方法；

实例：

(1).使用HashSet存储字符串对象；

[java] view plain copy

//使用HashSet存储字符串对象；
package com.zr.day14;

import java.util.HashSet;

class HashSetDemo
{
    public static void main(String[] args)
    {
        HashSet hs = new HashSet();
        System.out.println(hs.add("messi"));
        System.out.println(hs.add("kaka"));
        System.out.println(hs.add("bale"));
        //返回false，存储失败；
        //String类中复写了hashCode()方法和equals()方法，所以保证了元素的唯一性；
        System.out.println(hs.add("messi"));

        System.out.println(hs);//可以看出结果是无序的；
    }
}

(2).使用HashSet存储自定义对象；

[java] view plain copy

//使用HashSet存储自定义对象；
package com.zr.day14;

import java.util.HashSet;

//自定义Person对象
class Person
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    //覆盖hashCode方法；
    public int hashCode()
    {
        //根据对象的实际属性内容来获取哈希值；
        return this.name.hashCode()+this.age*38;
    }
    //覆盖equals方法；
    public boolean equals(Object obj)
    {
        if(!(obj instanceof Person))
            return false;
        Person p = (Person)obj;
        boolean b = this.name.equals(p.name) && this.age == p.age;
        System.out.println(this.name+"--比较--"+p.name +"--结果--"+b);
        return b;
    }
    //覆盖toString方法；
    public String toString()
    {
        return this.name+"::"+this.age;
    }
}

class HashSetDemo
{
    public static void main(String[] args)
    {
        HashSet hs = new HashSet();
        hs.add(new Person("p1",21));
        hs.add(new Person("p2",22));
        hs.add(new Person("p3",23));
        hs.add(new Person("p2",22));
        hs.add(new Person("p3",23));

        System.out.println(hs);
    }
}

通过上述示例可以看出，每当新添加一个对象时，会计算这个对象的哈希值，同已有的对象哈希值进行比较，如果哈希值相等，则再调用equals方法判断是否是同一个对象；

代码运行结果：

总结：在HashSet中是通过hashCode()和equals()方法来保证元素的惟一性的，而且这两个方法还作为判断操作和删除操作的依据，所以对于自定义的对象，要覆盖这两个方法；

5.2 TreeSet

TreeSet相较于HashSet，其底层使用的是二叉树的数据结构，可以对集合中的元素进行排序；

排序的两种方式：

(1).使TreeSet中的元素自身具备比较性；

实现Java.lang.Comparable接口，覆盖接口中定义的int compareTo(Object o)方法；

比较时，当主要条件相同时，必须要判断次要条件；

保证元素惟一性的依据：compareTo()；

元素对象被定义完成就具备比较性，这种顺序称为元素的自然顺序，或者叫默认顺序；

String类实现了Comparable接口，其自然顺序是字典顺序；

同样，基本数据类型包装类也实现了Comparable接口；

自定义类如果要存放到TreeSet集合中需要实现Comparable接口；

(2).让集合自身具备比较性：将自定义的比较器传递给集合的构造方法；

Java.util.Comparator接口中定义了int compare(Object o1, Object o2)方法；

当元素自身不具备比较性时，或者具备的比较性不是实际环境所需要的，就可以使用自定义的比较器；

在集合初始化的时候就定义了比较方式；

示例：

(1).使用TreeSet存储字符串对象；

[java] view plain copy

//使用TreeSet存储字符串对象，验证其排序共能；
package com.zr.day14;

import java.util.Comparator;
import java.util.TreeSet;

class TreeSetDemo
{
    public static void main(String[] args)
    {
        //将自定义的比较器作为参数传递给TreeSet的构造方法，是集合一初始化就具备比较性
        TreeSet ts = new TreeSet(new MyComparator());
        ts.add("ggxd");
        ts.add("mmn");
        ts.add("abc");
        ts.add("zz");
        //String类实现了Comparable接口，覆盖了compareTo()方法，保证了元素的唯一性；
        ts.add("zz");
        //输出结果按照字符串的字典顺序排列；
        System.out.println(ts);
    }
}
//自定义一个比较器按照字符串的长度进行排序
//实现java.util.Comparator接口
class MyComparator implements Comparator
{
    //覆盖compare方法
    public int compare(Object o1, Object o2)
    {
        //强制类型转换
        String s1 = (String)o1;
        String s2 = (String)o2;
        //基本数据类型包装类实现了comparable接口，因此可以封装后调用compareTo接口；
        int num = Integer.valueOf(s1.length()).compareTo(Integer.valueOf(s2.length()));
        if(num==0)
            //当主要条件相同时，必须要比较次要条件；
            //按字符串的字典顺序；
            return s1.compareTo(s2);
        return num;
    }

}

(2).使用TreeSet存储自定义对象；

[java] view plain copy

//使用TreeSet存储自定义对象；
package com.zr.day14;

import java.util.*;

class TreeSetTest
{
    public static void main(String[] args)
    {
        //使用匿名内部类自定义一个比较器
        //主要的比较方式是按照name的长度比较，次要的比较方式是按照age从大到小；
        TreeSet ts = new TreeSet(new Comparator()
        {
            public int compare(Object o1, Object o2)
            {
                Person p1 = (Person)o1;
                Person p2 = (Person)o2;
                int num = Integer.valueOf(p1.getName().length()).compareTo(Integer.valueOf(p2.getName().length()));
                if(num==0)
                    return Integer.valueOf(p2.getAge()).compareTo(Integer.valueOf(p1.getAge()));
                return num;
            }
        });
        ts.add(new Person("alonsol",30));
        ts.add(new Person("messi",29));
        ts.add(new Person("messi",27));
        ts.add(new Person("bale",21));
        ts.add(new Person("zidane",25));


        System.out.println(ts);
    }
}
//自定义Person对象，定义其自然顺序
//实现Comparable接口，复写compareTo方法；
class Person implements Comparable
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String toString()
    {
        return this.name+"::"+this.age;
    }

    //主要排序方式是按照name的字典顺序，次要的排序是按照age的从小到大；
    public int compareTo(Object o){
        if(!(o instanceof Person))
            throw new ClassCastException("转换异常");
        Person p = (Person)o;
        int num = this.name.compareTo(p.name);
        if(num==0)
            return Integer.valueOf(this.age).compareTo(Integer.valueOf(p.age));
        return num;
    }
}

6.Map集合

Map集合中存储的是键值对，而且保证键的惟一性；

6.1 Map集合中的共性方法

(1).添加操作

Object put(Object key, Object value)：要么返回null，要么返回该key对应的之前的值；

void putAll(Map m)

(2).删除操作

Object remove(Object key)：根据键查找移除，返回该键对应的value

void clear()：清空集合

(3).判断操作

boolean containKey(Object key)：判断键；

boolean containValue(Object value)：判断值

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

(4).获取操作

Object get(Object key)：根据键获取值；

int size()：获取集合大小；

Collection values()：获取value的集合；

6.2 Map集合中的迭代操作

因为Map集合中没有定义迭代器，所以要取出Map集合中的元素只有利用Set集合的迭代器；

(1).方式一：set keySet()

将Map中的所有键存储到Set集合中，在利用Set集合的迭代器，使用迭代方式获取所有键，然后调用Map集合中的get方法，获取每个键对应的value值；

(2).方式二：set<Map.Entry<k,v>> entrySet()

使用entrySet方法返回的是集合键与值之间的映射关系结合，关系的类型是Map.Entry类型，该类是Map接口中的一个静态内部接口，其中定义了getKey(),getValue(),setValue()等方法，通过这些方法同样可以获取Map集合中的键和值；

内部接口中只提供了方法的定义，具体的实现由Map的子类去实现；

[java] view plain copy

package com.zr.day14;
import java.util.*;
//自定义对象，和所在城市信息，使用Map集合存储；
class MapDemo
{
    public static void main(String[] args)
    {
        HashMap<Stu,String> hm = new HashMap<Stu,String>();
        //Map中添加元素的方法是put;
        hm.put(new Stu("zxx",38),"北京");
        hm.put(new Stu("lhm",15),"上海");
        hm.put(new Stu("mesi",54),"武汉");
        hm.put(new Stu("hua",76),"深圳");
        hm.put(new Stu("hua",36),"深圳");

        //方式一：keySet方式
        Set<Stu> ks = hm.keySet();
        Iterator<Stu> it = ks.iterator();
        while(it.hasNext())
        {
            Stu stu = it.next();
            String city = hm.get(stu);
            System.out.println(stu + "-----" + city);
        }

        //方式二：entrySet方式
        Set<Map.Entry<Stu,String>> es = hm.entrySet();
        Iterator<Map.Entry<Stu,String>> iter = es.iterator();
        while(iter.hasNext())
        {
            Map.Entry<Stu,String> me = iter.next();
            Stu stu = me.getKey();
            String city = me.getValue();
            System.out.println(stu + "********" + city);
        }
    }
}
//自定义Stu对象，因为不确定要存储到什么类型的集合中；
//所以复写其hashCode()方法和equals()方法保证其唯一性；
//实现Comparable接口复写compareTo()方法，设置其自然顺序；
class Stu implements Comparable<Stu>
{
    private String name;
    private int age;
    public Stu(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public int hashCode()
    {
        return this.name.hashCode() + (this.age * 38);
    }
    public boolean equals(Object o)
    {
        if(!(o instanceof Stu))
            throw new ClassCastException("类型不匹配");
        Stu stu = (Stu)o;
        return this.name.equals(stu.name) && this.age == stu.age;
    }
    public int compareTo(Stu stu)
    {
        int num = this.name.compareTo(stu.name);
        if(num==0)
            return Integer.valueOf(this.age).compareTo(Integer.valueOf(stu.age));
        return num;
    }
    public String toString()
    {
        return this.name+":"+this.age;
    }
}

(3).练习：根据给定的字符串按照指定的格式打印字符和字符个数；

[java] view plain copy

//根据指定字符串按照指定格式打印字符和字符的个数；
//指定字符串：“abcabcabcabdabef”
//打印格式：a()b()c()...
//步骤：
//1.将字符串转换策划那个字符数组
//2.定义一个Map集合用来存储映射关系
//3.遍历字符数组
//4.将Map集合中的数据变成指定的字符串形式返回
package com.zr.day14;
import java.util.*;
class MapTest
{
    public static void main(String[] args)
    {
        String str = "abcabc2abcabdabef";
        String pri = printMap(str);
        System.out.println(pri);
    }
    public static String printMap(String str)
    {
        //字符串转化为字符数组
        char[] chs = str.toCharArray();
        //定义Map集合
        TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
        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]);
            if(value != null)
                count = value;
            tm.put(chs[x], ++count);
            count=0;
        }

        Set<Character> ks = tm.keySet();
        Iterator<Character> it = ks.iterator();
        StringBuilder sb = new StringBuilder();
        while(it.hasNext())
        {
            Character ch = it.next();
            Integer value = tm.get(ch);
            //按照指定格式
            sb.append(ch+"("+value+")");
        }
        return sb.toString();
    }
}

6.3 Map集合扩展；集合嵌套；

7. 集合框架中的工具类

7.1 Collections：提供了很多用来操作集合的方法；

(1).sort(list)：用来给List集合排序，可以指定比较器，Set中可以直接使用TreeSet；

(2).max,min：用来获取集合中的最值元素，可以使用默认顺序可以使用自定义比较器；

(3).int binarySearch(list, key)：二分查找，针对有序的集合，返回值-(插入值)-1；

(4).void fill(list, object)：将集合中的所有元素替换为指定元素；

(5).boolean replaceAll(list , old, new)：使用新值替换列表中出现的所有某一指定值；

(6).void reverse (list)：反转列表中的元素；

(7).Comparator reverseOrder()：反转默认顺序的比较器；

(8).Comparator reverseOrder(comparator)：反转指定比较器顺序；

(9).void shuffle(list)：随机排列

(10).List synchronizedList(list)：返回线程同步的列表；

(11).void swap(list,i,j)：交换指定位置的元素；

7.2 Arrays：专门用来操作数组的工具类；

(1).二分查找

(2).排序

(3).填充fill

(4).List asList(可变参数)：将数组转换为列表；

数组转变为集合：

asList，将数组转换为集合，可以使用集合的思想和方法操作数组；

但是，不可以使用集合的增删方法，因为数组的长度是固定的；否则会出现UnSupportedOperationException；

数组中的元素都是对象的引用时，那么数组中的元素就直接转换为集合中的元素；

数组中的元素是基本数据类型时，那么就将整个数组作为集合中的元素；

集合转变为数组：

Collection中提供的toArray()和toArray(object[ ] array)操作可以完成集合到数组的转换；

集合转换为数组，主要是限定对集合元素的操作；

当指定类型的数组长度小于集合的size,那么该方法内部会创建一个新数组，长度为集合的size；

当指定类型的数组长度大于集合的size,使用原来的数组；

最好是指定大小刚刚好的数组：size()；