java容器集合总结

java容器---集合总结

 

思考为什么要引入容器这个概念？

   Java有多种方式保存对象（应该是对象的引用），例如使用数组时保存一组对象中的最有效的方式，如果你想保存一组基本类型的数据，也推荐使用这种方式，但大家知道数组是具有固定尺寸的，你必须事先知道你要需要多少个对象。但是在一般的情况中，你在写程序中并不知道将需要多少个对象，或者是否需要更加复杂的方式来存储对象，因此数组尺寸固定很不爽！

   为了解决上述问题，引入了容器的概念。容器提供了完善的方法来保存对象，你可以使用这些工具来解决数量惊人的问题。Java容器类可以自动调整自己的尺寸，因此与数组不同，你可以将任意数量的对象放到容器中，并不担心容器设置为多大。

集合特点：
1，用于存储对象的容器。
2，集合的长度是可变的。
3，集合中不可以存储基本数据类型值。

java容器类库用途是保存对象。分为2类：

 1. Collection

      一个独立元素的序列，这些元素都服从一条或多条规则。List必须按照插入的顺序保存元素，Set不能有重复元素。Queue按照排队规则来确定对象产生的顺序（通常与插入的顺序相同）。

 2. Map

      一组成对的键值对对象，允许使用键来查找值，将数字和对象关联到一起。映射表允许我们使用另一个对象来查找某个对象，也被称为关联数组或字典。Map很强大

List类型

List接口在Collection的基础上添加了大量的方法，使得可以在List中间插入和移除元素。

   1 ArrayList和 LinkedList

  都按照被插入的顺序保存元素，区别在于执行某些操作时的性能。且LinkedList包含的操作也多于ArrayList.

（1）ArrayList  ：优势随机访问元素比较快，有连续的数组空间，但是在List的中间插入和移除元素时较慢，需要大量的移动内部的元素。

   你可以把ArrayList  当做“可以自动扩充自身的数组”来看待，使用ArrayList也相当简单：创建一个实例，用add（）插入对象；然后用get（）访问这些对象，此时需要索引，就像数组一样，但是不需要方括号。ArrayList还有一个size()方法，使你知道有多少个元素添加进来，从而不会不小心因索引越界而引发错误。

（2）LinkedList：在LinkedList中间插入删除较快，提供优化的顺序访问。随机访问时较慢，特性集较ArrayList  大。各种Queue以及栈的行为，由LinkedList提供支持。

Set类型

    1.HashSet TreeSet LinkedHashSet 

    输出显示在Set中，每个相同的项只保存一次，但存储的方式不同：

    (1)  Hashset存储方式复杂，但保证了最快的获取速度

   （2）TreeSet按照升序保存对象

   （3）LinkedHashSet按照添加的顺序保存对象

 

Map

 

    可以使用键来查找对象，类似于数组下标。Map.put(key,value)插入数据，Map.get(key)查找数据。键要求唯一。存储方式不是顺序存储，速度快。不必指定Map的尺寸，因为它自己会自动的调整。

 

   （1）HashMap使用最快的查找技术，存储无顺序。

 

   （2）TreeMap按照比较结果升序保存。

 

   （3）LinkedHashMap按照插入顺序保存键，同时保留HashMap的查询速度。

迭代器（也是一种设计模式）

   容器缺点：使用容器，必须对容器的确切类型进行编程，但若像更换或扩展至其他容器，必须重写代码。迭代器可以解决这个问题，实现代码的重用。它是一个对象，它的工作是遍历并选择序列中的对象，而客户端程序员不必知道或关心该序列底层的结构。它是轻量级对象，创建的代价小。

因此经常对迭代器有些奇怪的限制：

1)使用方法Iterator()要求容器返回一个Iterator。Iterator将准备好返回序列中的第一个元素。

2)使用next()获得序列的下一个元素。

3)使用hasNext()检查序列中是否还有元素。

4)使用remove()将迭代器新近返回的元素删除。

    迭代器能够将遍历序列的操作与序列底层的结构分离，它统一了对容器的访问方式，这是它的威力所在。

框架的顶层Collection接口：

Collection的常见方法：

1，添加。
    boolean add(Object obj):
    boolean addAll(Collection coll):

