前言:

①Collecttion集合的体系结构

②Collecttion集合的遍历方式

方式一:迭代器

方式二:foreach/增强for循环

方式三:Lambda表达式

③常见数据结构

前言:

Collection：是所有集合的顶级接口,里面规定了集合操作元素的相关功能方法集合与数组一样,用于存储一组元素,但是集合又多个不同的实现类来实现不同的数据结构

1.概述:

集合和数组都是容器。

集合是java中存储对象数据的一种容器。

2.数组和集合的元素存储的个数问题？

数组定义后，类型确定、长度固定。

集合的大小不固定，类型也可以选择不固定。

3.数组和集合的元素存储元素的类型问题？

数组可以存储基本数据类型和引用数据类型的数据

集合只能存储引用数据类型的数据

4.数组和集合适合的场景？

数组适合做数据个数和类型确定的场景；

数据的个数不确定，且要做增删元素的时候。

①Collecttion集合的体系结构

1.Collecttion集合的体系结构:

①Collecttion单列集合，每个元素(数据)只包含一个值。

②Collection 是单列集合的祖宗接口，它的功能是全部单列集合都可以继承使用的。

③Map双列集合，每个元素包含两个值(键值对)。

2.Collecttion集合特点：

①List系列集合:添加的元素是有序、可重复、有索引。

ArrayList、LinkedList:有序、可重复、有索引。

②Set系列集合:添加的元素是无序、不重复、无索引。

HashSet:无序、不重复、无索引。

LinkedHashSet:有序、不重复、无索引。

TreeSet:按照大小默认升序排序、不重复、无索引。

3.代码演示:

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

/**
 * Collection  单列集合(祖宗接口)  每个数据只包含一个值
 * 1、list:  (Arraylist  Linkedlist)有序、可重复、有索引
 * 2、Set:  (HashSet   TreeSet有序   LinkedHashSet 按照大小默认升序排序)无序、不重复、无索引
 * Map  双列集合  每个数据包含两个值
 */
/**单列集合API
 * add()  添加元素
 * clear()  清空元素
 * isEmpty()  判断集合是否为空，是则返回true
 * size()  获取集合的大小
 * contains("")  判断集合是否包含某个元素
 * remove("")  删除某个元素值：如果有多个重复元素，默认删除前面的第一个
 * object[] arrs = c.toArray()   把集合转换成数组
 * 扩展 :
 * c1.addAll(c2)  把c2的集合元素传给c1（c2不会删去元素）
 */
public class Collection_Demo1 {
    public static void main(String[] args) {
        //有序、可重复、有索引
        Collection list = new ArrayList<>();//多态
        list.add("JAVA");
        list.add("JAVA");
        list.add(23);
        list.add(23);
        list.add(false);
        list.add(false);
        System.out.println(list);
        System.out.println("=========================");
        //无序、不重复、无索引
        Collection list1 = new HashSet();//多态
        list1.add("JAVA");
        list1.add("JAVA");
        list1.add(23);
        list1.add(23);
        list1.add(false);
        list1.add(false);
        System.out.println(list1);
 System.out.println("=========================");
        Collection <String>list2 = new ArrayList<>();
        list2.add("JAVA");
        list.addAll(list1);
    }
}

4.集合对于泛型的支持

集合都是支持泛型的，可以在编译阶段约束集合只能操作某种数据类型。

5.注意:

集合和泛型都只能支持引用数据类型，不支持基本数据类型，所以集合中存储的元素都认为是对象。

6.Collecttion集合常用API

7.代码演示:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
/**单列集合API
 * add()  添加元素
 * clear()  清空元素
 * isEmpty()  判断集合是否为空，是则返回true
 * size()  获取集合的大小
 * contains("")  判断集合是否包含某个元素
 * remove("")  删除某个元素值：如果有多个重复元素，默认删除前面的第一个
 * object[] arrs = c.toArray()   把集合转换成数组
 * 扩展 :
 * c1.addAll(c2)  把c2的集合元素传给c1（c2不会删去元素）
 */
public class Collection_Demo3 {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        //1.添加元素，成功返回true
        c.add("JAVA");
        c.add("Python");
        c.add("HTML");
        System.out.println(c);
        //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"));
        System.out.println(c.contains("Python"));
        System.out.println(c.contains("Html"));
        //6.删除某个元素值：如果有多个重复元素，默认删除前面的第一个
        System.out.println(c.remove("JAVA"));
        System.out.println(c);
        //7.把集合转换成数组
        Object[] arrs = c.toArray();
        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("AK47");
        c2.add("58同城");
        //把c2的集合元素传给c1（c2不会删去元素）
        c1.addAll(c2);
        System.out.println(c1);
        System.out.println(c2);
    }
}

②Collecttion集合的遍历方式

方式一:迭代器

1.迭代器的遍历概述:

