黑马程序员----java基础--集合

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、集合类的描述

　　面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。数组很难对其数据进行操作，而集合可以很方便对存储的对象进行增删改查等操作。可以说集合比数组功能更加强大而且使用起来也更加方便。所以我们有必要深入的学习一下集合类。

集合的特点：

(1)、用于存储对象的容器

(2)、集合的长度是可变的

(3)、集合中不可以存储基本数据类型值

(4)、集合中存储的都是对象的引用(地址)

二、集合框架的构成以及分类

根据数据结构的不同，可以分为不同的集合(容器)。下图是集合框架构成图。

从途中可以看出集合类主要分为两大接口：1、Collection接口 2、Map接口。

Collection接口

　　|--List集合：元素都是有序的(存入和取出的顺序一致)，元素是可以重复的，因为该集合体系具有索引。

　　　　|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度快，但增删稍慢，线程不同步。

　　　　|--LinkedList:底层使用的是链表数据结构。特点：增删速度很快，查询稍慢，线程不同步。

　　　　|--Vector:底层是数组数据结构，线程同步，已被ArrayList替代了，因为效率低。

　　|--Set集合：元素是无序的(存入和取出的顺序不一定一致)，元素不可重复。Set接口中的方法和Collection接口中的方法一致。

　　　　|--HashSet集合：底层数据结构是哈希表，线程不安全，不同步。

　　　　　　|--LinkedHashSet:底层是链式的哈希表，该集合特点：存入数据和取出数据顺序一致，而且元素不重复，线程不同步。

　　　　|--TreeSet:底层是二叉树数据结构，可以对Set集合中的元素进行排序，线程不同步。

Map接口

　　|--Hashtable集合：底层是哈希表数据结构，不可以存入null键null值，该集合是线程同步的，效率低。JDK1.0出现的。

　　　　|--Properties集合:用来存储键值对型的配置文件的信息，可以和IO技术相结合。

　　|--HashMap集合：底层是哈希表数据结构，允许使用null键null值，该集合是不同步的。该集合替换了Hashtable集合，效率高。JDK1.2出现的。

　　　　|--LinkedHashMap集合：底层是链式的哈希表结构，使用LinkedHashMap存入和取出的顺序是一致的。

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

Java集合类大部分的都增加了泛型，已增加程序的安全性，以后会详细的介绍的。了解了集合类的大致下面我们具体的介绍这几大集合类。

三、Collection<E>接口

Collection是集合框架中的常用接口。其下有两个子接口：List（列表），Set（集）。

1、Collection集合集成体系:

　　|--Lsit

　　　　|--ArrayList

　　　　|--LinkedList

　　　　|--Vector

　　|--Set

　　　　|--HashSet

　　　　　　|--LinkedHashSet

　　　　|--TreeSet

2、Collection接口常见的方法

(1)、添加元素

boolean  add(Object obj);//往集合中添加元素
boolean  addAll(Collection c);//将另一Collection集合中的所有元素添加进Collection集合中

 (2)、删除元素

boolean  remove(Object obj);//删除指定元素
boolean  removeAll(Collection  con);//调用者只保留另一集合中没有的元素
void clear();//清空Collection集合全部元素

 (3)、判断

boolean  contains(Object obj);//判断集合中是否包含指定元素
boolean  containsAll();//判断此Collection集合中是否包含另一个Collection集合
boolean  isEmpty();//判断集合是否有元素

 (4)、获取

int  siez();//获取集合的大小,其实就是在判断集合是否为空
Iterator<E>   iterator();//获取Collection集合的迭代器

 (5)、获取交集

boolean   retainAll(Collection c);//调用者只保留两集合的共性元素

 (6)、集合变数组

Object[]   toArray();//把集合转换成数组
 <T> T[]  toArray(T[] a);//把集合转换成数组

  代码演示：

import java.util.*;
class CollectionDemo 
{
    public static void main(String[] args) 
    {
        //因为Collection是接口无法创建对象，所以找子类来创建对象，多态的应用。
        Collection<String> c1=new ArrayList<String>();
        Collection<String> c2=new ArrayList<String>();
        add(c1);        
        addAll(c1,c2);
        remove(c1);
        removeAll(c1,c2);
    }
    //演示add方法
    public static void add(Collection<String> con){
        con.add("小明");
        con.add("赵四");
        con.add("王五");
        con.add("老王");
        con.add("黑马");
        con.add("安卓");
        //获取集合的大小
        System.out.println("size="+con.size());
        //打印一下集合
        System.out.println(con);
    }
    //演示addAll方法
    public static void addAll(Collection<String> co1,Collection<String>co2){
        co1.add("小明");
        co1.add("赵四");
        co1.add("王五");
        co1.add("钱峰");

        co2.add("黑马");
        co2.add("赵四");
        co2.add("钱峰");
        //将co2中的元素添加到co1中
        co1.addAll(co2);
        System.out.println("addAll:"+co1);

        //获取两个集合的交集，保留和指定的集合相同的元素
        co1.retainAll(co2);
        System.out.println("co1和co2取交集："+co1);
    }
    //演示remove方法
    public static void remove(Collection<String> con){
        con.add("小明");
        con.add("赵四");
        con.add("王五");
        con.add("老王");
        con.add("黑马");
        con.add("安卓");
        System.out.println(con.remove("老王"));
        System.out.println(con.remove("java"));
        System.out.println("remove:"+con);

        //清空集合
        con.clear();        
        //判断集合是否为空
        System.out.println("con是否为空:"+con.isEmpty());
    }
    //演示removeAll方法
    public static void removeAll(Collection<String> co1,Collection<String>co2){
        co1.add("小明");
        co1.add("赵四");
        co1.add("王五");
        co1.add("老王");

        co2.add("老王");
        co2.add("赵四");
        co2.add("钱峰");
        //从co1集合中删除与co2集合相同的元素
        co1.removeAll(co2);
        System.out.println("removeAll:"+co1);
    }
    
}

 3、Collection集合迭代器：Iterator<E>接口

迭代器：是一个接口。作用：用于取集合中的元素。

　　每一个集合都有自己的数据结构，都有特定的取出自己内部元素的方式。为了便于操作所有的容器，取出元素。将容器内部的取出方式按照一个统一的规则向外提供，这个规则就是Iterator接口。也就说，只要通过该接口就可以取出Collection集合中的元素，至于每一个具体的容器依据自己的数据结构，如何实现的具体取出细节，这个不用关心，这样就降低了取出元素和具体集合的耦合性。

 注：在迭代时循环中next调用一次，就要hasNext判断一次。

获取Collection集中中元素的三种方式：