2，删除。
    boolean remove(object obj):
    boolean removeAll(Collection coll);
    void clear();
3，判断：
    boolean contains(object obj):
    boolean containsAll(Colllection coll);
    boolean isEmpty():判断集合中是否有元素。
4，获取：
    int size():
    Iterator iterator():取出元素的方式：迭代器。
    该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。
    所以该迭代器对象是在容器中进行内部实现的。
    对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，
    也就是iterator方法。
    Iterator接口就是对所有的Collection容器进行元素取出的公共接口。
5，其他：
    boolean retainAll(Collection coll);取交集。
    Object[] toArray():将集合转成数组。

package cn.itcast.p3.collection.demo;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        /*Collection coll = new ArrayList();
        show(coll);
    */
        Collection c1 = new ArrayList();
        Collection c2 = new ArrayList();
        show(c1,c2);
        
    }
    
    public static void show(Collection c1,Collection c2){
        
        //给c1添加元素。
        c1.add("abc1");
        c1.add("abc2");
        c1.add("abc3");
        c1.add("abc4");
        
        //给c2添加元素。
        c2.add("abc2");
        c2.add("abc5");
        c2.add("abc6");
        
        System.out.println("c1:"+c1);//c1:[abc1, abc2, abc3, abc4]
        System.out.println("c2:"+c2);//c2:[abc2, abc5, abc6]
        
        
        //将c2中的元素添加到c1集合中,添加一堆
        c1.addAll(c2);
        System.out.println(c1);//[abc1, abc2, abc3, abc4, abc2, abc5, abc6]
        
        //演示removeAll
        //将两个集合中的相同元素从调用removeAll的集合中删除,从c1中删除c1和c2相同的元素
    /*    boolean b = c1.removeAll(c2);
        System.out.println("removeAll:"+b);
        System.out.println("c1"+c1);//c1[abc1, abc3, abc4]
*/        
        //演示containsAll，c1集合中是否包含C2中的所有元素，包含返回true
        boolean b1 = c1.containsAll(c2);
        System.out.println("containsAll:"+b1);

        //演示retainAll 取交集，保留和指定的集合相同的元素，而删除不同的元素。和removeAll功能相反 。
        //c2:[abc2, abc5, abc6],
        //addAll后的C1:[abc1, abc2, abc3, abc4, abc2, abc5, abc6]
//        boolean b = c1.retainAll(c2);
//        System.out.println("retainAll:"+b);
//        System.out.println("c1:"+c1);//c1:[abc2, abc2, abc5, abc6]
    }
    /**
     * 测试集合 Collection集合中的方法
     * @param coll
     */
    public static void show(Collection coll){
        
        //1,添加元素。add.
        coll.add("abc1");
        coll.add("abc2");
        coll.add("abc3");
        System.out.println(coll);
        
        //2，删除元素。remove
        if(coll.contains("abc2")){
            coll.remove("abc2");//会改变集合的长度 
        }
        //清空集合
        //coll.clear();//清空集合中的元素，但是集合还在，集合为[]空
        System.out.println(coll.contains("abc3"));
        System.out.println(coll);
        
    }

}

Collection集合的遍历：使用Iterator

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class IteratorDemo {

    /**
     * java.util.NoSuchElementException
     */
    public static void main(String[] args) {

        Collection coll = new ArrayList();
        coll.add("abc1");
        coll.add("abc2");
        coll.add("abc3");
        coll.add("abc4");
        System.out.println(coll);//[abc1, abc2, abc3, abc4]
        //使用了Collection中的iterator()方法。 调用集合中的迭代器方法，是为了获取集合中的迭代器对象。
        Iterator it = coll.iterator();        
        while(it.hasNext()){
            System.out.println(it.next());
        }
        
    /*    for(Iterator it = coll.iterator(); it.hasNext(); ){
            System.out.println(it.next());
        }*/
        
    }

}

Collection
    |--List：有序(存入和取出的顺序一致),元素都有索引(角标)，元素可以重复。
    |--Set：元素不能重复,无序。

import java.util.ArrayList;
import java.util.List;
/**
 * 
List:特有的常见方法：有一个共性特点就是都可以操作角标。
    
1，添加
    void add(index,element);
    void add(index,collection);

2，删除；
    Object remove(index):

3，修改：
    Object set(index,element);
    
4，获取：
    Object get(index);
    int indexOf(object);获取指定元素的索引
    int lastIndexOf(object);
    List subList(from,to);
 *
 *
 */
