数据结构-数组（使用数组封装了一个集合）

MyArrAyList接口

public interface MyArrAyList<E> {
    //添加内容方法
    void add(E obj);  //通过任意用户类型obj进行添加,没有返回值

    //获取下标元素
     E get(int index); //通过下标,进行获取用户中的元素

    //获取内容个数
    int size();  //直接调用方法,然后直接返回给用户个数

    //修改元素
    boolean set(int index,E obj); //根据任意用户obj和每个元素所在的位置index进行修改,然后返回给用户

    //删除元素(根据下标)
    boolean remove(int index);  //根据索引删除数组中的元素,并返回给用户

    //删除元素(根据内容)
    boolean remove(E obj);  //根据任意用户内容删除,并返回给用户
}

MyArrAyListImpl实现类

public class MyArrAyListImpl<E> implements MyArrAyList<E>{
    //成员变量
    private Object[] objs; //定义数组的初始化,没有赋值
    private int size; //定义一个变量初始化,没有赋值

    public MyArrAyListImpl(){   //无参构造函数
         objs=new Object[10];  //定义数组的长度并且赋值给objs
        //Object[] objs = new Object[10]; //上面这个是等价于与它的
    }
    public MyArrAyListImpl(int size){  //有参构造方法
        if (size>0&&size<Integer.MAX_VALUE){  //判断用户输入的内容要大于0,并且要在Integer这个范围内
            objs=new Object[size];  //将用户输入的这个参数的长度赋值给这个数组

            //objs=new Object[1];    //假设长用户输入的长度为1,就将它赋值给这个数组objs
        }
    }

    @Override
    public String toString() {  //输出对象里面的所有属性值,如果重写,默认都是object,输出的就是地址值
        return "MyArrAyListImpl{" +
                "objs=" + Arrays.toString(objs) +
                ", size=" + size +
                '}';
    }

    //添加元素
    @Override
    public void add(E obj) {
        int c=size+1; //长度+1,然后赋值给c
        if (c>objs.length){   //判断添加后的用户是否大于数组本身长度10
            //进行数组长度的扩充 扩充为之前的1.5倍
            int oldLength=objs.length;  //获取之前数组的长度,并赋值给变量oldLength
            int newLength=oldLength+(oldLength>>1); //扩充数组的长度10+(10/2)=15,右移一位除以2,新数组的长度为15

            if (newLength<c){ //如果扩充的数组长度仍然满足不了要求 我们直接把现有的长度赋值给newLength
                newLength=c; //新的长度15=用户输入的长度16
            }
            //代表扩容后长度超过了最大范围
            if (newLength>Integer.MAX_VALUE||newLength<=0){  //新的长度不能大于Integer范围或新长度不能小于等于0
                //throw new RuntimeException(); //抛出异常
                throw new ArraysOutOfException("数组范围超出了上限"); //自定义异常
            }
            objs=Arrays.copyOf(objs,newLength); //把之前数组内容经过扩容复制给新数组
        }
         objs[size++]=obj; //把用户的值存入到数组中,并且把长度+1
        //return obj;

    }

    //根据下标获得元素
    @Override
    public E get(int index) {
        if (index < 0 || index >= size) { //如果下标小于0, 或者下标大于等于了数组中存储元素个数,这种情况都不对
            throw new ArrayIndexOutOfBoundsException("数组下标越界,范围请在0~"+(size-1));
        }
        return (E) objs[index];
    }

    //获得存储内容的个数
    @Override
    public int size() {
        return size;
    }