import java.util.*;
class CollectionDemo 
{
    public static void main(String[] args) 
    {
        //因为Collection是接口无法创建对象，所以找子类来创建对象，多态的应用。
        Collection<String> c=new ArrayList<String>();
        c.add("小明");
        c.add("黑马");
        c.add("安卓");
        c.add("小明");
        c.add("王五");
        //用Collection中的iterator()方法。调用集合中的迭代器方法，是为了获取集合中的迭代器对象。
        //这种方式比较占用内存，因为循环结束后it变量还在内存中没有被释放        
        Iterator<String> it=c.iterator();
        while (it.hasNext())
        {
            String name=it.next();
            System.out.println(name);
        }
        
        //建议使用这种方法，不消耗内存空间，it变量在for循环中，循环结束变量也就消失了
        for (Iterator<String> it=c.iterator();it.hasNext() ; )
        {
　　　　　　　　//Iterator中不能使用add添加方法，因为没有该方法，只能删除(remove)
            System.out.println(it.next());
        }
        
        //这种方式是增强for循环，是Iterator迭代器的简写，但是这种方式有很大的弊端
        //如果遍历Collection集合过程中还需要对元素进行操作，比如删除，需要使用迭代器。
        for(String name:c){            
            System.out.println(name);

        }
}

 迭代注意事项

　　(1)、迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。

　　(2)、迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。

　　(3)、迭代器的next方法返回值类型是Object，所以要记得类型转换。加上泛型后则不需要转换。

四、List<E>集合(接口)

List集合继承体系：

　　|--ArrayList

　　|--LinkedList

　　|--Vector

　　List本身是Collection接口的子接口，具备了Collection的所有方法。现在学习List体系特有的共性方法，查阅方法发现List的特有方法都有索引，这是该集合最大的特点。

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

1、List集合特有的方法

(1)、添加

void  add(int index,E element);//在指定索引位置上添加元素
void  addAll(int index,Collection<? extends E> c);//在指定索引位置上添加一堆元素

 (2)、删除

Object  remove(int index);//删除指定索引位置上的元素

 (3)、修改

Object  set(int index, E  element);//对指定索引位进行元素的修改

 (4)、获取

Object  get(int index);//获取指定索引位置上的元素
int  indexOf(Object obj);//获取指定元素第一次出现的索引位，如果该元素不存在返回-1；所以通过-1，可以判断一个元素是否存在。
int  lastIndexOf(Object obj);//反向索引指定元素的位置。
List  subList(int from,int to);//获取子列表,包含头不包含尾
Iterator  listIterator();//List集合特有的迭代器
Iterator  listIterator(int index);//从列表的指定位置开始返回List集合迭代器

 注意：对于List集合，底层判断元素是否相同，其实用的是元素自身的equals方法完成的。所以建议元素都要复写equals方法，建立元素对象自己的比较相同的条件依据。

代码演示：

import java.util.*;
class ListDemo 
{
    public static void main(String[] args) 
    {
        List<String> list=new ArrayList<String>();
        list.add("黑马");
        list.add("安卓");
        list.add("小明");
        list.add("王武");
        list.add("安卓");
        System.out.println("list:"+list);
        //在指定位置上添加元素
        list.add(3,"我爱黑马");
        System.out.println("listadd:"+list);

        //删除指定位置上的元素
        list.remove(4);
        System.out.println("listremove:"+list);

        //设置元素        
        System.out.println("listset:"+list.set(2,"我爱安卓"));

        //获取指定位置上的元素
        System.out.println("listget"+list.get(2));

        //获取元素第一次出现的位置。
        System.out.println("indexOf="+list.indexOf("安卓"));

        //获取子列表，包含头不包含尾
        System.out.println(list.subList(2,4));
    }
    
}

 2、List集合元素取出方式

(1)、List集合第一种取出方式：因为List集合有索引(角标)这个特殊的原因，所以List集合有自己特有的迭代方式，get方法。 

import java.util.*;
class ListIteratorDemo 
{
    public static void main(String[] args) 
    {
        List<String> list=new ArrayList<String>();
        list.add("黑马");
        list.add("安卓");
        list.add(".NET");
        list.add("IOS");
        //用集合的长度做循环条件，get方法取出元素
        for (int x=0;x<list.size() ;x++ )
        {            
            System.out.println(list.get(x));
        }
    }
}

(2)、List集合第二种取出方式：用Collection集合中的iterator()方法，这种方法有弊端只能遍历的过程中对集合删除操作。

import java.util.*;
class ListIteratorDemo 
{
    public static void main(String[] args) 
    {
        List<String> list=new ArrayList<String>();
        list.add("黑马");
        list.add("安卓");
        list.add(".NET");
        list.add("IOS");
        //Collection接口中的iterator方法。
        for (Iterator<String> it=list.iterator();it.hasNext() ; )
        {
            String s=it.next();
            if(s.equals("IOS")){
//                list.add("JAVA");//ConcurrentModificationException异常，出现并发操作。
                it.remove();//将IOS的引用从集合中删除了
            }
            System.out.println(s);
        }

    }
}

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

(3)、List集合取出方式第三种方式：Lsit集合特有迭代器:ListIterator

ListIterator迭代器中的方法：

import java.util.*;
class ListIteratorDemo 
{
    public static void main(String[] args) 
    {
        List<String> list=new ArrayList<String>();
        list.add("黑马");
        list.add("安卓");
        list.add(".NET");
        list.add("IOS");
        //获取ListIterator迭代器对象
        for (ListIterator<String> li=list.listIterator();li.hasNext() ; )
        {
            //它可以实现在迭代过程中完成对元素的增删改查。
            //注意：只有list集合具备该迭代功能。
            String s=li.next();
            if(s.equals("IOS"))
                li.add("JAVA");//增加元素
            if(s.equals(".NET"))
                li.remove();//删除元素
            if(s.equals("安卓"))
                li.set("JAVAEE");//修改元素
        }
        System.out.println(list);

    }
}

五、ArrayList、LinkedList、Vector集合

1、ArrayList集合的方法和List集合的方法差不多一样。所以可参照List的方法。

2、LinkedList集合

LinkedList集合中特有的方法：

(1)、添加元素

addFirst();//将指定元素插入集合元素的开头
addLast();//将指定元素插入集合元素的末尾

 ------JDK1.6版本后新的方法----------------

offerFirst();//与addFirst方法没有区别
offerLast();//与addLast方法没有区别

 (2)、获取但不删除元素 

//获取但不删相互，如果链表为空，抛出NoSuchElementException
E  getFirst();//返回此集合的第一个元素
E  getLast();//返回此集合的最后一个元素

  ------JDK1.6版本后新的方法----------------

//获取但不移除，如果链表为空，返回null。
peekFirst();
peekLast();

 (3)、获取并删除元素

//获取并移除，如果链表为空，抛出NoSuchElementException。
E   removeFirst();//移除并返回此集合的第一个元素
E   removeLast();//移除并返回此集合的最后一个元素

