java中List与Set的常用用法

java中的集合主要分为三种：Set（集）、List（列表）、Map（映射）

下图为List、Set和Collection的联系，我们可以看出List和Set均继承自Collection，值得注意的是List、Set和Collection都为接口，不能直接实例化对象。List的两个实现类为ArrayList和LinkedList。

1.List集合的元素是有序的（取出顺序和存储顺序一致），元素可以重复

（1）ArrayList：继承了List的特点，底层数据结构是数组，因此它的查询速度快，但是增删速度慢。他是线程不安全的，效率高。

（2）LinkedList：同样继承了List的特点，底层数据结构是链表，所以它的增删速度快，查询速度慢。线程不安全、效率高。

新建一个测试学生类，这里只说引用类型，不讨论基本类型，后面不再论述。

<span style="font-size:18px;">public class Student {
	private String name;	//学生姓名	
	private int age;		//学生姓名
	
	//构造函数
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	//重写	toString()方法
	public String toString() {
		return "姓名：" + name + "\t 年龄：" + age;
	}
	
}

</span>

鉴于篇幅原因，这里只给出ArrayList的代码，因为LinkedList和ArrayList一样的。

<span style="font-size:18px;">public static void main(String[] args) {
		//创建一个ArrayList的集合
		ArrayList<Student>  list = new ArrayList<Student>();
		Student s1 = new Student("张三", 19);		//创建学生对象
		Student s2 = new Student("李四", 17);		
		Student s3 = new Student("小明", 18);
		Student s4 = new Student("小红", 22);
		Student s5 = new Student("李四", 17);
		list.add(s1);   //增加成员
		list.add(s2); 
		list.add(s3); 
		list.add(s4); 
		list.add(s5); 
		//有三种遍历方式
		
		//1.迭代器
//		Iterator<Student> iterator = list.iterator();
//		while (iterator.hasNext()) {
//			System.out.println(iterator.next());
//		}
		
		//2.for循环遍历
//		for (int i = 0; i < list.size(); i++) {
//			System.out.println(list.get(i));
//		}
		
		//3.增强for循环
		for (Student student : list) {
			System.out.println(student);
		}
	}</span>

通过重写Collectios的sort方法可以实现自定排序，以上面为例，按年龄从小到大排序：

<span style="font-size:18px;">//重写sort方法，通过匿名内部类实现
		Collections.sort(list,new Comparator<Student>() {

			@Override
			public int compare(Student o1, Student o2) {
				if((o1.getAge()-o2.getAge())>0){
					return 1;
				}else if((o1.getAge()-o2.getAge())<0){
					return -1;
				}else
				return 0;
			}
		});</span>

还可以通过在自定义类（Student类）中实现Comparable接口，重写compareTo()方法来实现自定义排序，按年龄从大到小排序：

<span style="font-size:18px;">@Override
	public int compareTo(Student o) {
		if((this.getAge()-o.getAge())>0){
			return 1;
		}else if((this.getAge()-o.getAge())<0){
			return -1;
		}else
		return 0;
	}</span>

1.Set集合的元素是唯一的，不可重复（有两种遍历方式：1.迭代器，2.增强for.代码参照上面）

（1）HashSet：继承了Set的特点，元素唯一，但是无序。底层数据结构是哈希表，通过重写HashCode()方法和equals()方法可以保证元素的唯一性。

（2）TreeSet：继承了Set的特点，元素唯一而且有序（使用元素的自然顺序对元素进行排序，或者根据创建 set时提供的 Comparator进行排序，具体取决于使用的构造方法）。底层数据结构是二叉树，通过Compareable接口的compareTo()方法来保证元素的唯一性。

<span style="font-size:18px;">public static void main(String[] args) {
		//创建一个HashSet的集合
		HashSet<Student> hs = new HashSet<Student>();
		Student s1 = new Student("张三", 19);		//创建学生对象
		Student s2 = new Student("李四", 17);		
		Student s3 = new Student("小明", 18);
		Student s4 = new Student("小红", 22);
		Student s5 = new Student("李四", 17);
		hs.add(s1);   //增加成员
		hs.add(s2); 
		hs.add(s3); 
		hs.add(s4); 
		hs.add(s5); 
		
		for (Student student : hs) {
			System.out.println(student);
		}</span>

运行上面的程序我们发现，咦，怎么有两个 "李四"，17 ，这是因为没有重写HashCode()方法和equals()方法，导致元素不是唯一的，解决方案就是在Student类中重写HashCode()方法和equals()方法即可。

自动重写HashCode()方法和equals()方法步骤：右击选择Source，找到Generate hashCode() and equals(),点击去，全选确定即可，系统会自动帮你重写。代码入下：

<span style="font-size:18px;">@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}</span>

运行后发现李四只剩一个了，这是因为重写了HashCode()方法和equals()方法，保证了元素的唯一性。
下面是TreeSet的：

<span style="font-size:18px;">public static void main(String[] args) {
		//创建一个TreeSet的集合
		TreeSet<Student> hs = new TreeSet<Student>();
		Student s1 = new Student("张三", 19);		//创建学生对象
		Student s2 = new Student("李四", 17);		
		Student s3 = new Student("小明", 18);
		Student s4 = new Student("小红", 22);
		Student s5 = new Student("李四", 17);
		hs.add(s1);   //增加成员
		hs.add(s2); 
		hs.add(s3); 
		hs.add(s4); 
		hs.add(s5); 
		
		for (Student student : hs) {
			System.out.println(student);
		}
	}</span>

运行上面的代码会发现error:Exception in thread "main" java.lang.ClassCastException.这又是怎么回事？这是因为
TreeSet通过Compareable接口的compareTo()方法来保证元素的唯一性。可以通过下面两种方式来解决：

1.自定义类(Student)继承Comparable接口重写compareTo()方法来实现

以上面Student类为例，按年龄从小到大排序

<span style="font-size:18px;">	@Override
	public int compareTo(Student o) {
		if((this.getAge()-o.getAge())>0){
			return 1;
		}else if((this.getAge()-o.getAge())<0){
			return -1;
		}else
		return 0;
	}</span>

对于这种方式，TreeSet采用的构造器应当是无参的，也就是使用元素的自然顺序对元素进行排序。

2.创建set集合的时候，传入Comparator进行排序，进行排序,也叫作比较器排序

public static void main(String[] args) {
		//创建一个TreeSet的集合
		TreeSet<Student> hs = new TreeSet<Student>(new Comparator<Student>() {

			@Override
			public int compare(Student o1, Student o2) {
				int num1 = o1.getAge() - o2.getAge();
				int num2 = num1==0?o1.getName().compareTo(o2.getName()):num1;
				return num2;
			}
		});
		Student s1 = new Student("张三", 19);		//创建学生对象
		Student s2 = new Student("李四", 17);		
		Student s3 = new Student("小明", 18);
		Student s4 = new Student("小红", 22);
		Student s5 = new Student("李四", 17);
		hs.add(s1);   //增加成员
		hs.add(s2); 
		hs.add(s3); 
		hs.add(s4); 
		hs.add(s5); 
		
		for (Student student : hs) {
			System.out.println(student);
		}
	}

这里使用了内部类，也达到了同样的目的。