①遍历就是一个一个的把容器中的元素访问一遍。

②迭代器在java中的代表是Iterator，迭代器是集合的专用遍历方式。

2.Collecttion集合获取迭代器

3.Iterator中的常用方法

4.代码演示:

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

/**迭代器（Iterator）  是集合的专用迭代器
 * Iterator<E> iterator()  得到迭代器对象，默认值向当前集合的索引0
 * 迭代器取元素越界会报异常
 */
public class Iterator_Demo4 {
    public static void main(String[] args) {
        Collection<String> lists = new ArrayList<>();//多态
        lists.add("JAVA");
        lists.add("python");
        lists.add("html");
        System.out.println(lists);

        //1、得到当前集合的迭代器
        Iterator<String> it = lists.iterator();
        //一次只能取出一个元素  取元素不要越界
        String ele = it.next();
        System.out.println(ele);
        System.out.println(it.next());
        System.out.println("==================================");
        //2、定义while循环  取出全部元素
        while (it.hasNext()){
            String eles = it.next();
            System.out.println(eles);
        }
    }
}

方式二:foreach/增强for循环

1.概述:

①增强for循环既可以遍历数组也可以遍历集合。

②它是JDK5之后出现的，其内部原理是一个Iterator迭代器，遍历集合相当于是迭代器的简化写法。

③实现Iterable接口的类才可以使用迭代器和增强for，Collection接口已经实现了Iterable接口。

2.增强for循环的遍历格式:

3.代码演示:

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;

/**增强for循环  既可以遍历数组也可以遍历集合
 * 内部原理是一个Iterator迭代器，遍历集合相当于是迭代器的简化写法
 * 实现Iterable接口的类才可以使用迭代器和增强for循环  Collection实现了Iterable接口
 *  for(元素数据类型  变量名  :数组或Collection集合){ 在此处使用变量 }
 */

public class Demo {
    public static void main(String[] args) {
        //举例:增强for循环  遍历
        Collection<String> list = new ArrayList<>();
        list.add("JAVA");
        list.add("python");
        list.add("html");
        for (String ele: list){
            System.out.println(ele);
        }
        System.out.println("============================");
        double[] score = {100,99,23,14,56,14};
        for (double sc : score) {
            System.out.println(sc);
//            if (sc == 100) {
//                sc = 102;//修改无意义，不会影响数组的元素值
//            }
        }
        System.out.println("======================");
        //Lambda 遍历方式
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        System.out.println("=====================");
        //简便遍历方法
        list.forEach(System.out::println);
    }
}

方式三:Lambda表达式

1.Lambda表达式遍历集合

JDK8开始的新技术Lambda表达式，提供了一种更简单、更直接的遍历集合的方式。

2.Collection结合Lambda遍历的API

例如:

3.代码演示:

/**Lambda  遍历方式
 *
 */
public class Demo {
    public static void main(String[] args) {
        //举例:增强for循环  遍历
        Collection<String> list = new ArrayList<>();
        list.add("JAVA");
        list.add("python");
        list.add("html");
        for (String ele: list){
            System.out.println(ele);
        }
        System.out.println("============================");
        double[] score = {100,99,23,14,56,14};
        for (double sc : score) {
            System.out.println(sc);
//            if (sc == 100) {
//                sc = 102;//修改无意义，不会影响数组的元素值
//            }
        }
        System.out.println("======================");
        //Lambda 遍历方式
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        System.out.println("=====================");
        //简便遍历方法
        list.forEach(System.out::println);
    }
}

4.案例:影片信息在程序中的表示

需求:

某电影院需要在后台存储上述三部电影，然后依次展示出来。

分析:

①定义一个电影类，定义一个集合存储电影对象；

②创建3个电影对象，封装相关数据，把3个对象存入到集合中去。

③遍历集合中的3个对象，输出相关信息。

电影类:

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 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;
    }

    public String getName() {
        return name;
    }

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

实现类:

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        //1定义电影类
        //2.创建三个电影类
        Movie m1 = new Movie("《肖申克的救赎》",9.7,"罗宾斯");
        Movie m2 = new Movie("《霸王别姬》",9.7,"张国荣");
        Movie m3 = new Movie("《阿甘正传》",9.5,"张丰毅");
        //3.创建一个电影类型ArrayList集合，存储三部电影
        ArrayList<Movie> movies = new ArrayList<>();
        movies.add(m1);
        movies.add(m2);
        movies.add(m3);
        //4.遍历电影类型的集合中的每个电影对象，访问它的信息即可
        for (int i = 0; i < movies.size(); i++) {
            Movie m = movies.get(i);
            System.out.println("电影名称："+m.getName());
            System.out.println("电影得分："+m.getScore());
            System.out.println("电影导演："+m.getActor());
            System.out.println("-----------------------------");
        }
    }
}

5.集合中存储的元素是什么信息?

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