day10-集合

day10 集合

1.集合概述

1.1为什么要用集合？

当我们在实现购物车功能时，可能需要随时添加新商品对象进来（个数不确定） ，也随时可能删除商品对象，这个时候之前学习的数组不满足我们的需求

1.2 什么是集合？

集合与数组类似，也是一种容器，用于装数据。

数组定义完成并启动后，类型确定、长度固定。

问题：在个数不能确定，且要进行增删数据操作的时候，数组是不太合适的。

1.3 集合的特点

集合的大小不固定，启动后可以动态变化，类型也可以选择不固定。集合更像气球。

集合非常适合做元素个数不确定，且要进行增删操作的业务场景。
集合还停工了许多丰富好用的功能，而数组的功能比较单一

1.4 总结

1、数组和集合的元素存储的个数问题。

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

集合类型可以不固定，大小是可变的。

2、数组和集合存储元素的类型问题。

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

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

3、数组和集合适合的场景

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

集合适合做数据个数不确定，且要做增删元素的场景。

2.集合类ArrayList

2.1集合类ArrayList介绍

ArrayList简单介绍

Arraylist代表的是集合类，集合是一种容器，与数组类似，不同的是集合的大小是不固定的。

通过创建ArrayList的对象表示得到一个集合容器，同时ArayList提供了此数组更好用，更丰富的API(功能)给程序员使用

2.2 ArrayList的创建和使用

2.3 ArrayList总结

ArrayList类如何创建集合对象,如何添加元素？

ArrayList list = new ArrayList();
public boolean add(E e)
publiv void add(int index,E element)

2.4 泛型概述

**需求：**在这个地方我们可以看到 我们可以往集合中存入任意类型的元素,那我们如何限定存入的元素呢？

ArrayList:其实就是一个泛型类，可以在编译阶段约束集合对象只能操作某种数据类型。

举例：

ArrayList:此集合只能操作字符串类型的元素。

ArrayList:此集合只能操作整数类型的元素。

ArrayList<自定义类>:此集合只能操作自定的类中的元素。

注意：集合中只能存储引用类型，不支持基本数据类型。

2.5 泛型总结

1、怎么去统—ArrayList集合操作的元素类型？
•使用泛型：<数据类型>
• ArrayList list1 = new ArrayList);

2.6 ArrayList集合常用方法

2.7 案例练习

1.遍历并删除元素值。

代码演示：

public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(98);
        arrayList.add(77);
        arrayList.add(66);
        arrayList.add(89);
        arrayList.add(79);
        arrayList.add(50);
        arrayList.add(100);

//        for (int i = 0; i < arrayList.size(); i++) {
//            if (arrayList.get(i) < 80) {
//                arrayList.remove(arrayList.get(i));
//            }
//        }
        //出现问题 ！：从前往后删除的时候 每删除掉一个索引处的值,集合长度可变 集合往前移动 会出现问题。
        for (int i = arrayList.size() - 1; i >= 0; i--) {
            if (arrayList.get(i) < 80) {
                arrayList.remove(arrayList.get(i));
            }
        }
        System.out.println(arrayList);
    }

2.影片信息在程序中的表示

代码演示：

电影类Movie

public class Movie {
    private String movieName;//电影名称
    private String actor;//主演
    private String director;//导演
    private Double score;

    public Movie() {
    }

    public Movie(String movieName, String actor, String director, Double score) {
        this.movieName = movieName;
        this.actor = actor;
        this.director = director;
        this.score = score;
    }

    public String getMovieName() {
        return movieName;
    }

    public void setMovieName(String movieName) {
        this.movieName = movieName;
    }

    public String getActor() {
        return actor;
    }

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

    public String getDirector() {
        return director;
    }

    public void setDirector(String director) {
        this.director = director;
    }

    public Double getScore() {
        return score;
    }

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

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

测试类：

