简单动态数组的实现代码

Posted 2020-08-04 coder-lcp

以下是本人动态数组实现的源代码，仅供参考，不足之处请指正：

import java.util.*;
public class My_List implements Collection{
/***************************************************************/
	//测试模块
	//主方法,测试用
	public static void main(String [] args){
		/*
		My_List ma = new My_List();
		//测试add方法
		ma.add("abc");
		ma.add("asdfj");
		System.out.println(ma.size());
		//测试get方法
		System.out.println(ma.get(0));
		System.out.println(ma.get(1));
		//测试add方法二
		ma.add(1,"改变后的值");
		System.out.println(ma.get(1));
		//测试addAll方法
		List lis = new ArrayList();
		lis.add("1");
		lis.add("2");
		lis.add("3");
		ma.addAll(1,lis);
		System.out.println("执行addAll之后的长度" + ma.size());
		System.out.println("执行addAll之后的第四个元素是 " + ma.get(3));
		//测试clear函数
		//ma.clear();
		//System.out.println("clear函数执行之后的元素个数 " + ma.size());
		//测试contains方法
		System.out.println("是否包含1字符串？ " + ma.contains("1"));
		System.out.println("是否包含23字符串？ " + ma.contains("23"));
		
		//lis.add("asddfj");
		//测试containsAll方法
		System.out.println("ma是否包含lis的所有元素？ " + ma.containsAll(lis));
		//测试equals方法
		My_List lis2 = new My_List();
		lis2.add("abc");
		lis2.add("123");
		lis2.add("我和你");
		
		My_List lis3 = new My_List();
		lis3.add("abc");
		lis3.add("123");
		lis3.add("我he");
		boolean b3 = lis2.equals(lis3);
		System.out.println(b3);
		//测试indexOf方法
		//lis.add(null);
		//int index_FirstNull = lis.indexOf(null);
		lis.add("asdjsdfaasdaa");
		lis.add(null);
		System.out.println("3第一次出现的索引为  " + lis.indexOf("3"));
		
		//测试lastIndexOf
		lis.add(null);
		lis.add("我和你");
		lis.add(null);
		lis.add("3");
		System.out.println("最后一次出现我和你的地方  " + lis.lastIndexOf("我和你"));
		//测试isEmpty
		System.out.println("lis.isEmpty ?  " + lis.isEmpty());
		My_List lis_isEmpty = new My_List();
		System.out.println("lis_isEmpty.isEmpty ?  " + lis_isEmpty.isEmpty());
		
		//测试remove
		
		System.out.println("remove之前lis的长度为 " + lis.size());
		System.out.println("remove之前，index = 2的值为  " + lis.get(2));
		System.out.println("remove之前，index = 6的值为  " + lis.get(6));
		//lis.remove(null);
		//lis.remove(10);
		lis.remove(1);
		System.out.println("remove之后lis的长度为 " + lis.size());
		System.out.println("remove之后，index = 1的值为  " + lis.get(1));
		System.out.println("remove之后，index = 4的值为  " + lis.get(4));
		*/
		//removeAll测试
		My_List lis = new My_List();
		lis.add("1");
		lis.add("2");
		lis.add("3");
		lis.add("我和你");
		lis.add(null);
		lis.add("4");
		lis.add("5");
		lis.add("6");
		/*
		System.out.println("removeAll之前lis的长度为 " + lis.size());
		System.out.println("removeAll之前，index = 1的值为  " + lis.get(1));
		List lis_removeAll = new ArrayList();
		lis_removeAll.add("我和你");
		lis_removeAll.add("3");
		lis_removeAll.add(null);
		lis.removeAll(lis_removeAll);
		
		//System.out.println("removeAll之前，index = 6的值为  " + lis.get(6));;
		System.out.println("removeAll之后lis的长度为 " + lis.size());
		System.out.println("removeAll之后，index = 3的值为  " + lis.get(3));
		System.out.println("removeAll之后，index = 4的值为  " + lis.get(4));
		*/
		
		//方法retainAll测试
		/*
		List lis_retainAll = new ArrayList();
		lis_retainAll.add("1");
		lis_retainAll.add("2");
		lis_retainAll.add("我和你");
		lis_retainAll.add("null");
		//lis_retainAll.add();
		System.out.println("执行retainAll方法之前的lis的size =  " + lis.size());
		lis.retainAll(lis_retainAll);
		System.out.println("执行retainAll方法之后的lis的size =  " + lis.size());
		System.out.println("执行完retainAll方法之后lis的值输出 = ");
		System.out.println(lis.get(2));
		*/
		
		//set方法的测试
		/*
		lis.set(2,"soga");
		System.out.println("索引2值替换之后变为" + lis.get(2));
		//subList方法的测试
		My_List ml = new My_List();
		ml = lis.subList(2,4);
		System.out.println("subList返回的对象长度为 = " + ml.size());
		System.out.println("其中索引1的值为 = " + ml.get(1));
		*/
		/*
		//测试toArray
		Object [] ob_test1 = new Object[]{"2","4","akjsdf","我和你",null};
		Object [] ob = lis.toArray(ob_test1);
		System.out.println("toArray的长度为  " + ob.length);
		System.out.println("返回数组的第一个值为 " + ob[0]);
		*/
		
		//迭代方法测试
		/*
		Iterator it = lis.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
			it.remove();
			//it.remove();
		}
		System.out.println("迭代之后的size = " + lis.size());
		*/
		//返回哈希值方法测试
		int has = lis.hashCode();
		System.out.println("列表哈希值为  " + has);
	}
/********************************************************************/
	//My_List代码
	/*
	*成员变量
	*/
	Object [] object = null;
	//初始的数组长度
	int len = 10;
	//定义每次增加的长度
	int addLen = 10;
	//动态数组当前的元素个数
	private int size;
	//构造方法
	public My_List(){
		object = new Object[len];
		size = 0;
	}
	