    ------JDK1.6版本后新的方法----------------

//获取并移除，如果链表为空，返回null;
pollFirst();
pollLast();

　　因为LinkedList中有特有的方法removeFirst()或者removeLast()(pollFirst、pollLast)，所以LinkedList有4种迭代的方法。一种是:Iterator，一种是：iterator，一种是for循环遍历get方法，一种是LinkedList特有的方法。

//LinkedList特有取出方式
import java.util.*;
class LinkedListDemo 
{
    public static void main(String[] args) 
    {
        LinkedList<String> list=new LinkedList<String>();
        list.add("黑马");
        list.add("安卓");
        list.add(".NET");
        list.add("IOS");
        while(!(list.isEmpty()))//通过判断集合是否为空来循环删除元素，知道为空停止循环
            System.out.println(list.removeFirst());    //获取元素并且删除元素    
    }
}

3、Vector集合

(1)、Vector中特有的方法：

枚举就是Vector特有的取出方式。发现枚举和迭代器很像。其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。

//获取枚举接口的方法
Enumeration<E>   elements();//返回此集合的枚举

 而Eumeration枚举接口中的方法:

boolean  hasMoreElements();//相当于Iterator中的hasNext()
E  nextElement();//相当与Iterator中的next()

 另外Collections集合工具类中也提供了Collection集合获取枚举接口的方法

 static Enumeration< T>   enumeratio(Collection<T> c);//返回一个指定 collection 上的枚举。

 代码演示：

import java.util.*;
class VectorDemo 
{
    public static void main(String[] args) 
    {
        Vector<String> v=new Vector<String>();
        v.add("黑马");
        v.add("安卓");
        v.add("IOS");
        v.add("JAVAEE");

        //用Iterator迭代器方法取出元素
        for (Iterator<String> it=v.iterator();it.hasNext() ; )
        {
            System.out.println(it.next());
        }

        //用Enumeration枚举的方法取出元素
        for (Enumeration<String> en=v.elements();en.hasMoreElements() ; )
        {
            System.out.println(en.nextElement());
        }

        //Collections.enumeration()方法获取枚举Enumeration接口
        for (Enumeration<String> en=Collections.enumeration(v);en.hasMoreElements() ; )
        {
            System.out.println(en.nextElement());
        }
    }
}

  4、List集合综合练习

(1)、请使用LinkedList来模拟一个堆栈或者队列数据结构。

　　堆栈：先进后出 First In Last Out FILO
　　队列：先进先出 First In First Out FIFO

思路：应该自定义一个LinkedList类，把要LinkedList封装到自己的类中。

import java.util.*;
class DuiLie
{
    private LinkedList link;
    //对象一初始化就创建了LinkedList集合
    DuiLie(){
        link=new LinkedList();
    }
    //队列的添加元素的功能。
    public void myAdd(Object obj){
        link.addFirst(obj);
    }
    //队列的删除元素的功能。
    public Object myRemove(){
        return link.removeLast();
    }
    //判断队列是否为空
    public boolean isNull(){
        return link.isEmpty();
    }

}
class DuiLieDemo
{
    public static void main(String[] args) 
    {
        DuiLie dl=new DuiLie();
        dl.myAdd("黑马");
        dl.myAdd("IOS");
        dl.myAdd("安卓");
        dl.myAdd(".NET");
        dl.myAdd("JAVAEE");
        while (!(dl.isNull()))
        {
            System.out.println(dl.myRemove());
        }

    }
}

 (2)、将自定义对象作为元素存到ArrayList集合中，并去除重复元素。比如：存人对象，同姓名同年龄，视为同一个人。为重复元素。

/*
List集合中必须定义一个新的容器来过滤重复元素.
而set集合则不用，因为set集合是无序的，不可重复的。
*/
import java.util.*;
class Person
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return age;
    }
    public String toString(){
        return "name="+name+"....."+"age="+age;
    }
    public boolean equals(Object obj){//即使使用了泛型，equals方法中的参数也是Object obj，
        if(!(obj instanceof Person))//因为复写的Object类中的方法,Object类的equals方法参数就是Object obj。
            throw new RuntimeException("类型转换异常");
        Person p=(Person)obj;
        return this.name.equals(p.name)&&this.age==p.age;//判断name和age是否相同
    }
}
class ArrayListDemo
{
    public static void main(String[] args) 
    {
        List<Person> list=new ArrayList<Person>();
        list.add(new Person("黑马",120));
        list.add(new Person("安卓",110));
        list.add(new Person("IOS",45));
        list.add(new Person(".NET",97));
        list.add(new Person("JVAEE",12));
        list.add(new Person("IOS",45));
        list.add(new Person("黑马",120));
        //迭代原集合
        printCollection(list);        
        System.out.println("---去除重复元素后的集合---------");
        list=getSingleElement(list);
        printCollection(list);

    }
    public static List<Person> getSingleElement(List<Person> list){
        //1、定义一个临时容器用来装过滤后的数据
        List<Person> newList=new ArrayList<Person>();
        //2、迭代list集合
        for (Iterator<Person> it=list.iterator();it.hasNext() ;)
        {
            Person p=it.next();
        //3、判断被迭代到的元素是否在临时容器存在
        //contains方法内部依靠的是equals方法,其实remove方法也调用equals方法的   
            if(!(newList.contains(p)))
                newList.add(p);
        }
        return newList;

    }
    //迭代器取出集合中的元素
    private static void printCollection(List<Person> list){
        for (Iterator<Person> it=list.iterator();it.hasNext() ; )
        {
            System.out.println(it.next());
        }
    }
}

六、Set<E>集合(只能用Iterator迭代器取数据)

Set接口中的方法和Collection中方法一致的。Set集合元素不可重复且无序。Set接口取出方式只有一种：迭代器。

Set集合继承体系

　　|--HashSet

　　　　|--LinkedHashSet

　　|--TreeSet

import java.util.*;
class  SetDemo
{
    public static void main(String[] args) 
    {
        //Set集合无需并且不可重复，方法和Collection方法一样
        Set<String> set=new HashSet<String>();
        set.add("黑马");//添加元素
        set.add("JAVAEE");
        set.add("安卓");
        set.add("IOS");
        set.add(".NET");
        set.add("JAVAEE");
        set.remove("IOS");//删除元素

        //Iterator迭代器取出元素
        for (Iterator<String> it=set.iterator();it.hasNext() ; )
        {
            System.out.println(it.next());
        }
    }
}

 七、HashSet、LinkedHashSet、TreeSet集合

(1)、HashSet集合

HashSet实现Set接口，由哈希表（实际上是一个HashMap实例）支持。

哈希表确定元素是否相同:因为集合本身不可重复的特点所以不用定义新的Set集合来存放不重复元素。
(1)、 先判断的是两个元素的哈希值是否相同。如果相同，再判断两个对象的内容是否相同。

