JavaSE阶段综合项目学生管理系统（写属于自己的MyList接口和ArrayList集合实现类工具）

JavaSE阶段综合训练小项目——学生管理系统

---

项目要求：

1. 学生要求有学号（唯一）、姓名、年龄、班级、Java成绩、Html成绩、Spring成绩、总分
2. 设计到的功能概括： 增、删、改、查、过滤信息、排序
3. 要求自己写MyList接口、MyArrayList实现类、MyComparator接口和Java8函数式接口
4. 要求Package层次分明、文档注释清晰可查、命名规范正确
5. 按以上要求实现以下功能，如图：
   

---

分包情况如下：

---

Package层次设计：

为什么分包写呢？因为要锻炼以下分包写内容，理解各个数据层之间的相互调用关系！为以后做铺垫！毕竟上班不是你一个人单独完成整个项目是吧！都是分模块去写项目的！所以要从娃娃抓起！????

各个层次之间的调用关系：

学着去理解各个层之间的调用关系，各个数据层之间调用并给他提供了什么服务！

图画的有点糙，请见谅，但是他们之间的联系意思还在！????

---

代码：

menu（操作菜单）：StudentApplicationMenu

package com.mylifes1110.java.menu;

import com.mylifes1110.java.service.StudentService;

import java.util.Scanner;

/**
 * @author Ziph
 * 学生操作的菜单
 */
public class StudentApplicationMenu {
    static Scanner sc = new Scanner(System.in);

    public static void main(String[] args) {
        StudentService studentService = new StudentService();
        int choice = 0;

        while (true) {
            System.out.println("--------------------------------------------");
            System.out.println("欢迎来到学生信息管理系统，小Z全心全力为您服务！");
            System.out.println("1.查看所有学生信息");
            System.out.println("2.添加学生信息");
            System.out.println("3.根据学生学号查询学生信息");
            System.out.println("4.根据学生学号删除学生信息");
            System.out.println("5.根据学生学号修改学生信息");
            System.out.println("6.根据班级名称查询学生信息");
            System.out.println("7.根据需求排序学生信息");
            System.out.println("8.根据需求展示符合要求的学生信息");
            System.out.println("0.退出学生信息管理系统");
            System.out.println("--------------------------------------------");
            System.out.print("请做出您的选择：");
            choice = sc.nextInt();

            switch (choice) {
                case 1:
                    studentService.showAll();
                    break;
                case 2:
                    studentService.addStudent();
                    break;
                case 3:
                    studentService.getStudentById();
                    break;
                case 4:
                    studentService.deleteStudentById();
                    break;
                case 5:
                    studentService.updateStudentById();
                    break;
                case 6:
                    studentService.getStudentByClassName();
                    break;
                case 7:
                    studentService.sortStudent();
                    break;
                case 8:
                    studentService.showFilter();
                    break;
                case 0:
                    System.out.println("感谢您的使用！");
                    return;
                default:
                    break;
            }
        }
    }
}

entity（实体类）：Student

package com.mylifes1110.java.entity;

/**
 * @author Ziph
 * @Entity 学生类
 */
public class Student {
    private int id;                     //学号            int
    private String name;                //姓名            String
    private int age;                    //年龄            int
    private char sex;                   //性别            char
    private String className;           //班级            String
    private double javaScore;           //java成绩        double
    private double htmlScore;           //html成绩        double
    private double springScore;         //spring成绩      double
    private double totalScore;          //总成绩          double

    public Student() {
    }

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

