动态数组的存储速度比较 集合框架

集合框架：

自定义数据结构(增删改查等)

package 数组;

/**
 * 创建动态数组
 * @author 百合
 *
 */

public class ArrayDemo{
	
	//定义一个数组来存放数据
	
	String[] src = new String[0];
	
	/**
	 * 增加元素加入容器 
	 * @param s要加入容器的个数
	 */
	public void add(String s){
		//创建一个新的数组，长度为src+1；
		String[] dest = new String[src.length+1];
		//将新加入的数组放在数组的最后一位
		dest[dest.length-1] = s;
		//将src数组的值copy到dest数组里面
		for(int i = 0;i<src.length;i++){
			dest[i] = src[i];
		}
		//将src指向新数组
		src = dest;
	}
		
	
	/**
	 * 获取元素的地址
	 * @param index
	 * @return
	 */
	public String get(int index){
		
		return src[index];
	}
	
	/**
	 * 修改指定位置的元素
	 * @param index修改的元素位置
	 * @param s修改后的新元素
	 */
	public void update(int index,String s){
		if(index >=0 && index<size()){
			src[index]= s;
		}else{
			System.out.println("指定的下标超出范围");
		}
			
	} 
	
	
	/**
	 * 将指定的元素插入到指定的位置
	 */
	public void insert(int index,String s){
				
		if(index>=0 && index <size()){
			String[] dest = new String[src.length+1];
			//将插入的数组放到指定的位置
			dest[index] = s;
			for(int  i  = 0;i < index;i++){
				dest[i] = src[i];
			}
			
			for(int i = index;i<src.length;i++){
				dest[i+1] = src[i];
			}
			
			//将src指新数组
			src = dest;
			
		}else{
			System.out.println("指定的下标超出范围");
		}
	}
	
	/**
	 * 删除指定位置的元素
	 * @param inde下标的元素
	 */
	public void dalete(int index){
		String[] dest = new String[src.length-1];
			
		for(int i = 0;i<index;i++){
			dest[i] = src[i];	
		}
		
		for(int i = index +1;i<src.length;i++ ){
			dest[i-1] = src[i];
		}
		src = dest;
		
	}
	
	/**
	 * 
	 * @return 返回得到容器的元素的个数
	 *
	 */
	public int size(){
		
		return src.length;
	}
}

 

//测试ArrayDemo数组

//泛型的类类型，可以调用方法

package 数组;

public class ArrayTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//获得系统时间
		long t1 = System.currentTimeMillis();
		System.out.println(t1);
		ArrayDemo am = new ArrayDemo();
		am.add("元素1");
		am.add("元素2");
		am.add("元素3");
		am.add("元素4");
		am.add("元素5");
		//am.dalete(4);
		am.insert(0,"元素六");
		
		long t2 = System.currentTimeMillis();
		System.out.println(t2);

	//遍历
		for(int i = 0;i<am.size();i++){
			String num = am.get(i);
			System.out.println(num);
			System.out.println(Math.abs(t2-t1));
		}
		System.out.println(Math.abs(t2-t1));
	}

}

 

 

 

//修改后的数组，使用泛型可以存储任意的类型

 

/**
 * 动态数组，用来装任意类型的动态数组
 * 
 * @author 百合
 * 
 */
public class ArrayQueue<E> {

	private int len = 0;// 长度
	private int initContiner;// 初始容量
	private int rate;// 增长比率
	// 定义一个用来存放数据的数组
	// 初始长度为0，表示没有装任何数据
	Object[] src;

	public ArrayQueue() {
		this.initContiner = 10;
		this.rate = 10;
		src = new Object[initContiner];
	}

	// 创建容器对象的时候指定容量和增长比率
	public ArrayQueue(int initContiner, int rate) {
		this.initContiner = initContiner;
		this.rate = rate;
		src = new Object[initContiner];
	}

	/**
	 * 将指定的元素加入容器
	 * 
	 * @param s
	 *            要加入到容器中的元素
	 */
	public void add(E s) {
		// 如果长度小于容量,就将元素放到数组第一个为null的位置
		if (len >= src.length) {
			// 创建新数组
			// 定义一个新数组，用来装数据,长度比src+1
			Object[] dest = new Object[src.length + rate];
			// 将源数组中的数据按照下标顺序拷贝到新数组
			System.arraycopy(src, 0, dest, 0, len);
			src = dest;

		}
		src[len] = s;

		len++;
	}

	/**
	 * 获取指定下标位置的元素
	 * 
	 * @param index
	 *            要获取的元素的下标
	 * @return 返回获取到的元素
	 */
	public E get(int index) {
		return (E) src[index];
	}

	/**
	 * 修改指定位置元素的值
	 * 
	 * @param index要修改的元素位置
	 * @param s
	 *            修改后的新元素
	 */
	public void update(int index, E s) {
		if (index >= 0 && index < size()) {
			src[index] = s;
		} else {
			System.out.println("指定的下标超出范围！！！");
		}

	}

	/**
	 * 将指定元素插入到指定位置
	 * 
	 * @param index
	 *            要插入元素的位置
	 * @param s
	 *            要插入的新元素
	 */
	public void insert(int index, E s) {
		if (index >= 0 && index < size()) {
			// 定义新数组，长度比原数组+1
			Object[] dest = new Object[src.length + 1];
			// 将新元素放到新数组的指定位置
			dest[index] = s;
			// 将源数组中下标<index,拷贝到新数组相同的下标位置
			for (int i = 0; i < index; i++) {
				dest[i] = src[i];
			}

			// 将源数组中其他下标的元素拷贝到新数组下标+1的位置
			for (int i = index; i < src.length; i++) {
				dest[i + 1] = src[i];
			}
			// 将src指向新数组
			src = dest;

		} else {
			System.out.println("指定的下标超出范围！！！");
		}
	}

	/**
	 * 删除指定位置的元素
	 * 
	 * @param index
	 *            要删除的元素的下标
	 */
	public void delete(int index) {
		if (index >= 0 && index < size()) {
			// 定义新数组，长度是原始数组长度-1
			Object[] dest = new Object[src.length - 1];

			// 如果下标<index,则按下标位置拷贝
			for (int i = 0; i < index; i++) {
				dest[i] = src[i];
			}
			// index位置的值丢掉不需要拷贝

			// >index的下标位置拷贝到新数组下标-1的位置
			for (int i = index + 1; i < src.length; i++) {
				dest[i - 1] = src[i];
			}
			// 将src指向新数组
			src = dest;

		} else {
			System.out.println("指定的下标超出范围！！！");
		}
	}

	/**
	 * 获得容器中元素个数的方法 容器中不为null的元素个数
	 * 
	 * @return 返回元素的个数
	 */
	public int size() {
		return len;
	}
}



//测试
public class MainDemo {

	public static void main(String[] args) {
		// 在创建容器对象的时候，将泛型具体化
		ArrayQueue<String> queue = new ArrayQueue<String>();

		
		//获得系统时间
		long t1 = System.currentTimeMillis();
		
		for (int i = 0; i < 10; i++) {
			queue.add("元素" + i);
		}
		queue.add("新元素");
		
		
		long t2 = System.currentTimeMillis();

		for (int i = 0; i < queue.size(); i++) {
			String s = queue.get(i);
			System.out.println(s);
		}
		System.out.println(Math.abs(t2-t1));
	}

}

 //上述的两个是对数据的存取速度进行比较，第二种的速度比第一种的开辟速度快很多

java的API中有一系列的方法可以供调用，例如：list  set  map等