版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
一、集合的定义
集合是由相同类型的互不相同的数据元素聚焦而成，元素之前不存在任何逻辑关系。顺序结构就是使用数组，元素与元素顺序存储，但是元素之间没关系，也就是元素无论在哪个位置存储都是一样的。
二、集合的抽象数据类型
- 接口 Set定义了集合的操作
package set;
public interface Set {
//添加元素，是否成功返回一个boolean
boolean add(Object obj);
//删除元素
boolean remove(Object obj);
//是否包含一个元素
boolean contains(Object obj);
//根据index返回元素
Object value(int i);
//根据元素查询
Object find(Object obj);
//set中元素的个数
int size();
//判断集合是否为空
boolean isEmpty();
//输出(打印)所有的元素
void outputAll();
//与另一个集合的并集
Set union(Set set);
//与另一个集合的交集
Set intersection(Set set);
//清除集合的所有元素---不用返回boolean
void clear();
}
三、顺序结构实现Set
- SequenceSet
package set;
import java.util.Arrays;
/**
* 使用顺序结构存储来实现集合
*/
public class SequenceSet implements Set {
//集合的最大长度
private final int maxSize = 10;
//用于存储元素的空集合
private Object[] setArray;
//集合的长度
private int length;
//构造函数进行初始化：长度为0,有一个10个长度的空集合，对成员变量进行初始化
public SequenceSet() {
length = 0;
setArray = new Object[maxSize];
}
//初始化一个自定义长度的集合
public SequenceSet(int n) {
if (n <= 0) {
System.out.println("集合的长度不能小于0");
System.exit(1);
} else {
this.length = 0;
this.setArray = new Object[n];
}
}
/**
* 1.如果集合中存在该值则返回false，集合中的元素不能重复
* 2.检查数组的空间是否够用，如果不够用则扩大一倍，把原来的数据复制到新的数组中
* 3.把obj插入到数组的最后一个位置上
* 4.集合的长度+1
* 5.返回true表示成功
*
* @param obj
* @return
*/
public boolean add(Object obj) throws IllegalArgumentException {
if (obj == null) {
throw new IllegalArgumentException("Argument can't be null");
}
for (int i = 0; i < length; i++) {
if (obj.equals(setArray[i]))
return false;
}
//length是集合的长度，如果与数组的长度相同则说明数据满了
if (length == setArray.length) {
//Object[] newArray = new Object[length * 2];
//使用数组的扩容工具进行扩容的同时把原数组复制到新数组中
Object[] newArray = Arrays.copyOf(setArray, length * 2);
//可以优化为将引用setArray指向新的地址空间,然后只对setArray操作即可
setArray = newArray;
}
setArray[length] = obj;
length++;
//打印数组的工具类：Arrays
return true;
}
/**
* 1.检查obj在数组中是否存在，如果存在，把这个数组的值复制到另一个数组,数组的长度-1，并返回true
* 2.如果不存在，则返回false.
*
* @param obj
* @return
*/
public boolean remove(Object obj) {
for (int i = 0; i < setArray.length; i++) {
if (obj.equals(setArray[i])) {
//如果存在则进行数组的复制
Object[] removedArray = new Object[length - 1];
System.arraycopy(setArray, 0, removedArray, 0, i);
System.arraycopy(setArray, i + 1, removedArray, i, length - i - 1);
setArray = removedArray;
length--;
return true;
}
}
return false;
}
public boolean contains(Object obj) {
if (obj == null) {
throw new IllegalArgumentException("Argument can't be null");
}
for (int i = 0; i < setArray.length; i++)
if (obj.equals(setArray[i])) return true;
return false;
}
/**
* 根据Index返回值
*
* @param index
* @return
*/
public Object value(int index) {
if (index > length - 1 || index < 0) {
throw new IllegalArgumentException("Wrong arg, please input a correct arg");
}
for (int i = 0; i < setArray.length; i++) {
return setArray[index];
}
return null;
}
public Object find(Object obj) {
if (obj == null) {
throw new IllegalArgumentException("Argument can't be null");
}
for (int i = 0; i < setArray.length; i++)
if (obj.equals(setArray[i])) return setArray[i];
return null;
}
public int size() {
return length;
}
public boolean isEmpty() {
return length == 0;
}
public void outputAll() {
for (int i = 0; i < setArray.length; i++)
System.out.println(setArray[i]);
}
/**
* 两个集合的并集
*
* @param set
* @return
*/
public Set union(Set set) {
SequenceSet tempSet = new SequenceSet(setArray.length);
for (int i = 0; i < setArray.length; i++)
tempSet.setArray[i] = setArray[i];
tempSet.length = length;
SequenceSet destSet = (SequenceSet) set;
for (int i = 0; i < destSet.length; i++)
tempSet.add(destSet.setArray[i]);
return tempSet;
}
/**
* 求两个集合的交集,两个集合都包含
*
* @param set
* @return
*/
public Set intersection(Set set) {
SequenceSet destSet = (SequenceSet) set;
int len = destSet.size() > length ? length : destSet.size();
SequenceSet tempSet = new SequenceSet(len);
for (int i = 0; i < destSet.size(); i++)
if(contains(destSet.setArray[i])) tempSet.add(destSet.setArray[i]);
return tempSet;
}
public void clear() {
length = 0;
}
@Override
public String toString() {
int iMax = length - 1;
if (iMax == -1) return "[]";
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int i = 0; ; i++) {
sb.append(String.valueOf(setArray[i]));
if (i == iMax)
return sb.append("]").toString();
sb.append(", ");
}
}
}
- 测试类
package setTest;
import set.SequenceSet;
public class SequenceSetTest {
public static void main(String[] args) {
SequenceSet sequenceSet = new SequenceSet();
//sequenceSet.add(null);
sequenceSet.add("ok");
sequenceSet.add("hello");
sequenceSet.add("word");
System.out.println(sequenceSet.toString());
sequenceSet.remove("word");
System.out.println(sequenceSet.toString());
System.out.println(sequenceSet.remove("ko"));
System.out.println(sequenceSet.toString());
System.out.println(sequenceSet.size());
System.out.println(sequenceSet.contains("ko"));
System.out.println(sequenceSet.value(0));
sequenceSet.clear();
sequenceSet.add("apple");
sequenceSet.add("banana");
sequenceSet.add("pair");
System.out.println(sequenceSet.toString());
System.out.println(sequenceSet.size());
SequenceSet unionSet = new SequenceSet();
unionSet.add("testUnion");
System.out.println(unionSet);
SequenceSet interSet = new SequenceSet();
interSet.add("apple");
System.out.println(sequenceSet.intersection(interSet));
}
}