public class ListDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        List list = new ArrayList();
        show(list);
    }

    public static void show(List list) {
        
        //添加元素
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        System.out.println(list);//[abc1, abc2, abc3]
        
        //插入元素,在列表的指定位置插入元素    
        list.add(1,"abc9");
        
        System.out.println(list);//[abc1, abc9, abc2, abc3]
        
        //删除元素。
        System.out.println("remove:"+list.remove(2));//remove:abc2
        
        //修改元素。
        System.out.println("set:"+list.set(1, "abc8"));//set:abc9
        
        //获取元素。
        System.out.println("get:"+list.get(0));//get:abc1
        System.out.println(list);//[abc1, abc8, abc3]
        //获取子列表。
        System.out.println("sublist:"+list.subList(1, 3));//sublist:[abc8, abc3]
        //根据对象获取位置
        System.out.println(list.indexOf("abc8"));//1
        System.out.println(list.lastIndexOf("abc3"));//2
        System.out.println(list);//[abc1, abc8, abc3]
    }
}

List的遍历方式以及使用，使用Iterator接口的子接口ListIterator来完成在迭代中对集合元素进行的增删改查，不会抛出并发修改的异常

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;


public class ListDemo2 {

    /**
     * @param args
     */
    public static void main(String[] args) {

        List list = new ArrayList();
        showListIterator(list);
    }
    
    /**
     * 可以使用Iterator接口的子接口ListIterator来完成在迭代中对集合元素进行的增删改查，不会抛出并发修改的异常
     * 线程只操作迭代对象，不修改集合，这就不是并发的操作，是迭代对象ListIterator中自己的增删改方法，而不是调用集合中的方法
     * @param list
     */
    public static void showListIterator(List list){
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        list.add("abc4");
        list.add("abc5");
        System.out.println("list:"+list);
    
        ListIterator it = list.listIterator();
        while(it.hasNext()){
            Object obj = it.next();
            if(obj.equals("abc4")){
                //it.add("abc9");//不是list.add
                it.set("abc9");
            }
            else
                System.out.print(" "+obj);
        }
        System.out.print("\n");
        System.out.println("********************************");
        //System.out.println("hasnext:"+it.hasNext());
        //System.out.println("hasPrevious:"+it.hasPrevious());
        //System.out.println("previous:"+it.previous());
        //逆向遍历
        while(it.hasPrevious()){
            System.out.print(" "+it.previous());//输出 abc5 abc9 abc3 abc2 abc1
        }
        System.out.print("\n");
        System.out.println("********************************");
        System.out.println(list);
        
    }
    /**
     * java.util.ConcurrentModificationException:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常
     * 集合和迭代器同时对元素进行修改，就会产生异常，一个线程对collection集合迭代，另一个对Collection进行修改的时候，
     * 就会出现上面的异常
     * @param list
     */
    public static void showConcurrentModificationException(List list){
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        System.out.println("list:"+list);
    
        Iterator it = list.iterator();
        while(it.hasNext()){
            Object obj = it.next();//java.util.ConcurrentModificationException
                            //在迭代器过程中，不要使用集合操作元素，容易出现异常。
                        //可以使用Iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作。 
            if(obj.equals("abc2")){
                list.add("abc9");
            }
            else
                System.out.println("next:"+obj);
        }
        System.out.println(list);
        
    }
    /**
     * List集合的遍历，下面两种方法都可以
     * @param list
     */
    public static void show(List list) {
        
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        list.add("abc4");
        //第一种使用iterator
        Iterator it = list.iterator();
        while(it.hasNext()){
            System.out.println("next:"+it.next());
        }
        
        //list特有的取出元素的方式之一。
        
        for(int x=0; x<list.size(); x++){
            System.out.println("get:"+list.get(x));
        }
    }

}

List:
    |--Vector:内部是数组数据结构，是同步的。增删，查询都很慢！
    |--ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。
    |--LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。

Vector：

import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;

public class VectorDemo {