    //修改元素
    @Override
    public boolean set(int index, E obj) {
        try {
            checkedIndex(index); //检查下标合法性
            objs[index]=obj;
            return true; //把用户输入的值赋值给指定的下标
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    //删除元素
    @Override
    public boolean remove(int index) {
        try {
            checkedIndex(index); //判断下标的合法性
            System.arraycopy(objs,index+1,objs,index,size-1-index);
            //objs[size-1]=null; //把最后一个元素清空
            //size--;
            //这一步操作相当于上面两步实现
            objs[--size]=null;
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    //根据内容删除元素
    @Override
    public boolean remove(E obj) {
        for (int i = 0; i <size ; i++) {
            if (obj.equals(objs[i])){
                return remove(i);
            }
        }
        return false;
    }

    //对检查下标方法的提取
    private void checkedIndex(int index){
        if (index<0||index>=size){
            throw new ArrayIndexOutOfBoundsException("数组下标越界,范围请在0~"+(size-1));
        }

    }
}

自定义异常

public class ArraysOutOfException extends RuntimeException{

    public ArraysOutOfException(){
        super();
    }

    public ArraysOutOfException(String msg){
        super(msg);
    }
}

底层删除功能的实现

public class Test02 {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5,10,6};
        //删除下标为3的元素
        int index=3;
        /*
        参数一: 源数组(需要拷贝元素的数组)
        参数二:从哪个下标开始拷贝
        参数三:新数组
        参数四:新数组添加到指定元素的下标
        参数五:拷贝元素的长度
         */
        System.arraycopy(arr,index+1,arr,index,arr.length-1-index);
        arr[arr.length-1]=0;

        System.out.println(Arrays.toString(arr));
    }
}

实体类

public class Student {
    private String id;
    private String name;
    private Gender sex;
    private Integer age;
    private String addr;

    public Student() {
    }

    public Student(String id, String name, Gender sex, Integer age, String addr) {
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.addr = addr;
    }

    public Student(String id, String name, Integer age, String addr) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.addr = addr;
    }

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public Gender getSex() {
        return sex;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(id, student.id) &&
                Objects.equals(name, student.name) &&
                sex == student.sex &&
                Objects.equals(age, student.age) &&
                Objects.equals(addr, student.addr);
    }

    @Override
    public String toString() {
        return "Student{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", sex=" + sex +
                ", age=" + age +
                ", addr='" + addr + '\'' +
                '}';
    }
}

枚举类

public enum Gender {
    男,女
}

测试类

ublic class Test01 {
    //创建集合
    private static MyArrAyList<Student> list = new MyArrAyListImpl();
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); //创建扫描器对象
        System.out.println("-----------欢迎使用学生管理系统------------");
         //创建集合对象,并将泛型类型设置为Student类型
        while (true) {
            System.out.println("1.添加学生");
            System.out.println("2.查询学生");
            System.out.println("3.修改学生");
            System.out.println("4.删除学生");
            System.out.println("5.退出系统");
            int i = scanner.nextInt(); //将用户输入的信息赋值给i
            switch (i){
                case 1:
                    System.out.println("请输入学生姓名:");
                    String name = scanner.next();
                    System.out.println("请输入学生性别(0.女 1.男):");
                    int sex = scanner.nextInt();
                    System.out.println("请输入学生年龄:");
                    int age = scanner.nextInt();
                    System.out.println("请输入学生住址:");
                    String addr = scanner.next();

                    String id = System.currentTimeMillis()+"";  //获取唯一的学生id的标识,并且赋值给id

                    Student stu = new Student(id,name,age,addr); //创建用户并通过构造方法,将用户的变量值放进去
                    if (sex==0){  //判断用户输入的是否为0,是的话就输出女,否则就输出男
                        stu.setSex(Gender.女);  //设置性别为女
                    }else {
                        stu.setSex(Gender.男); //设置性别为男
                    }
                    list.add(stu);  //将学生对象信息放到集合里面
                    System.out.println(stu);  //通过toString方法进行学生信息查看
                    break;
                case 2:
                    System.out.println("Id"+"\t\t\t\t"+"姓名"+"\t\t"+"性别"+"\t\t"+"年龄"+"\t\t"+"家庭住址");
                    for (int j = 0; j <list.size();j++) {  //通过获取集合的长度进行循环
                        Student s = list.get(j);  //从集合中取出每个对象,并返回学生对象
                        //通过get/set方法得到每个学生的属性,进行打印输出
                        System.out.println(s.getId()+"\t"+s.getName()+"\t\t"+s.getSex()+"\t\t\t"+s.getAge()+"\t\t\t"+s.getAddr());
                    }
                    break;
                case 3:
                    System.out.println("请输入学生的id");
                    String s2 = scanner.next();  //将用户输入的id信息赋值给s2
                    Student student1 = findStudentById(s2);  //用户输入的id信息赋值给学生对象

                    if (student1==null){
                        System.out.println("查无此人!!");
                        break;
                    }
                    System.out.println("id为:"+student1.getId()+"旧的地址为"+student1.getAddr());  //得到用户的id和用户的住址
                    System.out.println("请输入新的地址:");
                    String addr2 = scanner.next();  //将用户输入的新的地址赋值给addr2
                    student1.setAddr(addr2);  //设置用户的新地址
                    System.out.println("修改成功!!");
                    break;
                case 4:
                    System.out.println("是否确定删除学生信息:(y/n)");
                    String s1 = scanner.next();  //用户输入的退出的信息赋值给s1
                    if (!("y".equals(s1))){      //用户输入的值不等于y,就跳出switch循环
                        break;
                    }
                    System.out.println("请输入学生的id");
                    String s3 = scanner.next();  //将用户输入的id信息赋值给s3

                    Student student2 = findStudentById(s3);  //给用户输入id信息赋值给学生对象

                    if (student2==null){   //通过id查询学生对象里的信息,如果学生信息为null,就判断并跳出switch循环
                        System.out.println("查无此人!!");
                        break;
                    }

                    boolean f = list.remove(student2);   //通过集合删除学生对象信息
                    if (f){   //返回值为true证明删除成功,false证明删除失败
                        System.out.println("删除成功!!");
                    }else {
                        System.out.println("删除失败!!");
                    }
                    break;
                case 5:
                    System.out.println("感谢使用本系统");
                    return;
                default:
                    System.out.println("编号输入错误!");
            }
        }
    }
    //list={Student1,Student2,Student3}

    public static Student findStudentById(String sid){  //定义一个共用方法将形参接收用户传过来的参数
        //根据学生Id 进行信息查询
        for (int i = 0; i <list.size(); i++) {  //循环获取用户每次输入的学生信息,通过集合储存然后取出每个学生的对象
            if (sid.equals(list.get(i).getId())){ //用户输入的id和集合里面储存id作比较,并且给这个比较后的id返回给这个方法
                    return list.get(i);
            }
        }
        return null;  //集合里面找不到学生对象id时,就会返回null
    }

}