java数组的动态输入 java中动态数组

使用Java中的数组

int[] arr=new int[10];
for(int i=0;i<arr.length;i++)
    arr[i]=i;
int[] scores =new int[]{100,99,66};
for (int i=0;i<scores.length;i++)
    System.out.println(scores[i]);
for(int score:scores)
    System.out.println(score);
scores[0]=98;
for(int score:scores)
    System.out.println(score);

自己实现的动态数据

public class Array<E> {
    private E[] data;
    private int size;

    /**
     *构造函数，传入数组的容量capacity构造Array
     */
    public Array(int capacity){
        data = (E[])new Object[capacity];
        size=0;
    }

    /**
     * 无参数的构造函数，默认数组的容量capacity=10
     */
    public Array(){
        this(10);
    }

    //获取数组中的元素个数
    public int getSize(){
        return size;
    }

    // 获取数组的容量
    public int getCapacity(){
        return data.length;
    }

    // 返回数组是否为空
    public boolean isEmpty(){
        return  size==0;
    }

    // 向所有元素后添加一个新元素,O(1)
    public void addLast(E e){
//        if(size==data.length)
//            throw new IllegalArgumentException("AddLast failed!");
//        data[size]=e;
//        size++;
     add(size,e);
    }

    // 在所有元素前添加一个新元素,O(1)
    public void addFirst(E e){
        add(0, e);
    }

    //在第index个位置插入一个新元素e,O(n/2)=O(n)
    public void add(int index,E e) {
        if (index < 0 || index > size)
            throw new IllegalArgumentException("Add failed!,Require index >= 0 and index <= size.");

        if (size == data.length)
            resize(2*data.length);

        for(int i = size-1;i>=index;i--)
            data[i+1]=data[i];
        data[index]=e;
        size++;
    }

    //获取index索引位置的元素,O(1)
    public E get(int index){
        if(index<0 || index>=size)
            throw new IllegalArgumentException("Get failed.Index is illegal.");
        return data[index];
    }

    //修改index索引位置的元素为e,O(1)
    void set(int index,E e){
        if(index<0 || index>=size)
            throw new IllegalArgumentException("Set failed.Index is illegal.");
        data[index]=e;
    }

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

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

    // 从数组中删除index位置的元素, 返回删除的元素,O(n)
    public E remove(int index){
        if(index<0 || index>=size)
            throw new IllegalArgumentException("Remove failed.Index is illegal.");
        E ret=data[index];
        for(int i = index+1;i<size;i++)
            data[i-1]=data[i];
        size--;
        data[size]=null;//loitering objects != memory leak

        if(size == data.length / 2)
            resize(data.length / 2);
        return ret;
    }

    // 从数组中删除第一个元素, 返回删除的元素
    public E removeFirst(){
        return remove(0);
    }

     从数组中删除最后一个元素, 返回删除的元素
    public E removeLast(){
        return remove(size-1);
    }

    // 从数组中删除元素e
    public void removeElement(E e){
        int index=find(e);
        if(index!=-1)
            remove(index);
    }

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

    // 将数组空间的容量变成newCapacity大小
    private void resize(int newCapacity){
        E[] newData=(E[])new Object[newCapacity];
        for(int i=0;i<size;i++)
            newData[i]=data[i];
        data=newData;
    }

}

验证自己实现的动态数组

public class Main {
    public static void main(String[] args) {

//        int[] arr=new int[10];
//        for(int i=0;i<arr.length;i++)
//            arr[i]=i;
//        int[] scores =new int[]{100,99,66};
//        for (int i=0;i<scores.length;i++)
//            System.out.println(scores[i]);
//        for(int score:scores)
//            System.out.println(score);
//        scores[0]=98;
//        for(int score:scores)
//            System.out.println(score);


           Array<Integer> arr=new Array<>();
           for (int i=0;i<10;i++)
               arr.addLast(i);
           System.out.println(arr);

           arr.add(1,100);
           System.out.println(arr);

           arr.addFirst(-1);
           System.out.println(arr);

           arr.remove(2);
           System.out.println(arr);

           arr.removeElement(4);
        System.out.println(arr);

        arr.removeFirst();
        System.out.println(arr);

    }
}

自己定义一个Student类，来验证刚才实现的动态数组

public class Student {

    private String name;
    private int score;

    public Student(String studentname,int studentScore){
        name =studentname;
        score=studentScore;
    }

    @Override
    public String toString(){
        return String.format("Student(name: %s,score: %d)",name,score);
    }

    public static void main(String[] args) {
        Array<Student> arr=new Array<>();
        arr.addLast(new Student("Alice",100));
        arr.addLast(new Student("Bob",66));
        arr.addLast(new Student("David",88));
        System.out.println(arr);
    }
}