数据结构学习（一）：数组<JAVA>_array<student>-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_37768971/article/details/87988194

本文详细介绍了自定义Array类的实现过程，包括数组的基本操作如增删查改，以及动态数组和泛型的应用。通过具体示例展示了如何在Java中实现这些功能，并附带测试代码和运行结果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

2019年2月27日第一次书写......

2019年7月20日第二次书写并修改完善......

一：学习之路

从今天开始数据结构的学习，并通过优快云记录自己的学习之路，加油哦！！！

二：实现内容：

1.Array类里面实现的众多数组的基本操作，包括增、删、查、改等方法；

2.main函数里面完成了对Array方法的测试，并通过println显示测试结果；

3.补充了动态数组以及泛型的方法，使得功能更加全面。

三：代码及注释

1.Array类：

package IMUHERO;
public class Array<E>{
    //基本参数，size表示当前元素的个数,capacity表示设定的容量大小，data是内部存储结果的数组
    private int size=0;
    private int capacity;
    private E [] data ;

    //有参构造方法
    public Array(int capacity){
        this.capacity=capacity;
        data= (E[])new Object[capacity];
    }
    //无参构造方法
    public Array(){
        this(10);
    }

    //初始的简单方法，获得元素个数、判断是否为空、获得数组容量大小
    public int getSize(){
        return size;
    }
    public boolean isEmpty(){
        return size==0;
    }
    public int getCapacity(){
        return capacity;
    }

    //向任意下标index中插入元素e
    public void  add(int index,E e){
        //size的隐含意义是最后一个元素下标＋1
        if (index>size||index<0) {
            throw new IllegalArgumentException("Index is illegal!");
        }
        //将要插入位置后面的所有元素向后移动
        for (int i=size;i>index ; i--) {
            data[i]=data[i-1];
        }
        data[index] = e;
        size++;//注意要维护size
        if (size==capacity) {
            resize(2*capacity);
        }
    }

    //向数组头添加元素
    public void addFirst(E e){
        add(0,e);
    }

    //向数组尾添加元素
    public void addLast(E e){
        add(size,e);
    }

    //删除下标为index的元素
    public E remove(int index){
        E res = data[index];
        if (index>=size||index<0) {
            throw new IllegalArgumentException("Index is illegal!");
        }
        for (int i=index;i<size-1;i++ ) {
            data[i]=data[i+1];
        }
        size--;//注意要维护size

        //注意capacity/2！=0是隐含条件
        if (size==capacity/4&&capacity/2!=0) {
            resize(capacity/2);
        }
        return res;//返回删除掉的元素值res
    }

    //删除数组头的元素
    public E removeFirst(){
        return remove(0);
    }

    //删除数组尾的元素
    public E removeLast(){
        return remove(size-1);
    }

    //修改下标为Index的元素值为e，并返回原值
    public E set(int index,E e ){
        if (index>=size||index<0) {
            throw new IllegalArgumentException("Index is illegal!");
        }
        E res = data[index];
        data[index]=e;
        return res;//返回修改掉的元素值res
    }

    //查找下标为index处的元素值
    public E get(int index){
        if (index>=size||index<0) {
            throw new IllegalArgumentException("Index is illegal!");
        }
        return data[index];
    }

    //查找数组中是否包含元素e
    public boolean contain(E e){
        for (int i=0;i<size ;i++ ) {
            if (data[i].equals(e)) {
                return true;
            }
        }
        return false;
    }

    // 查找数组中元素e所在的索引，如果不存在元素e，则返回-1
    public int find(E e){
        for(int i = 0 ; i < size ; i ++){
            if(data[i].equals(e))
                return i;
        }
        return -1;
    }

    //删除第一次出现e的元素，并返回它的下标；如果不存在，返回-1
    public int removeElement(E e){
        int index = find(e);
        if(index != -1){
            remove(index);
        }
        return index;
    }

    //动态数组的resize方法
    public void resize(int newCapacity){
        E [] newData = (E[])new Object[newCapacity];
        for (int i=0; i<size; i++) {
            newData[i]=data[i];
        }
        data=newData;
        capacity=newCapacity;
    }

