一、基本要点

1、集合与数组类似，但是集合中元素的个数是可以动态变化的
注意：集合只能存放自定义数据类型，不能存放基本数据类型

2、集合分为三大类

List：存放数据可重复，且有顺序
Set：存放数据不可重复且无序（TreeSet在特定情况下是有序的）
Map：双列型，存放的数据key不可以重复，value可以重复

一、List接口

它有2个实现类 ArrayList和LinkedList

list.clear()—-删除所有元素的方法

1、ArrayList

ArrayList是基于数组实现的，底层是一个动态的Object数组，其容量能自动增长
因为它是数组结构，具有下标，所以增删很慢，查询很快

1）单个查询：list.get(下标);

2）循环遍历：

for循环:for(int i = 0; i<list.size(); i++)
foreach循环:for(Object temp: list)
lambda表达式：list.foreach(r -> {})
注意：lambda表达式不能直接遍历数组，需要转成集合才能使用lambda表达式遍历

3）泛型：用于给集合指定具体存放的数据类型，只能存放自定义数据类型，不能存放基本数据类型
例如List aList = new ArrayList();

4）添加数据：list.add()

5）删除操作
list.remove() 可以通过下标删，也可以通过内容删（这里如果内容也是Integer类型，那么可能跟下标混淆，所以这个时候泛型的作用就显示出来了,通过这个方法删除的时候，集合就要使用泛型了）
list.clear()清除所有元素

6）更新操作：list.set(index, object) 更新指定下标的元素

package com.decade.list;

import java.util.ArrayList;
import java.util.List;

public class ArrayListDemo01 {

    public static void main(String[] args) {
        //创建一个ArrayList集合，默认长度是10
        ArrayList arrayList = new ArrayList();

        //增
        arrayList.add("one");
        arrayList.add(true);
        arrayList.add(3.14F);

        //foreach循环
        for (Object temp: arrayList) {
            System.out.println(temp);
        }

        System.out.println("===============");

        //删
        arrayList.remove(1);

        //foreach循环
        for (Object temp: arrayList) {
            System.out.println(temp);
        }

        System.out.println("===============");

        //改
        arrayList.set(0, "test");

        //foreach循环
        for (Object temp: arrayList) {
            System.out.println(temp);
        }

        System.out.println("===============");

        //泛型
        List<String> bList = new ArrayList<String>();
        bList.add("a");

        bList.forEach(System.out::println);
    }
}

2、LinkedList

1）LinkedList底层是链表，增删特别快，但是查询比较慢
LinkedList和ArrayList的方法是相同的

2）集合转成数组
Object[] array = list.toArray();

package com.decade.list;

import java.util.LinkedList;
import java.util.List;

public class LinkedListDemo02 {

    public static void main(String[] args) {
        //声明一个LinkedList
        List<String> aList = new LinkedList<String>();

        aList.add("aaa");
        aList.add("bbb");

        //将集合转成数组
        Object[] array = aList.toArray();
    }
}

二、Set接口

它有2个实现类 HashSet和TreeSet
set.clear()—-删除所有元素的方法

1、HashSet

1）HashSet集合存放的数据是无序（不保证有序，不是保证无序）且不可重复的，如果存放重复数据，那么集合会自动帮你去重

默认初始容量是16，加载因子是0.75，意思是16*0.75=12
当集合中元素个数超过12个时，集合扩容一倍到32

HashSet底层是哈希表，没有下标，故删除时不能通过下标去删除
也正因如此，set集合中没有修改方法，只能先删除再添加
也没有get(index)这种获取单个元素的方法

package com.decade.list;

import java.util.HashSet;
import java.util.Set;

public class HashSetDemo03 {

    public static void main(String[] args) {
        Set<String> aSet = new HashSet<>();
        //增
        aSet.add("dasdas");
        aSet.add("zasda");
        aSet.add("aasda");
        aSet.add("casdasd");

        aSet.forEach(System.out::println);
        System.out.println("==========");

        //删
        aSet.remove("aasda");

        aSet.forEach(System.out::println);
        System.out.println("==========");

        //改，先删再增
        aSet.remove("casdasd");
        aSet.add("bcasdasd");

        aSet.forEach(System.out::println);
        System.out.println("==========");

        boolean flag = aSet.contains("bcasdasd");

        System.out.println("flag = " + flag);
    }
}

2、TreeSet

TreeSet底层是二叉树
存放的数据不可重复，但是有序（对于实现了Comparable、Comparator接口的类型来说）

方法与HashSet中的相同

package com.decade.list;

import java.util.Set;
import java.util.TreeSet;

public class TreeSetDemo04 {

    public static void main(String[] args) {
        Set<String> bSet = new TreeSet<>();

        bSet.add("zasda");
        bSet.add("casd");
        bSet.add("aadsas");

        bSet.forEach(System.out::println);
    }
}

三、Map接口

双列型，存放的数据数据是无序的，key不可以重复，value可以重复

1、HashMap

1）底层是哈希表，key不可以重复，value可以重复，无序

2）常用方法

插入操作和修改操作
map.put(key,value);（put方法的返回值是此key之前的旧值，如果没有，那么返回null）
查询 map.get(key);
遍历操作 map.foreach((k,v) -> {}) 注意，使用lambda表达式进行遍历时，也要使用k，v的双列结构
HashMap可以直接打印，因为它的源码中覆盖了toString()
删除所有方法，hashMap.clear()
删除方法，hashMap.remove(key)，根据key去删除

package com.decade.list;

import java.util.HashMap;
import java.util.Map;

public class HashMapDemo05 {

    public static void main(String[] args) {

        Map<String, String> hashMap = new HashMap<>();

        //插入
        hashMap.put("asa", "ok");
        hashMap.put("add", "test");
        hashMap.put("bsd", "java");
        hashMap.put("dc", "check");

        //HashMap可以直接打印，因为它的源码中覆盖了toString()
        System.out.println(hashMap);

        //遍历操作  map.foreach((k,v) -> {}) 注意，使用lambda表达式进行遍历时，也要使用k，v的双列结构
        hashMap.forEach((k,v) -> {
            System.out.println(k + "=" + v);
        } );

        //修改
        hashMap.put("dc", "newValue");
        System.out.println(hashMap);

        //删除
        hashMap.remove("dc");
        System.out.println(hashMap);

        //查询
        String value = hashMap.get("bsd");
        System.out.println(value);
    }
}