一. 集合

集合与数组类似，都是一种容器。
集合是Java中存储对象数据的一种容器。
集合也被称为对象容器。

数组的特点

集合的特点

集合的大小不固定，启动后可以动态变化，类型也可以选择不固定。集合更像气球，可大可小。
集合非常适合做元素个数不能确定，且要做元素的增删操作的场景。
同时，集合提供的种类特别丰富，功能也是非常强大的，开发中集合用的更多。
注意：集合中只能存储引用类型数据，如果要存储基本类型数据可以选用包装类。

包装类：把基本数据类型变成了一个引用数据类型，不是基本数据而是对象数据。
数据也可以称为元素。

二. 集合的体系特点

集合类体系结构

Collection集合体系

Collection接口是单列集合的祖宗接口。
Collection集合不支持索引，不能用fori来遍历。
List接口和Set接口都继承了Collection接口。
ArrayList和LinkedList实现了List接口，实现类就是一种所谓的子类。
ArrayList和LinkedList它们底层存储数据的结构是不一样的，在以后做增删操作的时候，它们的性能是有差别的。
Collection集合并没有规定什么特点，它只是代表了一个普通集合，真正分特点的是由List和Set分特点的。
添加的元素有序：先加了的元素在前面，后加了的元素在后面。
可重复：允许有同样的值的元素。
有索引：就是说第一个元素的索引是0，第二个元素的索引是1。
添加的元素无序：先加的元素可能是跑到后面去了，后加的元素可能是跑到前面去了。
不重复：就是不允许有两个同样的值在里面，它会去重复的。
集合打内容，因为集合本身已经重写了toString方法了，所以它里面打的是内容。

泛型

泛型相当于是一个标签

package com.gch.d1_collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;

/**
   目标:明确Collection集合体系的特点
 */
public class CollectionDemo1 {
    public static void main(String[] args) {
        // List系列集合:添加的元素是有序、可重复、有索引
        // 把子类对象给到父类接口,父类引用指向子类对象,这是多态的写法
        Collection list = new ArrayList();
        list.add("Java");
        list.add("Java");
        list.add("Mybatis");
        list.add(23);
        list.add(23);
        list.add(false);
        list.add(false);
        System.out.println(list); // [Java, Java, Mybatis, 23, 23, false, false]

        // Set系列集合:添加的元素是无序、不重复、无索引
        Collection list1 = new HashSet();
        list1.add("Java");
        list1.add("Java");
        list1.add("Mybatis");
        list1.add(23);
        list1.add(23);
        list1.add(false);
        list1.add(false);
        System.out.println(list1); // [Java, false, 23, Mybatis]

        System.out.println("------------------泛型-------------------");
//        Collection<String> list2 = new ArrayList<String>();
        // 泛型相当于是一个标签
        Collection<String> list2 = new ArrayList<>(); // 从JKD7开始之后后面的泛型类型申明可以省略不写
        list2.add("Java");
//        list2.add(23); // 直接报错,添加的类型为String
        list2.add("Mybatis");

        // 集合也被称为对象容器
        // 集合和泛型不支持基本数据类型,只能支持引用数据类型
        Collection<Integer> list3 = new ArrayList<>();
        list3.add(23); // 自动装箱
        list3.add(233);
        list.add(2333);

        Collection<Double> list4 = new ArrayList<>();
        list4.add(23.4);
        list4.add(23.0);
        list4.add(233.3);
    }
}

三. Collection集合常用API

package com.gch.d2_collection_api;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

/**
    目标：Collection集合的常用API.
    Collection是集合的祖宗类，它的功能是全部集合都可以继承使用的，所以要学习它。
    Collection API如下:
         - public boolean add(E e)：  把给定的对象添加到当前集合中 。
         - public void clear() :清空集合中所有的元素。
         - public boolean remove(E e): 把给定的对象在当前集合中删除。
         - public boolean contains(Object obj): 判断当前集合中是否包含给定的对象。
         - public boolean isEmpty(): 判断当前集合是否为空。
         - public int size(): 返回集合中元素的个数。
         - public Object[] toArray(): 把集合中的元素，存储到数组中。
    小结：
        记住以上API。
 */
