简单动态数组的实现代码
以下是本人动态数组实现的源代码，仅供参考，不足之处请指正：
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;
}
}
代码有点长，各位需要就参考下，不足之处请指正！