    public Student(int id, String name, int age, char sex, String className, double javaScore, double htmlScore, double springScore) {
        this(id, name, age, sex, className);
        this.javaScore = javaScore;
        this.htmlScore = htmlScore;
        this.springScore = springScore;
        /**
         * 计算总成绩
         */
        this.totalScore = javaScore + htmlScore + springScore;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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 char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public String getClassName() {
        return className;
    }

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

    public double getJavaScore() {
        return javaScore;
    }

    /**
     * javaScore的set方法
     * 注意：需要涉及到修改Java成绩，而总成绩也会随之改变！
     *
     * @param javaScore java成绩
     */
    public void setJavaScore(double javaScore) {
        this.totalScore -= this.javaScore;
        this.javaScore = javaScore;
        this.totalScore += this.javaScore;
    }

    public double getHtmlScore() {
        return htmlScore;
    }

    /**
     * htmlScore的set方法
     * 注意：需要涉及到修改html成绩，而总成绩也会随之改变！
     *
     * @param htmlScore html成绩
     */
    public void setHtmlScore(double htmlScore) {
        this.totalScore -= this.htmlScore;
        this.htmlScore = htmlScore;
        this.totalScore += this.htmlScore;

    }

    public double getSpringScore() {
        return springScore;
    }

    /**
     * springScore的set方法
     * 注意：需要涉及到修改spring成绩，而总成绩也会随之改变！
     *
     * @param springScore spring成绩
     */
    public void setSpringScore(double springScore) {
        this.totalScore -= this.springScore;
        this.springScore = springScore;
        this.totalScore += this.springScore;
    }

    /**
     * 获得总成绩的get方法
     * 注意：总成绩是计算出来的，不能修改，所以只提供get方法！
     *
     * @return 返回总成绩
     */
    public double getTotalScore() {
        return totalScore;
    }

    @Override
    public String toString() {
        return "Students{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                ", className='" + className + '\'' +
                ", javaScore=" + javaScore +
                ", htmlScore=" + htmlScore +
                ", springScore=" + springScore +
                ", totalScore=" + totalScore +
                '}';
    }
}

manager（管理层）：StudentManager

package com.mylifes1110.java.manager;

import com.mylifes1110.java.entity.Student;
import com.mylifes1110.java.util.MyComparator;
import com.mylifes1110.java.util.impl.MyArrayList;
import com.mylifes1110.java.util.impl.MyFilter;

/**
 * @author Ziph
 * 完成所有学生管理系统的相关功能
 * 逻辑代码、输入数据
 * 只负责接收前端数据、调用后端
 */
public class StudentManager {
    /**
     * 使用MyArrayList集合容器来存储学生对象
     */
    private MyArrayList<Student> allStudent = null;

    /**
     * 无参构造方法初始化MyArrayList集合容器
     */
    public StudentManager() {
        allStudent = new MyArrayList<Student>();
    }

    /**
     * 有参构造方法初始化手动传入容量MyArrayList容器
     *
     * @param initCapacity 手动输入的初始化容量；要求数据大于等于0且小于Integer.MAX_VALUE - 8
     */
    public StudentManager(int initCapacity) {
        allStudent = new MyArrayList<Student>(initCapacity);
    }

    /**
     * 添加学生对象
     * 注意：采用尾插法，插入到集合的末端
     *
     * @param student Student类对象
     * @return 添加学生成功，返回true；失败则返回false
     */
    public boolean add(Student student) {
        if (student == null) {
            System.out.println("存入的学生对象不能为空");
        }
        allStudent.add(student);
        return true;
    }

    /**
     * 根据学生的唯一ID，删除指定学生
     *
     * @param studentId 学生学号
     * @return 返回删除的学生对象
     */
    public Student remove(int studentId) {
        int index = findIndexById(studentId);
        try {
            return allStudent.remove(index);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println(e.getMessage());
        }
        return null;
    }

    /**
     * 根据学生的唯一ID，修改学生信息
     *
     * @param studentId 学生学号
     * @return 修改成功，返回true；失败则返回false
     */
    public boolean modify(int studentId) {
        return false;
    }

    /**
     * 根据学生唯一ID，查询单个学生对象信息
     *
     * @param studentId 学生学号
     * @return 返回学生对象信息或null
     */
    public Student get(int studentId) {
        /**
         * 查找下标
         * 判断如果查找的下标符合规则，则返回该下标在集合容器中的对象
         * 如果不符合规则，则返回null
         */
        int index = findIndexById(studentId);
        if (index >= 0) {
            return allStudent.get(index);
        }
        return null;
    }

    /**
     * 遍历并打印所有学生信息
     * 判断如果集合容器中没有学生对象，则返回提示信息
     */
    public void get() {
        if (allStudent.isEmpty()) {
            System.out.println("亲爱的同学，目前系统中没有学生信息！请您添加哦！");
        }

        for (int i = 0; i < allStudent.size(); i++) {
            System.out.println(allStudent.get(i));
        }
    }

