JavaSE笔记-集合

Java集合大致可分为：List,Set,Map,Queue

List:有序，可重复

Set:无序（输出和插入顺序不一定一致），不可重复

Map:映射关系,根据key去访问value

Queue:队列，先进先出(FIFO)

集合类只能存储对象

List<int>       //错误
List<Integer>

Collection体系结构

圆圈表示:interface

长方形表示：class

带三角的实线代表继承关系，使用关键字extends

带三角的虚线代表实现关系，使用关键字implements

Iterable

iterable定义了iterator()，forEach(Consumer<? super T> action)

这2个方法用于遍历元素

1.forEach方法遍历集合

Consumer是一个函数式接口，只有一个accept(T t)方法，可以使用Lambda表达式

    public static void main(String[] args){
        Collection<String> coll = new HashSet<>();
        //在集合中添加10个元素
        for(int i=0;i<10;i++){
            coll.add("小王"+i);
        }
        //使用forEach遍历集合
        coll.forEach(name->System.out.println(name));
    }

输出（因为HashSet并未实现SortedSet接口，所以里边的元素是无序的）

2.iterator()遍历集合

集合类使用iterator()方法，会返回一个Iterator

Iterator接口主要用于遍历Collection中的元素

有上边的4个方法，其中forEachRemaining()用来使用Lambda表达式来遍历集合

　　2.1不使用Lambda表达式

    public static void main(String[] args){
        Collection<String> coll = new ArrayList<>();
        //在集合中添加10个元素
        for(int i=0;i<10;i++){
            coll.add("小王"+i);
        }
        //获得一个iterator
        Iterator<String> iterator = coll.iterator();
        //iterator中是否还有下一个元素
        while(iterator.hasNext()){
            //返回集合中的下一个元素
            String name = iterator.next();
            System.out.println(name);
            //删除一个元素
            if("小王5".equals(name)){
                iterator.remove();
            }
            //更改iterator中元素，但是集合中的元素没有改变
            //因此可以得出集合传给iterator的是元素的值，而不是引用
            name = "李四";
        }
        System.out.println(coll.contains("小王5"));
    }

注意在使用iterator迭代集合元素的过程中（不要在while循环里边改coll），不要改变集合中的元素，否则会产生ConcurrentModificationException

　　2.2使用Lambda表达式

    public static void main(String[] args){
        Collection<String> coll = new ArrayList<>();
        //在集合中添加10个元素
        for(int i=0;i<10;i++){
            coll.add("小王"+i);
        }
        //获得一个iterator
        Iterator<String> iterator = coll.iterator();
        iterator.forEachRemaining(name->System.out.println(name));
    }

3.使用foreach循环来遍历元素

    public static void main(String[] args){
        Collection<String> coll = new ArrayList<>();
        //在集合中添加10个元素
        for(int i=0;i<10;i++){
            coll.add("小王"+i);
        }

        for(String name:coll){
            System.out.println(name);
        }
}

注意在使用foreach遍历集合元素的过程中（不要在for循环里边改coll），不要改变集合中的元素，否则会产生ConcurrentModificationException

Collection

Collection中的操作可以操作所有的List,Set,Queue

   public static void main(String[] args){
        Collection<String> coll = new ArrayList<>();
        //在集合中添加一个元素
        coll.add("张三");
        //返回true
        System.out.println(coll.contains("张三"));
        //返回1
        System.out.println(coll.size());
        //删除元素
        coll.remove("张三");
        //返回0
        System.out.println(coll.size());
        //在集合中添加10个元素
        for(int i=0;i<10;i++){
            coll.add("小王"+i);
        }
        //把集合转换成数组
        String[] array = coll.toArray(new String[10]);
        System.out.println(array[5]);
    }

 Set

特点是不允许包含重复元素，继承自Collection接口，没有添加额外方法

1.HashSet

特点

不保证有序

线程不安全，有2个线程同时修改HashSet时，需要通过代码同步

集合元素可以是null

数据结构：散列表
HashSet判定2个元素相等的条件是：1.equals()方法比较相等　　2.hashCode()返回值相等

class A{
    @Override
    public boolean equals(Object obj) {
        return true;
    }
}

class B{
    @Override
    public int hashCode() {
        return ;
    }

    @Override
    public boolean equals(Object obj) {
        return true;
    }
}