    /**Enumeration枚举接口的功能和Iterator迭代器接口的功能是重复的，Iterator接口添加了一个可选的移除方法，并使用较短的方法名
     * java1.2开始，使用Iterator替代Enumeration
     * @param args
     */
    public static void main(String[] args) {

        Vector v = new Vector();
        
        v.addElement("abc1");
        v.addElement("abc2");
        v.addElement("abc3");
        v.addElement("abc4");
        
        Enumeration en = v.elements();
        while(en.hasMoreElements()){
            System.out.println("nextelment:"+en.nextElement());
        }
        
        Iterator it = v.iterator();
        
        while(it.hasNext()){
            System.out.println("next:"+it.next());
        }
        
    }

}

ArrayList

package cn.itcast.p.bean;

public class Person  {

    private String name;
    private int age;
    
    
    public Person() {
        super();
        
    }
    public Person(String name, int age) {
        super();
        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 name+":"+age;
    }
 
  }
}

import java.util.ArrayList;
import java.util.Iterator;

import cn.itcast.p.bean.Person;

public class ArrayListTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        ArrayList<Person> al = new ArrayList<Person>();
        al.add(new Person("listP1",21));
        al.add(new Person("listP1",22));
        al.add(new Person("listP2",23));
        al.add(new Person("listP3",24));
        
        System.out.println(al);//[listP1:21, listP1:22, listP2:23, listP3:24]
        
        Iterator it = al.iterator();
        while(it.hasNext()){
            Person p = (Person) it.next();
            System.out.println(p.getName()+"--"+p.getAge());
        }
    }
}

输出：

[listP1:21, listP1:22, listP2:23, listP3:24]
listP1--21
listP1--22
listP2--23
listP3--24

LinkedList:
    addFirst();
    addLast():
    jdk1.6
    offerFirst();
    offetLast();

    getFirst();.//获取但不移除，如果链表为空，抛出NoSuchElementException.
    getLast();
    jdk1.6
    peekFirst();//获取但不移除，如果链表为空，返回null.
    peekLast():

    removeFirst();//获取并移除，如果链表为空，抛出NoSuchElementException.
    removeLast();
    jdk1.6
    pollFirst();//获取并移除，如果链表为空，返回null.
    pollLast();
   

import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {

        LinkedList link = new LinkedList();
        
        link.addFirst("abc1");
        link.addFirst("abc2");
        link.addFirst("abc3");
        link.addFirst("abc4");
        System.out.println(link);
        
        System.out.println("使用getFirst---"+link.getFirst());//获取第一个但不删除。当链表为空的时候会抛出抛出NoSuchElementException
        System.out.println("使用getLast---"+link.getLast());//获取最后一个元素，当链表为空的时候会抛出抛出NoSuchElementException
        System.out.println("使用peekFirst---"+link.peekFirst());//获取第一个元素，当链表为为空的时候不会报异常
        System.out.println("使用peekLast---"+link.peekLast());//获取最后一个元素
        
//        System.out.println("使用link.removeFirst---"+link.removeFirst());//获取第一个元素但是会删除。abc4，当链表为空的时候会抛出抛出NoSuchElementException
//        System.out.println("使用removeFirst---"+link.removeFirst());//abc3
//        System.out.println("使用removeLast---"+link.removeLast());//获取最后一个元素，并移除abc1
        System.out.println("使用pollFirst---"+link.pollFirst());//获取第一个元素并从集合中移除（1.6，出来的新方法，当链表为为空的时候不会报异常）
        System.out.println("使用pollFirst---"+link.pollFirst());
        System.out.println("使用pollLast---"+link.pollLast());//获取最后一个元素并从集合中移除
        System.out.println("使用pollLast---"+link.pollLast());
//        while(!link.isEmpty()){
//            System.out.println(link.removeLast());
//        }
        
        
        System.out.println(link);
//        Iterator it = link.iterator();
//        while(it.hasNext()){
//            System.out.println(it.next());
//        }
    }

}