(2)、 判断哈希值相同，其实判断的是对象的HashCode方法。判断内容相同，用的是equals方法。如果哈希值不同，不需要判断equals。

判断HastSet集合中的元素是否相同，一般要复写对象的hashCode方法和equals方法。

哈希表的原理：

(1)、对对象元素中的关键字(对象中的特有数据)，进行哈希算法的运算，并得出一个具体的算法值，这个值 称为哈希值。

(2)、哈希值就是这个元素的位置。

(3)、如果哈希值出现冲突，再次判断这个关键字对应的对象是否相同。如果对象相同，就不存储，因为元素重复。如果对象不同，就存储，在原来对象的哈希值基础 +1顺延。

(4)、存储哈希值的结构，我们称为哈希表。

(5)、既然哈希表是根据哈希值存储的，为了提高效率，最好保证对象的关键字是唯一的。 这样可以尽量少的判断关键字对应的对象是否相同，提高了哈希表的操作效率。

需求：往HashSet集合中存储Person对象。如果姓名和年龄相同，视为同一个人，视为相同元素。 

/*
如果姓名和年龄相同，视为同一个人，视为相同元素
*/

import java.util.*;
class Person
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return age;
    }
    public String toString(){
        return "name="+name+"....."+"age="+age;
    }
    public int hashCode(){//复写了hashCode方法
        return name.hashCode()+age*37;
    }
    public boolean equals(Object obj){//即使使用了泛型，equals方法中的参数也是Object obj，
        if(!(obj instanceof Person))//因为复写的Object类中的方法,Object类的equals方法参数就是Object obj。
            throw new RuntimeException("类型转换异常");
        Person p=(Person)obj;
        return this.name.equals(p.name)&&this.age==p.age;//建立了自己的比较方式
    }
}
class HashSetDemo
{
    public static void main(String[] args) 
    {
        Set<Person> set=new HashSet<Person>();
        set.add(new Person("黑马",98));
        set.add(new Person("安卓",76));
        set.add(new Person("IOS",67));
        set.add(new Person(".NET",34));
        set.add(new Person("JAVAEE",21));
        set.add(new Person("IOS",67));
        set.add(new Person("安卓",76));
        for (Iterator<Person> it=set.iterator();it.hasNext() ; )
        {
            System.out.println(it.next());
        }
    }
}

 2、LinkedHashSet集合

LinkedHashSet这个集合不仅存入的顺序和取出的顺序一致，并且该集合可以自动去除重复元素。

需求：数组去重复，例如: 原始数组是{4,2,4,6,1,2,4,7,8}，得到结果{4,2,6,1,7,8}

import java.util.*;
class LinkedHashSetDemo
{
    public static void main(String[] args) 
    {
        int[] arr={4,2,4,6,1,2,4,7,8};
        Integer[] in=getSingleElement(arr);
        for (int x=0;x<in.length ;x++ )
        {
            if(x<in.length-1)
                System.out.print(in[x]+",");
            else
                System.out.print(in[x]);
        }

    }
    public static Integer[] getSingleElement(int[] arr){
        //无序变有序,并且去重
        LinkedHashSet<Integer> lhs=new LinkedHashSet<Integer>();
        for (int x=0;x<arr.length ;x++ )
        {
            lhs.add(arr[x]);
        }
        //集合变成数组返回
        return (Integer[])lhs.toArray(new Integer[lhs.size()]);
    }
}

 3、TreeSet集合

用于对Set集合进行元素的指定顺序排序，排序需要依据元素自身具备的比较性。 如果元素不具备比较性，在运行时会发生ClassCastException异常。

TreeSet判断元素唯一性的方式：就是根据比较方法的返回结果是否为0，是0就是相同元素，不存。

TreeSet集合排序的两种方式：

(1)、TreeSet排序的第一种方式：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo(T)方法。也种方式也成为元素的自然顺序，或者叫做默认顺序。

(2)、TreeSet的第二种排序方式：让集合具备比较性。当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。集合需要传入比较器(Comparator接口)，让集合具备比较行为。定义一个Comparator的子类对象，复写compare(T o1, T o2)方法。 将该类对象作为参数传递给TreeSet集合的构造函数。如果自定义类实现了Comparable接口，并且TreeSet的构造函数中也传入了比较器，那么将以比较器的比较规则为准。记住，排序时，当主要条件相同时，一定判断一下次要条件。Comparable<T>、Comparator<T>都带着泛型的。第二种方式较为灵活。

注：只有TreeSet和TreeMap集合的构造函数能接收Comparator比较器。

需求：往TreeSet集合中存储Student对象，并按照学生的姓名排序。

第一种方式：让学生自身具备比较性，实现Comparable接口,复写compareTo方法

import java.util.*;
class Student implements Comparable<Student>
{
    private String name;
    private int age;
    Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return age;
    }
    public String toString(){
        return "name="+name+"....."+"age="+age;
    }
    //复写Comparable接口的compareTo方法
    public int compareTo(Student stu){
        int num=this.name.compareTo(stu.name);//先按照姓名排序，如果姓名相同然后再按照年龄排序
        if(num==0)
            return new Integer(this.age).compareTo(new Integer(stu.age));//按照年龄排序
        return num;
    }
}
class TreeSetDemo 
{
    public static void main(String[] args) 
    {
        Set<Student> set=new TreeSet<Student>();
        set.add(new Student("黑马",120));
        set.add(new Student("安卓",43));
        set.add(new Student("IOS",87));
        set.add(new Student(".NET",21));
        set.add(new Student("JAVAEE",12));
        set.add(new Student("PHP",98));
        set.add(new Student("黑马",34));
        for (Iterator<Student> it=set.iterator();it.hasNext() ; )
        {
            System.out.println(it.next());
        }
    }
}

 第二种方式：学生自身不具备比较性，这时候就可以定义一个类实现Comparator接口，覆盖compare(T o1, T o2)方法。

//Student类接上例
//实现Comparator接口，复写compare方法。比较器
class StuComparator implements Comparator<Student>
{
    public int compare(Student s1,Student s2){
        int num=s1.getAge()-s2.getAge();//先按照年龄排序
        if(num==0)
            return s1.getName().compareTo(s2.getName());//年龄相同的再按照姓名排序
        return num;
    }
}
class TreeSetDemo 
{
    public static void main(String[] args) 
    {
        Set<Student> set=new TreeSet<Student>(new StuComparator());//两种方式同时存在以比较器为主
        set.add(new Student("黑马",120));
        set.add(new Student("安卓",43));
        set.add(new Student("IOS",87));
        set.add(new Student(".NET",21));
        set.add(new Student("JAVAEE",12));
        set.add(new Student("PHP",98));
        set.add(new Student("黑马",34));
        for (Iterator<Student> it=set.iterator();it.hasNext() ; )
        {
            System.out.println(it.next());
        }
    }
}

 练习：对字符串进行长度排序。

