学习日志---集合框架基础实现(MyVector,MySet)

标签：java算法

数组有限并且连续；

实现动态数组：可以变更数组长度，可以调整数组的大小：

//动态对象数组
public class DynamicArray {
    
	final static int defaultSize=10;
	Object[] arr; //对象数组
	int maxSize; //数组的最大长度
	
	//默认的构造方法
	public DynamicArray()
	{
	   init(defaultSize);	
	}
	
	//指定对象数组长度的构造方法
	public DynamicArray(int size)throws Exception
	{
		if(size<=0)
		{
			throw new Exception("数组长度参数异常！");
		}
		init(size);
	}
	
	//根据已有对象数组，拷贝复制生成新的对象数组
	public DynamicArray(DynamicArray a)
	{
	   arr = new Object[a.maxSize];
	   for(int i=0;i<a.maxSize;i++)
	   {
		   arr[i]=a.arr[i];
	   }
	   maxSize = a.maxSize;
	}
	
	
    public void init(int size)
    {
       arr = new Object[size];
       maxSize = size;
    }
    
    //调整对象数组的大小
	public void reSize(int size)throws Exception
	{
		//如果调整的大小<=0,非法！
		if(size<=0)
		{
			throw new Exception("数组长度参数异常！");
		}
		//如果调整的大小与原来相同，则没必要调整，直接返回。
		if(size==maxSize)
			return ;
		//构造一个新的对象数组
		Object[] newArray = new Object[size];
		//判断新调整的大小，比原来大，还是比原来小
                //这里的maxSize和size需要特别注意，防止下标越界，如当size大于maxSize时，返回应是maxSize,从而取得小的那段值。 这样下面的循环n才不会使数组arr越界
		int n=(size > maxSize)? maxSize:size;
		
		for(int i=0;i<n;i++)
		{
		   newArray[i]=arr[i];	
		}
		arr = newArray;
		maxSize = size;
	}
}

向量类：

Vector类，MyVector类的实现，里面用到了system中的arraycopy方法。

//这个方法可以对data数组进行前后一位推移，自己复制自己
		System.arraycopy(data, index, data, index+1, count-index);
		System.arraycopy(data, index+1, data, index, j);

public interface Collection {
  
	//在指定位置添加
	public void add(int index,Object element) throws Exception;
	//在集合末端添加
	public void add(Object element) throws Exception;
	//在指定位置设置元素
	public void set(int index,Object element) throws Exception;
    //获得指定位置的元素
	public Object get(int index) throws Exception;
	//获得集合大小
	public int size();
	//在指定位置删除
	public void remove(int index) throws Exception;
	//删除指定对象
	public void remove(Object element) throws Exception;
	//是否包含指定对象
	public boolean contain(Object element) throws Exception;
	
	
}


//用户自定义的Vector类
public class MyVector implements Collection{
    
        //data.length和count不同，前者是数组开辟空间大小，后者是数组中存了多少东西
	private Object[] data; //集合对象数组
	private int count;  //集合大小
	private final static int defaultSize=10;
	
	public MyVector()
	{
	   init(defaultSize);	
		
	}
	
	public MyVector(int size)
	{
		init(size);
	}
	
	public void init(int size)
	{
		data = new Object[size];
		count=0;
	}
	
	//动态扩充内存
        //这个方法是确保类中的空间足够大，判断空间是否够
        //minCapacity是指需要的最小空间
	private void ensureCapacity(int minCapacity)
	{
                //是看data的空间
		int oldCapacity = data.length;
		if(minCapacity>oldCapacity)
		{
			Object[] oldData = data;
			int newCapacity = oldCapacity*2;
			if(newCapacity<minCapacity)
			{
				newCapacity = minCapacity;
			}
			data = new Object[newCapacity];
                        //这是system的方法，把旧的拷贝到新的空间中
			System.arraycopy(oldData, 0, data, 0, count);
		}
	}
	
	
	@Override
	public void add(int index, Object element) throws Exception {
		// TODO Auto-generated method stub
		if(index>=count+1)
		{
			throw new ArrayIndexOutOfBoundsException(index);
		}
		ensureCapacity(count+1);
                //这个方法可以对data数组进行后一位推移，自己复制自己
		System.arraycopy(data, index, data, index+1, count-index);
		data[index]=element;
		count++;
	}

	@Override
	public void add(Object element) throws Exception {
		// TODO Auto-generated method stub
                ensureCapacity(count+1);
		add(count,element);
	}

	@Override
	public boolean contain(Object element) throws Exception {
		// TODO Auto-generated method stub
		//可用index去下标，完成查找
		return indexOf(element)>=0;
	}

	@Override
	public Object get(int index) throws Exception {
		// TODO Auto-generated method stub
		if(index>=count||index<0)
		{
		  throw new ArrayIndexOutOfBoundsException(index);
		}
		return data[index];
	}