Set:元素不可以重复，是无序。
    Set接口中的方法和Collection一致。
    |--HashSet: 内部数据结构是哈希表 ，是不同步的。
        如何保证该集合的元素唯一性呢？
        是通过对象的hashCode和equals方法来完成对象唯一性的。
        如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。
        如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
        如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。
        记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。
        一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。
        建立对象判断是否相同的依据。

      如果HashSet不覆盖equal和hashCode方法的话，默认的是使用Object中的equal和hashCode方法
      Object中的equal方法比较地址的，而不是比较内容，如果添加重复的对象，地址不同，就会认为没有重复的对象
      所以比较对象是否相同，必须覆盖equal和hashCode方法

package cn.itcast.p.bean;

public class Person /*extends Object*/ {

    private String name;
    private int age;
    
    
    public Person() {
        super();
        
    }
    public Person(String name, int age) {
        super();
        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 name+":"+age;
    }
    @Override
    public boolean equals(Object obj) {//判断人的内容是否相同
        System.out.println("调用了equals方法---------------");
        if(this == obj) //this只是否为Person对象
            return true;
        if(!(obj instanceof Person)){
            throw new ClassCastException("类型转化错误！");
        }
        Person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.age;//字符创name的内容相同吗
    }
    
    @Override
    public int hashCode() { //判断人的hash值是否相同
        System.out.println("调用了hashCode方法---------------");
        return name.hashCode()+ age;
    }
}

往hashSet里面添加元素，进行遍历：

package cn.itcast.p4.hashset.test;

import java.util.HashSet;
import java.util.Iterator;

import cn.itcast.p.bean.Person;


/*
 * 往hashSet集合中存储Person对象。如果姓名和年龄相同，视为同一个人。视为相同元素。
 */
public class HashSetTest {

    /**
     * @param args
     */
    public static void main(String[] args) {

        
        HashSet hs = new HashSet();
        
        /*
         * HashSet集合数据结构是哈希表，所以存储元素的时候，我们需要覆盖hashCode方法和equal方法，来确保放入的对象的唯一性
         * 使用的元素的hashCode方法来确定位置，如果位置相同，
         * 在通过元素的equals来确定是否相同,如果相同的话，就不往set里面存
         */
        
        hs.add(new Person("lisi4",24));
        hs.add(new Person("lisi7",27));
        hs.add(new Person("lisi1",21));
        hs.add(new Person("lisi9",29));
        hs.add(new Person("lisi7",27));
        
        
        Iterator it = hs.iterator();
        
        while(it.hasNext()){
            Person p = (Person)it.next();
            //System.out.println(p);
            System.out.println(p.getName()+"...."+p.getAge());
        }
    }

}

 输出：

调用了hashCode方法---------------
调用了hashCode方法---------------
调用了hashCode方法---------------
调用了hashCode方法---------------
调用了hashCode方法---------------
调用了equals方法---------------
lisic....21
lisia....24
lisid....29
lisib....27

 结果说明调用了5次hashCode，调用了一次equals方法，说明当执行到这句话的时候，hs.add(new Person("lisi7",27));调用了equal方法，因为hash表里面已经有了一个name为lisi7，年龄为27的对象，hash值相同，需要判断内容是否相同，调用equal方法判断内容是否相同，相同，不往hashset里面存储。

TreeSet

自然排序，如果存放的是自定义对象，使用TreeSet，必须实现Comparable接口，覆盖里面的compareTo方法，添加元素的时候进行比较；如果添加的是字符串
就不需要覆盖compareTo方法，因为字符串有自己的compareTo方法；
自定义对象在TreeSet存储时候，如果不覆盖，就会报 java.lang.ClassCastException: cn.itcast.p.bean.Person cannot be cast to java.lang.Comparable异常

public class Person /*extends Object*/ implements Comparable{

    private String name;
    private int age;
    
    
    public Person() {
        super();
        
    }
    public Person(String name, int age) {
        super();
        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 name+":"+age;
    }
    @Override
    public boolean equals(Object obj) {//判断人的内容是否相同
        System.out.println("调用了equals方法---------------");
        if(this == obj) //this只是否为Person对象
            return true;
        if(!(obj instanceof Person)){
            throw new ClassCastException("类型转化错误！");
        }
        Person p = (Person)obj;
        return this.name.equals(p.name) && this.age == p.age;//字符创name的内容相同吗
    }
    