    /**
     * 根据学生的学号，查询该学生在容器中的下标位置
     *
     * @param studentId 查询的学号
     * @return 查询的学号存在，则返回该下标；不存在，则返回-1
     */
    private int findIndexById(int studentId) {
        int index = -1;
        for (int i = 0; i < allStudent.size(); i++) {
            if (allStudent.get(i).getId() == studentId) {
                index = i;
                break;
            }
        }
        return index;
    }

    /**
     * 根据班级名称查询学生列表
     *
     * @param className 班级名称
     */
    public void get(String className) {
        for (int i = 0; i < allStudent.size(); i++) {
            if (allStudent.get(i).getClassName().equals(className)) {
                System.out.println(allStudent.get(i));
            }
        }
    }

    /**
     * 指定排序规则，使用自定义排序接口的方法
     *
     * @param comparator 自定义接口
     */
    public void sort(MyComparator<Student> comparator) {
        /**
         * 排序不允许在原始数据上做操作，创建一个新数组，把元素据复制一份，进行排序
         */
        Object[] sortTemp = allStudent.toArray();

        /**
         * 排序规则：选择排序
         */
        for (int i = 0; i < sortTemp.length - 1; i++) {
            for (int j = i + 1; j < sortTemp.length; j++) {
                if (comparator.compare((Student) sortTemp[i], (Student) sortTemp[j]) > 0) {
                    Student temp = (Student) sortTemp[i];
                    sortTemp[i] = sortTemp[j];
                    sortTemp[j] = temp;
                }
            }

        }
        for (Object obj : sortTemp) {
            System.out.println(obj);
        }
    }

    /**
     * 自定义过滤器，满足条件的会展示学生信息
     *
     * @param filter 过滤器接口
     */
    public void showStudentFilter(MyFilter<Student> filter) {
        for (int i = 0; i < allStudent.size(); i++) {
            if (filter.accept(allStudent.get(i))) {
                System.out.println(allStudent.get(i));
            }
        }
    }
}

service（业务层）：StudentService

package com.mylifes1110.java.service;

import com.mylifes1110.java.entity.Student;
import com.mylifes1110.java.manager.StudentManager;

import java.util.Scanner;

/**
 * @author Ziph
 * 业务层（Service）
 * 接收学生对菜单的操作请求，并执行相应的逻辑代码
 * 调用StudentManager，传递数据再传入底层实现类MyArrayList
 */
public class StudentService {
    Scanner sc = new Scanner(System.in);

    /**
     * 调用StudentManager，传入数据
     */
    StudentManager studentManager = new StudentManager();

    /**
     * 显示所有学生
     */
    public void showAll() {
        studentManager.get();
    }

    /**
     * 学生信息的添加功能
     */
    public void addStudent() {
        System.out.println("请按照顺序正确输入学生信息！");


        int studentId;
        do {
            System.out.print("请输入学生学号：");
            studentId = sc.nextInt();
        } while (!checkedStudentId(studentId));


        System.out.print("请输入学生姓名：");
        String name = sc.next();

        System.out.print("请输入学生年龄：");
        int age = sc.nextInt();

        System.out.print("请输入学生性别：");
        char sex = sc.next().charAt(0);

        System.out.print("请输入学生所在班级：");
        String className = sc.next();

        System.out.println("注意：如果没有成绩录入成绩为0即可！");
        System.out.print("请输入学生Java成绩：");
        double javaScore = sc.nextDouble();
        System.out.print("请输入学生Html成绩：");
        double htmlScore = sc.nextDouble();
        System.out.print("请输入学生Spring成绩：");
        double springScore = sc.nextDouble();
        /**
         * 将输入内容封装成对象
         */
        Student student = new Student(studentId, name, age, sex, className, javaScore, htmlScore, springScore);
        boolean result = studentManager.add(student);
        if (result == true) {
            System.out.println("添加成功！");
        } else {
            System.out.println("添加失败！");
        }
    }

