复习集合

第一部分 集合框架

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

二、数组和集合类同是容器，有何不同？
数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。

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

第二部分 Collection
Collection是集合框架中的常用接口。其下有两个子接口：List（列表），Set（集）。
所属关系：
Collection
|–List//元素是有序的，元素可以重复。因为该集合体系有索引。
|–Set//元素是无序的，元素不可以重复。

一、Collection接口中的常见操作
1、添加元素
add(Objectobj); //add方法的参数类型是Object。以便于接收任意类型对象。
2、删除元素
remove(Objectobj);
removeAll(另一集合);//调用者只保留另一集合中没有的元素。
clear();//清空集合
3、判断元素
contains(Objectobj);//判断是否存在obj这个元素
isEmpty();//是否为空
4、获取个数，集合长度
size();
5、取交集
retainAll(另一集合);//调用者只保留两集合的共性元素。
注：集合中存储的都是对象的引用（地址）。

二、迭代
1、概述
迭代是取出集合中元素的一种方式。
对于集合的元素取出这个动作：
当不足以用一个函数来描述，需要用多个功能来体现，所以就将取出这个动作封装成一个对象来描述。就把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内部的元素。那么取出方式就被定义成了内部类。
而每一个容器的数据结构不同，所以取出的动作细节也不一样。但是都具有共性内容： 判断和取出。那么就可以将这些共性抽取。
那么这些内部类都符合一个规则（或者说都抽取出来一个规则）。该规则就是Iterator。通过一个对外提供的方法：iterator();，来获取集合的取出对象。
因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。

2、迭代的常见操作
hasNext();//有下一个元素，返回真
next();//取出下一个元素
remove();//移除
注：在迭代时循环中next调用一次，就要hasNext判断一次。
使用：
ArrayList a=newArrayList();//创建一个集合
Iteratorit=a.iterator();//获取一个迭代器，用于取出集合中的元素。
第一种打印方式：
for(Iterator iter = a.iterator();iter.hasNext(); )
{
System.out.println(iter.next());
}
第二种打印方式：
Iteratoriter = a.iterator();
while(iter.hasNext())
{
System.out.println(iter.next());
}
3、迭代注意事项
迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。
迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。
迭代器的next方法返回值类型是Object，所以要记得类型转换。

第三部分 List
一、List
组成
List：元素是有序的，元素可以重复。因为该集合体系有索引。
|–ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
|–LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。
|–Vector：底层是数组数据结构。线程同步。被ArrayList替代了。

二、List的特有方法
凡是可以操作角标的方法都是该体系特有的方法。
1、增
booleanadd(index,element);//指定位置添加元素
BooleanaddAll(index,Collection);//在指定位置增加给定集合中的所有元素，若省略位置参数，则在当前集合的后面依次添加元素
2、删
Booleanremove(index);//删除指定位置的元素
3、改
set(index,element);//修改指定位置的元素。
4、查
get(index);//通过角标获取元素
subList(from,to);//获取部分对象元素
5、其他
listIterator();//List特有的迭代器
indexOf(obj);//获取元素第一次出现的位置，如果没有则返回-1
注：List集合判断元素是否相同，移除等操作，依据的是元素的equals方法。

三、ListIterator
1、概述
ListIterator是List集合特有的迭代器，是Iterator的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所以在迭代器时，只能用迭代器的方法操作元素。可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作。如果想要其他的操作，如添加、修改等，就需要使用其子接口：ListIterrator。该接口只能通过List集合的ListIterator方法获取。
2、ListIterator特有的方法
add(obj);//增加
set(obj);//修改为obj
hasPrevious();//判断前面有没有元素
previous();//取前一个元素

四、枚举Enumeration
枚举：
就是Vector特有的取出方式。Vector有三种取出方式。
其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。
特有方法：
addElement(obj);//添加元素，相当于add(obj);
Enumerationelements();//Vector特有取出方式(枚举)
hasMoreElements();//相当于Iterator的hasNext()方法
nextElements();//相当于Iterator的next()方法
示例一：

package collections;

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

public class CollectionsDemo2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new MyComparator()));
        ts.add("asd");
        ts.add("xc");
        ts.add("vbnm");
        ts.add("songxue");
        for (Iterator<String> iterator = ts.iterator(); iterator.hasNext();) {
            System.out.println("ts: "+iterator.next());
        }
    }

}
class MyComparator implements Comparator<String>{

