Java集合基础笔记

Java集合分为 Collection 和 Map 两大体系。

• Collection是单列集合
• Map是双列集合

Collection

Collection常用方法

        List<Object> list = new ArrayList<>();

        // add():添加单个元素
        list.add("right");
        list.add(10);
        list.add(false);
        System.out.println("1. list: " + list);

        // remove():删除指定元素
        list.remove(Integer.valueOf(10));
        boolean result = list.remove("left");
        System.out.println("2. remove result: " + result + ", list: " + list);

        boolean rc = list.contains("right");
        System.out.println("3. contains: " + rc);

        // size():获取元素个数
        int size = list.size();

        // isEmpty():判断是否为空
        boolean isEmpty = list.isEmpty();
        System.out.println("4. size: " + size + ", isEmpty:" + isEmpty);

        // clear():清空
        list.clear();
        System.out.println("5. clear: " + list);

        // addAll():添加多个元素
        List<Object> list2 = new ArrayList<>();
        list2.add("one");
        list2.add("two");
        list.addAll(list2);
        System.out.println("6. addAll: " + list);

        // containsAll():查找多个元素是否都存在
        boolean rca = list.containsAll(list2);
        System.out.println("7. containsAll: " + rca);

        // removeAll():删除多个元素
        list.add("three");
        list.removeAll(list2);
        System.out.println("8. removeAll: " + list);
        

输出结果：

1. list: [right, 10, false]
2. remove result: false, list: [right, false]
3. contains: true
4. size: 2, isEmpty:false
5. clear: []
6. addAll: [one, two]
7. containsAll: true
8. removeAll: [three]

Iterator迭代器

Collection实现了Iterable接口，Iterable中定义了iterator()方法来获取迭代器。

Iterator对象称为迭代器，主要用于遍历Collection集合中的元素，仅用于遍历集合，Iterator本身并不存放对象。
for循环底层就是使用的迭代器。
使用：

        //先得到list对应的迭代器
        Iterator<Book> iterator = bookList.iterator();
        //hasNext()判断是否还有数据
        while (iterator.hasNext()) {
            //next()返回下一个元素
            Book book = iterator.next();
            System.out.println(book);
        }
        
        //此时iterator指向最后的元素，如果需要第二次遍历需要重置迭代器
        iterator = bookList.iterator();
        ...
        

List

List接口常用方法：

        List<String> list = new ArrayList<>();

        list.add("jack");
        list.add("张一鸣");
        // add(int index, Object e) 指定位置插入元素
        list.add(1, "马云");
        System.out.println("1. " + list);

        List<String> list2 = new ArrayList<>();
        list2.add("jack");
        list2.add("pony");
        // addAll(int index, Collection eles) 指定位置插入集合全部元素
        list.addAll(2, list2);
        System.out.println("2. " + list);

        // get(int index) 获取指定位置元素
        System.out.println("3. " + list.get(4));

        // indexOf(Object o) 返回对象在集合中首次出现位置
        System.out.println("4. " + list.indexOf("jack"));
        // lastIndexOf(Object o) 返回对象在集合最后一次出现位置
        System.out.println("5. " + list.lastIndexOf("jack"));

        // remove(Object o) 删除指定元素
        list.remove("pony");
        System.out.println("6. " + list);

        // set(int index, Object e) 替换指定位置元素
        list.set(2, "王兴");
        System.out.println("7. " + list);

        // subList(int fromIndex, int toIndex) 返回指定位置的自集合，相当于[0,2)前开后闭
        System.out.println("8. " + list.subList(0, 2));

输出结果：

1. [jack, 马云, 张一鸣]
2. [jack, 马云, jack, pony, 张一鸣]
3. 张一鸣
4. 0
5. 2
6. [jack, 马云, jack, 张一鸣]
7. [jack, 马云, 王兴, 张一鸣]
8. [jack, 马云]

List 和 数组转换

	String[] array = {"one", "two", "three", "four"};
	List<String> list = new ArrayList<>();
    Collections.addAll(list, "tom", "sam", "lisa", "lee");

	//List转数组
    String[] transArray = list.toArray(new String[0]);
    System.out.println(Arrays.toString(transArray));

    //数组转List，方式1
    //这种方法返回的是一个静态List，不能添加删除元素
    List<String> transList = Arrays.asList(array);
    System.out.println(transList);

    //数组转List，方式2，可以添加删除元素
    List<String> transList2 = new ArrayList<>();
    Collections.addAll(transList2, array);

ArrayList扩容机制

1. ArrayList中维护了一个Object类型的数组elementData
2. 当创建ArrayList对象时，如果使用的是无参构造器，则elementData容量为0，第1次添加，则扩容elementData为10，如需要再次扩容，则扩容elementData为1.5倍。
3. 如果使用指定大小的构造器，初始容量为指定大小，扩容时每次1.5倍。

Set

特点：

1. 无序（添加和取出的顺序不一致），没有索引
2. 不允许重复元素，所以最多包含一个null

主要实现类：HashSet、TreeSet

HashSet

1. 底层实际是一个HashMap
2. 不保证元素是有序的，取决于Hash后，再确定索引的结果

Queue

队列：先进先出，不可以在队列中间添加元素。
Queue是 Collection的子接口，和List 、 Set平级。

Queue有两种实现类型，链表和循环数组（对应的实现类型为LinkedList和ArrayDeque），循环数组比链表更高效，比较常用，但是循环数组是个有界集合即容量有限，如果要收集的对象数量没有上限，就选用链表来实现。

两种实现类

	// 循环数组类型
	Queue<String> queue = new ArrayDeque<>();
	
	// 链表类型
	Queue<String> queue2 = new LinkedList<>();

压入元素：

        queue.add("tom");
        queue.offer("jack");

队列没有满时：都是从队尾压入元素并返回true。
如果队列满了：add()方法会抛出异常，offer()方法返回false。

弹出元素：

        queue.remove();
        queue.poll();

队列不为空：都是删除并返回这个队列头部的元素。
队列为空：remove()方法会抛出异常，poll()方法返回null。

查询头部元素：

        queue.element();
        queue.peek();

队列不为空：都是返回这个队列头部的元素并不删除。
队列为空：element()方法会抛出异常，peek()方法返回null。

Stack

栈，后进先出。
Stack是Verctor的子类。

继承关系图：

初始化：

        Stack<String> stack = new Stack<>();
        

从栈顶压入元素：

        stack.push("tom");

弹出并返回栈顶元素：

        stack.pop();

返回栈顶元素并不弹出：

        stack.peek();

返回栈是否为空：

        stack.empty();

返回元素在栈中的位置：

        stack.search("tom");

Map转成集合

	Map<String, Integer> map = new HashMap<>();
    
    //获取key的集合
    Set<String> stringSet = map.keySet();
    
    //获取value的集合
    Collection<Integer> values = map.values();
    
    //获取entry的集合
    Set<Map.Entry<String, Integer>> entrySet = map.entrySet();