import java.util.*;
class LenComparator implements Comparator<String>
{
    public int compare(String s1,String s2){
        int num=s1.length()-s2.length();//按照长度排序
        return (num==0)?s1.compareTo(s2):num;//如果长度相同，按照字符串自然排序
    }
}
class StringLength 
{
    public static void main(String[] args) 
    {
        TreeSet<String> ts=new TreeSet<String>(new LenComparator());
        ts.add("aaaa");
        ts.add("zz");
        ts.add("nbag");
        ts.add("cba");
        ts.add("abc");        
        for (Iterator it=ts.iterator();it.hasNext() ; )
        {
            System.out.println(it.next());
        }

    }
}

八、Map<K,V>接口

Map集合该集合存储键值对。一对一对往里存。而且要保证键的唯一性。Map也称为双列集合;Collection集合称为单列集合，Collection一次存一个元素。和Set很像,Set底层就是使用了Map集合。

Map集合继承体系：

　　|--Hashable

　　　　|--Properties

　　|--HashMap

　　　　|--LinkedHashMap

　　|--TreeMap

1、Map集合常用方法

(1)、添加元素

Value  put(key,value);//返回前一个和key关联的值，如果没有返回null。如果出现添加相同的键，那么后添加的值会覆盖原有键对应的值，并且put方法会返回被覆盖的值

 (2)、删除

void  clear();//清空map集合
value  remove(Object key);//根据指定的key删除这个键值对

 (3)、判断

boolean  containsKey(key);//判断集合中是否存在指定的键
boolean  containsValue(value);//判断集合中是否存在指定的值
boolean  isEmpty();//判断集合是否为null

 (4)、获取

1 value  get(Key);//通过键获取值，如果没有该键返回null，可以通过返回null来判断是否存在指定键。当然有特殊情况，就是在hashmap集合中，是可以存储null键null值的。
2 int  size();//获取键值对个数，也就是Map集合的长度
3 Set<Key>  keySet();//返回Set集合，该集合中存放的是Map集合中的全部键(Key)的值
4 Set<Map.Entry<Key,Value>>  entrySet();//返回Set集合，该集合存放的是Map集合的映射关系，关系的数据类型就是：Map.Entry。
5 Collection<Value>   values();//返回Collection集合，该集合中存放的是Map集合中的全部值。返回的Collection集合可以通过Iterator迭代器获取到全部值

 map中是没有迭代器的，collection具备迭代器，只要将map集合转成Set集合，可以使用迭代器了。之所以转成set，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用的就是map的方法。

2、 Map集合的三种取出方式

(1)、取出map集合中所有元素的方式一：  Set<Key>  keySet()方法。

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

import java.util.*;
class KeySetDemo 
{
    public static void main(String[] args) 
    {
        Map<Integer,String> map=new HashMap<Integer,String>();
        map.put(1,"王武");
        map.put(7,"孙琦");
        map.put(6,"李四");
        map.put(4,"赵四");
        map.put(2,"钱枫");
        //先获取map集合的所有键的Set集合,keySet();
        Set<Integer> keyset=map.keySet();
        //有了Set集合。就可以获取其迭代器。
        for (Iterator<Integer> it=keyset.iterator();it.hasNext() ; )
        {
            Integer key=it.next();
            //有了键可以通过map集合的get方法获取其对应的值。
            String value=map.get(key);
            System.out.println("key="+key+":::"+"value="+value);
        }
    }
}

 (2)、取出map集合中所有元素的方式二：Set<Map.Entry<Key,Value>>  entrySet()方法。

将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry. Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口。为什么要定义在内部呢？

因为只有有了Map集合，有了键值对，才会有键值的映射关系。关系属于Map集合中的一个内部事物。而且该事物在直接访问Map集合中的元素。

接口 Map.Entry<K,V>中的方法：

import java.util.*;
class EntrySetDemo 
{
    public static void main(String[] args) 
    {
        Map<Integer,String> map=new HashMap<Integer,String>();
        map.put(1,"王武");
        map.put(7,"孙琦");
        map.put(6,"李四");
        map.put(4,"赵四");
        map.put(2,"钱枫");
        //将Map集合中的映射关系(Map.Entry)取出。存入到Set集合中。
        Set<Map.Entry<Integer,String>> entryset=map.entrySet();
        //用迭代器进行迭代Set集合
        for (Iterator<Map.Entry<Integer,String>> it=entryset.iterator();it.hasNext() ; )
        {
            //it.next()返回的是Map集合中的映射关系(Map.Entry<K,V>)
            Map.Entry<Integer,String> en=it.next();
            //通过Map.Entry中的getKey()和getValue()取到Map集合键和值。
            int key=en.getKey();
            String value=en.getValue();
            System.out.println("key="+key+":::"+"value="+value);
        }
    }
}

  (3)、取出map集合中所有元素的方式三：Collection<Value>  values();返回Collection集合，然后在用Iterator迭代器来取出元素

import java.util.*;
class ValuesDemo 
{
    public static void main(String[] args) 
    {
        Map<Integer,String> map=new HashMap<Integer,String>();
        map.put(1,"王武");
        map.put(7,"孙琦");
        map.put(6,"李四");
        map.put(4,"赵四");
        map.put(2,"钱枫");
        //用values方法取到Map集合中的全部的值，存放到Collection中
        Collection<String> value=map.values();
        //用迭代器进行迭代这个存放Map集合全部值的Collection集合
        for (Iterator<String> it=value.iterator();it.hasNext() ; )
        {
            System.out.println("value="+it.next());
        }
    }
}

 3、Map集合综合练习

(1)、需求：描述一个学生，学生属性：姓名，年龄。每一个学生都有对应的归属地。学生Student，地址String。注意：姓名和年龄相同的视为同一个学生。保证学生的唯一性。

import java.util.*;
class Student 
{
    private String name;
    private int age;
    Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void setName(String name){
        this.name=name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
    public String toString(){
        return "name="+name+"....."+"age="+age;
    }
    public int hashCode(){
        return name.hashCode()+age*37;
    }
    public boolean equals(Object obj){
        if(!(obj instanceof Student))
            throw new RuntimeException("类型转换异常");
        Student stu=(Student)obj;
        return this.name.equals(stu.name)&&this.age==stu.age;
    }
}
class HashMapDemo
{
    public static void main(String[] args) 
    {
        //将学生对象和学生的归属地通过键与值的形式存储到map集合中
        Map<Student,String> map=new HashMap<Student,String>();
        map.put(new Student("张三",20),"北京");
        map.put(new Student("钱枫",21),"深圳");
        map.put(new Student("王武",19),"郑州");
        map.put(new Student("赵四",33),"香港");
        map.put(new Student("孙琦",29),"广州");
        map.put(new Student("钱枫",21),"上海");
        //第一种方式：keySet();
        for (Iterator<Student> it=map.keySet().iterator();it.hasNext() ; )
        {
            Student stu=it.next();
            String address=map.get(stu);
            System.out.println(stu+":::"+address);
        }
        //第二种取出方式
        for (Iterator<Map.Entry<Student,String>> it=map.entrySet().iterator();it.hasNext() ; )
        {
            Map.Entry<Student,String> me=it.next();
            Student stu=me.getKey();
            String address=me.getValue();
            System.out.println(stu+":::"+address);
        }
    }
}