 public static void main(String[] args) {
//分析
//①	：三部电影是3个对象，定义一个电影类，定义一个集合存储电影对象。
        ArrayList<Movie> arrayList = new ArrayList<>();
//②	：创建3个电影对象，封装相关数据，把3个对象存入到集合中去。
        Movie m1 = new Movie("肖申克的救赎","蒂姆罗宾斯","杨导",9.9);
        Movie m2 = new Movie("流浪地球","吴京","未知",9.8);
        Movie m3 = new Movie("复仇者联盟4","神龙李青","罗伯特兄嘚",9.7);
        arrayList.add(m1);
        arrayList.add(m2);
        arrayList.add(m3);
        System.out.println(arrayList);//[com.itgaohe.arrayListAPI.Movie@4554617c, cn.bdqn.arrayListAPI.Movie@74a14482, cn.bdqn.arrayListAPI.Movie@1540e19d]
//③	：遍历集合中的3个对象，输出相关信息。
        for (int i = 0; i < arrayList.size(); i++) {
            Movie movie = arrayList.get(i);
            System.out.println("电影名：" + movie.getMovieName());
            System.out.println("演员名：" + movie.getActor());
            System.out.println("导演名：" + movie.getDirector());
            System.out.println("电影评分：" + movie.getScore());
        }
    }

3.学生信息系统的数据搜索

代码演示：

Student

public class Student {
    private int number;
    private String name;
    private int age;
    private String className;
    public Student() {
    }

    public Student(int number, String name, int age, String className) {
        this.number = number;
        this.name = name;
        this.age = age;
        this.className = className;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }
}

测试类

  public static void main(String[] args) {
        //定义ArrayList集合存储学生数据
        // ①   定义Student类，定义ArrayList集合存储如上学生对象信息，并遍历展示出来
        ArrayList<Student> arrayList = new ArrayList<>();
        arrayList.add(new Student(20180302, "刁子熙", 88, "保健一班"));
        arrayList.add(new Student(20180303, "东方不败", 56, "推拿二班"));
        arrayList.add(new Student(20180304, "西门吹雪", 40, "288班"));
        arrayList.add(new Student(20180305, "天山童姥", 68, "精神人班"));
        for (int i = 0; i < arrayList.size(); i++) {
            Student student = arrayList.get(i);
            System.out.println(student.getNumber() + "," + student.getName() + "," + student.getAge() + "," + student.getClassName());
        }

//        定义扫描器 扫描数据
        Scanner sc = new Scanner(System.in);
        //使用死循环，让用户可以不停的搜索
        while (true) {
            System.out.println("请输入学生的学号：");
            int number = sc.nextInt();
            //调用查询方法 返回学生对象
            Student student = getStudentByNumber(arrayList, number);
            //比对学生对象 如果学生对象为null 没查到此人
            if (student == null) {
                System.out.println("没查到此人！");
            } else {
                System.out.println("找到了该学生,该学生的信息是" + student.getNumber() + "," + student.getName() + "," + student.getAge() + "," + student.getClassName());
            }
        }
    }

    // ②   提供一个方法，可以接收ArrayList集合，和要搜索的学号，返回搜索到的学生对象信息，并展示。
    public static Student getStudentByNumber(ArrayList<Student> a, int number) {
        for (int i = 0; i < a.size(); i++) {
            Student student = a.get(i);
            //判断 如果学号比对成功 则将对象返回出去
            if (student.getNumber() == number) {
                return student;
            }
        }
        //否则 返回null值
        return null;
    }

2.8 总结ArrayList的方法

2.9 ArrayList的扩容机制（补充）

在Java中，ArrayList是一个使用非常频繁的集合类型，它的底层是Object数组，所以它拥有数组所拥有的特性，比如支持随机访问，所以查询效率高，但插入数据需要移动元素，所以效率低。

1.ArrayList在调用无参构造方法时创建的是一个长度为0的空数组，当调用add()方法添加元素时，ArrayList才会触发扩容机制

2.调用add()方法添加元素时，ArrayList才会触发扩容机制 长度为10

3.当集合添加的内容超过10的时候 会进行二次扩容 长度为原来的1.5倍 1.5*10=15

4.当进行第三次扩容的时候 1.5*15 = 22.5 ArrayList底层是通过移位操作计算得到的新容量。所以新容量应该等于15 >> 1 + 15 = 22 ArrayList经过第三次扩容后容量为22

5.addAll()方法总是选择扩容一次后的容量与旧容量加上添加的元素个数的容量中取一个最大值作为新的容量，比如：当前ArrayList中有10个元素，而addAll()方法需要添加6个元素，当ArrayList触发扩容后的新容量应该为15，而旧容量加上需要添加的元素容量为16，从中取一个较大值为16，所以新容量应该为16。

2.10 员工管理系统

NumberOutOfBoundsException工号重复异常

//工号重复异常
public class NumberOutOfBoundsException extends RuntimeException{
    public NumberOutOfBoundsException() {
    }

