fastvector.java~58~

数据挖掘中常常会遇到apriori算法 这是apriori算法的java版

//Container Interface
package apriori;
import java.util.*;
import java.io.*;

/**Vector ()
 * Constructs an empty vector with an array size of 10 and a capacity increment of zero.
 * Vector (int initialCapacity)
 * Constructs an empty vector with the specified initial capacity and a capacity increment of zero.
 * Vector (int initialCapacity, int capacityIncrement)
 * Constructs an empty vector with the specified initial capacity and capacity increment. */
public class FastVector implements Copyable, Serializable {
    public class FastVectorEnumeration implements Enumeration {

    /** The counter. */
    private int m_Counter;

    /** The vector. */
    private FastVector m_Vector;

    /** 特殊的元素  enumeration时将会略过*/
    private int m_SpecialElement;

    /**
     * 构造一个 enumeration.
     *
     * @param vector
     */
    public FastVectorEnumeration(FastVector vector) {

      m_Counter = 0;
      m_Vector = vector;
      m_SpecialElement = -1;
    }

    /**
     * 构造一个拥有特殊元素的enumeration.
     * 这个特殊元素将在enumeration回被略去.
     *
     * @param vector
     * @param special 特殊元素的索引
     */
    public FastVectorEnumeration(FastVector vector, int special) {

      m_Vector = vector;
      m_SpecialElement = special;
      if (special == 0) {
	m_Counter = 1;
      } else {
	m_Counter = 0;
      }
    }


    /**
     * 测试是否有更多的元素供enumerate
     * @return true 如果有一些元素留下
     */
    public final boolean hasMoreElements() {

      if (m_Counter < m_Vector.size()) {
	return true;
      }
      return false;
    }

    /**
     * 返回下一个元素
     *
     * @return 下一个要被enumerate的元素。
     */
    public final Object nextElement() {

      Object result = m_Vector.elementAt(m_Counter);

      m_Counter++;
      if (m_Counter == m_SpecialElement) {
	m_Counter++;
      }
      return result;
    }
  }
  private Object[] m_Objects;

  /** 现在的容量大小 */
  private int m_Size;

  /** 容量增长的幅度 */
  private int m_CapacityIncrement;

  /** 容量要增加的倍数. */
  private double m_CapacityMultiplier;

  /**
   *构造一个不带参数的vector.
   */
  public FastVector() {

    m_Objects = new Object[0];
    m_Size = 0;
    m_CapacityIncrement = 1;
    m_CapacityMultiplier = 2;
  }

  /**
   * 构造一个拥有容量参数的vector.
   *
   * @param capacity  vector的初始容量
   */
  public FastVector(int capacity) {

    m_Objects = new Object[capacity];
    m_Size = 0;
    m_CapacityIncrement = 1;
    m_CapacityMultiplier = 2;
  }

  /**
   * 构造一个拥有参数的vector，参数包括容量，增加的幅度，需乘的倍数。
   *
   * @param capacity vector的初始容量
   */
  public FastVector(int capacity, int capIncrement,
		    double capMultiplier) {

    m_Objects = new Object[capacity];
    m_Size = 0;
    m_CapacityIncrement = capIncrement;
    m_CapacityMultiplier = capMultiplier;
  }

  /**
   * 加一个元素到vector中，如果它的容量不够，增加它的容量.
   *
   * @param element the element to add
   */
  public final void addElement(Object element) {

    Object[] newObjects;

    if (m_Size == m_Objects.length) {
      newObjects = new Object[(int)m_CapacityMultiplier *
			     (m_Objects.length +
			      m_CapacityIncrement)];
      System.arraycopy(m_Objects, 0, newObjects, 0, m_Size);//复制数组从m_Objects到newObjects
      m_Objects = newObjects;
    }
    m_Objects[m_Size] = element;
    m_Size++;
  }

  /**
   * @return vector的容量
   */
  public final int capacity() {

    return m_Objects.length;
  }

  /**
   * 构造一个 vector的 shallow copy
   *
   * @return the new vector
   */
  public final Object copy() {

    FastVector copy = new FastVector(m_Objects.length,
				     m_CapacityIncrement,
				     m_CapacityMultiplier);
    copy.m_Size = m_Size;
    System.arraycopy(m_Objects, 0, copy.m_Objects, 0, m_Size);
    return copy;
  }

