数组的实现及分析

我只是很简单的仿照了jdk的ArrayList类的源码实现了一下,总体来说还是很简单,后面也有对数组的总结和分析,来都来了,建议看着理解一下。

实现:

import java.util.Arrays;

public class IArray<E> {
	// 定义一个数组
	private Object[] intArray;
	// 定义数组的实际有效长度
	private int elems;
	// 定义数组的最大长度
	private int length;

	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

	// 默认构造一个长度为10的数组
	public IArray() {
		this(10);
	}

	// 构造函数,初始化一个长度为length 的数组
	public IArray(int initialCapacity) {
		if (length < 0)
			throw new IllegalArgumentException("Illegal Capacity: " + length);
		elems = 0;
		this.length = initialCapacity;
		intArray = new Object[length];
	}

	/**
	 * 获取数组的有效长度
	 * 
	 * @return
	 */
	public int Size() {
		return elems;
	}

	/**
	 * 遍历显示元素
	 */
	public void print() {
		for (int i = 0; i < elems; i++) {
			System.out.print(intArray[i] + " ");
		}
		System.out.println();
	}

	/**
	 * 添加元素
	 * 
	 * @param value,假设操作人是不会添加重复元素的,如果有重复元素对于后面的操作都会有影响。
	 * @return添加成功返回true,添加的元素超过范围了返回false
	 */
	public boolean add(Object value) {
		isGrow(elems + 1);
		intArray[elems] = value;
		elems++;
		return true;
	}

	/**
	 * 给数组扩容
	 */
	private void isGrow(int minCapacity) {
		if (minCapacity < length)
			return;
		int oldCapacity = length;
		int newCapacity = oldCapacity + (oldCapacity >> 1);// 扩大原来的一半
		newCapacity = (newCapacity > MAX_ARRAY_SIZE) ? MAX_ARRAY_SIZE : newCapacity;
		this.length = newCapacity;
		intArray = Arrays.copyOf(intArray, length);
	}

	/**
	 * 根据下标获取元素
	 * 
	 * @param i
	 * @return查找下标值在数组下标有效范围内,返回下标所表示的元素 查找下标超出数组下标有效值,提示访问下标越界
	 */
	public Object get(int i) {
		if (i < 0 || i > elems) {
			System.out.println("访问下标越界:" + i);
			throw new ArrayIndexOutOfBoundsException();
		}

		else
			return intArray[i];

	}

	/**
	 * 查找元素
	 * 
	 * @param searchValue
	 * @return查找的元素如果存在则返回下标值,如果不存在,返回 -1
	 */
	public int find(Object searchValue) {
		int i;
		for (i = 0; i < elems; i++) {
			if (intArray[i] == searchValue) {
				break;
			}
		}
		if (i == elems) {
			return -1;
		}
		return i;
	}

	/**
	 * 删除元素
	 * 
	 * @param value
	 * @return如果要删除的值不存在,直接返回 false;否则返回true,删除成功
	 */
	public boolean delete(Object value) {
		int k = find(value);
		if (k == -1) {
			return false;
		} else {
			if (k == elems - 1) {
				elems--;
			} else {
				for (int i = k; i < elems - 1; i++) {
					intArray[i] = intArray[i + 1];
				}
				elems--;
			}
			return true;
		}
	}

	/**
	 * 修改数据
	 * 
	 * @param oldValue原值
	 * @param newValue新值
	 * @return修改成功返回true,修改失败返回false
	 */
	public boolean modify(Object oldValue, Object newValue) {
		int i = find(oldValue);
		if (i == -1) {
			System.out.println("需要修改的数据不存在");
			return false;
		} else {
			intArray[i] = newValue;
			return true;
		}
	}

}

测试:

		IArray<Integer> iArray = new IArray<Integer>(2);
		System.out.println(iArray.Size());
		iArray.add(1);
		iArray.add(2);
		iArray.add(3);
		iArray.add(4);
		iArray.add(5);

		System.out.println(iArray.Size());
		System.out.println(iArray.get(3));
		System.out.println(iArray.find(6));
		iArray.print();

		if (iArray.delete(2)) {
			System.out.println("删除成功!");
		} else {
			System.out.println("删除成功!");
		}

数组的优缺点分析:

  • 插入块,上面我们实现的是一个无序数组,无序数组的插入速度为1,但是如果是有序数组的话,就很慢了,首先要找到插入的位置,然后再将后面的元素整体向后移位,复杂度为n。

  • 查找慢,如果我们查找是根据数组的下标来,查找速度就很快,为1,但这实际中这么查没意义,如果使用哈希表就不一样了。有序数组的查找速度为log n,无序的为n。

  • 删除慢,根据元素值删除,我们要先找到该元素所处的位置,然后将元素后面的值整体向前面移动一个位置,复杂度为n。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yelvens

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值