    public NumberOutOfBoundsException(String message) {
        super(message);
    }

    public NumberOutOfBoundsException(String message, Throwable cause) {
        super(message, cause);
    }
}

NameOutOfBoundsException员工编号长度异常

//员工编号长度异常
public class NameOutOfBoundsException extends RuntimeException{
    public NameOutOfBoundsException() {
    }

    public NameOutOfBoundsException(String message) {
        super(message);
    }

    public NameOutOfBoundsException(String message, Throwable cause) {
        super(message, cause);
    }
}

AgeOutOfBoundsException 年龄异常

public class AgeOutOfBoundsException extends RuntimeException{
    public AgeOutOfBoundsException() {
    }

    public AgeOutOfBoundsException(String message) {
        super(message);
    }

    public AgeOutOfBoundsException(String message, Throwable cause) {
        super(message, cause);
    }
}

Employee员工类

public class Employee {
    //    number员工编号:7位
    private int number;
    //    name姓名:2-6
    private String name;
    //    16~35
    private int age;
    private String address;

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        String numbers = String.valueOf(number);
        if (numbers.length() == 7) {
            this.number = number;
        } else {
            throw new NameOutOfBoundsException("工号长度不对！");
        }

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        if (name.length() >= 2 && name.length() <= 6) {
            this.name = name;
        } else {
            throw new NameOutOfBoundsException("你输入名字超长了！");
        }
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age >= 16 && age <= 35) {
            this.age = age;
        } else {
            throw new AgeOutOfBoundsException("年龄区间不对！");
        }

    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public Employee(int number, String name, int age, String address) {
        this.number = number;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public Employee() {
    }

    @Override
    public String toString() {
        return "Employee{" +
                "number=" + number +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

测试类：

public class Test {
    public static Scanner sc = new Scanner(System.in);
    public static Employee employee = null;//定义员工对象
    public static ArrayList<Employee> al = new ArrayList<>();//定义存储员工的集合

    public static void main(String[] args) {
        //1.创建扫描器
        Test.show();
        Test.choice();
    }

    public static void show() {
        System.out.println("------欢迎来到公司员工管理系统------");
        System.out.println("请选择你的操作:\n1 添加员工\n2 删除员工\n3 修改员工\n4 查看所有员工\n5 退出");
    }

    public static void choice() {
        int i = 0;
        while (true) {
            try {
                System.out.println("请输入你的选择:");
                //用字符串接收
                String next = sc.next();
                //将string的选择转为int类型
                i = Integer.parseInt(next);
            } catch (NumberFormatException e) {
                e.printStackTrace();
            }
            //条件判断输入的选择
            switch (i) {
                case 1:
                    System.out.println("执行添加操作");
                    add();
                    break;
                case 2:
                    System.out.println("执行删除操作");
                    remove();
                    break;
                case 3:
                    System.out.println("执行修改操作");
                    update();
                    break;
                case 4:
                    System.out.println("执行查看操作");
                    select();
                    break;
                case 5:
                    System.out.println("执行退出操作");
                    System.exit(200);
                    break;
                default:
                    System.out.println("你的输入有误 请重新输入！");
                    choice();
                    break;
            }
        }
    }

    //添加
    public static void add() {
        employee = new Employee();
        addNumber();
        addName();
        addAge();
        System.out.println("请输入员工地址：");
        String address = sc.next();
        employee.setAddress(address);

        //将员工对象加入到集合中
        al.add(employee);
        System.out.println("员工对象添加完成！");
        System.out.println(al);
    }

    //添加员工号
    public static void addNumber() {
        while (true) {
            System.out.println("请输入员工编号：");
            try {
                String number1 = sc.next();
                int number = Integer.parseInt(number1);
                //判断一下员工的工号是否重复 如果重复则提示工号重复，需要重新输入工号
                for (int i = 0; i < al.size(); i++) {
                    if (al.get(i).getNumber() == number) {
                        System.out.println("员工编号不能重复！请重新输入！");
                        //递归调用添加方法
                        addNumber();
                    }
                }
                //添加值
                employee.setNumber(number);
                break;
            } catch (NameOutOfBoundsException e) {
                System.out.println("输入的员工编号必须是七位");
                e.printStackTrace();
            } catch (NumberFormatException e) {
                System.out.println("输入的必须是数字");
                e.printStackTrace();
            }

        }
    }

    //添加名字
    public static void addName() {
        while (true) {
            try {
                System.out.println("请输入你的姓名:");
                String name = sc.next();
                employee.setName(name);
                break;
            } catch (NameOutOfBoundsException e) {
                System.out.println("输入的名字必须是2到6位");
                e.printStackTrace();
            }
        }
    }

    //添加年龄
    public static void addAge() {
        while (true) {
            try {
                System.out.println("请输入年龄：");
                String age1 = sc.next();
                int i = Integer.parseInt(age1);
                employee.setAge(i);
                break;

            } catch (NumberFormatException e) {
                System.out.println("请输入数字");
                e.printStackTrace();
            } catch (AgeOutOfBoundsException e) {
                System.out.println("年龄的范围是16到35之间");
                e.printStackTrace();

            }
        }

    }

    //删除
    public static void remove() {
        //1.先展示已有的员工信息
        System.out.println("现有员工为" + al);
        while (true) {
            try {
                //2.提示要删除的工号
                System.out.println("请输入你要删除的员工的工号:");
                String delNumber = sc.next();
                //3.输入的工号如果不是 七位或者不是数字则会提示用户让用户重新输入，
                // 如果工号不存在则提示用户没有要删除的员工信息， 请选择其他操作，如果工号存在则删除掉此用户
                if (delNumber.length() == 7) {
                    //转为int类型
                    int number = Integer.parseInt(delNumber);
                    //从集合中遍历要删除的内容
                    for (int i = 0; i < al.size(); i++) {
                        if (al.get(i).getNumber() == number) {
                            al.remove(i);
                            break;
                        }
                        //没有找到对应长度的学生信息
                        if (i == al.size() - 1) {
                            System.out.println("没有这个员工的信息");
                        }
                    }
                } else {
                    System.out.println("输入的工号必须是七位,请重新输入");
                    remove();
                }
                break;
            } catch (NumberFormatException e) {
                System.out.println("要查询的员工编号必须为数字");
            }
        }
    }

    //修改
    public static void update() {
        //1.先展示已有的员工信息
        System.out.println("现有员工为" + al);
        while (true) {
            try {
                System.out.println("请输入要修改的员工工号:");
                String updateNumber = sc.next();
                if (updateNumber.length() == 7) {
                    int number = Integer.parseInt(updateNumber);
                    for (int i = 0; i < al.size(); i++) {
                        if (al.get(i).getNumber() == number) {
                            employee = new Employee();
                            employee.setNumber(number);
                            System.out.println("请输入你的姓名:");
                            String name = sc.next();
                            employee.setName(name);
                            System.out.println("请输入你的年龄:");
                            int age = sc.nextInt();
                            employee.setAge(age);
                            System.out.println("请输入你的地址:");
                            String address = sc.next();
                            employee.setAddress(address);
                            al.set(i, employee);
                            System.out.println("修改成功！");
                            break;
                        } else {
                            System.out.println("没有这个员工信息,请选择其他操作");
                            break;
                        }
                    }
                } else {
                    System.out.println("输入的员工编号必须是7位");
                    update();
                }
                break;
            } catch (NumberFormatException e) {
                e.printStackTrace();
                System.out.println("要查询的员工编号必须位数字");
            }
        }

    }

    //查询所有
    public static void select() {
        for (int i = 0; i < al.size(); i++) {
            System.out.println(al.get(i));
        }
    }
}

接下来我们对于集合框架整体架构进行学习

3.集合的概述和集合类的继承体系

3.1集合类体系结构

Collection单列集合，每个元素（数据）只包含一个值。
Map双列集合，每个元素包含两个值（键值对）。

注意：前期先掌握Collection集合体系的使用。

3.2 Collection集合体系

Collection集合特点

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

ArrayList、LinekdList ：有序、可重复、有索引。

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

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

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

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

3.3 总结

1、集合的代表是？
Collection接口。
2、Collection集合分了哪2大常用的集合体系？
List系列集合：添加的元素是有序、可重复、有索引。
Set系列集合：添加的元素是无序、不重复、无索引。
3、如何约定集合存储数据的类型，需要注意什么？
集合支持泛型。
集合和泛型不支持基本类型，只支持引用数据类型。

4.Collection集合

4.1 Collection 集合概述和使用

Collection集合概述
是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
JDK 不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现

创建Collection集合的对象
多态的方式
具体的实现类ArrayList

4.2 Collection 集合常用方法

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
boolean removeAll(Object o)	根据条件进行删除
void clear()	清空集合
boolean contains(Object o)	判断集合中是否存在指定的元素
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中元素的个数

4.3.迭代器遍历概述

遍历就是一个一个的把容器中的元素访问一遍。
迭代器在Java中的代表是Iterator，迭代器是集合的专用的遍历方式。

4.3.1 Collection集合获取迭代器

方法名称	说明
Iterator iterator()	返回集合中的迭代器对象，该迭代器对象默认指向当前集合的0索引

4.3.2 Iterator中的常用方法

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

4.3.3 迭代器执行流程

4.3.4 迭代器使用过程中的注意事项:

1.如果当前位置没有元素，还要强行获取，会报NoSuchElementException
2.迭代器遍历完毕，指针不会复位
3.循环中只能用一次next方法
4.迭代器遍历时，不能用集合的方法进行增删改查【但是可以用迭代器的方法进行删除】

4.3.5 总结

1、迭代器的默认位置在哪里。
Iterator iterator()：得到迭代器对象，默认指向当前集合的索引0
2、迭代器如果取元素越界会出现什么问题。
会出现NoSuchElementException异常。

4.4 增强for循环

4.4.1 增强for循环使用

格式：

for(元素数据类型 变量名 : 数组或者Collection集合) {
         //在此处使用变量即可，该变量就是元素
}

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

举例：

Collection<String> list = new ArrayList<>();
...
for(String ele : list) {
System.out.println(ele);
}

4.4.2 增强for修改变量

修改第三方变量的值不会影响到集合中的元素

4.4.3 总结

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

2.增强for循环格式：

for(元素数据类型 变量名 : 数组或者Collection集合) {
         //在此处使用变量即可，该变量就是元素
}

4.5 Lambda表达式遍历集合

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

方法名称	说明
default void forEach(Consumer<? super T> action):	结合lambda遍历集合

4.6 案例:Collection集合存储学生对象并遍历

**需求：**创建一个Collection集合存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

思路：
定义学生类
创建Collection集合对象
创建学生对象
把学生添加到集合
遍历集合(迭代器方式)

4.7 总结

集合中存储的是元素的什么信息？

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

1. Collection是单列集合的顶层接口，所有方法被List和set系列集合共享

2. 常见成员方法：

add、 clear、 remove、 contains、 isEmpty、 size

3. 三种通用的遍历方式：
   • 迭代器：在遍历的过程中需要删除元素，请使用迭代器。
   • 增强for、Lambda：
   仅仅想遍历，那么使用增强for或Lambda表达式。

5.List集合

5.1 集合类体系结构

5.2 List集合概述和特点

List集合概述

有序集合，这里的有序指的是存取顺序

用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素

与Set集合不同，列表通常允许重复的元素

List集合特点

有序：存储和取出的元素顺序一致

有索引：可以通过索引操作元素

可重复：存储的元素可以重复

5.3 List集合特有方法

方法名	说明
void add(ntindex,Eelement)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(intindex)	返回指定索引处的元素方法名

5.4 五种遍历方式对比

6. 常见的数据结构

6.1 数据结构

数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率

栈
队列
数组
链表

…

7.ArrayList集合

7.1 List集合常用实现类ArrayList

ArrayList特点：底层数据结构是数组，查询快，增删慢

8.LinkedList集合

8.1 List集合常用实现类

List集合常用子类：ArrayList，LinkedList

ArrayList：底层数据结构是数组，查询快，增删慢

LinkedList：底层数据结构是链表，查询慢，增删快

练习：
      使用LinkedList完成存储字符串并遍历

8.2 LinkedList集合的特有功能

方法名	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

8.3 LinkedList的底层源码

9.泛型

9.1 泛型概述

泛型：

泛型：是JDK5中引入的特性，可以在编译阶段约束操作的数据类型，并进行检查。

泛型的格式：<数据类型>; 注意：泛型只能支持引用数据类型。

集合体系的全部接口和实现类都是支持泛型的使用的。

泛型的好处：

统一数据类型。

把运行时期的问题提前到了编译期间，避免了强制类型转换可能出现的异常，因为编译阶段类型就能确定下来。

9.2 泛型的定义位置

泛型可以在很多地方进行定义:
类后面———— 泛型类
方法申明上——泛型方法
接口后面 ———泛型接口

9.3 泛型的细节

泛型中不能写基本数据类型

指定泛型的具体类型后，传递数据时，可以传入该类类型或者其子类类型

如果不写泛型，类型默认是Object

9.4 泛型类的概述

定义类时同时定义了泛型的类就是泛型类。

泛型类的格式：

修饰符 class 类名<泛型变量>{  }

范例：

public class MyArrayList<T> {  }

此处泛型变量T可以随便写为任意标识，常见的如E、T、K、V等。

作用：

编译阶段可以指定数据类型，类似于集合的作用。

课程案例导学

模拟ArrayList集合自定义一个集合MyArrayList集合,完成添加和查找功能的泛型设计即可。

泛型类的原理：

 把出现泛型变量的地方全部替换成传输的真实数据类型。

9.5 泛型类的总结

1、泛型类的核心思想：把出现泛型变量的地方全部替换成传输的真实数据类型

2、泛型类的作用：编译阶段约定操作的数据的类型，类似于集合的作用。

9.6 泛型方法的概述

定义方法时同时定义了泛型的方法就是泛型方法。
泛型方法的格式：

修饰符 <泛型变量> 方法返回值 方法名称(形参列表){}

范例：

 public <T> void show(T t) {  }

作用：

方法中可以使用泛型接收一切实际类型的参数，方法更具备通用性。

课程案例导学

模拟ArrayList集合自定义一个集合MyArrayList集合,完成添加全部的功能泛型设计即可！

泛型方法的原理：

 把出现泛型变量的地方全部替换成传输的真实数据类型。

9.7 泛型方法的总结

1、泛型方法的核心思想：把出现泛型变量的地方全部替换成传输的真实数据类型

2、泛型方法的作用：方法中可以使用泛型接收一切实际类型的参数，方法更具备通用性

9.8 泛型接口的概述

使用了泛型定义的接口就是泛型接口。

泛型接口的格式：

修饰符 interface 接口名称<泛型变量>{}

范例：

public interface Data<E>{}

作用：

泛型接口可以让实现类选择当前功能需要操作的数据类型

课程案例导学

讲解List<E>带学生深入理解

泛型接口的原理：

实现类可以在实现接口的时候传入自己操作的数据类型，这样重写的方法都将是针对于该类型的操作。

9.9 泛型接口的总结

泛型接口的作用:

泛型接口可以约束实现类，实现类可以在实现接口的时候传入自己操作的数据类型这样重写的方法都将是针对于该类型的操作。

9.10 类型通配符