【JAVA】10 Collection 集合

1 Collection

2 List

1. List集合类中的元素有序（添加顺序和取出顺序一致、可以重复）
2. List集合中的每个元素都由其对应的顺序索引
3. List容器中的元素都对应一个整数型的序号记载在其容器中的位置，可以根据序号存取容器中的元素
4. JDK API中List接口的实现类：ArrayList、LinkedList、Vector

1.1 常用函数

1. add()
2. addAll(1,list2)
3. list.indexOf(“tom”)
4. list.remove(0)
5. list.set(1,“jessy”)
6. list.remove(5)

1.2 ArrayList

1. 可以加入多个null
2. ArrayList是由数组来实现数据存储的
3. 线程不安全（执行效率高），多线程情况下不使用ArrayList
4. 源码机制
   1. ArrayList中维护了一个Object类型数组elementData，

transient Object[] elementData; 

2. 当创建ArrayList对象时，如果使用无参构造器，则初始elementData容量为0，第1次添加，则扩容elementData为10，如果需要再次扩容，则扩容elementData为1.5倍
3. 如果使用指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，则直接扩容elementData为1.5倍
4. 如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，则直接扩容elementData为1.5倍

1.3 Vector

1. Vector类定义的说明

public class Vector<E> extends Abstract<E> implements List<E>,RandomAccess,Clonable,Serializable

2. Vector 底层也是一个对象数组

protected Object[] elementData;

3. Vector是线程同步的，即线程安全，Vector类的操作方法带有synchronized，在开发中需要线程同步安全时，考虑使用Vector

public synchronized E get(int index){
	if(index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);
	return elementData(index);
}

4. ArrayList 和 Vector 比较

1.4 LinkedList

1. LinkedList底层实现双向链表和双端队列特点
2. 可以添加任意元素（元素可重复），包括Null
3. 线程不安全，没有实现同步
4. LinkedList 底层维护了一个双向链表
5. LinkedList中维护了两个属性first和last分别指向首节点和为节点
6. 每个节点（Node对象），里面又维护了prev、next、item三个属性，其中通过prev指向前一个，通过next指向后一个节点，最终实现双向链表
7. LinkedList的元素的添加和删除，不是通过数组完成的，相对来说效率比较高

public class LinkedListExercise {
    public static void main(String[] args){
        Node jack = new Node("jack");
        Node tom = new Node("tom");
        Node jessy = new Node("jessy");

        jack.next=tom;
        tom.pre=jack;
        tom.next=jessy;
        jessy.pre=tom;

        System.out.println("从头到尾遍历");
        Node first = jack;
        while (true){
            if(first==null){
                break;
            }
            System.out.println(first);
            first=first.next;
        }

        System.out.println("从尾到头遍历");
        Node last=jessy;
        while (true){
            if(last==null){
                break;
            }
            System.out.println(last);
            last=last.pre;
        }

        //插入节点alice
        Node alice = new Node("alice");
        alice.next = tom.next;
        tom.next=alice;
        alice.pre = tom;
        jessy.pre =alice;

        System.out.println("从头到尾遍历");
        first = jack;
        while (true){
            if(first==null){
                break;
            }
            System.out.println(first);
            first=first.next;
        }
        
    }
}

class Node {
    public Object item;
    public Node pre;
    public Node next;

    public Node(Object name){
        this.item=name;
    }

    public String toString(){
        return "Node name=" + item;
    }
}

8. 常用函数
   1. remove(loc)
      1. 默认删除第一个节点
      2. loc：第几个节点
   2. set(loc,val)
9. ArrayList 和LinkedList的区别

	底层结构	增删的效率	改查的效率
ArrayList	可变数组	较低，数组扩容	较高
LinkedList	双向链表	较高，通过链表追加	较低

3 Map

https://xianshang.blog.csdn.net/article/details/81487594

3.1 HashMap

1. Map中的key和value都可以为null
2. 一对k-v是放在一个HashMap$Node中，因为Node实现了Entry接口，有些书也说一对Entry就是一对k-v
3. Map遍历

import java.util.*;

public class HashSetSource {
    public static void main(String args[]){
        Map map = new HashMap();
        map.put("邓超","孙俪");
        map.put(null,"刘亦菲");
        map.put("鹿晗","关晓彤");

        System.out.println("1.for循环遍历");
        for(Object value: map.values()){
            System.out.println(value);
        }

        System.out.println("2.迭代器遍历");
        Iterator iterator = map.values().iterator();
//        System.out.println(iterator);         //java.util.HashMap$ValueIterator@1b6d3586
//        System.out.println(iterator.next());  //孙俪
        while (iterator.hasNext()){
            Object value = iterator.next();
            System.out.println(value);
        }

        System.out.println("3.EntrySet迭代器");
        Set entrySet = map.entrySet();
        Iterator iterator1 =entrySet.iterator();
        while (iterator1.hasNext()){
            Object o = iterator1.next();
            Map.Entry entry = (Map.Entry) o;
            System.out.println(entry.getKey()+"-"+entry.getValue());
        }
    }
}

4. 底层使用hash表方式存储，不能保证映射的顺序
5. HashMap没有实现同步，因为线程不安全，方法没有做同步互斥处理，没有synchronized
6. 底层机制

3.2 HashTable

1. 使用

HashMap hashMap = new HashMap();
hashMap.put(i,"hello");

2. 存放的元素是键值对 K-V
3. hashtable的键和值都不能为Null,否则就会抛出NullPointerException
4. hashTable 使用方法基本上和HashMap一样
5. hashTable是线程安全的，hashMap是线程不安全的
6. HashTable和HashMap的对比

	版本	线程安全（同步）	效率	允许null键null值
HashMap	1.2	不安全	高	可以
HashTable	1.0	安全	较低	不可以

2.3 Properties

1. Properties类继承自HashTable类并且实现了Map接口，也是使用一种键值对的形式来保存数据
2. 使用特点和HashTable类似
3. Properties还可以用于从xxx.properties文件中，加载数据到Properties类并进行读取和修改
4. 说明：xxx.properties文件通常作为配置文件
5. 使用

Properties properties = new Properties();
properties.put("abc",null);

4 Set

1. 介绍
   1. 无序（添加和取出的顺序不一致），没有索引
   2. 不允许重复元素，所以最多包含一个Null
2. 常用方法：和Collection接口一样
3. 遍历方式：同Collection的遍历方式一样，因为Set接口是Collection接口的子接口
   1. 可以使用迭代器
   2. 增强for
   3. 不能使用索引的方式来获取

4.1 HashSet

1. HashSet实现了Set接口
2. HashSet实际上是HashMap

public HashSet(){
	map = new HashMap();
}

2. 有且仅能能存放一个Null值
3. HashSet不保证元素是有序的，取决于hash后，再确定索引的结果。不保证存放元素的顺序和取出顺序一致
4. 不能有重复元素/对象
5. 使用

HashSet set = new HashSet();
set.add("小明");	//ok
set.add("小明");	//加入不了——>底层机制

6. 底层机制
   1. HashMap底层：数组+链表+红黑树

4.2 LinkedHashSet

1. LinkedHashSet是HashSet的子类
2. LinkedHashSet底层是一个LinkedHashMap，底层维护了一个数组+双向链表
3. LinkedHashSet根据元素的hashCode来决定元素存储位置，同时使用链表维护元素的次序，使得元素看起来是以插入顺序保存的
4. LinkedHashSet不允许添加重复元素

5 Collection工具类

1. Collection是一个操作Set、List和Map等集合的工具类
2. Collections中提供了一系列静态方法对集合元素进行排序、查询、修改
3. 排序

4. 查找、替换

6 总结