 (2)、需求：对学生对象的年龄进行升序排序。因为数据是以键值对形式存在的。所以要使用可以排序的Map集合中TreeMap集合。

import java.util.*;
class Student implements Comparable<Student>
{
    private String name;
    private int age;
    Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void setName(String name){
        this.name=name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
    public String toString(){
        return "name="+name+"....."+"age="+age;
    }
    public int compareTo(Student stu){
        int num=this.age-stu.age;//按年龄排序
        if(num==0)
            return this.name.compareTo(stu.name);//按姓名排序
        return num;
    }
    /*
    因为写的Student类，使用者有可能存放到HashMap集合中。
    所以有必要复写hashCode方法和equals方法。
    而且即使你不写，这两个方法都会存在Student类中，因为Object类中有这两个方法
    public int hashCode(){
        return name.hashCode()+age*37;
    }
    public boolean equals(Object obj){
        if(!(obj instanceof Student))
            throw new RuntimeException("类型转换异常");
        Student stu=(Student)obj;
        return this.name.equals(stu.name)&&this.age==stu.age;
    }
    */
}
class StuComparator implements Comparator<Student>
{
    public int compare(Student s1,Student s2){
        int num=s1.getAge()-s2.getAge();
        return (num==0)?s1.getName().compareTo(s2.getName()):num;
    }
}
class TreeMapDemo 
{
    public static void main(String[] args) 
    {
        TreeMap<Student,String> tm=new TreeMap<Student,String>(new StuComparator());
        tm.put(new Student("张三",20),"北京");
        tm.put(new Student("钱枫",21),"深圳");
        tm.put(new Student("王武",19),"郑州");
        tm.put(new Student("赵四",33),"香港");
        tm.put(new Student("孙琦",29),"广州");
        tm.put(new Student("钱枫",21),"武汉");
        tm.put(new Student("王武",19),"上海");//键相同值就会覆盖原来的键的值
        Set<Map.Entry<Student,String>> entryset=tm.entrySet();
        for (Iterator<Map.Entry<Student,String>> it=entryset.iterator();it.hasNext() ; )
        {
            Map.Entry<Student,String> en=it.next();
            Student stu=en.getKey();
            String address=en.getValue();
            System.out.println(stu+":::"+address);
        }
    }
}

 (3)、需求： 使用LinkedHashMap则是跟原来存入的顺序是一致的。

import java.util.*;
class LinkedHashMapDemo 
{
    public static void main(String[] args) 
    {
        LinkedHashMap<Integer,String> lhm=new LinkedHashMap<Integer,String>();
        lhm.put(1,"王武");
        lhm.put(7,"孙琦");
        lhm.put(6,"李四");
        lhm.put(4,"赵四");
        lhm.put(2,"钱枫");
        lhm.put(2,"黑马");//覆盖原来相同键的值
        Set<Map.Entry<Integer,String>> entryset=lhm.entrySet();
        for (Iterator<Map.Entry<Integer,String>> it=entryset.iterator();it.hasNext() ; )
        {
            Map.Entry<Integer,String> en=it.next();
            Integer key=en.getKey();
            String value=en.getValue();
            System.out.println(key+":::"+value);
        }
    }
}

 运行结果：

 (4)、需求："sdfgzxcvas--==,.?dfxcvdf"获取该字符串中的字母出现的次数。希望打印结果：a(1)c(2).....

通过结果发现，每一个字母都有对应的次数。说明字母和次数之间都有映射关系。注意了，当发现有映射关系时，可以选择Map集合。因为Map集合中存放就是映射关系。

什么使用Map集合呢？

当数据之间存在这映射关系时，就要先想Map集合。

思路：

1，将字符串转换成字符数组。因为要对每一个字母进行操作。

2，定义一个Map集合，因为打印结果的字母有顺序，所以使用Treemap集合。

3，遍历字符数组。将每一个字母作为键去查Map集合。如果返回null，将该字母和1存入到Map集合中。

    如果返回不是null，说明该字母在Map集合已经存在并有对应次数。     那么就获取该次数并进行自增，然后将该字母和自增后的次数存入到Map集合中。覆盖掉原来键所对应的值。

4，将Map集合中的数据变成指定的字符串形式返回。

//"sdfgzxcvas--==,.?dfxcvdf"获取该字符串中的字母出现的次数。希望打印结果：a(1)c(2).....
import java.util.*;
class  TreeMapTest
{
    public static void main(String[] args) 
    {
        String str="sdfgzxcvas--==,.?dfxcvdf";
        str=getCharCount(str);
        System.out.println(str);
    }
    public static String getCharCount(String str){
        TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();
        //把字符串转换成字符数组
        char[] arr=str.toCharArray();        
        for (int x=0;x<arr.length ;x++ )
        {
            //程序健壮性的判断，如果是除了字母以外的字符直接过滤掉
            if(!((arr[x]>='a'&& arr[x]>='z') || (arr[x]>='A'&& arr[x]>='Z')))
                continue;
            //将数组中的字母作为键去查map表中的值
            Integer value=tm.get(arr[x]);
            int count=0;
            //判断值是否为null,如果不为空记录这个值
            if(value!=null)
                count=value;
            //如果不为空，count加1存进集合中，如果count=0，也加1存进去
            count++;
            tm.put(arr[x],count);            
            /*
            if(value==null)
                tm.put(arr[x],1);
            else{
                value=value+1;
                tm.put(arr[x],value);
            }
            */
        }
        //创建字符串缓冲区用来修改成固定的字符串格式。
        StringBuilder sb=new StringBuilder();
        for (Iterator<Map.Entry<Character,Integer>> it=tm.entrySet().iterator();it.hasNext() ; )
        {
            Map.Entry<Character,Integer> en=it.next();
            Character key=en.getKey();
            Integer value=en.getValue();
            sb.append(key+"("+value+")");
        }        
        return sb.toString();
    }
}