    /**
     * 学号校验
     * 因为学号是学生唯一的ID，所有不可能出现重复，即使在添加学生的时候也不能出现覆盖！
     */
    private boolean checkedStudentId(int studentId) {
        if (studentId <= 0) {
            System.out.print("请输入错误！请输入正确的学生学号！");
            return false;
        }
        Student student = studentManager.get(studentId);
        if (student != null) {
            System.out.println("该学号已存在！请您重新输入！");
            return false;
        }
        return true;
    }

    /**
     * 通过学生学号来查询学生信息
     */
    public void getStudentById() {
        int id = 0;
        do {
            System.out.print("请输入学生学号：");
            id = sc.nextInt();
            if (id <= 0) {
                System.out.print("请输入错误！请输入正确的学生学号！");
            }
        } while (id <= 0);

        Student student = studentManager.get(id);
        if (student != null) {
            System.out.println("学号为" + id + "学生信息：");
            System.out.println(student);
        } else {
            System.out.println("学号为" + id + "的学生不存在！");
        }
    }

    /**
     * 根据学生学号删除学生信息
     */
    public void deleteStudentById() {
        int id = 0;
        do {
            System.out.print("请输入要删除学生的学号：");
            id = sc.nextInt();
            if (id <= 0) {
                System.out.print("请输入错误！请输入正确的学生学号！");
            }
        } while (id <= 0);
        Student student = studentManager.remove(id);
        if (student != null) {
            System.out.println("删除成功！");
        } else {
            System.out.println("删除失败！");
        }
    }

    public void updateStudentById() {
        int id = 0;
        do {
            System.out.print("请输入要修改学生的学号：");
            id = sc.nextInt();
            if (id <= 0) {
                System.out.println("学生学号输入错误！");
            }
        } while (id <= 0);

        Student student = studentManager.get(id);

        if (student != null) {
            System.out.println("需要修改的此学生信息为：");
            System.out.println("学生学号为：" + student.getId());
            System.out.println("学生姓名为：" + student.getName());
            System.out.println("学生年龄为：" + student.getAge());
            System.out.println("学生性别为：" + student.getSex());
            System.out.println("学生班级名称为：" + student.getClassName());
            System.out.println("学生java成绩为：" + student.getJavaScore());
            System.out.println("学生html成绩为：" + student.getHtmlScore());
            System.out.println("学生spring成绩为：" + student.getSpringScore());
            System.out.println("--------------------------------------------------");
            int choice = 0;
            while (true) {
                System.out.println("1.修改学生学号：");
                System.out.println("2.修改学生姓名：");
                System.out.println("3.修改学生性别：");
                System.out.println("4.修改学生年龄：");
                System.out.println("5.修改学生班级名称：");
                System.out.println("6.修改学生java成绩：");
                System.out.println("7.修改学生html成绩：");
                System.out.println("8.修改学生spring成绩：");
                System.out.println("0.保存并退出");
                choice = sc.nextInt();
                switch (choice) {
                    case 1:
                        int studentId = 0;
                        do {
                            System.out.print("请输入学生的新学号：");
                            studentId = sc.nextInt();
                            if (studentId <= 0) {
                                System.out.print("请输入错误！请输入正确的学生学号！");
                            }
                        } while (studentId <= 0);

                        Student student1 = studentManager.get(studentId);
                        if (student1 == null) {
                            student.setId(studentId);
                        } else {
                            System.out.println("学号为" + studentId + "的学生已存在！");
                        }
                        break;
                    case 2:
                        System.out.print("请输入学生的新姓名：");
                        String name = sc.next();
                        student.setName(name);
                        break;
                    case 3:
                        System.out.print("请输入学生的新性别：");
                        char sex = sc.next().charAt(0);
                        student.setSex(sex);
                        break;
                    case 4:
                        System.out.print("请输入学生的新年龄：");
                        int age = sc.nextInt();
                        student.setAge(age);
                        break;
                    case 5:
                        System.out.print("请输入学生的新班级名称：");
                        String className = sc.next();
                        student.setClassName(className);
                        break;
                    case 6:
                        System.out.print("请输入学生的新java成绩：");
                        double javaScore = sc.nextDouble();
                        student.setJavaScore(javaScore);
                        break;
                    case 7:
                        System.out.print("请输入学生的新html成绩：");
                        double htmlScore = sc.nextDouble();
                        student.setHtmlScore(htmlScore);
                        break;
                    case 8:
                        System.out.print("请输入学生的新spring成绩：");
                        double springScore = sc.nextDouble();
                        student.setSpringScore(springScore);
                        break;
                    case 0:
                        System.out.print("修改成功！");
                        System.out.println("修改后的学生信息为：" + student);
                        return;
                    default:
                        break;
                }
            }
        } else {
            System.out.println("对不起，没有查询到没有此学生！");
            return;
        }
    }