    @Override
    public int hashCode() { //判断人的hash值是否相同
        System.out.println("调用了hashCode方法---------------");
        return name.hashCode()+ age;
    }
    @Override
    public int compareTo(Object o) {
        if(!(o instanceof Person))
            throw new ClassCastException("类型转化错误");
        Person p = (Person)o;
        int temp = this.age-p.age;
        
        return temp==0 ? (this.name.compareTo(p.name)) : temp;//temp等于0表示年龄相等。
    }
}

import java.util.Iterator;
import java.util.TreeSet;

import cn.itcast.p.bean.Person;

public class TreeSetDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        demo2();
    }
    
    /*
     * 自定义对象，使用TreeSet，进行自然排序的时候，
     * 需要实现Comparable接口，添加元素的时候进行比较,
     * 以Person对象年龄进行排序，如果年龄相同，就按照姓名排序
     * 
     */

   public static void demo2(){
       TreeSet ts = new TreeSet();
        ts.add(new Person("zhangsan",28));
        ts.add(new Person("lisi",21));
        ts.add(new Person("zhouqi",29));
        ts.add(new Person("zhaoliu",25));
        ts.add(new Person("wangu",24));
        ts.add(new Person("zhouqi",29));
        
        Iterator it = ts.iterator();
        while(it.hasNext()){
            Person p = (Person)it.next();
            System.out.println(p.getName()+":"+p.getAge());
        }
   }
    /**
     * 添加的是字符串对象，因为字符串内部实现了compareTo方法，
     * 所以不需要实现Comparable接口里面的
     */
    public static void demo1() {
        TreeSet ts = new TreeSet();
        
        ts.add("abc");
        ts.add("zaa");
        ts.add("aa");
        ts.add("nba");
        ts.add("cba");
        
        Iterator it = ts.iterator();
        
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }

}

TreeSet(Comparator<? super E> comparator)
Comparator

public class Person{

    private String name;
    private int age;
    
    
    public Person() {
        super();
        
    }
    public Person(String name, int age) {
        super();
        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 name+":"+age;
    }

}

Comparator比较器：

import java.util.Comparator;

import cn.itcast.p.bean.Person;
/**
 * 创建了一个根据Person类的name进行排序的比较器。
 * 先按照姓名进行比较，如果姓名相同，再按照年龄进行比较
 */
public class ComparatorByName implements Comparator {

    @Override
    public int compare(Object o1, Object o2) {

        Person p1 = (Person)o1;
        Person p2 = (Person)o2;
        
        int temp = p1.getName().compareTo(p2.getName());
        //比较姓名相同，在比较年龄
        return temp==0?p1.getAge()-p2.getAge(): temp;
//        return 1;//有序。
    }

}

package cn.itcast.p5.treeset.demo;

import java.util.Iterator;
import java.util.TreeSet;

import cn.itcast.p.bean.Person;
import cn.itcast.p5.comparator.ComparatorByName;

public class TreeSetComparator {

    /**
     * @param args
     */
    public static void main(String[] args) {

        TreeSet ts = new TreeSet(new ComparatorByName());
        
        /*
         * 自定义对象，使用TreeSet，进行自然排序的时候，
         * 需要实现Comparable接口，添加元素的时候进行比较
         * 
         * 以Person对象年龄进行排序，如果年龄相同，就按照姓名排序
         * 
         */
        ts.add(new Person("zhangsan",28));
        ts.add(new Person("lisi",21));
        ts.add(new Person("zhouqi",29));
        ts.add(new Person("zhaoliu",25));
        ts.add(new Person("wangu",24));
        
        Iterator it = ts.iterator();
        while(it.hasNext()){
            Person p = (Person)it.next();
            System.out.println(p.getName()+":"+p.getAge());
        }
    }

}

输出：

lisi:21
wangu:24
zhangsan:28
zhaoliu:25
zhouqi:29

package cn.itcast.p5.treeset.test;

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

import cn.itcast.p.bean.Person;
import cn.itcast.p5.comparator.ComparatorByLength;

/* 
 * 对字符串进行长度排序，比较内容
 * 
 * "20 18 -1 89 2 67"
 */

public class TreeSetTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //接口内部类
        TreeSet ts = new TreeSet(new Comparator<String>() {

            @Override
            public int compare(String o1, String o2) {
                int temp = o1.length()-o2.length();
                return temp==0 ? o1.compareTo(o2):temp;
            }
        });

        ts.add("aaaaa");
        ts.add("zz");
        ts.add("nbaq");
        ts.add("cba");
        ts.add("abc");
        ts.add("abc");
        
        Iterator it = ts.iterator();
        
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }

}

