Hi，大家好，我是编程小6，很荣幸遇见你，我把这些年在开发过程中遇到的问题或想法写出来，今天说一说Java动态数组,希望能够帮助你!!!。

1.Java动态数组的用法详解

     Java动态数组是一种可以任意伸缩数组长度的对象，在Java中比较常用的是ArrayList，ArrayList是javaAPI中自带的java.util.ArrayList。下面介绍一下ArrayList作为Java动态数组的用法。

 语法：add()是添加一个新的元素,remove()删除一个元素,size()获得ArrayList的长度。ArrayList的下标是从0开始。

import java.util.ArrayList;
 
public class JavaArrayList {
	public static void main(String[] args) {
		// Java动态数组的初始化
		ArrayList al = new ArrayList();
		// 向Java动态数组中添加数据
		al.add("a");
		al.add("b");
		al.add("c");
		// 输出Java动态数组
		for (int i = 0; i < al.size(); i++) {
			String alEach = (String) al.get(i);
			System.out.println(alEach);
		}
		// 删除数组中的某个元素,删除第二个元素
		al.remove(1);
		// 修改Java动态数组，把新的元素放到第二个位置
		al.add(1, "2");
		// //输出Java动态数组
		for (int i = 0; i < al.size(); i++) {
			String alEach = (String) al.get(i);
			System.out.println(alEach);
		}
	}
}

2.动态数组实现(ArrayList原理)

2.1 什么是数组

        同类数据元素的集合，在计算机中以连续的地址存储，编译时确定长度，无法改变。

2.2 什么是动态数组

       数据结构中顺序表的物理实现，同类数据元素的集合，在计算机中以连续的地址存储，大小在创建时决定，但是可以改变。

2.3 为什么使用动态数组

       支持随机访问,查询速度快。但是插入和删除都需要移动元素，比起链表开销较大。如：java集合类中的ArrayList Vector等

2.4 动态数组实现代码(ArrayList原理)

/**
 * 顺序表的实现
 * @author chengh
 * @param 
 */
public class ArrayList<E> {
    private Object[] data = null; // data: 用来保存此线性表数据的数组
    private int capacity; // capacity： 线性表的容量
    private int current; // current： 当前数据的下标
    /**
     * 初始化为声明大小，则设置为10。
     */
    ArrayList() {
        this(10);
    }
    /**
     * 初始化线性表，声明保存数据的数组大小。
     * @param initialSize 顺序表的初始化大小
     */
    ArrayList(int initialSize) {
        if (initialSize >= 0) {
            this.capacity = initialSize;
            data = new Object[initialSize];
            current = 0;
        } else {
            throw new RuntimeException("初始化大小不能小于0：" + initialSize);
        }
    }
    /**
     * 在线性表的末尾添加元素，添加之前确认线性表是否已满
     * @param e 待加入的元素
     * @return
     */
    public boolean AddElement(E e) {
        ensureCapacity();
        data[current] = e;
        ++current;
        return true;
    }
    /**
     * 检查存储数据的数组容量，如果数组已经满，则扩充容量；否则不操作。
     */
    private void ensureCapacity() {
        int index;
        if (current == capacity) {
            capacity *= 2;
            Object[] newData = new Object[capacity];
            for(index = 0; index < current; ++index) {
                newData[index] = data[index];
            }
            data = newData;
        }
    }
    /**
     * 返回下标为index的元素
     * @param index 欲取得元素的下标
     * @return
     */
    public E get(int index) {
        validateIndex(index);
        return (E) data[index];
    }
    /**
     * 
     * @param index 待插入的位置
     * @param e 待插入的元素
     * @return
     */
    public boolean set(int index, E e) {
        validateIndex(index);
        data[index] = e;
        return true;
    }
    /**
     * 验证下标值是否合法，非法时抛出异常
     * @param index 待验证的下标值
     */
    private void validateIndex(int index) {
        if (index < 0 || index > current) {
            throw new RuntimeException("无效的下标：" + index);
        }
    }
    /**
     * 返回当前顺序表的大小
     * @return
     */
    public int size() {
        return current;
    }
    /**
     * 在指定位置插入指定元素
     * @param index 待插入的位置
     * @param e 待插入的元素
     * @return
     */
    public boolean insert(int index, E e) {
        validateIndex(index);
        ensureCapacity();
        for (int temp = current; temp > index; --temp) {
            data[temp] = data[temp - 1];
        }
        data[index] = e;
        return true;
    }
    /**
     * 删除下标为index元素
     * @param index 待删除元素的下标
     * @return
     */
    public boolean delete(int index) {
        validateIndex(index);
        for ( ; index < current - 1; ++index) {
            data[index] = data[index + 1];
        }
        data[current - 1] = null;
        --current;
        return true;
    }
    @Override
    public String toString() {
        String str = "[ ";
        for (Object o : data) {
            if (o != null) {
                str += o + " ";
            }
        }
        str += "]";
        return str;
    }
} 

今天的分享到此就结束了，感谢您的阅读，如果确实帮到您，您可以动动手指转发给其他人。