    /**
     * 根据班级名称查询学生列表信息
     */
    public void getStudentByClassName() {
        System.out.print("请输入班级名称：");
        String className = sc.next();
        studentManager.get(className);
    }

    /**
     * 实现需求的学生排序
     * 利用了Java8新特性lambda表达式和函数式接口
     */
    public void sortStudent() {
        int choice = 0;
        while (true) {
            System.out.println("请选择学生信息升序排名条件：");
            System.out.println("1.根据学生学号   2.根据年龄   3.根据总成绩   0.退出");
            choice = sc.nextInt();
            switch (choice) {
                case 1:
                    studentManager.sort(((s1, s2) -> s1.getId() - s2.getId()));
                    break;
                case 2:
                    studentManager.sort((s1, s2) -> s1.getAge() - s2.getAge());
                    break;
                case 3:
                    /**
                     * 因为double类型两个数相减强转会舍弃小数部分，不精确，乘以100后转化为int保证精确度，避免一系列问题；比如：两位学生的分为为80.5，80
                     */
                    studentManager.sort((s1, s2) -> (int) ((s1.getTotalScore() - s2.getTotalScore()) * 100));
                    break;
                    /*
                    匿名内部类写法：
                    studentManager.sort(new MyComparator<Student>() {
                        @Override
                        public int compare(Student s1, Student s2) {
                            return (int) ((s1.getTotalScore() - s2.getTotalScore()) * 100);
                        }
                    });
                     */
                case 0:
                    return;
                default:
                    break;
            }
        }
    }

    /**
     * 1.查询年龄大于20岁的学生信息
     * 2.查询总分大于等于250分的学生信息
     */
    public void showFilter() {
        int choice = 0;
        while (true) {
            System.out.println("请选择查询学生信息规则：");
            System.out.println("1.查询年龄大于20岁的学生信息    2.查询总分大于等于250分的学生信息    0.退出");
            choice = sc.nextInt();
            switch (choice) {
                case 1:
                    studentManager.showStudentFilter(s -> s.getAge() >= 20);
                    break;
                case 2:
                    studentManager.showStudentFilter(s -> s.getTotalScore() >= 150);
                    break;
                case 0:
                    return;
                default:
                    break;
            }
        }
    }
}

utils（工具类）：MyList接口（注意：很多功能没有用上，所有就没写，但留了足够的注释，可以参看！）

package com.mylifes1110.java.util;

/**
 * @author Ziph
 * @param <E> 泛型，应用在不同类型下，作为集合
 * 添加操作：
 * add(E e);
 * add(int index, E e);
 * 删除操作：
 * remove(E e)
 * remove(int index, E e)
 * 修改操作：
 * set(int index);
 * 查询操作：
 * E get(int index);
 * 有效元素个数：
 * int size();
 * 获取Object的类型的数组对象：
 * Object[] toArray();
 * 判断是否为空操作：
 * boolean isEmpty();
 * 判断某个对象是否在当前集合中存在：
 * boolean contains(Object obj);
 * 返回集合中指定范围的MyList集合的子集合：
 * MyArrayList<E> subList(int start, int end);
 * 返回第一个对象的下标：
 * int indexOf(Object obj);
 * 返回最后一个对象的下标：
 * int lastIndexOf(Object obj);
 * @author Ziph
 */
public interface MyList<E> {
    /**
     * 添加元素到集合末尾（尾插法）
     *
     * @param e 泛型集合对象
     * @return 添加成功，返回true；失败则返回false
     */
    boolean add(E e);

    /**
     * 根据传入下标位置添加元素到集合末尾（尾插法）
     *
     * @param index 指定的下标位置
     * @param e     泛型集合对象
     * @return 添加成功，返回true；失败则返回false
     */
    boolean add(int index, E e);