输出：

zz
abc
cba
nbaq
aaaaa

Map

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapDemo {

    public static void main(String[] args) {
        
        Map<Integer,String> map = new HashMap<Integer,String>();
        method(map);
    }
    /**
     * 
     * Set<Map.Entry<K,V>> entrySet()方法：返回一个set集合，里面装的是Map.Entry接口类型的键值对象
     * 
     * 第二种遍历map的方式：通过看API:Set<Map.Entry<K,V>> entrySet()：Map.Entry<K,V>接口类型，
     * 里面有K getKey() 返回与此项对应的键。 V getValue()  返回与此项对应的值。 

     * 思路：通过把map转化为set，进行迭代
     * 通过使用entrySet方法吧键和值的映射关系作为对象，存储到set集合中，这个映射关系的类型为Map.Entry类型
     * 
     * 
     */
    public static void method_3(Map<Integer,String> map){
        map.put(8,"lisi");
        map.put(2,"zhaoliu");
        map.put(7,"wangwu");
        map.put(6,"wangwang");
        Set<Map.Entry<Integer, String>>entrySet = map.entrySet();
        System.out.println(entrySet);//[2=zhaoliu, 6=wangwang, 7=wangwu, 8=lisi]
        Iterator<Map.Entry<Integer, String>>it = entrySet.iterator();
        //System.out.println(it.next());
        while(it.hasNext()){
            Map.Entry<Integer, String> entryMap = it.next();
            Integer key = entryMap.getKey();//获取键
            String value = entryMap.getValue();//获取值
            System.out.println(key+":"+value);
        }
    }
    /*
     * 第一种遍历的方法
     * Set<K> keySet()：返回键的set集合
     * 取出map中的所有元素。
     * 原理，通过keySet方法获取map中所有的键所在的Set集合，在通过Set的迭代器获取到每一个键，
             在对每一个键通过map集合的get方法获取其对应的值即可。  
             
     */
    public static void method_2(Map<Integer,String> map){
        
        map.put(8,"zhaoliu");
        map.put(2,"zhaoliu");
        map.put(7,"xiaoqiang");
        map.put(6,"wangcai");
        
        Set<Integer> keySet = map.keySet();
        System.out.println(keySet);//键的set集合[2, 6, 7, 8]
        Iterator<Integer> it = keySet.iterator();//迭代keySet
        while(it.hasNext()){
            Integer key = it.next();
            String value = map.get(key);
            System.out.println(key+":"+value);
        }
    }
    /**
     * 常用方法：
            1，添加。
                value put(key,value):返回前一个和key关联的值，如果没有返回null.
            
            2，删除。
                void  clear():清空map集合。
                value remove(key):根据指定的key翻出这个键值对。 
            
            3，判断。
                boolean containsKey(key):
                boolean containsValue(value):
                boolean isEmpty();
            
            4，获取。 
                value get(key):通过键获取值，如果没有该键返回null。
                                当然可以通过返回null，来判断是否包含指定键。 
                int size(): 获取键值对的个数。 
                
            5.特殊方法： Collection<V> values() 包含的值的 Collection 视图。
     * @param map
     */
    public static void method(Map<Integer,String> map){//学号和姓名
        // 添加元素。
        System.out.println(map.put(8, null));//null
        System.out.println(map.put(8, "xiaoqiang"));//wangcai 存相同键，值会覆盖。
        map.put(2,"zhangsan");
        map.put(7,"zhaoliu");
        
        /*System.out.println(map);
        //删除。
        System.out.println("remove:"+map.remove(2));
        //判断。
        System.out.println("containskey:"+map.containsKey(6));
        System.out.println("containsValue:"+map.containsValue("zhaoliu"));
        
        //获取。 
        System.out.println("get:"+map.get(7));
        System.out.println(map);*/
        //返回key对应的所有value的集合
        Collection<String>values = map.values();
        System.out.println(values);
        Iterator<String>it = values.iterator();
        while(it.hasNext()){
            String value = it.next();
            System.out.println(value);
        }
    }
    
}

