Set与Map

Set
1，无序的（存入与取出顺序不一定一致）
2，不允许有重复元素、


一、HashSet
哈希表结构
1，判断存入对象的哈希码值是否在集合中已经存在
2，如果存在，调用equals()方法判断对象内容是否一致
3，如果返回true，则对象已经存在，不存储
4，如何返回false，则可以存在另一片内存中
5，哈希码值不一致，则将其存储在当前哈希码值对应存在的地方


注意：
1，存入哈希的对象的类，必须重写HashCode(Object obj)和equals()方法
2，存对象时，是根据哈希码值寻找存储地点；取对象时，也根据哈希码值计算出它的存储索引
3，Set接口对于存，取，删除对象都有很高的效率
4，HashSet不保存元素加入的顺序，因此是无序的


例子：新建一个Students类，有属性name和age  重写HashCode和equals方法
public class Students {
private String name;
private int age;


public Students(String name, int age) {
super();
this.name = name;
this.age = age;
}


@Override
public String toString() {
return "Students [name=" + name + ", age=" + age + "]";
}


// 重写hashCode方法
@Override
public int hashCode() {
//这里的算法没有特殊要求可以随意写
return this.name.hashCode() * 7 + age * 3;
}


// 重写equals方法
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
} else {
if (obj instanceof Students) {
Students students = (Students) obj;
if (this.name.equals(students.name) && this.age == students.age) {
return true;
}
}
}
return false;
}
}


测试类中，新建HashSet集合，并存入students对象进去，在遍历打印
public class Test1 {
public static void main(String[] args) {
// 创建HashSet集合存入数据类型为Students
HashSet<Students> hashSet = new HashSet<Students>();
// 创建Students对象
Students s1 = new Students("熊熊1", 1);
Students s2 = new Students("熊熊2", 2);
Students s3 = new Students("熊熊3", 3);
Students s4 = new Students("熊熊4", 4);
Students s5 = new Students("熊熊5", 5);
Students s6 = new Students("熊熊6", 6);
Students s7 = new Students("熊熊7", 7);
Students s8 = new Students("熊熊8", 8);
Students s9 = new Students("熊熊1", 1);
//向集合中添加数据
hashSet.add(s1);
hashSet.add(s2);
hashSet.add(s3);
hashSet.add(s4);
hashSet.add(s5);
hashSet.add(s6);
hashSet.add(s7);
hashSet.add(s8);
hashSet.add(s9);
//遍历集合中的元素
for (Students students : hashSet) {
System.out.println(students);
}
}
}


二、TreeSet
红黑树（二叉树）
1，比较性
Comparable
让存储对象所在类实现Comparable接口，重写compareTo方法
局限是只能使当前类的对象拥有可比较性
2，比较器
Comparator
自定义一个比较器：
1，创建实现Comparator接口的类
2，重写compare方法
使用：
1，new TreeSet<E>(Comparator的对象类);






注意：
1，对象类实现Comparable接口
2，对象类重写compareTo方法
3，compareTo方法返回值
= 0：表示对象相同，不存储
> 0：存储在二叉树右边 （例如：return 1;从小到大排列）
< 0：存储在二叉树左边 （例如：return -1;从大到小排列）


比较器例子：实现存储Dog，判断姓名，年龄，性别都是一样才是同一只狗，否则就是不同的狗，可以存储
1，创建一个Dog类，有name，age和sex属性，给构造函数和get，set方法，toString方法
2，创建一个MyComparator比较器
import java.util.Comparator;


import com.xiong.work15_01.Students;


/**
 * 姓名，年龄，性别比较器
 * 
 */
public class MyComparator implements Comparator<Dog> {
@Override
public int compare(Dog o1, Dog o2) {
int a, b, c;
a = o1.getName().compareTo(o2.getName());
b = o1.getAge() - o2.getAge();
c = o1.getSex().compareTo(o2.getSex());
if (a != 0) {
return a;
} else if (b != 0) {
return b;
} else if (c != 0) {
return c;
} else {
System.out.println(o1 + "和" + o2 + "是同一只狗");
return 0;
}


}
}
测试类
public class Test1 {
public static void main(String[] args) {
// 创建比较器
MyComparator myComparator = new MyComparator();


TreeSet<Dog> treeSet = new TreeSet<Dog>(myComparator);
Dog s1 = new Dog("小黑", 11, "男");
Dog s2 = new Dog("小白", 12, "女");
Dog s3 = new Dog("小花", 13, "女");
Dog s4 = new Dog("小长", 14, "男");
Dog s5 = new Dog("小短", 15, "男");
Dog s6 = new Dog("小黑", 11, "男");
Dog s7 = new Dog("小黑", 12, "男");
// 向集合中添加数据
treeSet.add(s1);
treeSet.add(s2);
treeSet.add(s3);
treeSet.add(s4);
treeSet.add(s5);
treeSet.add(s6);
treeSet.add(s7);
// 遍历集合中的元素
for (Dog students : treeSet) {
System.out.println(students);
}
}
}




Map 
也是存放数据的集合
key value 键值对：映射关系
Map中的Key值不能相同


Map<Key的数据类型,value的数据类型>();
put(k,v); 存储一对
putAll(); 存储一组

remove(k); 删除一对
clean(); 清空

get(key); 获得所对应的value
values(); 获取map中所有Value，以set形式返回
entrySet(); 获取整合entry集合，以set形式返回

boolean emptu = hashMap.isEmpty();  判断map集合是否为空
String remove = hashMap.remove(p1);  移除集合中元素


1，HashMap
1，不同步的
2，允许空键，允许空值
2，Hashtable
1，同步的
2，TreeMap
1，不允许空键，允许空值
2，key必须拥有可比较性，也就是说key所在的类需要实现comparable接口
键值：
Set<String> keySet = map.keySet();
value值：
Collection<Integer> values = treeMap.values();
键值对：
Set<Entry<String, Integer>> entrySet = treeMap.entrySet();
再用foreach遍历




例子：hashMap


public class HashMapDemo {
public static void main(String[] args) {
Map<String, Object> map = new HashMap<String,Object>();
/**
* 使用put方法存值
* 如果key值相同，则后存的会将前面的覆盖
*/
map.put("王1", new Person("王大爷1", 11));
map.put("王2", new Person("王大爷2", 12));
map.put("王3", new Person("王大爷3", 13));
map.put("王4", new Person("王大爷4", 14));
map.put("王5", new Person("王大爷5", 15));
map.put("王1", new Person("王大爷6", 16));

Set<String> keySet = map.keySet();
for (String string : keySet) {
System.out.print(string+",");
//获取value
System.out.println(map.get(string));
}
}
}