使用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);
    }
}

使用Java动态数组的实现相关推荐

Java动态数组的用法详解
Java动态数组是一种可以任意伸缩数组长度的对象,在Java中比较常用的是ArrayList,ArrayList是javaAPI中自带的java.util.ArrayList.下面介绍一下ArrayL ...
java 动态数组_Java动态数组的用法详解
Java动态数组是一种可以任意伸缩数组长度的对象,在Java中比较常用的是ArrayList,ArrayList是javaAPI中自带的java.util.ArrayList.下面介绍一下ArrayL ...
java动态数组的实现的_基于Java的动态数组分析与实现
动态数组概念基于Java提供的静态数组封装自己的动态数组,动态数组涉及的组成部分如下图所示. 组成部分解读data:静态数组,通过泛型支持多种类型的元素:private E[] data;. si ...
java动态数组的实现的_Java实现数据结构之【动态数组】
数组是学习编程语言时较先接触到的一种数据结构,本章基于Java的静态数组实现动态数组,并进行简单的复杂度分析数组相信各位都知道,那什么是动态数组呢?我们定义一个数组后,一般长度会直接定义好,如果数组 ...
自定义实现Java动态数组
写在前面通常,我们会用高级程序语言中的数组来描述线性表的顺序存储结构,而这种顺序表的特点时逻辑顺序与物理顺序相同,即数组中元素的内存地址是连续的. 那么很显然,这样的数组(静态数组)在空间被占满后再 ...
Java动态数组和泛式
1.认识动态数组和泛式之前我们所使用的数组最大的问题在于其可操作性弱,当我们定义完一个数组并存入相应元素后,很难对其中的元素做出增减操作,且数组的长度也不可变,当我们要存入超出数组长度的元素时,就需 ...
java动态数组的实现_动手编写—动态数组（Java实现）
目录数组基础回顾自定义动态数组动态数组的设计抽象父类接口设计抽象父类设计动态数组之DynamicArray 补充数组缩容全局的关系图声明数组基础回顾 1.数组是一种常见的数据结构,用 ...
Java动态数组和静态数组详解
前言必读读者手册(必读)_云边的快乐猫的博客-CSDN博客数组: 概念:数组就是存储数据长度固定的容器,保证多个数据的数据类型要一致,不能出现混合类型 1.什么数据类型就只能储存什么数据元素,比 ...
java 动态数组的应用
import java.util.*; import java.util.GregorianCalendar; /** * 测试数组列表的功能 * @author Administrator * */ ...

使用Java动态数组的实现

使用Java动态数组的实现相关推荐

最新文章

热门文章