不要小瞧数组

定义

所谓数组，是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按无序的形式组织起来的一种形式。这些无序排列的同类数据元素的集合称为数组。

代码实现

package com.company;

public class Array<E> {
    // 泛型数组
    private E[] data;
    // 存储元素数量
    private int size;

    // 构造函数
    public Array(){
        this(10);
    }

    //构造函数
    public Array(int capacity){
        data = (E[]) new Object[capacity];
        size = 0;
    }

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

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

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

    // 向数组头部插入元素
    public void addFirst(E elem){
        for (int i = size; i >= 0; i--) {
            data[i + 1] = data[i];
        }
        data[0] = elem;
        size++;
    }

    // 向数组末尾添加元素
    public void addLast(E elem){
        if (size == data.length){
            resize(data.length * 2);
        }
        data[size++] = elem;
    }

    // 向指定位置插入元素
    public void add(int index, E elem){
        if (size == data.length){
            resize(data.length * 2);
        }
        if (index < 0 || index > size){
            throw new IllegalArgumentException("Illegal insertion position");
        }
        for (int i = size - 1; i > index - 1; i--) {
            data[i + 1] = data[i];
        }
        data[index] = elem;
        size++;
    }

    // 获取索引对应的元素
    public E get(int index){
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("Array Index Overflow");
        }
        return data[index];
    }

    // 获取第一个元素
    public E getFirst(){
        return get(0);
    }

    // 获取最后一个元素
    public E getLast(){
        return get(size - 1);
    }

    // 修改索引对应的元素
    public void set(int index, E elem){
        if (index < 0 || index >= size){
            throw new IllegalArgumentException("Illegal insertion position");
        }
        data[index] = elem;
    }

    // 判断是否存在该元素
    public boolean contains(E elem){
        for (int i = size; i > 0; i--) {
            if (data[i].equals(elem)){
                return true;
            }
        }
        return false;
    }

    // 查找元素对应的索引
    public int find(E elem){
        for (int i = 0; i < size; i++) {
            if (data[i].equals(elem)){
                return i;
            }
        }
        return -1;
    }

    // 删除指定索引的元素
    public E remove(int index){
        E ret = data[index];
        for (int i = index;i < size;i++){
            data[i] = data[i+1];
        }
        size--;
        data[size] = null;
        if (size == data.length / 2 && data.length /2 != 0){
            resize(data.length / 2);
        }
        return ret;
    }

    // 从头部删除元素
    public E removeFirst(){
        return remove(0);
    }

    // 从尾部删除元素
    public E removeLast(){
        return remove(size -1);
    }

    // 删除指定元素
    public void removeElem(E elem){
        int index = find(elem);
        if (index != -1)
        {
            remove(index);
        }
    }

    // 修改数组容量
    private void resize(int newCapacity){
        E[] newData = (E[]) new Object[newCapacity];
        for (int i = 0; i < data.length; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

    @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();
    }
}

标签：index,不要,小瞧,int,数组,return,data,public,size
来源： http://blog.51cto.com/13559120/2350901