    @Override
    public String toString(){
        StringBuffer str=new StringBuffer();
        str.append(String.format("Array: size = %d , capacity = %d\n", size, capacity));
        str.append("[");
        for (int i=0;i<size ; i++) {
            str.append(data[i]);
            if (i!=size-1) {
                str.append(",");
            }
        }
        str.append("]");
        return str.toString();
    }
}

2.main函数：

①测试动态数组等多功能

package IMUHERO;

public class Main {

    public static void main(String[] args) {
	// write your code here
        Array<Integer> test=new Array<>();

        System.out.println("********************向数组尾添加十个元素：*******************");
        for (int i=0;i<10;i++){
            test.addLast(i);
        }
        System.out.println(test);//触发扩容机制

        System.out.println("********************向数组头插入一个元素：100*******************");
        test.addFirst(100);
        System.out.println(test);

        System.out.println("********************向下标为2的位置插入一个元素：200*******************");
        test.add(2,200);
        System.out.println(test);

        System.out.println("********************删除下标为2的元素：200*******************");
        test.remove(2);
        System.out.println(test);

        System.out.println("********************删除数组头的元素：100*******************");
        test.removeFirst();
        System.out.println(test);

        System.out.println("********************删除数组尾的元素：9*******************");
        test.removeLast();
        System.out.println(test);

        System.out.println("********************修改下标2的元素为300*******************");
        test.set(2,300);
        System.out.println(test);

        System.out.println("********************查找下标2的元素值*******************");
        System.out.println("下标2处的值为："+test.get(2));

        System.out.println("********************查找数组是否包含某个元素e*******************");
        System.out.println("e==300："+test.contain(300));
        System.out.println("e==400："+test.contain(400));

        System.out.println("********************查找下标元素300的下标值*******************");
        System.out.println("元素300的下标为："+test.find(300));

        System.out.println("********************删除6个元素，查看容量情况*******************");
        for(int i=0;i<7;i++){
            test.removeLast();
        }
        System.out.println(test);
    }
}

result：

********************向数组尾添加十个元素：*******************
Array: size = 10 , capacity = 20
[0,1,2,3,4,5,6,7,8,9]
********************向数组头插入一个元素：100*******************
Array: size = 11 , capacity = 20
[100,0,1,2,3,4,5,6,7,8,9]
********************向下标为2的位置插入一个元素：200*******************
Array: size = 12 , capacity = 20
[100,0,200,1,2,3,4,5,6,7,8,9]
********************删除下标为2的元素：200*******************
Array: size = 11 , capacity = 20
[100,0,1,2,3,4,5,6,7,8,9]
********************删除数组头的元素：100*******************
Array: size = 10 , capacity = 20
[0,1,2,3,4,5,6,7,8,9]
********************删除数组尾的元素：9*******************
Array: size = 9 , capacity = 20
[0,1,2,3,4,5,6,7,8]
********************修改下标2的元素为300*******************
Array: size = 9 , capacity = 20
[0,1,300,3,4,5,6,7,8]
********************查找下标2的元素值*******************
下标2处的值为：300
********************查找数组是否包含某个元素e*******************
e==300：true
e==400：false
********************查找下标元素300的下标值*******************
元素300的下标为：2
********************删除6个元素，查看容量情况*******************
Array: size = 2 , capacity = 5
[0,1]

②实现Student的泛型操作

代码：

Student类：


public class Student {
    private String name;
    private int scores;
    Student (String name ,int scores){
        this.name=name;
        this.scores=scores;
    }
    @Override
    public String toString(){
        return String.format("%s的成绩是：%d",name,scores);
    }
}

main:

package IMUHERO;

public class main {
    public static void main(String[] args) {
    Array<Student>student=new Array<>();
        student.addLast(new Student("xiaoming",100));
        student.addLast(new Student("xiaoli",90));
        student.addFirst(new Student("xiaoxiao",80));
        System.out.println(student);
        Array<String>str=new Array<>();
        str.addLast("one");
        str.addLast("two");
        str.addLast("three");
        System.out.println(str);
    }
}

result：

Array: size = 3 , capacity = 10
[xiaoxiao的成绩是：80, xiaoming的成绩是：100, xiaoli的成绩是：90]
Array: size = 3 , capacity = 10
[one, two, three]