class C{
    @Override
    public int hashCode() {
        return ;
    }
}
public class Test {
    public static void main(String[] args){
        Set<Object> set = new HashSet<>();
        //仅equals()相同
        set.add(new A());
        set.add(new A());
        //hashCode(),equals()均相同
        set.add(new B());
        set.add(new B());
        //仅hashCode()相同
        set.add(new C());
        set.add(new C());
        for(Object a : set){
            System.out.println(a);
        }
    }

输出

可以看出只有B,equals和hashCode都相同时，HashSet才会认为这2个元素使同一个元素

当hashCode相同时，HashSet会把多个元素放在一个bucket中，构成同义词链表，会减慢访问速度

因此，使用HashSet时，要保证2个对象equals返回true时，hashCode也要返回true

2.TreeSet

特点

排过序

线程不安全，有2个线程同时修改HashSet时，需要通过代码同步

数据结构：红黑树

TreeSet的排序规则

　　2.1自然排序 （默认）

调用集合元素的compareTo(Object obj)方法比较元素大小关系，然后按元素大小升序排列

a.compareTo(b)

a>b,返回正数

a=b,返回0

a<b,返回负数

使用TreeSet时，要保证2个对象equals返回true时，a.compareTo(b)要返回0

因此在向TreeSet中添加元素时，要实现Comparable接口，否则抛出ClassCashException

    public static void main(String[] args){
　　　　　//Integer已经实现Comparable接口
        TreeSet<Integer> set = new TreeSet<>();
        set.add();
        set.add();
        set.add();
        set.add();
        for(Integer i : set){
            System.out.println(i);
        }
    }

输出

　　2.2通过Comparator接口（函数式接口）

　　

compare(a,b)

返回正数,a>b

返回0,a=b

返回负数,a<b

实现逆序，返回相反的数就行了

    public static void main(String[] args) {
　　　　 //使用TreeSet(Comparator<? super E> comparator)构造
        TreeSet<Integer> set = new TreeSet<>(
                (num1,num2)-> {
                    if (num1 < num2)
                        return ;
                    if(num1 > num2)
                        return -;
                    return ;
                }
        );
        set.add();
        set.add();
        set.add();
        for (int num : set){
            System.out.println(num);
        }
    }

输出

3.EnumSet

　　所有元素必须是enum类型

　　EnumSet是有序的

　　不允许放入null

　　没有构造器， 通过静态方法获得EnumSet

List

特点是元素有序，可重复，继承自Collection接口，还添加了一些根据索引操作元素的方法

　　List判断2个元素相等的条件是equals方法返回true

set方法只能用于修改集合中已经存在的值，不能新增加元素。

使用List的sort方法进行排序

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李小四");
        list.add("王大少爷");
        //集合的顺序是张三，李小四，王大少爷
        list.sort(
                ((o1, o2) ->{
                    if(o1.length() < o2.length())
                        return 1;
                    if(o1.length() == o2.length())
                        return 0;
                    return -1;
                } )
        );
        for (String s: list) {
            System.out.println(s);
        }
    }

输出

 使用ListIterator迭代

ListIterator()方法返回一个ListIterator,ListIterator增加了向前迭代元素的方法，以及添加元素的方法

   public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李小四");
        list.add("王大少爷");
        //集合的顺序是张三，李小四，王大少爷
        ListIterator<String> listIterator = list.listIterator();
        //注意这里调用add方法采用的是头插法
        listIterator.add("周杰伦");
        System.out.println(list);
        while(listIterator.hasNext()){
            listIterator.next();
        }
        System.out.println("你还想怎么样啊，到底了");
        System.out.println("========================");
        System.out.println("我还能反着遍历元素啊");
        while(listIterator.hasPrevious()){
            System.out.println(listIterator.previous());
        }
    }

输出

 ArrayList,Vector

ArrayList,Vector是List的2个典型实现，调用不带参数构造方法，initialCapacity=10；带参数的构造方法，自己指定initialCapacity

ArrayList不是线程安全的，Vector是线程安全的

Queue

数据结构：队列（FIFO）

不允许随机访问

element()方法返回头元素，不删除集合中元素

peek()方法返回头元素或者null，不删除集合中元素

poll()方法返回头元素或者null,删除集合中元素

1.PriorityQueue

　　按元素大小重新排序，因此取出头元素时，是最小的元素

　　PriorityQueue不允许插入null

　　PriorityQueue对元素的排序方法同样有2种，自然排序和定制排序，思路和TreeSet一样