    /**
     * 在集合中移除指定元素
     *
     * @param object 指定集合中的元素
     * @return 移除元素成功，返回true；失败则返回false
     */
    boolean remove(Object object);

    /**
     * 在集合中移除指定下标位置的元素
     *
     * @param index 指定的下标位置
     * @return 移除元素成功，返回true；失败则返回false
     */
    E remove(int index);

    /**
     * 覆盖替换指定下标位置的元素
     *
     * @param index 指定的下标位置
     * @param e     需要被替换存储在指定下标位置的元素
     * @return 返回之前指定位置的元素
     */
    E set(int index, E e);

    /**
     * 获取指定下标位置的元素
     *
     * @param index 指定的下标位置
     * @return 返回指定下标位置的元素
     */
    E get(int index);

    /**
     * 获取集合中有效元素个数
     *
     * @return 返回有效元素个数
     */
    int size();

    /**
     * 获取当前集合中，所有元素的Object的类型的数组对象
     *
     * @return 返回Object数组中的所有对象
     */
    Object[] toArray();

    /**
     * 判断当前集合是否为空
     *
     * @return 如果集合中元素为空，返回true；反之，返回false
     */
    boolean isEmpty();

    /**
     * 判断某个对象是否在当前集合中存在
     *
     * @param obj 需要判断的对象
     * @return 需要判断的对象存在，返回true；反之，返回false
     */
    boolean contains(Object obj);

    /**
     * 返回集合中指定范围的MyList集合的子集合
     *
     * @param start 指定的起始下标，不能大于end
     * @param end   指定的终止下标，不能小于等于start
     * @return 根据指定的范围返回当前子集合；不符合此范围要求，返回null
     */
    MyList<E> subList(int start, int end);

    /**
     * 获取指定元素在集合中出现的第一个下标位置
     *
     * @param obj 指定元素
     * @return 获取到集合中指定元素出现的第一个下标位置，返回true；反之，返回false
     */
    int indexOf(Object obj);

    /**
     * 获取指定元素在集合中出现的最后一个下标位置
     *
     * @param obj 指定元素
     * @return 获取到集合中指定元素出现的最后一个下标位置，返回true；反之，返回false
     */
    int lastIndexOf(Object obj);
}

utils（工具类）：MyComparator

package com.mylifes1110.java.util;

/**
 * @author Ziph
 */
public interface MyComparator<E> {
    /**
     * 自定义排序的方法，方法的返回值是int类型
     *
     * @param s1 student类型
     * @param s2 student类型
     * @return >0 前者大于后者；<0 前者小于后者； == 前者于后者相同
     */
    public int compare(E s1, E s2);
}

utils（工具实现类）：MyFilter接口

package com.mylifes1110.java.util.impl;

/**
 * @author Ziph
 * @param <E>
 */
public interface MyFilter<E> {
    public boolean accept(E e);
}

utils（工具实现类）：MyArrayList

package com.mylifes1110.java.util.impl;

import com.mylifes1110.java.util.MyList;

import java.util.Arrays;

/**
 * MyList接口实现类
 *
 * @param <E>
 * @author Ziph
 */
public class MyArrayList<E> implements MyList<E> {

    /**
     * ArrayList集合底层是使用数组实现的，创建一个保存Object类型的数组
     */
    private Object[] elementDate = null;

    /**
     * 集合初始化默认容量
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 数组最大长度Integer.MAX_VALUE - 8
     * 通俗易懂的可以这么说因为数组的标签占一部分容量（8）
     * 所以我们必须减去8，以免溢出容量
     */
    private static final int MAX_SIZE = Integer.MAX_VALUE - 8;

    /**
     * 保存数组中的有效元素个数（下一个元素插入的下标位置）
     */
    private int size = 0;

    /**
     * 无参构造方法默认初始化集合容量
     */
    public MyArrayList() {
        elementDate = new Object[DEFAULT_CAPACITY];
    }

