数据结构3——数组、集合

1：数组是所有高级语言中必备的数据结构储存类型，但是数组有一个明显的缺点：必须提前知道数组内存的大小。这对于需要动态扩展的情况而言，无疑是一个弊端。

　　因此创造了一个Vector 类来扩展数组的内存大小。

package com.hone.set;

//总体的操作集合：扩充数组内存大小，添加，删除，修改，查找
public class MyVector {
    
    private Object[] elementData;        //定义一个数组
    private int elementCount;            //定义数组中元素的个数
    
    
    //定义一个方法用于扩种数组的内存，同传入一个规定的最小内存量
    public void ensureCapacity(int minCapacity){
        int  oldCapacity=elementData.length;        //获得元数组的长度
        if(minCapacity>oldCapacity){            //同时判断要求的最小内存量是否大于原数组的内存，否则无意义
            Object[] oldData=elementData;        //同时将数组中的元素传入到一个数组中，方便待会儿传入扩充数组中
            int newCapacity=oldCapacity*2;        //实现真正的扩充内存作用
            if (minCapacity>newCapacity) {        //判断新的内存容量是否满足要求
                newCapacity=minCapacity;
            }
            elementData=new Object[newCapacity];    //将新的数组内存大小传入到原数组中
            System.arraycopy(oldData, 0, elementData, 0, elementCount);
        }
    }
    
    //定义一个构造函数，当用户不传入自己值的时候，设定默认的值
    public MyVector(){
        this(10);
    }

    //定义一个构造函数，用户自己定义所需要数组内存的大小
    public MyVector(int i) {
        elementData=new Object[i];
        elementCount=0;
    }
    
    
    //该方法用于在默认的index处，传入一个属性值
    /*
     * 总体的思路是：首先将原来数组从index开始向后面移动一个位置，空出index的位置
     * 然后将element元素复制给index处
     */
    public void add(int index, Object element){
        //首先防止越界
        if(index>elementCount){
            System.out.println("请输入在数组范围内的下标值");
        }
        ensureCapacity(elementCount+1);                //扩充数组的大小
        System.arraycopy(elementData, index, elementData, index+1, elementCount-index);
        elementData[index]=element;
        elementCount++;
    }
    
    //同时也可以在数组的最后面直接添加元素
    public void add( Object element){
        add(elementCount, element);
    }
    
    
    //修改index处的元素
    public void set(int index , Object element){
        //首先防止越界
        if(index>elementCount){
            System.out.println("请输入在数组范围内的下标值");
        }
        elementData[index]=element;
    }
    
    //获取index处元素的位置
    public Object get(int index){
        //首先防止越界
        if(index>elementCount){
            System.out.println("请输入在数组范围内的下标值");
        }
        return elementData[index];
    }
    
    //获取数组的大小
    public int size(){
        return elementCount;
    }
    
    //查找element元素在数组中的下标位置
    public int indexOf(Object element){
        for (int i = 0; i < elementCount; i++) {
            if (element.equals(elementData[i])) 
                return i;
        }
        return -1;        //返回-1表示没有找到对应的元素或者传入的是一个空值
    }
    
    //判断数组中是否包含某个元素
    public boolean contain(Object element){
        return indexOf(element)>=0;
    }
    
    //删除下标为index的元素
    public void remove(int index){
        //首先防止越界
        if(index>elementCount||index < 0){
            System.out.println("请输入在数组范围内的下标值");
        }
        System.arraycopy(elementData, index+1, elementData, index, elementCount-index-1);
        elementCount--;
        elementData[elementCount]=null;
    }
    
    //删除element的元素
    public void removeElement(Object element){
        int i =indexOf(element);
        remove(i);
    }
}

1.1：必须说明的是Vector类只支持对象数组，不支持基本数据类型，基本的数据类型必须包装为相应的对象类。

2：集合

集合特征：无序且不重复。

操作集合：

• 增
• 删
• 改
• 查
• 集合是否包含
• 集合是否相等
• 集合是否为空

  package com.hone.set;
  
  //设定一个集合类
  public class Set {
      private MyVector values = new MyVector();
      //添加一个元素,这里面必须添加一个不重复的元素
      public void add(Object element){
          if (element==null) return ;
          if (values.indexOf(element)< 0) {
              values.add(element);
          }
      }
      
      //删除element的元素
      public void remove(Object element){
          values.removeElement(element);
      }
      
      //判断集合中是否包含某个元素
      public boolean contain(Object element){
          return values.contain(element);
      }
      
      //检查是否包含某个集合
      public boolean include(Object obj){
          if (obj instanceof Set) {
              Set mySet=(Set) obj;
          int count=0;        //用于计数
          while (count<values.size()) {
              Object ele=values.get(count);        //获取count点对应的元素值
              count ++;
              if (contain(ele)) 
                  return true;
              }
              return false;
          }
          else
              return false;
      }
      
      //判断两个集合是否相等
      public boolean eqauls(Object obj){
          if (obj instanceof Set) {
              Set myset=(Set) obj;
              if (include(myset)&&myset.include(this)) {
                  return true;
              }
              else return false;
          }
          else return false;
      }
  
      //获取集合的大小
      public int size(){
          return values.size();
      }
      //同时判断集合是否为空
      public boolean isEmpty(){
          return values.size()>0;
      }
      
      //输出集合中的元素
      public void print(){
          for (int i = 0; i < values.size(); i++) {
              System.out.print(values.get(i)+"  ");
          }
      }
  }