    @Override
    public int compare(String o1, String o2) {
        if (o1.length()>o2.length()) {
            return 1;
        }
        if (o1.length()<o2.length()) {
            return -1;
        }
        return o1.compareTo(o2);
    }

}

示例二：

package arraylist;

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

public class ArrayListTest {

    /**
     * 去除ArrayList里面重复的元素
     * @param args
     */
    public static void main(String[] args) {
        ArrayList<Object> al=new ArrayList<Object>();
        al.add("java01");
        al.add("java01");
        al.add("java02");
        al.add("java01");
        al.add("java02");
        al.add("java03");

        System.out.println(SingleElement(al));
    }

    public static Object SingleElement(ArrayList<Object> al) {
        //建立一个临时容器
        ArrayList<Object> newAl = new ArrayList<Object>();
        for (Iterator<Object> it= al.iterator();it.hasNext();) {
            Object obj=it.next();
            if (!newAl.contains(obj)) {
                newAl.add(obj);
            }
        }
        return newAl;
    }

}

五、LinkedList
LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。
特有方法：
1、增
addFirst();
addLast();
2、获取
//获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
getFirst();
getLast();
3、删
//获取元素，并删除元素。如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
在JDK1.6以后，出现了替代方法。
1、增
offFirst();
offLast();
2、获取
//获取元素，但是不删除。如果集合中没有元素，会返回null。
peekFirst();
peekLast();
3、删
//获取元素，并删除元素。如果集合中没有元素，会返回null。
pollFirst();
pollLast();

package linkedlist;

import java.util.LinkedList;

public class Duilie {
    private LinkedList<Object> list;
    Duilie(){
        list = new LinkedList<Object>();
    }
    public void myAdd(Object obj){
        list.addFirst(obj);
    }
    public Object myGet(){
        return list.removeLast();
    }
    public boolean isNull(){
        return list.isEmpty();
    }
}
package linkedlist;

public class TestDuilie {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Duilie d= new Duilie();
        d.myAdd("java01");
        d.myAdd("java02");
        d.myAdd("java03");
        d.myAdd("java04");
        while (!d.isNull()) {

            System.out.println(d.myGet());
        }
    }

}

第四部分 Set
一、概述
Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。
|–HashSet：底层数据结构是哈希表。线程不同步。 保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同，还会继续判断元素的equals方法，是否为true。
|–TreeSet：可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0。
Set集合的功能和Collection是一致的。

二、HasSet
HashSet：线程不安全，存取速度快。
可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。
注意：HashSet对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。

package set;

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

public class HashsetDemo {

    public static void main(String[] args) {
        HashSet<Object> hs=new HashSet<>();
        hs.add("java01");
        hs.add("java02");
        hs.add("java03");
        hs.add("java04");
        for(Iterator<Object> it= hs.iterator();it.hasNext();){
            Object obj=it.next();
            System.out.println(obj);
        }
    }
}

三、TreeSet
1、特点
a、底层的数据结构为二叉树结构（红黑树结构）
b）可对Set集合中的元素进行排序，是因为：TreeSet类实现了Comparable接口，该接口强制让增加到集合中的对象进行了比较，需要复写compareTo方法，才能让对象按指定需求（如人的年龄大小比较等）进行排序，并加入集合。
java中的很多类都具备比较性，其实就是实现了Comparable接口。
注意：排序时，当主要条件相同时，按次要条件排序。
c、保证数据的唯一性的依据：通过compareTo方法的返回值，是正整数、负整数或零，则两个对象较大、较小或相同。相等时则不会存入。
2、Tree排序的两种方式
1）第一种排序方式：自然排序
让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也被称为元素的自然顺序，或者叫做默认顺序。
2）第二种方式：比较器
当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式。定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法。
当两种排序都存在时，以比较器为主。

package set;

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

public class TreeSetDemo {

    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<>();
        ts.add(new Student("xiaoming1",12));
        ts.add(new Student("xiaoming2",13));
        ts.add(new Student("xiaoming3",10));

        for (Iterator<Student> iterator = ts.iterator(); iterator.hasNext();) {
            Student stu =  iterator.next();
            System.out.println(stu.getName()+"....."+stu.getAge());
        }
    }

}
package set;

public class Student implements Comparable<Object> {

    private String name ;
    private int age;