public class CollectionDemo {
    public static void main(String[] args) {
        // HashSet:添加的元素是无序，不重复，无索引。

        Collection<String> c = new ArrayList<>();
        // List集合允许元素重复,基本上添加元素不会失败
        // 1.添加元素, 添加成功返回true。
        c.add("Java");
        c.add("HTML");
        System.out.println(c.add("HTML"));
        c.add("MySQL");
        c.add("Java");
        System.out.println(c.add("黑马"));
        System.out.println(c); // [Java, HTML, HTML, MySQL, Java, 黑马]

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

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

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

        // 5.判断集合中是否包含某个元素。 精准匹配的
        System.out.println(c.contains("Java"));  // true
        System.out.println(c.contains("java")); // false
        System.out.println(c.contains("黑马")); // true

        // 6.删除某个元素:如果有多个重复元素默认删除前面的第一个！
        // 只能通过元素值来删,不能通过索引删,因为这个集合是Collection类型的一个集合。
        System.out.println(c.remove("java")); // false
        System.out.println(c);
        System.out.println(c.remove("Java")); // true
        System.out.println(c);

        // 7.把集合转换成数组  [HTML, HTML, MySQL, Java, 黑马]
        Object[] arrs = c.toArray(); // 数组:[HTML, HTML, MySQL, Java, 黑马]
        System.out.println("数组:" + Arrays.toString(arrs));

        System.out.println("----------------------拓展----------------------");
        Collection<String> c1 = new ArrayList<>();
        c1.add("java1");
        c1.add("java2");
        Collection<String> c2 = new ArrayList<>();
        c2.add("赵敏");
        c2.add("殷素素");
        // addAll把c2集合的元素全部倒入到c1中去。c2里面的数据还是在的
        c1.addAll(c2);
        System.out.println(c1); // [java1, java2, 赵敏, 殷素素]
        System.out.println(c2); // [赵敏, 殷素素]
    }
}

四. Collection集合的遍历方式

方式一：迭代器
方式二：foreach/增强for循环
方式三：lambda表达式

方式一：迭代器迭代器是不能遍历数组的

package com.gch.d3_collection_traversal;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
    a.迭代器遍历集合。
        --流程：
            1.先获取当前集合的迭代器
                Iterator<String> it = lists.iterator();
            2.定义一个while循环，问一次取一次。
              通过it.hasNext()询问是否有下一个元素，有就通过
              it.next()取出下一个元素。
    小结：
        记住代码。
 */
public class CollectionDemo01 {
    public static void main(String[] args) {
        ArrayList<String> lists = new ArrayList<>();
        lists.add("赵敏");
        lists.add("小昭");
        lists.add("素素");
        lists.add("灭绝");
        System.out.println(lists); // [赵敏, 小昭, 素素, 灭绝]
        // [赵敏, 小昭, 素素, 灭绝]
        //   it

        System.out.println("--------------1.迭代器遍历--------------");
        // public interface Iterator<E>  Iterator是一个泛型接口
        // 1、得到当前集合的迭代器对象。 这个迭代器就是遍历器的意思
        Iterator<String> it = lists.iterator();

//        // next是先取元素再移位的
//        String ele = it.next();
//        System.out.println(ele); // 赵敏
//        System.out.println(it.next()); // 小昭
//        System.out.println(it.next()); // 素素
//        System.out.println(it.next()); // 灭绝
        // 访问越界了,运行报错
//        System.out.println(it.next()); // NoSuchElementException 出现没有/无此元素异常的错误

        // boolean hasNext():询问当前位置是否有元素存在,存在返回true,不存在返回false
        // E next():获取当前位置的元素,并同时将迭代器对象移向下一个位置,注意防止取出越界。

        // 2、定义while循环(问一次取一次)
        while (it.hasNext()){ // while循环一旦条件是false,循环结束
            String ele = it.next();
            System.out.println(ele);
        }
        // 迭代器的默认位置是在集合元素的第一个位置,也就是索引为0的位置
    }
}

方式二：foreach/增强for循环

增强for循环

增强for循环：既可以遍历集合也可以遍历数组。
它是JDK5之后出现的，其内部原理是一个iterator迭代器，遍历集合相当于是迭代器的简化写法。
实现iterable接口的类才可以使用迭代器和增强for，Collection接口已经实现了iterable接口。
格式：