interface MyMap{
    public static interface MyEntry{//内部接口
        void get();
    }
}

class MyDemo implements MyMap.MyEntry{
    public void get(){}
}

class Outer{
    static class Inner{
        static void show(){}
    }
}

HashMap

public class Person  {

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


    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    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;
    }

    @Override
    public String toString() {
        
        return "Person:"+getName()+":"+getAge();
    }
}

package cn.itcast.p2.bean;

public class Student extends Person {

    public Student() {
        super();
        
    }

    public Student(String name, int age) {
        super(name, age);
        
    }

    @Override
    public String toString() {
        
        return "Student:"+getName()+":"+getAge();
    }
    
    

    
}

package cn.itcast.p7.hashmap.demo;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

import cn.itcast.p2.bean.Student;

public class HashMapDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {

        
        /*
         * 将学生对象和学生的归属地通过键与值存储到map集合中。
         * 
         */
        
        HashMap<Student,String> hm = new HashMap<Student,String>();

        
        hm.put(new Student("lisi",38),"北京");
        hm.put(new Student("zhaoliu",24),"上海");
        hm.put(new Student("xiaoqiang",31),"沈阳");
        hm.put(new Student("wangcai",28),"大连");
        hm.put(new Student("zhaoliu",24),"铁岭");
        
//        Set<Student> keySet = hm.keySet();        
//        Iterator<Student> it = keySet.iterator();
        
        Iterator<Student> it = hm.keySet().iterator();
        
        while(it.hasNext()){
            Student key = it.next();
            String value = hm.get(key);
                System.out.println(key.getName()+":"+key.getAge()+"---"+value);
        }

    }

}
    

结果：

xiaoqiang:31---沈阳
wangcai:28---大连
lisi:38---北京
zhaoliu:24---铁岭

HashMap要比较自定义对象也必须重写equal方法和hashCode方法。

TreeMap

排序，实现Comparator接口

package cn.itcast.p3.comparator;

import java.util.Comparator;

import cn.itcast.p2.bean.Person;

public class ComparatorByName implements Comparator<Person> {

    @Override
    public int compare(Person o1, Person o2) {
        
        int temp = o1.getName().compareTo(o2.getName());
        return temp==0? o1.getAge()-o2.getAge(): temp;
    }

}

package cn.itcast.p8.treemap.demo;

import java.util.Iterator;
import java.util.Map;
import java.util.TreeMap;

import cn.itcast.p2.bean.Student;
import cn.itcast.p3.comparator.ComparatorByName;

public class TreeMapDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {

        TreeMap<Student,String> tm = new TreeMap<Student,String>(new ComparatorByName());
        
        tm.put(new Student("lisi",38),"北京");
        tm.put(new Student("zhaoliu",24),"上海");
        tm.put(new Student("xiaoqiang",31),"沈阳");
        tm.put(new Student("wangcai",28),"大连");
        tm.put(new Student("zhaoliu",24),"铁岭");
        
        
        Iterator<Map.Entry<Student, String>> it = tm.entrySet().iterator();
        
        while(it.hasNext()){
            Map.Entry<Student,String> me = it.next();
            Student key = me.getKey();
            String value = me.getValue();
            System.out.println(key.getName()+":"+key.getAge()+"---"+value);
        }
    }
}

输出结果：

lisi:38---北京
wangcai:28---大连
xiaoqiang:31---沈阳
zhaoliu:24---铁岭

LinkedHashMap

package cn.itcast.p1.map.demo;

import java.io.File;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapDemo {

    /**
     * LinkedHashMap 按顺序存入，按顺序取出
     */
    public static void main(String[] args) {
        
        File f= null;
        HashMap<Integer,String> hm = new LinkedHashMap<Integer,String>();
        
        hm.put(7, "zhouqi");
        hm.put(3, "zhangsan");
        hm.put(1, "qianyi");
        hm.put(5, "wangwu");
        
        Iterator<Map.Entry<Integer,String>> it = hm.entrySet().iterator();
        
        while(it.hasNext()){
            Map.Entry<Integer,String> me = it.next();
            
            Integer key = me.getKey();
            String value = me.getValue();
            
            System.out.println(key+":"+value);
        }
    }

}