	@Override
	public void remove(int index) throws Exception {
		// TODO Auto-generated method stub
		if(index>=count||index<0)
		{
		  throw new ArrayIndexOutOfBoundsException(index);
		}
		int j=count-index-1;
		if(j>0)
		{
			System.arraycopy(data, index+1, data, index, j);
		}
		count--;
                //把最后的一位弄成null去掉，因为前移了
		data[count]=null;
	}

        //找到元素的下标
	public int indexOf(Object element)
	{
	        //循环找相同元素
		if(element==null)
		{
			for(int i=0;i<count;i++)
			{
				if(data[i]==null)
					return i;
			}
		}
		else
		{
			for(int i=0;i<count;i++)
			{
				if(data[i].equals(element))
					return i;
			}
		}
		return -1;
	}
	
	@Override
	public void remove(Object element) throws Exception {
		// TODO Auto-generated method stub
		int index = indexOf(element);
		if(index>=0)
		{
			remove(index);
		}
	}

	@Override
	public void set(int index, Object element) throws Exception {
		// TODO Auto-generated method stub
		if(index>=count||index<0)
		{
		  throw new ArrayIndexOutOfBoundsException(index);
		}
		data[index]=element;
	}

	@Override
	public int size() {
		// TODO Auto-generated method stub
		return count;
	}

	
}

MySet类的实现；基于上述的MyVector类实现

需要迭代器接口：基于数组实现的，因此可以

public interface MyIterator {
  
	//是否有下一个元素
	public boolean hasNext();
	//获得下一个元素
	public Object next();
}

下面是MySet类：里面存MyVector对象用于存数据

//用户自定义的MySet类
public class MySet {

	private MyVector value = new MyVector();
	
	//添加对象
	public void add(Object obj)throws Exception
	{
		//不允许添加空对象
		if(obj==null)
		{
			return ;
		}
		//由于Set类不允许添加重复的元素，所有先查找该对象是否已经存在。
		if(value.indexOf(obj)<0)
		{
			value.add(obj);
		}
		else
		{
			return;
		}
	}
	
	//删除对象
	public void remove(Object obj)throws Exception
	{
		value.remove(obj);
	}
	
	//是否包含一个对象
	public boolean contain(Object obj)throws Exception
	{
		return value.contain(obj);
	}
	
	public int size()
	{
		return value.size();
	}
	
	public Object get(int index)throws Exception
	{
		return value.get(index);
	}
	
	//是否包含另一个集合对象.
    public boolean include(Object obj)throws Exception
    {
    	if( obj instanceof MySet)
    	{
    		MySet set = (MySet)obj;
    		int count=0;
    		while(count<set.size())
    		{
    			Object temp = set.get(count);
    			count++;
    			if(!contain(temp))
    				return false;
    		}
    		return true;
    	}
    	else
    	{
    		return false;
    	}
    }
    
    //判断两个集合是否相等
    public boolean equals(Object obj) 
    {
    	if(obj instanceof MySet)
    	{
    	   MySet set = (MySet)obj;
    	   try
    	   {
    	           //互相包含即可，但是比较慢，因为要互相循环
	    	   if(include(set)&&set.include(this))
	    	   {
	    		   return true;
	    	   }
	    	   else
	    		   return false;
    	   }
    	   catch(Exception ex)
    	   {
    		   ex.printStackTrace();
    		   return false;
    	   }
    	}
    	else
    	{
    		return false;
    	}
    }
   
    //判断集合是否为空
    public boolean isEmpty()
    {
    	return value.size()>0;
    }
	
    
    
}

集合框架实现双色球机选号码：

public class MyLotto {

	
	public static void main(String[] args) {
		
		Vector<Integer> v = new Vector<Integer>();
		
		//初始化红球号码
		for(int i=1;i<=33;i++)
		{
			v.add(i);
		}
		
		//随机生成六个红球
		
		for(int i=0;i<6;i++)
		{
		        //在v删除后，v的长度会变，因此下面的len也会变，随机取位置时可以从所在范围内取，可以保证取得对应位置上的数字唯一，因为下面取到后就删除了。
		        //简单说就是把数字放在vector中，取一个删一个，直至选出六个即可
			int len = v.size();
			int random = (int)(Math.random()*100)%len; 
			System.out.println("第"+(i+1)+"个红球号码是："+v.get(random));
			//取出一个位置的号码后，会把这个位置删掉，也就是前移一位
		    v.remove(random);//删除元素  
		}
		
		//随机抽取篮球
		int num = (int)(Math.random()*100)%16;
		//从0-15,因此要加一
		System.out.println("蓝球号码是："+(num+1));
		
		
	}

}

学习日志---集合框架基础实现(MyVector,MySet)

标签：java算法

原文地址：http://wukong0716.blog.51cto.com/10442773/1688500