 (5)、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 demo()
    {
        HashMap<String,List<Student>> czbk = new HashMap<String,List<Student>>();
        List<Student> reyu = new ArrayList<Student>();
        List<Student> jiuye = new ArrayList<Student>();
        czbk.put("yureban",reyu);
        czbk.put("jiuyeban",jiuye);
        reyu.add(new Student("01","zhagnsa"));
        reyu.add(new Student("04","wangwu"));
        jiuye.add(new Student("01","zhouqi"));
        jiuye.add(new Student("02","zhaoli"));
        Iterator<String> it = czbk.keySet().iterator();
        while(it.hasNext())
        {
            String roomName = it.next();
            List<Student> room = czbk.get(roomName);            
            System.out.println(roomName);
            getInfos(room);
        }    
    }
    public static void getInfos(List<Student> list)
    {
        Iterator<Student> it = list.iterator();
        while(it.hasNext())
        {
            Student s = it.next();
            System.out.println(s);
        }
    }
    public static void main(String[] args) 
    {
         demo();        
    }
    public static void getStudentInfo(HashMap<String,String> roomMap)
    {
        Iterator<String> it = roomMap.keySet().iterator();
        while(it.hasNext())
        {
            String id = it.next();
            String name = roomMap.get(id);
            System.out.println(id+":"+name);
        }
    }
}

 (6)、 Map在有映射关系时，可以优先考虑,在查表法中的应用较为多见。

import java.util.*;
class MapTest1 
{
    public static void main(String[] args) 
        {
        System.out.println(getWeek(1));
    }
    public static String getWeek(int num){
        if(num<1 || num>7)
            throw new RuntimeException("没有这个星期，请重新输入");
        String[] weeks={"","星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
        String s=weeks[num];
        TreeMap<String,String> tm=new TreeMap<String,String>();
        tm.put("星期一","Mon");
        tm.put("星期二","Tue");
        tm.put("星期三","Wes");
        tm.put("星期四","Sta");
        tm.put("星期五","Wek");
        tm.put("星期六","Sun");
        tm.put("星期日","Sun");        
        return tm.get(s);
    }
}

 总结：

使用集合的技巧： 

(1)、看到Array就是数组结构，有角标，查询速度很快。

(2)、看到Link就是链表结构：增删速度快，而且有特有方法。addFirst； addLast； removeFirst()； removeLast()； getFirst()；getLast()；

(3)、看到Hash就是哈希表，就要想要哈希值，就要想到唯一性，就要想到存入到该结构的中的元素必须覆盖hashCode，equals方法。

(4)、看到Tree就是二叉树，就要想到排序，就想要用到比较。

比较的两种方式：

一个是Comparable：覆盖compareTo方法；

一个是Comparator：覆盖compare方法。

LinkedHashSet，LinkedHashMap:这两个集合可以保证哈希表有存入顺序和取出顺序一致，保证哈希表有序。

集合什么时候用？

当存储的是一个元素时，就用Collection。当存储对象之间存在着映射关系时，就使用Map集合。 保证唯一，就用Set。不保证唯一，就用List。

九、Collections工具类

Collections：集合框架的工具类。里面定义的都是静态方法。

1、Collection和Collections有什么区别？

Collection是集合框架的一个顶层接口，它里面定义了单列集合的共性方法。它有两个常用的子接口：List对元素都有定义索引，是有序的，可以重复元素；Set不可以重复元素，无序的。

Collections是集合框架中的一个工具类。该类中的方法都是静态的，提供的方法中有可以对List集合进行排序、二分查找等方法。

2、Collections中的常用静态方法

(1)、对List集合进行排序

Collections.sort(List<T> list);//List集合进行元素的自然顺序排序
Collections.sort(List<T> list,Comparator<?super T> c);//按指定的比较器方法排序

 (2)、对List集合进行二分查找

int  Collections.binarySearch(List list, T key);//对List集合进行二分查找，返回角标。
int  Collections.binarySearch(List list,T key,Comparator<T> c);//传入自定义的比较器进行查找

 (3)、对List集合中的对象进行置换

Collections.swap(List list,int i,int j);// 在指定集合的指定位置处交换元素

 (4)、fill方法可以将list集合中所有元素替换成指定元素。

Collections.fill(List<T> list, T obj);//使用指定元素替换指定集合中的所有元素。

 (5)、获取Collection集合中的最大元素

T  Collections.max(Collection coll);//根据元素的自然顺序，返回最大元素
T  Collections.max(Collection coll, Comparator<T> comp);//根据指定比较器产生的顺序，返回最大元素。

 (6)、List集合中新值替换老值

Collections.replaceAll(List list, T oldValue,T newValue);// 使用另一个值替换列表中出现的所有某一指定值。

 (7)、集合进行反转

Collections.reverse(List list);//反转指定集合中元素的顺序
Comparator<T>   reverseOrder();//返回一个比较器，它强行逆转实现了 Comparable 接口的对象。
Comparator<T>   reverseOrder(Comparator<T> comp);// 返回一个比较器，该比较器将强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。

 (8)、使用指定的随机源对指定列表进行置换。

Collections.shuffle(List list);//使用默认随机对集合进行置换。
Collections.shuffle(List list,Random rnd);//使用默认随机对集合进行置换

 (9)、不同步的集合转成同步的集合。

//原理：定义一个类，将集合所有的方法加同一把锁后返回。
Collection  Collections.synchronizedCollection(Collection coll);
List  Collections.synchronizedList(List list);
Set  Collections.synchronizedSet(Set set);
Map  Collections.synchronizedMap(Map);

 代码演示：

(1)、

import java.util.*;
class CollectionsDemo 
{    
    public static void main(String[] args) 
    {
         List<String> list = new ArrayList<String>();
            list.add( "abcde");
            list.add( "cbad");
            list.add( "bb");
            list.add( "zzz");
            list.add( "cba");
            list.add( "a");
            sort(list);
            binarySearch(list);
            swap(list);
            fill(list);
            max(list);
            replaceAll(list);
            reverse(list);
            shuffle(list);
    }
    //对List集合进行默认排序，因为TreeSet和TreeMap都能排序了
    public static void sort(List<String> list){
        //List集合默认排序
        Collections.sort(list);
        sop(list);//运行结果：[a, abcde, bb, cba, cbad, zzz]
        
        //指定比较器，按照比较器的比较方式进行比较
        Collections.sort(list,new StringLenComp());
        sop(list);//运行结果：[a, bb, cba, zzz, cbad, abcde]
    }

    //二分查找
    public static void binarySearch(List<String> list){
        //二分查找在查找之前必须根据元素的自然顺序对集合进行升序排序。
        //如果没有对列表进行排序，则结果是不确定的。
       //如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。 
       Collections.sort(list);
       sop(list);//[a, abcde, bb, cba, cbad, zzz]
       int index=Collections.binarySearch(list,"bb");
       sop("index="+index);//index=2

       //指定比较器进行二分查找
       int num=Collections.binarySearch(list,"bb",new StringLenComp());
       sop(list);//运行结果：[abcde, cbad, bb, zzz, cba, a]
       sop("index="+num);//运行结果：index=2

    }

