[数据结构] - 数组

标签：一个   缺点   遍历   查找   原来   --   容器   存在   插入   

1、Java数组介绍

　　在Java中，数组是用来存放同一种数据类型的集合，注意只能存放同一种数据类型(Object类型数组除外)。

• 在内存中，数组是一块连续的区域。 拿上面的看电影来说，这几个人在电影院必须坐在一起。

• 数组需要预留空间，在使用前要先申请占内存的大小，可能会浪费内存空间。 比如看电影时，为了保证10个人能坐在一起，必须提前订好10个连续的位置。这样的好处就是能保证10个人可以在一起。但是这样的缺点是，如果来的人不够10个，那么剩下的位置就浪费了。如果临时有多来了个人，那么10个就不够用了，这时可能需要将第11个位置上的人挪走，或者是他们11个人重新去找一个11连坐的位置，效率都很低。如果没有找到符合要求的作为，那么就没法坐了。
• 插入数据和删除数据效率低，插入数据时，这个位置后面的数据在内存中都要向后移。删除数据时，这个数据后面的数据都要往前移动。 比如原来去了5个人，然后后来又去了一个人要坐在第三个位置上，那么第三个到第五个都要往后移动一个位子，将第三个位置留给新来的人。 当这个人走了的时候，因为他们要连在一起的，所以他后面几个人要往前移动一个位置，把这个空位补上。
• 随机读取效率很高。因为数组是连续的，知道每一个数据的内存地址，可以直接找到给地址的数据。

• 并且不利于扩展，数组定义的空间不够时要重新定义数组。一种解决办法是封装一次数组，数组元素超过75%时候就动态扩容，新申请一个1.5倍的数组，把原来的数组全部拷贝过去。

①、数组的声明

第一种方式：

数据类型 []  数组名称 = new 数据类型[数组长度];

这里 [] 可以放在数组名称的前面，也可以放在数组名称的后面，我们推荐放在数组名称的前面，这样看上去 数据类型 [] 表示的很明显是一个数组类型，而放在数组名称后面，则不是那么直观。

第二种方式：

数据类型 [] 数组名称 = {数组元素1，数组元素2，......}

　这种方式声明数组的同时直接给定了数组的元素，数组的大小由给定的数组元素个数决定。

//声明数组1,声明一个长度为3，只能存放int类型的数据
int [] myArray = new int[3];
//声明数组2,声明一个数组元素为 1,2,3的int类型数组
int [] myArray2 = {1,2,3};

②、访问数组元素以及给数组元素赋值

　　数组是存在下标索引的，通过下标可以获取指定位置的元素，数组小标是从0开始的，也就是说下标0对应的就是数组中第1个元素，可以很方便的对数组中的元素进行存取操作。

　　前面数组的声明第二种方式，我们在声明数组的同时，也进行了初始化赋值。
　　
　

//声明数组,声明一个长度为3，只能存放int类型的数据
int [] myArray = new int[3];
//给myArray第一个元素赋值1
myArray[0] = 1;
//访问myArray的第一个元素
System.out.println(myArray[0]);

上面的myArray 数组，我们只能赋值三个元素，也就是下标从0到2，如果你访问 myArray[3] ，那么会报数组下标越界异常。

③、数组遍历

　　数组有个 length 属性，是记录数组的长度的，我们可以利用length属性来遍历数组。
　　

//声明数组2,声明一个数组元素为 1,2,3的int类型数组
int [] myArray2 = {1,2,3};
for(int i = 0 ; i < myArray2.length ; i++){
    System.out.println(myArray2[i]);
}

2、简单封装一个动态数组

package me.liangtian.array;
 
public class Array<E> {
    /**
     * 存放数据的数组
     */
    private E[] data;
    /**
     * 数组中现有数据量
     */
    private int size;
    
    public Array(int capacity) {
        data = (E[])new Object[capacity];
        size = 0;
    }
    /**
     * 默认数组长度10
     */
    public Array() {
        new Array<>(10);
    }
    /**
     * 得到数组长度
     */
    public int getCapacity() {
        return data.length;
    }
    /**
     * 已有数组大小
     */
    public int getSize() {
        return size;
    }
    /**
     * 判断数组是否为空
     */
    public boolean isEmpty() {
        return size == 0;
    }
    /**
     * 索引index处添加一个元素
     * 1.判断索引是否有效
     * 2.判断数组是否已经满了，若满了那么扩容
     * 3.从后往前，index处的元素后移一个位置
     * 4.index索引处元素赋值
     * 5.size++
     */
    public void add(int index, E e) {
        if(index < 0 || index > size) {
            throw new IllegalArgumentException("add failed, index must between 0 and size");
        }
        if(index == size) {
            resize( 2 * data.length);
        }
        for (int i = size -1; i >= index; i--) {
            data[i+1] = data[i];
        }
        data[index] = e;
        size++;
    }
    /**
     * 在尾部添加新元素
     */
    public void addLast(E e) {
        add(size, e);
    }
    /**
     * 在头部添加新元素
     */
    public void addFirst(E e) {
        add(0, e);
    }
    
    /**
     * 是否包含否个元素
     */
    public boolean contains(E e) {
        for (E e1 : data) {
            if(e1.equals(e)) {
                return true;
            }
        }
        return false;
    } 
    
    /**
     * 动态扩容
     * 1.新建一个容器，大小为指定大小newCapacity
     * 2.将之前的容器的元素按原有顺序放到新的容器中
     * 3.将原指针指向新容器
     */
    private void resize(int newCapacity) {
        E[] newDate = (E[]) new Object[newCapacity];
        for(int i = 0; i < size; i++) {
            newDate[i] = data[i];
        }
        data = newDate;
    }
    /**
     * 查找元素E在数组中的索引
     * 1.遍历所有的数组，若匹配到(equals非==)那么返回索引，否则返回-1
     */
    private int find(E e) {
        for (int i = 0; i < data.length; i++) {
            if(data[i].equals(e)) {
                return i;
            }
        }
        return -1;
    }
    
    /**
     * 删除元素并返回删除之前的位置
     * 若不存在则返回-1
     */
    public int removeElement(E e) {
        int index = find(e);
        if(index != -1) {
            remove(index);
        }
        return index;
    }
    /**
     * 根据索引删除元素,并返回删除元素
     * 1.判断索引是否有效
     * 2.将索引处的元素保存到单独一个变量，用于返回
     * 3.将所有元素左移，索引从小到大
     * 4.将size索引处的元素清空，并且size-1
     * 5.均摊算法复杂度。为防止算法复杂度振荡，只有size <= data.leng/4 那么重新调整数组大小为原大小二分之一
     *   注意数组容器大小不能为0
     */
    private E remove(int index) {
        if(index < 0 || index >= size) {
            throw new IllegalArgumentException("index must between 0 and size -1");
        }
        E removeData = data[index];
        for(int i = index + 1; i < size; i++) {
            data[i-1] = data[i];
        }
        data[index] = null;
        size--;
        if(size <= data.length/4 && data.length /2 != 0) {
            resize(data.length /2);
        }
        return removeData;
    }
}

[数据结构] - 数组

标签：一个   缺点   遍历   查找   原来   --   容器   存在   插入   

原文地址：https://www.cnblogs.com/gwyy/p/10265820.html