    /**
     * 有参构造器，手动初始化集合容量
     *
     * @param initCapacity 手工指定的容量大小，要求：传入容量大于0并且小于Integer.MAX_VALUE - 8
     * @throws IllegalArgumentException 如果指定的初始化容量不符合要求，就抛出不合法的参数异常
     */
    public MyArrayList(int initCapacity) {
        if (initCapacity < 0 || initCapacity > MAX_SIZE) {
            throw new IllegalArgumentException("Not in accordance with the rules of the capacity:" + initCapacity);
        } else {
            elementDate = new Object[initCapacity];
        }
    }

    @Override
    public boolean add(E e) {
        /**
         * 判断数组容量是否是安全容量（判断扩容）
         */
        safeCapacityEntrance(size + 1);
        elementDate[size++] = e;
        return true;
    }

    /**
     * 判断扩容的方法入口
     *
     * @param minCapacity 扩容的最小容量
     */
    public void safeCapacityEntrance(int minCapacity) {
        isSafeCapacity(minCapacity);
    }

    /**
     * 判断是否需要扩容
     *
     * @param minCapacity 扩容的最小容量
     */
    public void isSafeCapacity(int minCapacity) {
        if (minCapacity - elementDate.length > 0) {
            grow(minCapacity);
        }
    }

    /**
     * 为底层数组elementData扩容
     * 1.创建一个oldCapacity存在当前容量
     * 2.创建一个newCapacity存放扩容50%的容量
     * 3.判断newCapacity是否符合规范以及minCapacity是否符合规范，并抛出异常
     * 4.判断扩容条件，扩容后的容量-扩容的最小容量（size+1）是否小于0，如果小于0就证明不需要扩容，将minCapacity的地址给newCapacity
     * 5.复制元素移动到新数组中
     *
     * @param minCapacity 扩容的最小容量
     */
    private void grow(int minCapacity) {
        int oldCapacity = elementDate.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity > MAX_SIZE || minCapacity < 0) {
            throw new OutOfMemoryError("A collection of overflow！");
        }
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        elementDate = Arrays.copyOf(elementDate, newCapacity);
    }

    @Override
    public boolean add(int index, E e) {
        checkIndex(index);
        safeCapacityEntrance(size + 1);
        for (int i = size; i < index; i--) {
            elementDate[index] = e;
        }
        size++;
        return true;
    }

    /**
     * 指定下标的安全检查！如果不符合要求，则抛出异常！
     *
     * @param index 指定下标
     */
    private void checkIndex(int index) {
        if (index < 0 || index >= size) {
            throw new ArrayIndexOutOfBoundsException(index);
        }
    }

    @Override
    public boolean remove(Object obj) {
        if (obj == null) {
            for (int i = 0; i < size; i++) {
                if (elementDate[i] == null) {
                    fastRemove(i);
                    return true;
                }
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (elementDate[i].equals(obj)) {
                    fastRemove(i);
                }
                return true;
            }
        }
        return false;
    }

    /**
     * 移除元素
     * 记录移除元素下标位置numMoved
     * 判断位置下标位置numMoved是否合法
     * 合法，即可以移除；复制数组元素将原数组的有效元素个数复制到了新数组（size-1）
     * 将数组中有效元素个数的下标位置置空，交给GC销毁
     *
     * @param index
     */
    private void fastRemove(int index) {
        int numMoved = size - index - 1;
        if (numMoved > 0) {
            System.arraycopy(elementDate, size + 1, elementDate, size, numMoved);
        }
        elementDate[--size] = null;
    }

    @Override
    public E remove(int index) {
        checkIndex(index);
        E oldValue = (E) elementDate[index];
        int numMoved = size - index - 1;
        if (numMoved > 0) {
            System.arraycopy(elementDate, index + 1, elementDate, index, numMoved);
        }
        elementDate[--size] = null;
        return oldValue;
    }

    @Override
    public E set(int index, E e) {
        return null;
    }

    @Override
    public E get(int index) {
        checkIndex(index);
        return (E) elementDate[index];
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public Object[] toArray() {
        return Arrays.copyOf(elementDate, size);
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean contains(Object obj) {
        return false;
    }

    @Override
    public MyList<E> subList(int start, int end) {
        return null;
    }

    @Override
    public int indexOf(Object obj) {
        return 0;
    }

    @Override
    public int lastIndexOf(Object obj) {
        return 0;
    }
}

执行结果：