	/*
	*以下是实现Collection的方法
	*/
	//add方法一
	public boolean add(Object ob){
		boolean rtn = false;
		//判断当前动态数组对象的数目
		if(size == object.length){
			//相应地总长度增长
			len = len + 10;
			//如果当前的数组已满，则将之重新放进另一个数组中
			//先定义一个数组存储当前的数组值
			Object [] object_before = object;
			object = new Object[len];
			for(int i = 0;i<size;i++){
				object[i] = object_before[i];
			}
			//执行添加操作
			object[size] = ob;
			size++;
		}else{
			object[size] = ob;
			size++;
		}
		rtn = true;
		return rtn;
	}
	//add方法二,index超出范围则抛出异常
	public void add (int index,Object ob){
		if(index<0||index>size-1){
			new RuntimeException("IndexOutOfBoundsException");
		}else{
			object[index] = ob;
		}
	}
	//addAll方法
	public boolean addAll(int index,Collection c){
		boolean rtn = false;
		if(index<0||index>size-1){
			throw new RuntimeException("IndexOutOfBoundsException");
		}else if(c==null){
			throw new RuntimeException("NullPointerException");
		}else{
			for(int i = 0;i<c.size();i++){
				add(c.toArray()[i]);
			}
			rtn = true;
		}
		return rtn;
	}
	public boolean addAll(Collection c){
		boolean rtn = false;
		int size_before = size;
		for(int i = 0;i<c.toArray().length;i++){
			add(c.toArray()[i]);
		}
		if(size_before != size){
			rtn = true;
		}
		return rtn;
	}
	//移除所有元素
	public void clear(){
		for(int i = 0;i<size;i++){
			object[i] = 0;
		}
		size = 0;
	}
	//判断是否包含指定元素
	public boolean contains(Object ob){
		boolean rtn = false;
		for(int i = 0;i<size;i++){
			if(ob == null){
				if(object[i] == null){
					rtn = true;
					break;
				}
			}else{
				if(ob.equals(object[i])){
					rtn = true;
					break;
				}
			}
		}
		return rtn;
	}
	//判断是否包含Collection的所有元素
	public boolean containsAll(Collection c){
		for(int i = 0;i<c.size();i++){
			if(!contains(c.toArray()[i])){
				return false;
			}
		}
		return true;
	}
	//equals方法
	public boolean equals(Object ob){
		boolean rtn = true;
		//先判断对象是否是个列表
		if(ob.getClass().getName().equals("My_List")){
			//判断两者的长度是否一致
			if(((My_List)ob).size()==size){
				//判断对应位置对应元素是否相等
				for(int i = 0;i<size;i++){
					if(!(((My_List)ob).get(i).equals(object[i]))){
						return false;
					}
				}
			}else{
				rtn = false;
			}
			
		}else{
			rtn = false;
		}
		return rtn;
	}
	//get方法,超出范围抛出异常
	public Object get(int index){
		Object rtn = null;
		if(index<0||index>size-1){
			throw new ArrayIndexOutOfBoundsException("IndexOutOfBoundsException");
		}else{
			rtn = object[index];
		}
		return rtn;
	}
	
	//返回表的哈希码值(未实现)
	
	public int hashCode(){
		int rtn = 0;
		int hashCode = 1;
		Iterator i = iterator();
		while (i.hasNext()) {
			Object obj = i.next();
			hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
		}
		rtn = hashCode;
		return rtn;
	}
	
