黑马程序员---Java基础---Set集合

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一.泛型

                 JDK5之后支持带有泛型的类, 集合上如果加了泛型, 只能存储同一类型的数据, 获取数据时的类型也被指定了

                 这样做避免了一些不安全因素, 而且省去了强转的麻烦

 

二.可变参数

         1.什么是可变参数

                   JDK5之后函数的参数可以定义为可变参数

                   可变参数的定义方式为(类型... 变量名)

                   可变参数可以接收指定类型的0到多个实参, 也可以接收指定类型的一个数组.

                   这些实参都会传入到形参变量代表的数组中, 传了几个实参, 形参数组的长度就是几.

                   可变参数必须是参数列表的最后一个

         2.什么时候使用可变参数

                   定义一个函数的时候, 如果需要接收的数据个数不确定, 那么就可以定义为可变参数

                   调用方法时, 可以按照实际需求传入不同数量的实参

                  

三.List的分类

         1.ArrayList

                   数组实现, 查找快

         2.LinkedList

                   链表实现, 增删快

                   也是一种队列的实现, 可以使用remove()方法获取队首的元素

         3.Vector

                   和ArrayList原理相同, 但线程安全, 效率略低

                   拥有一种自己特有的迭代方式

                   使用elements()方法可以获取一个Enumeration,调用hasMoreElements()方法判断是否包含下一个, 调用nextElements()获取下一个

         4.Stack

                   Stack是一种栈结构的容器, 先存的元素最后被取出, 后存的元素先被取出

                  

四.Set集合

         1.HashSet

                   只去重复, 没有顺序

                   HashSet的add方法会调用hashCode和equals, 所以存储在HashSet中的对象需要重写这两个方法.可用Source中的GeneratehashCode() and equals()…自动生成

* 如果希望一个集合有去重复的功能, 可以在它的add方法中检查要添加的对象在集合中是否存在.

 * 迭代集合中每个元素, 和要添加的比较, 如果相同, 就不存.

 * 如果使用上述方法, 当集合元素特别多的时候, 效率会很低. 例如: 集合中有1万个元素, 当存储下一个的时候, 需要和前面1万个都比较, 效率较低.

 * HashSet的工作原理:

 *             每次存储对象的时候, 调用对象的hashCode()方法, 计算一个哈希值. 在集合中查找是否包含哈希值相同的元素.

 *                      如果没有哈希值相同元素, 直接存入.

 *                      如果有哈希值相同的元素, 逐个使用equals()方法比较.

 *                               比较结果全为false就存入.

 *                               如果比较结果有true则不存.

 * 如何将自定义类对象存入HashSet进行去重复

 *             类中必须重写hashCode()方法和equals()方法

 *             equals()方法中比较所有属性

 *             hashCode()方法要保证属性相同的对象返回值相同, 属性不同的对象尽量不同

 

         2.TreeSet

                  去重复, 并且可以按照某种顺序排序

                   TreeSet的add方法会将对象转为Comparable,然后调用compareTo方法, 所以存储在TreeSet中的对象必须实现Comparable, 重写compareTo方法

* TreeSet存储对象的时候, 可以排序, 但是需要指定排序的算法

* Integer能排序(有默认顺序), String能排序(有默认顺序), 自定义的类存储的时候出现异常(没有顺序)

* 如果想把自定义类的对象存入TreeSet进行排序, 那么必须实现Comparable接口

 *             在类上implementComparable

 *             重写compareTo()方法

 *             在方法内定义比较算法, 根据大小关系, 返回正数负数或零

 *             在使用TreeSet存储对象的时候,add()方法内部就会自动调用compareTo()方法进行比较, 根据比较结果使用二叉树形式进行存储

         3.LinkedHashSet

                   HashSet的子类, 去重复, 并且保留存储顺序

         4.迭代方式

                   使用迭代器Iterator

                   使用增强for循环

	public static void main(String[] args) {
		
		Set<String> set = new HashSet<String>();
		set.add("xxx");
		set.add("xxx");
		set.add("def");
		set.add("abc");
		
		for (Iterator<String> iter = set.iterator(); iter.hasNext(); )
			System.out.println(iter.next());
		
		System.out.println();
		
		for (String s : set)
			System.out.println(s);
	}

         5.练习

                   创建一个Student类, 包含3个属性: 姓名, 学号, 成绩. 创建若干对象(包含一部分重复的), 存储HashSet集合, 迭代HashSet集合.

                   用上面定义好的Student类创建若干对象, 成绩不同, 将这些对象装入TreeSet,并且按照成绩排序, 成绩相同的按照学号排序.

package it.tist;

public class Student implements Comparable<Student> {
	private String name;	//私有成员变量
	private String num;
	private double score;

	public Student() {		//构造函数
		super();
	}

	public Student(String name, String num, double score) {
		super();
		this.name = name;
		this.num = num;
		this.score = score;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getNum() {
		return num;
	}

	public void setNum(String num) {
		this.num = num;
	}

	public double getScore() {
		return score;
	}

	public void setScore(double score) {
		this.score = score;
	}

	public String toString() {		//以特定格式输出
		return "Student [name=" + name + ", num=" + num + ", score=" + score
				+ "]";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		result = prime * result + ((num == null) ? 0 : num.hashCode());
		long temp;
		temp = Double.doubleToLongBits(score);
		result = prime * result + (int) (temp ^ (temp >>> 32));
		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 (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (num == null) {
			if (other.num != null)
				return false;
		} else if (!num.equals(other.num))
			return false;
		if (Double.doubleToLongBits(score) != Double
				.doubleToLongBits(other.score))
			return false;
		return true;
	}

	@Override
	public int compareTo(Student o) {		//重写自然顺序
		int scoreGap;
		if (this.score < o.score)
			scoreGap = 1;
		else if (this.score > o.score)
			scoreGap = -1;
		else
			scoreGap = 0;
		return scoreGap != 0 ? scoreGap : this.num.compareTo(o.num); // 按成绩排序,成绩相同按照学号排序
	}
}

package it.tist;

import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetReview {

	public static void main(String[] args) {
		TreeSet<Student> ts1 = new TreeSet<Student>();
		ts1.add(new Student("张三", "NO.0001", 100));
		ts1.add(new Student("李四", "NO.0002", 95.5));
		ts1.add(new Student("王五", "NO.0003", 95.5));
		ts1.add(new Student("赵六", "NO.0004", 96));
		for (Iterator<Student> iter = ts1.iterator(); iter.hasNext();)
			System.out.println(iter.next());
	}

}

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------