    public Student(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 int compareTo(Object obj) {
        return 1;
        /*
        if (!(obj instanceof Student)) {
            throw new RuntimeException("不是学生对象");
        }
        Student stu=(Student)obj;
        return this.age-stu.getAge();
        */
    }

}

第五讲 Map集合
一、概述
1、简述：
Map集合是一个接口，和List集合及Set集合不同的是，它是双列集合，并且可以给对象加上名字，即键（Key）
2、特点：
1）该集合存储键值对，一对一对往里存
2）要保证键的唯一性。
二、Map集合的子类
Map
|–Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。JDK1.0，效率低。
|–HashMap：底层是哈希表数据结构。允许使用null键null值，该集合是不同步的。JDK1.2，效率高。
|–TreeMap：底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。
Map和Set很像。其实Set底层就是使用了Map集合。

三、Map集合的常用方法
1、添加
Vput(K key,V value);//添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值，并put方法会返回被覆盖的值。
2、删除
clear();//清空
Vremove(Object key);//删除指定键值对
3、判断
containsKey(Objectkey);//判断键是否存在
containsValue(Objectvalue)//判断值是否存在
isEmpty();//判断是否为空
4、获取
Vget(Object key);//通过键获取对应的值
size();//获取集合的长度
Collectionvalue();//获取Map集合中所以得值，返回一个Collection集合
注：HashMap集合可以通过get()方法的返回值来判断一个键是否存在，通过返回null来判断。

四、Map集合的两种取出方式
Map集合的取出原理：将Map集合转成Set集合。再通过迭代器取出。
示例：

package map;

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

public class MapTest01 {

    /**
     * 给一个字符串adfgaassdfk,打印类似a（2）,b(10)....
     * @param args
     */

    public static void main(String[] args) {
        String str="adfgaassdfk";
         CharCount(str);
    }
    public static String CharCount(String str){
        char[] chs=str.toCharArray();
        TreeMap<Character, Integer> tm = new TreeMap<Character,Integer>();
        //int count=0;
        for (int i = 0; i < chs.length; i++) {
            Integer value = tm.get(chs[i]);
            /*
            if (value!=null) {
                count = value;
                count++;
                tm.put(chs[i], value);
                }
            count=0;*/


            if (value==null) {
                tm.put(chs[i], 1);
            }else {
                value = value+1;
                tm.put(chs[i], value);
            }
        }
        StringBuilder sb = new StringBuilder();
        Set<Map.Entry<Character,Integer>> s=tm.entrySet();
        for (Iterator<Map.Entry<Character, Integer>> it = s.iterator(); it.hasNext();) {
            Map.Entry<Character, Integer> entry = it.next();
            char ch=entry.getKey();
            int i=entry.getValue();
            sb.append(ch+"("+i+")");
        }
        System.out.println(sb.toString());
        return null;
    }

}

五、Map集合的应用及扩展
1、何时使用Map集合：当量数据之间存在着映射关系的时候，就应该想到使用Map集合。
2、示例：
获取该字符串中的字母出现的次数，如：”sjokafjoilnvoaxllvkasjdfns”；希望打印的结果是：a(3)c(0)…..
通过结果发现，每个字母都有对应的次数，说明字母和次数之间有映射关系。代码如下：

package map;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;


public class MapTest02 {

    /**
     * map扩展
     * @param args
     */
    public static void main(String[] args) {
        Map<String,List<Student2>> school=new HashMap<String,List<Student2>>();
        List<Student2> jichu=new ArrayList<Student2>();
        List<Student2> jiuye=new ArrayList<Student2>();
        jichu.add(new Student2(01,"王二"));
        jichu.add(new Student2(02,"张一"));

        jiuye.add(new Student2(01,"李四"));
        jiuye.add(new Student2(02,"王五"));
        school.put("基础班", jichu);
        school.put("就业班", jiuye);
        Set<String> s=school.keySet();
        for (Iterator<String> it = s.iterator(); it.hasNext();) {
            String roomName =  it.next();
            List<Student2> list=school.get(roomName);
            System.out.println(roomName);
            getstudents(list);
        }
    }
    public static void getstudents(List<Student2> list){
        for (Student2 stu : list) {
            int id=stu.getId();
            String name=stu.getName();
            System.out.println(id+" : "+name);
        }
    }

}
class Student2{
    private int Id;
    private String name;
    public int getId() {
        return Id;
    }
    public void setId(int id) {
        Id =  id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Student2(int id, String name) {
        super();
        Id = id;
        this.name = name;
    }

}