	//返回第一次出现该元素的索引，不存在，返回-1
	public int indexOf(Object ob){
		int rtn = -1;
		//判断Object和列表中的元素是否兼容
		for(int i = 0;i<size;i++){
			if(object[i] == null){
				if(ob == null){
					return i;
				}
			}else{
				if(object[i].equals(ob)){
					return i;
				}
			}
		}
		return rtn;
	}
	//返回此元素最后出现的位置
	public int lastIndexOf(Object ob){
		int rtn = -1;
		for(int i = size-1;i>=0;i--){
			if(object[i] == null){
				if(ob == null){
					return i;
				}
			}else{
				if(object[i].equals(ob)){
					return i;
				}
			}
		}
		return rtn;
	}
	//判断列表是否包含元素
	public boolean isEmpty(){
		boolean rtn = true;
		if(size != 0){
			rtn = false;
		}
		return rtn;
	}
	//返回按照适当顺序上进行迭代的迭代器
	public Iterator iterator (){
		Iterator rtn = null;
		rtn = new My_Iterator(this);
		return rtn;
	}
	//移除元素,返回被移除的元素，如果传入的索引值超出范围抛出异常
	public Object remove(int index){
		Object rtn = null;
		if(index<0||index>=size){
			throw new RuntimeException("IndexOutOfBoundsException");
		}else{
			rtn = object[index];
			for(int i = index;i<size - 1;i++){
				object[i] = object[i+1];
			}
			size--;
		}
		return rtn;
	}
	public boolean remove(Object ob){
		boolean rtn = false;
		int index = indexOf(ob);
		if(index!=-1){
			remove(index);
			rtn = true;
		}
		return rtn;
	}
	//移除所有元素(问题起点)
	public boolean removeAll(Collection c){
		boolean rtn = false;
		//存储当前的size值，用于之后判断列表是否有元素发生了变动
		int size_before = size;
		Object [] ob_toArray = c.toArray();
		for(int i = 0;i<c.size();i++){
			remove(ob_toArray[i]);
		}
		//由于当c是对象本身时，其处于变化中，所以另外处理
		if((this == null && c == null)||this.equals(c)){
			clear();
		}
		//判断表中的元素是否发生了变化
		if(size_before == size){
			rtn = true;
		}
		return rtn;
	}
	//保留列表中的元素(代码质量的问题)(question)
	public boolean retainAll(Collection c){
		boolean rtn = false;
		//定义一个整形变量存储当前siez以便用于判断列表的值是否发生改变
		int size_before = size;
		Object [] ob_toArray  = c.toArray();
		for(int i = 0;i<size;i++){
			for(int j = 0;j<ob_toArray.length;j++){
				if(object[i]==null){
					if(ob_toArray[j]==null){
						break;
					}
				}else{
					if(object[i].equals(ob_toArray[j])){
						break;
					}
				}
				if(j==ob_toArray.length-1){
					//遍历完没有发现相应的元素，执行remove
					remove(i);
					//由于执行remove之后原来动态数组中的元素分布发生前移，所以i--
					i--;
				}
			}
		}
		if(size_before!=size){
			rtn = true;
		}
		return rtn;
	}
	//替换元素,返回以前元素
	public Object set(int index,Object ob){
		Object rtn = null;
		rtn = object[index];
		object[index] = ob;
		return rtn;
	}
	//size()返回列表中的元素数目
	public int size(){
		return size;
	}
	//返回从fromIndex到toIndex的元素，前包括后不包括
	public My_List subList(int fromIndex,int toIndex){
		My_List rtn = null;
		if((fromIndex>toIndex)||(fromIndex<0)||(toIndex>size-1)){
			throw new RuntimeException("IndexOutOfBoundsException");
		}else{
			rtn = new My_List();
			for(int i = fromIndex;i<toIndex;i++){
				rtn.add(get(i));
			}
		}
		return rtn;
	}
	//返回所有元素
	public Object[] toArray(){
		Object [] rtn = null;
		rtn = object;
		return rtn;
	}
	//返回列表中的元素
	public Object[] toArray(Object [] ob){
		Object [] rtn = null;
		My_List ml = new My_List();
		for(int i = 0;i<ob.length;i++){
			if(contains(ob[i])){
				ml.add(ob[i]);
			}
		}
		rtn = ml.toArray();
		return rtn;
	}
	
}


/*************************************************************************/

//迭代器的实现类
class My_Iterator implements Iterator{
	My_List ml = null;
	Object [] object = null;
	//定义构造函数
	public My_Iterator(My_List ml){
		this.ml = ml;
		object = ml.toArray();
	}
	/*
	*以下是实现Iterator接口的方法
	*/
	public boolean hasNext(){
		boolean rtn = true;
		if(point>(ml.size()-1)){
			rtn = false;
		}
		return rtn;
	}
	//定义一个指针变量，用于存储next时的当前游标
	private int point = 0;
	public Object next(){
		
		//每次调用next方法前，先将指针变量指向初始位置
		Object rtn = null;
		if(point>(ml.size()-1)){
			throw new RuntimeException("NoSuchElementException");
		}else{
			rtn = object[point];
			point++;
			remove_CanUsed = true;
		}
		return rtn;
	}
	//定义一个布尔变量用以标记remove已经是否被调用，同时，该变量在next方法调用后初始化为true,在remove被调用后被初始化为fals
	private boolean remove_CanUsed = false;
	public void remove(){
		//判断是否和当前的point一致
		if(remove_CanUsed){
			ml.remove(point-1);//这里减一是因为上面的next操作完后指针变量自增了
			//由于remove后操作的列表对应的排列顺序也改变了，所以指针相应地跟着减1
			point--;
		}else{
			throw new RuntimeException("IllegalStateException");
		}
		remove_CanUsed = false;
	}
}

　　代码有点长，各位需要就参考下，不足之处请指正！