JAVA数据结构 数组

一  .   数组

1.数组，可以说是JAVA中最常见和简单的数据结构，但是，万不可小瞧了数据，古书有言：大道至简。

2.数组基础

1）数组优点：根据下标快速查询；

2）数组最好应用于“索引有语意”的情况，例如数组int[] scores代表全班同学的成绩，scores[2]应当代表学号为2的同学的成绩。

反之，如果数组的索引没有语意，可以使用别的数据结构。但是，并非所有有语意的索引适合数组，例如身份证，因为18位的身份证号，会占用大量的存储空间。接下来，本人主要研究没有索引语意的数组，基于java数组二次封装属于我们的数组。制作属于我们的数组类：

  class Array 

               size = 0

 

 

下面贴出代码，定义一个泛型的数组，支持动态扩容，支持增、删、改、查。

public class Array<E> {

    private E[] data;
    private int size;

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

    public Array() {
        this(10);
    }

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

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

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

    //向所有元素后添加一个新元素
    public void addLast(E e) {
       add(size,e);
    }

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

    //在特定位置添加元素
    public void add(int index, E e){
        if (size == data.length)
            throw new IllegalArgumentException("数组空间已满");
        if(index < 0 || index > size)
            throw new IllegalArgumentException("index < 0 或者 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++;
    }

    // 动态扩容数组
    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 E get(int index){
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("index < 0 或者 index >= size");
        }
        return data[size];
    }

    public void set(int index, E e) {
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("index < 0 或者 index >= size");
        }
        data[index] = e;
    }

    public boolean contains(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 j = 0; j < size; j++) {
            if(data[j].equals(e)){
                return j;
            }
        }
        return -1;
    }

    //删除指定位置的元素
    public E remove(int index){

        if(index < 0 || index > size)
            throw new IllegalArgumentException("index < 0 或者 index > size");
        E ret = data[index];
        for (int i = index + 1; i < index; i++) {
            data[i-1] = data[i];
        }
        size--;
        data[size] = null;
        //数组缩小缩容
        if(size == data.length/2){
            resize(size/2);
        }
        return ret;
    }

    // 删除第一个元素
    public E removeFirst(){
        return remove(0);
    }

    //删除最后一个元素
    public E removeLast(){
        return remove(size-1);
    }

    public boolean removeElement(E e){
        int index = find(e);
        if(index != -1){
            remove(index);
            return true;
        }
        return false;
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("[");
        for (int i = 0; i < size; i++) {
            res.append(data[i]);
            if(i != size-1){
                res.append(",");
            }
        }
        res.append("]");
        return res.toString();
    }
}