集合类——Collection、List、Set接口

集合类

Java类集

我们知道数组最大的缺陷就是：长度固定。从jdk1.2开始为了解决数组长度固定的问题，就提供了动态对象数组实现框架——Java类集框架。Java集合类框架其实就是Java针对于数据结构的一种实现。

Java类集的本质就是动态对象数组。

在Java类集中提供有两个最为核心的接口：Collection和Map接口。

1、Collection接口

（1）定义:

public interface Collection<E> extends Iterable<E>

Collection是单个集合保存的最大接口。

Collection与写过的链表类似，每一次进行数据操作的时候只能对单个对象进行处理。且从jdk1.5开始追加泛型应用，这样可以避免ClassCastException异常的出现，里面的所有保存数据类型应该相同。

（2）常用方法

向集合中添加元素：boolean add(E e)

向集合中添加一组元素：boolean addAll(Collection<? extends E> c)

清空集合数据： void clear()

查找数据是否存在：boolean contains(Object o)

删除数据:boolean remove(Object o)

取得集合长度：int size()

将结合变为对象数组：Object[] toArray()

取得Iterator接口对象，用于集合输出：Iterator<E> iterator()

实则Collection接口只是一个存储数据的标准，并不能用来区分存储类型。如：需要区分可存储数据的重复与否。所以我们一般用来使用的是Collection的两个子接口：List和Set。

2、List接口

public interface List<E> extends Collection<E>

新增方法：

根据索引取得保存数据: E get(int index)

修改数据： E set(int index, E element)

List接口与Collection接口相比，比其增加了一个get()、set()方法，可以通过指定的索引值取得修改、内容。要想取得接口的实例化对象则其必须有子类，在List接口下有三个常用子类：ArrayList、Vector、LinkedList.

（1）ArrayList

public class ArrayList<E> extends AbstractList<E>

ArrayList是针对于List的数组实现。

package mycollection;
 
 
 
import java.util.*;
 
 
 
public class Test {
 
public static void main(String[] args) {
 
//这时候集合中只能存String类型的数据
 
List<String> list = new ArrayList<>();
 
list.add("hello");
 
list.add("world");
 
//添加重复元素
 
list.add("hello");
 
list.add("陕科大");
 
System.out.println(list);
 
//返回集合中元素的个数
 
System.out.println("新增元素后集合长度："+list.size());
 
//判断集合是否为空
 
System.out.println("集合是否为空："+list.isEmpty());
 
//判断集合是否包含指定元素(元素存在)
 
System.out.println("集合中是否包含元素“hello”:"+list.contains("hello"));
 
//判断集合是否包含指定元素(元素不存在)
 
System.out.println("集合中是否包含元素“haha”:"+list.contains("haha"));
 
//取得集合指定位置的元素
 
System.out.println("下标为2的元素："+list.get(2));
 
//修改指定位置的元素
 
System.out.println("修改下标为3的元素：");
 
list.set(3, "lemon");
 
System.out.println("修改元素后将集合中元素转化为数组并打印"+list.toArray());
 
for (String string : list) {
 
System.out.print(" "+string);
 
}
 
System.out.println();
 
//清空集合中元素
 
System.out.println("清空集合：");
 
list.clear();
 
System.out.println("清空后集合是否为空："+list.isEmpty());
 
 }
 
}

由上述运行结果我们可以发现List可以存储重复元素。

get()方法是List子接口提供的，根据指定下标返回元素。若我们要对Collection接口实现此操作，则引用该将其转换为对象数组再进行操作。

//利用Collection实现get()方法
 
public class Test {
 
public static void main(String[] args) {
 
//这时候集合中只能存String类型的数据
 
Collection<String> list = new ArrayList<>();
 
list.add("hello");
 
list.add("world");
 
//添加重复元素
 
list.add("hello");
 
list.add("陕科大");
 
//操作以Object为主，可能需要向下转型，就会出现ClassCastException异常
 
Object[] object = list.toArray();
 
System.out.println(Arrays.toString(object));
 
System.out.println("下标为2的元素:"+object[2]);
 
 }
 
}

（1）Vector

Vector是jdk1.0提出的，而ArrayList是jdk1.2提出的，Vector相对使用较少。

Vector的使用与ArrayList的使用类似

public class Test {
 
public static void main(String[] args) {
 
//这时候集合中只能存String类型的数据
 
List<String> list = new Vector<>();
 
list.add("hello");
 
list.add("world");
 
//添加重复元素
 
list.add("hello");
 
System.out.println(list);
 
//返回集合中元素的个数
 
System.out.println("新增元素后集合长度："+list.size());
 
//判断集合是否为空
 
System.out.println("集合是否为空："+list.isEmpty());
 
//判断集合是否包含指定元素(元素存在)
 
System.out.println("集合中是否包含元素“hello”:"+list.contains("hello"));
 
//判断集合是否包含指定元素(元素不存在)
 
System.out.println("集合中是否包含元素“haha”:"+list.contains("haha"));
 
//取得集合指定位置的元素
 
System.out.println("下标为2的元素："+list.get(2));
 
//修改指定位置的元素
 
System.out.println("修改下标为3的元素：");
 
list.set(1, "lemon");
 
System.out.println("修改元素后将集合中元素转化为数组并打印"+list.toArray());
 
for (String string : list) {
 
System.out.print(" "+string);
 
}
 
System.out.println();
 
//清空集合中元素
 
System.out.println("清空集合：");
 
list.clear();
 
System.out.println("清空后集合是否为空："+list.isEmpty());
 
 }
 
}