2.Deque和ArrayDeque

　　Deque代表一个双端队列

它们功能相同，区别是对失败情况的处理不同。一套接口遇到失败就会抛出异常，另一套遇到失败会返回特殊值（false或null）

　　ArrayDeque底层也是数组，数组长度默认是16

ArrayDeque可以作为栈和队列使用（推荐）

作为栈时使用下面2个方法操作元素

作为队列时使用下面方法操作元素

LinkedList

　　实现了List和Deque 2个接口，底层是链表，随机访问效率较差，插入删除效率高

　　LinkedList采用迭代器方式遍历效率高，ArrayList,Vector使用get效率高

Map体系结构

 Map

　　Key:无序，不可重复->组成一个keySet

　　Value:有序，可重复->组成一个List

   public static void main(String[] args){
        Map<Integer,String> map = new HashMap<Integer,String>();
        //添加元素
        map.put(1,"张三");
        map.put(2,"李四");
        map.put(3,"王五");
        //key是唯一的，如果放入相同的key，会把现有的覆盖
        map.put(3,"赵子龙");
        //输出赵子龙
        System.out.println(map.get(3));
        //删除赵子龙
        map.remove(3);
        //遍历
        for (int i : map.keySet()){
            System.out.println(map.get(i));
        }

    }

HashMap,Hashtable

　　区别：1.HashMap线程不安全，Hashtable线程安全

　　　　　2.HashMap可以使用null作为key和value（由于key是不可重复的，因此key只能有1个可以为null，value可以有无数个），Hashtable不可以

　　判定key和value是否相等

　　判定key相等通过equals()方法和hashCode()方法，判定value相等通过equals()方法

　

class MyKey{
    private int key;

    public MyKey(int key){
        this.key = key;
    }
    @Override
    public boolean equals(Object obj) {
        MyKey k = (MyKey) obj;
        if(key == k.key)
        return true;
        return false;
    }

    @Override
    public int hashCode() {
        return key;
    }
}
public class Test {
    public static void main(String[] args){
        Map<MyKey,String> map = new HashMap<>();
        map.put(new MyKey(1),"张三");
        map.put(new MyKey(2),"李四");
        //key相同，会覆盖原来的
        map.put(new MyKey(1),"周杰伦");
        //输出{MyKey@1=周杰伦, MyKey@2=李四}
        System.out.println(map);
        //返回true
        System.out.println(map.containsValue("李四"));
    }
}

LinkedHashMap

　　LinkedHashMap使用双向链表维护key,确保key插入顺序与迭代顺序一致

Properties

　　Properties相当于一个key,value都是String的Map

　　使用Properties读取配置文件

    public static void main(String[] args){
        Properties properties = new Properties();
        try {
            properties.load(new InputStreamReader(new FileInputStream("properties"),"utf-8"));
            System.out.println(properties);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

 TreeMap

　　数据结构：红黑树

　　每个key-value对作为红黑树节点

　　2种排序方式：自然排序和定制排序（看key，与TreeSet判等规则一致）

WeakHashMap

　　与HashMap区别：WeakHashMap的key中保存的是弱引用，HashMap中保存的是强引用

　　如果WeakHashMap中的key没有被其他强引用变量引用，这些key有可能被GC回收

IdentityHashMap

　　与HashMap区别：IdentityHashMap只有当key1 == key2 才认为2个key相等，HashMap两个key的equals,hashCode相等即相等

工具类Collections

　对List的操作

 public static void main(String[] args){
        List<Integer> list = new ArrayList<>();
        for (int i=0; i<10;i++){
            list.add(i);
        }
        //输出[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
        System.out.println(list);
        //逆序
        Collections.reverse(list);
        //输出[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
        System.out.println(list);
        //随机排序
        Collections.shuffle(list);
        System.out.println(list);
        //升序排序
        Collections.sort(list);
        System.out.println(list);
        //二分查找指定元素位置，List必须有序
        System.out.println(Collections.binarySearch(list,5));
    }

　　查找Collection最大最小值

    public static void main(String[] args){
        Collection<Integer> c = new HashSet<>();
        for (int i=0;i<10;i++){
            c.add(i);
        }
        //最大值9
        System.out.println(Collections.max(c));
        //最小值0
        System.out.println(Collections.min(c));
    }

　　同步集合

　　

通过上面3个方法得到同步后的集合，确保线程安全