集合顺序存储结构的实现和操作

具体的Demo：

Set接口：

public interface Set {

	/**
	 * @introduction 向集合中增加一个元素
	 * @param object
	 * @return
	 * @author Guo
	 */
	public boolean add(Object object);
	
	/**
	 * @introduction 从集合中删除一个元素
	 * @param object
	 * @return
	 * @author Guo
	 */
	public boolean remove(Object object);
	
	/**
	 * @introduction 判断一个元素是否属于这个集合
	 * @param object
	 * @return
	 * @author Guo
	 */
	public boolean contains(Object object);
	
	/**
	 * @introduction 返回集合中第index个元素的值
	 * @param index
	 * @return
	 * @author Guo
	 */
	public Object value(int index);
	
	/**
	 * @introduction 从集合中查找object并返回
	 * @param object
	 * @return
	 * @author Guo
	 */
	public Object find(Object object);
	
	/**
	 * @introduction  返回集合中元素的个数
	 * @return
	 * @author Guo
	 */
	public int size();
	
	/**
	 * @introduction 判断集合是否为空
	 * @return
	 * @author Guo
	 */
	public boolean isEmpty();
	
	/**
	 * @introduction 输出集合中所有的元素
	 * @author Guo
	 */
	public void output();
	
	/**
	 * @introduction 返回当前集合与参数集合set的并集
	 * @param set
	 * @return
	 * @author Guo
	 */
	public Set union(Set set);
	
	/**
	 * @introduction 返回当前集合与参数集合set的交集
	 * @param set
	 * @return
	 * @author Guo
	 */
	public Set intersection(Set set);
	
	/**
	 * @introduction 清除集合中的元素
	 * @author Guo
	 */
	public void clear();
}

 

SequenceSet类：

/**
 * @introduction 顺序存储结构的实现
 * @author Guo
 *
 */
public class SequenceSet implements Set{
	
	/**
	 * @introduction minSize为数组的初始长度
	 * @introduction array底层数组
	 * @introduction len集合当前的长度
	 * @author Guo
	 */
	private final int minSize = 10;
	private Object[] array;
	private int len;
	
	/**
	 * @introduction 无参的构造方法，初始化数组
	 * @author Guo
	 */
	public SequenceSet() {
	
		len = 0;
		array = new Object[minSize];
	}
	
	/**
	 * @introduction 指定长度的构造方法
	 * @param length
	 * @author Guo
	 */
	public SequenceSet(int length) {
		
		if(length < minSize)
			length = minSize;
		len = 0;
		array = new Object[length];
	}

	@Override
	public boolean add(Object object) {
		
		if(contains(object))
			return false;
		
		if(len == array.length) {
			
			Object[] arrayTemp = new Object[len*2];
			for(int i = 0; i < len; i++)
				arrayTemp[i] = array[i];
			array = arrayTemp;
		}
		array[len] = object;
		len++;
		return true;
	}

	@Override
	public boolean remove(Object object) {
		
		int i;
		for(i = 0; i < len; i++)
			if(array[i].equals(object))
				break;
		
		if(i < len) {
			
			array[i] = array[len-1];
			len--;
			return true;
		}
		else
			return false;
	}

	@Override
	public boolean contains(Object object) {
		
		for(int i = 0; i < len; i++)
			if(array[i].equals(object))
				return true;
		return false;
	}

	@Override
	public Object value(int index) {
		
		if(index <= 0 || index > len)
			return null;
		return array[index-1];
	}

	@Override
	public Object find(Object object) {
		
		for(int i = 0; i < len; i++)
			if(array[i].equals(object))
				return array[i];
		return null;
	}

	@Override
	public int size() {
		return len;
	}

	@Override
	public boolean isEmpty() {
		return len == 0;
	}

	@Override
	public void output() {
		
		for(int i = 0; i < len; i++)
			System.out.print(array[i] + " ");
		System.out.println();
	}

	@Override
	public Set union(Set set) {
		
		SequenceSet dset = (SequenceSet)set;
		SequenceSet setTemp = new SequenceSet(len + dset.len);
		int i;
		for(i = 0; i < len; i++)
			setTemp.array[i] = array[i];
		setTemp.len = len;
		for(i = 0; i < dset.len; i++) {
			
			Object object = dset.array[i];
			if(!contains(object))
				setTemp.array[setTemp.len++] = object;
		}
		return setTemp;
	}

	@Override
	public Set intersection(Set set) {

		SequenceSet dset = (SequenceSet)set;
		int length;
		if(len < dset.len)
			length = len;
		else
			length = dset.len;
		SequenceSet setTemp = new SequenceSet(length);
		for(int i = 0; i < dset.len; i++) {
			
			Object object = dset.array[i];
			if(contains(object))
				setTemp.array[setTemp.len++] = object;
		}
		return setTemp;
	}

	@Override
	public void clear() {
		len = 0;
	}
}

 

 

操作类：

public class TestSequenceSet {

	@Test
	public void testAdd() {
		
		Set set = new SequenceSet();
		set.add("zhou");
		set.add("yan");
		set.add("ping");
		set.output();
	}
	
	@Test
	public void testRemove() {
		
		Set set = new SequenceSet();
		set.add("xu");
		set.add("jian");
		set.add("guo");
		set.remove("xu");
		set.output();
		if(!set.remove("xu"))
			System.out.println("Not In Set");
	}
	
	@Test
	public void testContains() {
		
		Set set = new SequenceSet();
		set.add("zhou");
		if(set.contains("zhou"))
			System.out.println("In Set");
		else
			System.out.println("Not In Set");
		if(set.contains("xu"))
			System.out.println("In Set");
		else
			System.out.println("Not In Set");
	}
	
	@Test
	public void testValue() {
		
		Set set = new SequenceSet();
		set.add("zhou");
		set.add("xu");
		System.out.println(set.value(1));
		System.out.println(set.value(4));
	}
	
	@Test
	public void testFind() {
		
		Set set = new SequenceSet();
		set.add("xu");
		set.add("zhou");
		System.out.println(set.find("zhou"));
		System.out.println(set.find("xxx"));
	}
	
	@Test
	public void testSize() {
		
		Set set = new SequenceSet();
		set.add("xu");
		set.add("zhou");
		System.out.println(set.size());
	}
	
	@Test
	public void testIsEmpty() {
		
		Set set = new SequenceSet();
		System.out.println(set.isEmpty());
		set.add("zhou");
		System.out.println(set.isEmpty());
	}
	
	@Test
	public void testUnion() {
		
		Set set = new SequenceSet();
		set.add("xu");
		set.add("zhou");
		Set setCopy = new SequenceSet();
		setCopy.add("xu");
		setCopy.add("yan");
		set.union(setCopy).output();
	}
	
	@Test
	public void testIntersection() {
		
		Set set = new SequenceSet();
		set.add("xu");
		set.add("zhou");
		Set setCopy = new SequenceSet();
		setCopy.add("zhou");
		set.add("guo");
		set.intersection(setCopy).output();
	}
	
	@Test
	public void testClear() {
		
		Set set = new SequenceSet();
		set.add("xu");
		set.add("zhou");
		set.clear();
		set.output();
	}
}