简单动态数组的实现代码

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

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;
	}
}

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

时间： 2024-12-22 18:03:27

简单动态数组的实现代码的相关文章

Java的动态数组：ArrayList的简单运用（增删改查）

小伙伴们!今天做个笔记分享给大家!这个是我创建的QQ交流群:315677448感兴趣的欢迎你的加入.废话不多说直接进入今天的主体 ArrayList就是传说中的动态数组! 咱们创建一个Test类,具体代码如下: package Case0000014; import java.util.ArrayList; public class test {     public static void main(String[] args) {         ArrayList lis = new Ar

C++动态数组简单的模拟二元堆

//C++动态数组简单的模拟二元堆 #include<iostream> using namespace std; class BinaryHeap { private: int cap; //该阵列的最大容量 int size; //当前元素个数 int* datas; //数组首地址 public: explicit BinaryHeap(int cap_) :cap(cap_), size(0) { datas = new int[cap]; } ~BinaryHeap(){ delet

C++动态数组简单模拟二叉堆

//C++动态数组简单模拟二叉堆 #include<iostream> using namespace std; class BinaryHeap { private: int cap; //数组最大容量 int size; //当前元素个数 int* datas; //数组首地址 public: explicit BinaryHeap(int cap_) :cap(cap_), size(0) { datas = new int[cap]; } ~BinaryHeap(){ delete d

封装一个简单的动态数组

package com.immoc; import java.util.ArrayList; import java.util.List; /** * 实现动态数组 * */ public class Array <E> { private E[]data;; private int size; public Array(int capacity){ data = (E[]) new Object[capacity]; size = 0; } public Array(){ this(10);

动态数组索引越界问题

1.在C++中,可以采用几种不同的方法创建一个某种类型T的对象的数组.3种常用的方法如下: #define N 10 //数组的长度N在编译时已知 T static_array[10]; int n = 20; //数组的长度n是在运行时计算的 T* dynamic_array = new T[n]; std::vector<T> vector_array; //数组的长度可以在运行时进行修改 当然,我们仍然可以使用calloc()和malloc()函数,并且这样的程序仍然能够通过编译并顺利运

C基础 万能动态数组

引言 - 动态数组切入 开发中动态类型无外乎list 或者 vector, 这里就是在C中实现vector结构容器部分. 对于C中使用的数据结构, 可以参照下面感觉很不错框架源码学习 , 感觉是<<C接口与实现>>的标准Demo twemproxy  https://github.com/twitter/twemproxy/tree/master/src 写的很清楚易懂, 给人一种铺面而来的美感. 关于动态数组设计的总思路, 主要体现在下面的数组结构 struct array {}

两维的动态数组的C++封装

问题描述: 1.包装一个可扩展的动态的两维数组,支持泛型: 2.把存取的细节都包装起来,留一些简单的接口供外部使用: 3.稍作扩展可代替STL vector 使用: 程序代码: #ifndef _TWODIM_ARRAY_H_ #define _TWODIM_ARRAY_H_ #include <stdlib.h> #include <iostream> /* * encapsulate two dimension array * */ template<class T, s

浅谈动态数组原理及其实现

stl中的vector是竞赛中常用的容器,原因在于省内存,O(1)在后端插入和删除.随机下标访问,今天就来谈谈它的实现. 最简单的一个动态数组 动态数组并不是真正意义上的动态的内存,而是一块连续的内存,当添加新的元素时,容量已经等于当前的大小的时候(存不下了),执行下面3步 重新开辟一块大小为当前容量两倍的数组 把原数据拷贝过去 释放掉旧的数组 完事后再把这个元素加在后面. 那么你一定会很好奇,它为什么会是O(1).这个是均摊下来的结果,我们只需要证明总共拷贝的元素个数是O(n)级别的就好了(因

c语言中动态数组的建立

一维动态数组的创建,这个比较简单,直接上代码 1 #define _CRT_SECURE_NO_DEPRECATE 2 #include<stdio.h> 3 #include<stdlib.h> 4 void createOneDimensionalVector(){ 5 int n, i; 6 int *arr; 7 scanf("%d",&n); 8 arr = (int*)malloc(sizeof(int)*n); 9 for (i = 0;