package com.gch.d3_collection_traversal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
/**
     目标：Collection集合的遍历方式。

     什么是遍历? 为什么开发中要遍历？
     遍历就是一个一个的把容器中的元素访问一遍。
     开发中经常要统计元素的总和，找最值，找出某个数据然后干掉等等业务都需要遍历。

     Collection集合的遍历方式是全部集合都可以直接使用的，所以我们学习它。
     Collection集合的遍历方式有三种:
         （1）迭代器。
         （2）foreach(增强for循环)。
         （3）JDK 1.8开始之后的新技术Lambda表达式。

     b.foreach(增强for循环)遍历集合。
         foreach是一种遍历形式，可以遍历集合或者数组。
         foreach遍历集合实际上是迭代器遍历集合的简化写法。
         foreach遍历的关键是记住格式：
            for(被遍历集合或者数组中元素的类型 变量名称 : 被遍历集合或者数组){

            }
 */
public class CollectionDemo02 {
    public static void main(String[] args) {
        System.out.println("-------------------2.foreach遍历/增强for循环------------------------");
        Collection<String> lists = new ArrayList<>();
        lists.add("赵敏");
        lists.add("小昭");
        lists.add("殷素素");
        lists.add("周芷若");
        System.out.println(lists);
        // [赵敏, 小昭, 殷素素, 周芷若]
        //  ele
        System.out.println("------------------foreach遍历/增强for循环遍历集合----------------------");
        // foreach只是个技术名称,真正用到的还是for关键字
        for (String ele : lists) {
            System.out.println(ele);
        }

        System.out.println("--------------------foreach遍历数组/增强for循环遍历数组---------------------------");
        double[] scores = {100, 99.5 , 59.5};
        for (double score : scores) {
            System.out.println(score);
        }

        for (double score : scores) {
            System.out.println(score);
            if(score == 59.5){
                score = 100.0; // foreach遍历修改变量无意义，不会影响数组的元素值。
            }
        }
        System.out.println(Arrays.toString(scores)); // [100.0, 99.5, 59.5]
    }
}

方式三：Lambda表达式

package com.gch.d3_collection_traversal;
import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;

/**
     目标：Collection集合的遍历方式。
     Collection集合的遍历方式有三种:
         （1）迭代器。
         （2）foreach(增强for循环)。
         （3）JDK 1.8开始之后的新技术Lambda表达式。
     c.JDK 1.8开始之后的新技术Lambda表达式。
 */
public class CollectionDemo03 {
    public static void main(String[] args) {
        Collection<String> lists = new ArrayList<>();
        lists.add("赵敏");
        lists.add("小昭");
        lists.add("殷素素");
        lists.add("周芷若");
        System.out.println(lists); // [赵敏, 小昭, 殷素素, 周芷若]
        System.out.println("--------------3.Lambda表达式遍历-------------");
        // [赵敏, 小昭, 殷素素, 周芷若]
        //  s
        lists.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

//        lists.forEach(s -> {
//                System.out.println(s);
//        });

        // lists.forEach(s ->  System.out.println(s) );

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

五. Collection集合存储自定义类型的对象

结论：集合中存储的是元素对象的地址。

package com.gch.d4_collection_object;

public class Movie {
    private String name;
    private double score;
    private String actor;

    public Movie() {
    }

    public Movie(String name, double score, String actor) {
        this.name = name;
        this.score = score;
        this.actor = actor;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }

    @Override
    public String toString() {
        return "Movie{" +
                "name='" + name + '\'' +
                ", score=" + score +
                ", actor='" + actor + '\'' +
                '}';
    }
}

package com.gch.d4_collection_object;

import java.util.ArrayList;
import java.util.Collection;

public class TestDemo {
    public static void main(String[] args) {
        // 1、定义一个电影类
        // 2、定义一个集合对象存储3部电影对象
        Collection<Movie> movies = new ArrayList<>();
        movies.add(new Movie("《你好，李焕英》", 9.5, "张小斐,贾玲,沈腾,陈赫"));
        movies.add(new Movie("《唐人街探案》", 8.5, "王宝强,刘昊然,美女"));
        movies.add(new Movie("《刺杀小说家》",8.6, "雷佳音,杨幂"));

        System.out.println(movies);

        // 3、遍历集合容器中的每个电影对象
        for (Movie movie : movies) {
            System.out.println("片名:" + movie.getName());
            System.out.println("评分:" + movie.getScore());
            System.out.println("主演:" + movie.getActor());
        }
    }
}