    //对List集合中的对象进行置换
    public static void swap(List<String> list){
        sop(list);//运行结果：[abcde, cbad, bb, zzz, cba, a]
        Collections.swap(list,4,2);
        sop(list);//运行结果：[abcde, cbad, cba, zzz, bb, a]
    }

    //fill方法可以将list集合中所有元素替换成指定元素。
    public static void fill(List<String> list){
        sop(list);//运行结果：[abcde, cbad, bb, zzz, cba, a]
        Collections.fill(list,"我爱黑马");
        sop(list);//运行结果：[我爱黑马, 我爱黑马, 我爱黑马, 我爱黑马, 我爱黑马, 我爱黑马]
    }

    //获取Collection集合中的最大元素
    public static void max(List<String> list){
        String str=Collections.max(list);
        sop(str);//运行结果：zzz

        String s=Collections.max(list,new StringLenComp());
        sop(s);//运行结果：abcde
    }

    //List集合中新值替换老值
    public static void replaceAll(List<String> list){
        sop(list);//运行结果：[abcde, cbad, bb, zzz, cba, a]
        Collections.replaceAll(list,"cba","我要去黑马");
        sop(list);//运行结果：[abcde, cbad, bb, zzz, 我要去黑马, a]
    }

    //对集合进行反转
    public static void reverse(List<String> list){
        sop(list);//运行结果：[abcde, cbad, bb, zzz, cba, a]
        Collections.reverse(list);
        sop(list);//运行结果：[a, cba, zzz, bb, cbad, abcde]
        

    }

    //使用指定的随机源对指定列表进行置换。
    public static void  shuffle(List<String> list){
        sop(list);
        Collections.shuffle(list);
        sop(list);
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}
class StringLenComp implements Comparator<String>
{
    public int compare(String s1,String s2){
        int num=s1.length()-s2.length();
        if(num==0)
            return s1.compareTo(s2);
        return num;
    }
}

 (2)、

import java.util.*;
class ReverseOrderDemo
{
    public static void main(String[] args) 
    {
        //返回一个比较器，它强行逆转实现了 Comparable 接口的对象。
        TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder());
        ts.add( "abcde");
        ts.add( "cbad");
        ts.add( "bb");
        ts.add( "zzz");
        ts.add( "cba");
        ts.add( "a");        
        System.out.println(ts);//运行结果：[zzz, cbad, cba, bb, abcde, a]

        //对集合进行了两次的反转就又变成了自然排序的顺序了
        ts=new TreeSet<String>(Collections.reverseOrder(Collections.reverseOrder()));
        ts.add( "abcde");
        ts.add( "cbad");
        ts.add( "bb");
        ts.add( "zzz");
        ts.add( "cba");
        ts.add( "a");
        System.out.println(ts);//运行结果：[a, abcde, bb, cba, cbad, zzz]
    }
}

十、Arrays工具类

此类包含用来操作数组（比如排序和搜索）的各种方法。里面都是静态的方法。

(1)、数组按照升序进行排序

Arrays.sort(基本数据类型[]或者 对象[]);
2 eg:Arrays.sort(int[] arr);// 对指定的 int 型数组按数字升序进行排序。

 (2)、数组进行二分查找

1 int  Arrays.binarySearch(基本数据类型[] 或者 对象[],key);
2 eg: Arrays.binarySearch(int[] arr,int key);

 (3)、将数组转换成集合

List  asList(T...a);//T...a可变长度的数组
2 eg:String[] arr = {"abc","kk","qq"};
3 List<String> list = Arrays.asList(arr);//将arr数组转成list集合。

 将数组转换成集合，有什么好处呢？用aslist方法，将数组变成集合。

可以通过List集合中的方法来操作数组中的元素：isEmpty()、contains、indexOf、set；

注意（局限性）：数组是固定长度，不可以使用集合对象增加或者删除等，会改变数组长度的功能方法。比如add、remove、clear。（会报不支持操作异常UnsupportedOperationException）；

如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。

如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

import java.util.*;
class ArraysDemo
{
     public static void main(String[] args){
          int[] arr1 = {31,11,51,61};
          List< int[]> list1 = Arrays.asList(arr1);
           System.out.println(list1);//运行结果：[[I@659e0bfd]
           Integer[] arr2 = {31,11,51,61};
           List list2 = Arrays.asList(arr2);
           System.out.println(list2);//运行结果：[31, 11, 51, 61]
      }
}

  (4)、将数组内容变成字符串打印出去

String   Arrays.toString(基本数据类型[] 或者 对象[]);

 代码演示：

import java.util.*;
class ArraysDemo
{
    public static void main(String[] args){
        int[] arr={34,54,2,5,7,8};
        char[] ch={'a','g','j','h','l'};
        double[] dou={7.45,0.15,45.12,45,1256,4};
        byte[] by={0,1,5,3,5,0};
        String[] str={"nihao","hah","heihei"};
        System.out.println(Arrays.toString(arr));//运行结果：[34, 54, 2, 5, 7, 8]
        System.out.println(Arrays.toString(ch));//运行结果：[a, g, j, h, l]
        System.out.println(Arrays.toString(dou));//运行结果：[7.45, 0.15, 45.12, 45.0, 1256.0, 4.0]
        System.out.println(Arrays.toString(by));//运行结果：[0, 1, 5, 3, 5, 0]
        System.out.println(Arrays.toString(str));//运行结果：[nihao, hah, heihei]
    }
}

 十一、将集合转成数组

使用的就是Collection接口中的toArray方法。

Object[]  toArray();
T[]  toArray(T[] a);//返回数组的运行时类型与指定数组的运行时类型相同

 集合转成数组，可以对集合中的元素操作的方法进行限定，不允许对其进行增删。只要获取这些元素即可。 toArray方法需要传入一个指定类型的数组，那么长度该如何定义呢？

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

当指定类型的数组长度大于了集合的size，就不会新创建了数组，而是使用传递进来的数组。

所以建议，在传递指定类型数组时，最好的方式就是指定的长度和size相等的数组。

import java.util.*;
class ArraysDemo
{
    public static void main(String[] args){
        List<Integer> list=new ArrayList<Integer>();
        list.add(5);
        list.add(4);
        list.add(10);
        list.add(12);
        list.add(54);
        Integer[] arr=list.toArray(new Integer[list.size()]);//刚刚好的数组长度
        for (int x=0;x<arr.length ;x++ )
        {
            System.out.println(arr[x]);
        }
    }
}

 未完待续.............

 注：菜鸟日记，如有错误欢迎大神指正，欢迎探讨！！

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------