复习笔记4-集合框架

## 1.集合体系结构(Collection:单列集合)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/fe9bf8c4-7ae0-99c2-653e-cbdf431f03a4.png)
#### ①特点
ArrayList：有序 可重复 有索引
HashSet:无序 不重复 无索引
#### ②Collection的常见方法：
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/06f51b7c-1ca3-f0ba-7c3a-1d7c4401c31a.png)
```java
        Collection<String> c = new ArrayList<>();// 多态写法
        // 1.添加元素，添加成功返回true
        c.add("java1");
        c.add("java1");
        c.add("java2");
        c.add("java2");
        c.add("java3");
        System.out.println(c);// [java1, java1, java2, java2, java3]

        // 2.清空集合元素
        // c.clear();
        // System.out.println(c);// []

        // 3.判断集合是否为空，是空返回true，反之
        System.out.println(c.isEmpty());// false

        // 4.获取集合的大小
        System.out.println(c.size());// 5

        // 5.判断集合中是否包含某个元素
        System.out.println(c.contains("java1"));// true

        // 6.删除某个元素，如果有多个重复元素默认删除前面的第一个
        System.out.println(c.remove("java1"));// true
        System.out.println(c);// [java1, java2, java2, java3]

        // 7.把集合转换成数组
        Object[] arr =  c.toArray();
        System.out.println(Arrays.toString(arr));// [java1, java2, java2, java3]


        // 把一个集合的全部数据倒入到另一个集合中去
        Collection<String> c1 = new ArrayList<>();
        c1.add("java1");
        c1.add("java2");
        Collection<String> c2 = new ArrayList<>();
        c2.add("java3");
        c2.add("java4");
        c1.addAll(c2);// 就是把c2集合的全部数据倒入到c1集合中去
        System.out.println(c1);// [java1, java2, java3, java4]
        System.out.println(c2);// [java3, java4]
```
#### ③遍历方式
⭐迭代器（Iterator）
用来遍历集合的专用方式（数组没有迭代器）
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/4e8c0330-7c19-404a-1879-e25265343809.png)
```java
        Collection<String> c = new ArrayList<>();
        c.add("赵敏");
        c.add("小昭");
        c.add("素素");
        c.add("灭绝");
        System.out.println(c);  // c =  [赵敏, 小昭, 素素, 灭绝]

        // 使用迭代器遍历集合
        // 1.从集合对象中获取迭代器对象
         Iterator<String> it =  c.iterator();
         System.out.println(it.next());// 赵敏
         System.out.println(it.next());// 小昭
         System.out.println(it.next());// 素素
         System.out.println(it.next());// 灭绝
         System.out.println(it.next());// 出现异常

         // 2.使用循环结合迭代器遍历集合
        while (it.hasNext()){
            String ele = it.next();
            System.out.println(ele);
            // 赵敏
            // 小昭
            // 素素
            // 灭绝
            // System.out.println(it.next());  × 别用 
        }
```
⭐增强for
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/850f8493-7d6a-d647-b4d7-af0f5c8d305e.png)
```java
        Collection<String> c = new ArrayList<>();
        c.add("赵敏");
        c.add("小昭");
        c.add("素素");
        c.add("灭绝");
        System.out.println(c);
        // c =  [赵敏, 小昭, 素素, 灭绝]
        //        ele

        // 使用增强for遍历集合或者数组
        for (String ele : c) {
            System.out.println(ele);
        }
            // 赵敏
            // 小昭
            // 素素
            // 灭绝

        String[] names = {"迪丽热巴","古力娜扎","七七八八"};
        for (String name:names){
            System.out.println(name);
            // 迪丽热巴
            // 古力娜扎
            // 七七八八
        }
```
⭐lambda表达式
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/f3a5cab4-27cc-9d46-3368-51c93f044b33.png)
```java
        Collection<String> c = new ArrayList<>();
        c.add("赵敏");
        c.add("小昭");
        c.add("素素");
        c.add("灭绝");
        System.out.println(c);
        //  [赵敏, 小昭, 素素, 灭绝]
        //   s

        // 集合Lambda表达式遍历集合
        c.forEach(s -> {
            System.out.println(s);
        });
       
```
## 2.List集合
#### ①特点：有序 可重复 有索引
#### ②特有方法
当然，Collection的功能List也都继承了
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/5cc53bb6-407e-55da-1bd9-057fa366e068.png)
```java
        // 1.有序 可重复 有索引
        List<String> list = new ArrayList<>();// 经典代码
        list.add("蜘蛛精");
        list.add("至尊宝");
        list.add("至尊宝");
        list.add("牛夫人");
        System.out.println(list);// [蜘蛛精, 至尊宝, 至尊宝, 牛夫人]

        // 2.在某个索引位置插入元素
        list.add(2,"紫霞仙子");
        System.out.println(list);// [蜘蛛精, 至尊宝, 紫霞仙子, 至尊宝, 牛夫人]

        // 3.根据索引删除元素，返回被删除元素
        System.out.println(list.remove(2));// 紫霞仙子
        System.out.println(list);// [蜘蛛精, 至尊宝, 至尊宝, 牛夫人]

        // 4.返回集合中指定位置的元素
        System.out.println(list.get(3));// 牛夫人

        // 5.修改索引位置处的元素，修改成功后，会返回原来的数据
        System.out.println(list.set(3, "牛魔王"));// 牛夫人
        System.out.println(list);// [蜘蛛精, 至尊宝, 至尊宝, 牛魔王]
```
#### ③遍历方式
1.for循环（因为List集合有索引）
2.迭代器
3.增强for循环
4.Lambda表达式
```java
        List<String> list = new ArrayList<>();
        list.add("糖宝宝");
        list.add("蜘蛛精");
        list.add("至尊宝");

        // 1.  for循环
        for (int i = 0; i < list.size(); i++) {
            // i = 0  1  2
            String s = list.get(i);
            System.out.println(s);
            // 糖宝宝
            // 蜘蛛精
            // 至尊宝
        }

        // 2.  迭代器
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

        //3. 增强for循环 ：foreach遍历
        for (String s : list) {
            System.out.println(s);
        }

        // 4. Jdk1.8开始之后的Lambda表达式
        list.forEach(s-> {
            System.out.println(s);
        });
```
## 3.Set集合
Set要用到的常用方法，基本上就是Collection提供的。
自己几乎没有额外新增的一些常用功能
## 4.collections
是一个用来操作集合的工具类
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/badd2e02-4258-293c-3049-4d6fb891dcae.png)
```java
        // 1.为集合批量添加数据
        List<String> names = new ArrayList<>();
        Collections.addAll(names,"张三","李四","王五","赵六");
        System.out.println(names);// [张三, 李四, 王五, 赵六]

        // 2.打乱LIST集合中的元素顺序
        Collections.shuffle(names);
        System.out.println(names);// 打乱顺序

        // 3.对LIST集合中的元素进行升序排序
        List<Integer> list = new ArrayList<>();
        list.add(3);
        list.add(5);
        list.add(2);
        Collections.sort(list);
        System.out.println(list);// [2, 3, 5]
```
## 5.集合体系结构(Map:双列集合(键值对))
#### ①特点
Map集合的所有键是不允许重复的，但值可以重复
⭐HashMap:无序 不重复 无索引
#### ②应用
需要存储一一对应的数据时，就可以考虑使用Map集合来做
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/fcf8617e-8a80-8afa-3876-0068627d446f.png)
#### ③Map的常用方法
```java
        // 1.添加元素：无序 不重复 无索引
        Map<String,Integer> map = new HashMap<>();
        map.put("手表",100);
        map.put("手表",220);
        map.put("手机",2);
        map.put("JAVA",2);
        map.put(null,null);
        System.out.println(map);// {JAVA=2, null=null, 手表=220, 手机=2}

        // 2.获取集合的大小
        System.out.println(map.size());// 4

        // 3.清空集合
//        map.clear();
//        System.out.println(map);

        // 4.判断集合是否为空，为空返回true，反之
        System.out.println(map.isEmpty());

        // 5.根据键获取对应值
        int v1 = map.get("手表");
        System.out.println(v1);// 220

        // 6.根据键删除整个元素（删除键会返回键的值）
        System.out.println(map.remove("手表"));// 220
        System.out.println(map);// {JAVA=2, null=null, 手机=2}

        // 7.判断是否包含某个键，包含返回true，反之
        System.out.println(map.containsKey("手表"));// false
        System.out.println(map.containsKey("手机"));// true

        // 8.判断是否包含某个值
        System.out.println(map.containsValue(2));// true

        // 9.获取Map集合的全部键
        Set<String> keys = map.keySet();
        System.out.println(keys);// [JAVA, null, 手机]

        // 10.获取Map集合的全部值
        Collection<Integer> values = map.values();
        System.out.println(values);// [2, null, 2]

        // 11.把其他Map集合的数据倒入到自己集合中来（拓展）
        Map<String,Integer> map1 = new HashMap<>();
        map1.put("java1",10);
        map1.put("java2",20);
        Map<String,Integer> map2 = new HashMap<>();
        map2.put("java3",10);
        map2.put("java2",222);
        map1.putAll(map2);// putAll:把map2集合中的元素全部倒入一份到map1集合中去
        System.out.println(map1);// {java3=10, java2=222, java1=10}
        System.out.println(map2);// {java3=10, java2=222}
```
#### ④遍历方式
1.键找值
先获取map集合全部的键，再通过遍历键来找值
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/56cdbf22-9e47-2f31-7ab9-bf2d8f77bf4c.png)
```java
        // 准备一个Map集合
        Map<String,Double> map = new HashMap<>();
        map.put("蜘蛛精",162.5);
        map.put("蜘蛛精",169.8);
        map.put("紫霞",165.8);
        map.put("至尊宝",169.5);
        map.put("牛魔王",183.6);
        System.out.println(map);
        // {蜘蛛精=169.8, 牛魔王=183.6, 至尊宝=169.5, 紫霞=165.8}

        // 1.获取集合的全部键
        Set<String> keys = map.keySet();
        System.out.println(keys);// [蜘蛛精, 牛魔王, 至尊宝, 紫霞]
        // 2.遍历全部的键，根据键获取其对应的值
        for (String key : keys) {
            // 根据键获取其对应的值
           double value =  map.get(key);
            System.out.println(key + "------>" + value);
            // 蜘蛛精------>169.8
            //牛魔王------>183.6
            //至尊宝------>169.5
            //紫霞------>165.8
```
2.键值对
把“键值对”看成是一个整体进行遍历
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/cd8bb8eb-441a-276b-e4b8-f92f7a2855b0.png)
```java
        Map<String,Double> map = new HashMap<>();
        map.put("蜘蛛精",169.8);
        map.put("紫霞",165.8);
        map.put("至尊宝",169.5);
        map.put("牛魔王",183.6);
        System.out.println(map);
        // {蜘蛛精=169.8, 牛魔王=183.6, 至尊宝=169.5, 紫霞=165.8}
        // entries = [{蜘蛛精=169.8},{牛魔王=183.6},{至尊宝=169.5},{紫霞=165.8}]

        // 1.调用Map集合提供的entrySet方法，把Map集合转换成键值对类型的Set集合
        Set<Map.Entry<String, Double>> entries = map.entrySet();
        for (Map.Entry<String, Double> entry : entries) {
            String key = entry.getKey();
            Double value = entry.getValue();
            System.out.println(key + "--->" + value);
            // 蜘蛛精--->169.8
            //牛魔王--->183.6
            //至尊宝--->169.5
            //紫霞--->165.8
```
3.lambda
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/6dc16e8f-36cd-7ec9-534d-d14d46c3b6e4.png)
```java
        Map<String,Double> map = new HashMap<>();
        map.put("蜘蛛精",169.8);
        map.put("紫霞",165.8);
        map.put("至尊宝",169.5);
        map.put("牛魔王",183.6);
        System.out.println(map);
        // {蜘蛛精=169.8, 牛魔王=183.6, 至尊宝=169.5, 紫霞=165.8}
        map.forEach((k,v) -> {
            System.out.println(k + "--->" + v);
            // 蜘蛛精--->169.8
            //牛魔王--->183.6
            //至尊宝--->169.5
            //紫霞--->165.8
        });
```
## 6.Stream流(API)
用于操作集合或者数组的数据
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3899383/8863bf93-d577-f792-4239-053e2af1117a.png)
```java
        List<String> names = new ArrayList<>();
        Collections.addAll(names,"张三丰","张无忌","周芷若","赵敏","张强");
        System.out.println(names);// [张三丰, 张无忌, 周芷若, 赵敏, 张强]

        // 找出姓张且是3个字的名字，存入到一个新集合中去
        List<String> list = new ArrayList<>();
        for (String name : names) {
            if (name.startsWith("张") && name.length() == 3){
                list.add(name);
            }
        }
        System.out.println(list);// [张三丰, 张无忌]

        // 开始使用Stream流来解决这个需求
        List<String> list2 = names.stream().filter(s -> s.startsWith("张"))
                .filter(a -> a.length() == 3).collect(Collectors.toList());
        System.out.println(list2);// [张三丰, 张无忌]
```