  /**
   * 使用shallow copy复制vector
   *
   * @return 新的vector
   */
  public final Object copyElements() {

    FastVector copy = new FastVector(m_Objects.length,
				     m_CapacityIncrement,
				     m_CapacityMultiplier);
    copy.m_Size = m_Size;
    for (int i = 0; i < m_Size; i++) {
      copy.m_Objects[i] = ((Copyable)m_Objects[i]).copy();
    }
    return copy;
  }

  /**
   * 返回元素在的位置
   *
   * @param index 元素的索引
   * @return 元素的索引
   */
  public final Object elementAt(int index) {

    return m_Objects[index];
  }

  /**
   * 返回这个vector的一个enumeration.
   * @return
   */
  public final Enumeration elements() {

    return new FastVectorEnumeration(this);
  }

  /**
   * 返回这个vector的一个enumeration,略过给出索引的元素
   *
   * @param 需要略过元素的索引
   * @return
   */
  public final Enumeration elements(int index) {

    return new FastVectorEnumeration(this, index);
  }

  /**
   * 返回vector的第一个元素.
   *
   * @return
   */
  public final Object firstElement() {

    return m_Objects[0];
  }

  /**
   * 寻找与前面相同的元素
   *
   * @param
   * @return
   */
  public final int indexOf(Object element) {

    for (int i = 0; i < m_Size; i++) {
      if (element.equals(m_Objects[i])) {
	return i;
      }
    }
    return -1;
  }

  /**
   * 在给出的位置插入元素
   */

  public final void insertElementAt(Object element, int index) {

    Object[] newObjects;

    if (m_Size < m_Objects.length) {
      System.arraycopy(m_Objects, index, m_Objects, index + 1,
                       m_Size - index);
      m_Objects[index] = element;
    } else {
      newObjects = new Object[(int)m_CapacityMultiplier *
			     (m_Objects.length +
			      m_CapacityIncrement)];
      System.arraycopy(m_Objects, 0, newObjects, 0, index);
      newObjects[index] = element;
      System.arraycopy(m_Objects, index, newObjects, index + 1,
		       m_Size - index);
      m_Objects = newObjects;
    }
    m_Size++;
  }

  /**
   * 返回vector的最后一个元素
   *
   * @return
   */
  public final Object lastElement() {

    return m_Objects[m_Size - 1];
  }

  /**
   * 从vector中删除一个元素
   *
   * @param index 将要被删除元素的索引
   */
  public final void removeElementAt(int index) {

    System.arraycopy(m_Objects, index + 1, m_Objects, index,
                     m_Size - index - 1);
    m_Size--;
  }

  /**
   * 将vector中所有元素删除，并设置容量为0
   */
  public final void removeAllElements() {

    m_Objects = new Object[m_Objects.length];
    m_Size = 0;
  }

  /**
   *将一个vector所拥有的所有元素添加到另一个vector中去.
   *
   * @param toAppend 将FastVector拥有的元素添加。
   */
  public final void appendElements(FastVector toAppend) {

    setCapacity(size() + toAppend.size());
    System.arraycopy(toAppend.m_Objects, 0, m_Objects, size(), toAppend.size());
    m_Size = m_Objects.length;
  }

  /**
   * 将vector中所有的元素作为数组返回
   *
   */
  public final Object [] toArray() {

    Object [] newObjects = new Object[size()];
    System.arraycopy(m_Objects, 0, newObjects, 0, size());
    return newObjects;
  }

  /**
   * 设定vector将要给出的容量值
   *
   * @param capacity
   */
  public final void setCapacity(int capacity) {

    Object[] newObjects = new Object[capacity];

    System.arraycopy(m_Objects, 0, newObjects, 0, Math.min(capacity, m_Size));
    m_Objects = newObjects;
    if (m_Objects.length < m_Size)
      m_Size = m_Objects.length;
  }

  /**
   * 设定元素将要放置的位置
   *
   * @param element vector中要放的元素
   * @param index 元素要放置位置的索引
   */
  public final void setElementAt(Object element, int index) {

    m_Objects[index] = element;
  }

  /**
   * 返回vector现在的大小
   *
   * @return
   */
  public final int size() {

    return m_Size;
  }

  /**
   * 交换vector中的两个元素位置
   *
   * @param first 第一个元素的位置
   * @param second 第二个元素的位置
   */
  public final void swap(int first, int second) {

    Object help = m_Objects[first];

    m_Objects[first] = m_Objects[second];
    m_Objects[second] = help;
  }

  /**
   * 设定vector的容量为新的vector的容量
   */
  public final void trimToSize() {

    Object[] newObjects = new Object[m_Size];

    System.arraycopy(m_Objects, 0, newObjects, 0, m_Size);
    m_Objects = newObjects;
  }
}