ArrayList和Vector的区别：

A. 时间上：Vector是jdk1.0提供的；而ArrayList是jdk1.5提供的。

B. 处理形式：Vector是同步处理，性能较低；而ArrayList是异步处理，性能相对高。

C. 数据安全：Vector是线程安全的；而ArrayList是非线程安全的。

D. 输出形式：Vector支持Iterator、ListIterator、 foreach、Enumeration输出；而ArrayList支持Iterator、ListIterator、foreach输出。

（2）LinkedList

若还是利用子类向父类转型来使用的话，LinkedList的使用和前面两者也没什么区别。

ArrayList和LinkedList的区别：

观察ArrayList的源码，可以发现ArrayList里面存放的是一个数组，如果实例化此对象时传入了数组的大小，则里面保存的数组就会开辟一个定长的数组，但是后续中再进行数据保存，若该长度不够使用则会对数组进行动态扩充。所以我们在使用ArrayList时最好对其设置初始化大小。

LinkedList就是一个纯粹的链表实现，除性能高外与我们编写的链表没有什么区别。

ArrayList封装的是数组，而LinkedList封装的是链表。进行查找时ArrayList的时间复杂度为1，而LinkedList的时间复杂度为n。

3、Set接口

与List接口相比Set：Set中的内容是不允许重复的，且没有对Collection接口再进行方法的扩充。所以Set中没有get()方法。

Set接口中提供与两个常用子类：HashSet（无需存储）和TreeSet（有序存储）。

public class Test{
	public static void main(String[] args) {
//Set<Integer> set = new HashSet<>();
		Set<Integer> set = new TreeSet<>();
		set.add(20);
		set.add(6);
		set.add(15);
		set.add(-3);
		set.add(20);
		//添加重复元素
		System.out.println(set);
	}
}

HashSet运行后结果 TreeSet运行后结果

由此我们可以看出HashSet是对集合进行无需存储，而TreeSet则对集合进行有序存储（采用升序模式进行排列）。

（1）TreeSet中排序的分析

因此我们对TreeSet的排序来进行分析：

由于TreeSet可以进行排序操作，所以我们可以来实现数据的排序处理。此时进行的排序实际是针对对象数组进行的排序处理，而如果要对对象数组进行排序，则对象所在的类要实现Comparable接口并且要覆写compareTo()方法(要利用Comparable接口进行大小关系比较时必须要对所有的属性进行比较操作)。

//自定义类
class Person implements Comparable<Person>{
	private String name;
	private Integer age;
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	Person(String name, Integer age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	@Override
	public int compareTo(Person o) {
		if(this.age > o.age) {
			return 1;
		}else if(this.age < o.age) {
			return -1;
		}else {
			return this.name.compareTo(o.name);
		}
	}
}
public class Test{
	public static void main(String[] args) {
		Set<Person> set = new TreeSet<>();
		set.add(new Person("lemon",20));
		set.add(new Person("demon", 20));
		set.add(new Person("lemon",20));
		System.out.println(set);
	}
}

这样一个一个属性进行比较的操作过于麻烦，所以一般情况下我们都使用HashSet。

（2）重复元素的判断在使用TreeSet子类进行数据保存时。重复元素的判断依靠Comparable接口来实现。但是这并不是全部Set接口判断元素重复的方式，因为如果使用的是HashSet子类，因为其和Comparable没有任何关系，所以它判断重复要依靠Object类的两个方法：

hash码： public native int hashCode();

对象比较：public boolean equals(Object obj);

在Java中进行对象比较的操作有两个步骤：第一步要通过一个对象的唯一编码找到一个对象的信息，当编码匹配之后再进行下一步操作利用equals()方法进行内容比较。

/*
 * 标识对象的唯一性
 * */
//自定义类
class Person implements Comparable<Person>{
	private String name;
	private Integer age;
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	Person(String name, Integer age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	
	public int compareTo(Person o) {
		if(this.age > o.age) {
			return 1;
		}else if(this.age < o.age) {
			return -1;
		}else {
			return this.name.compareTo(o.name);
		}
	}
	@Override
	public int hashCode() {
		return Objects.hash(name,age);
	}
	@Override
	public boolean equals(Object obj) {
		if(this == obj) {
			return true;
		}
		if(obj == null|| getClass()!=obj.getClass()) {
			return false;
		}
		Person person = (Person) obj;
		return Objects.equals(name,person.name)
				&& Objects.equals(age,person.age);
	}
	
}
public class Test{
	public static void main(String[] args) {
		Set<Person> set = new HashSet<>();
		set.add(new Person("lemon",20));
		set.add(new Person("lemon",20));
		set.add(new Person("demon", 18));
		System.out.println(set);
	}
}