集合(Set接口的使用和理解)
集合(Set接口的使用和理解)
1- Set接口的理解：
/*
collection接口：单列集合，用来存储一个一个的对象
set接口：存储无序的、不可重复的数据
HashSet: 作为Set接口的主要实现类；线程不安全；可以存储null值
LinkedHashSet：作为hashSet的子类；"便利"其内部数据的时候，可以按照填写的顺序"便利"(填写顺序便利，其实就是--有序的,但是这个只是看起来有序，实际底层还是无序的)
treeSet：可以按照添加对象的指定属性，进行排序 （指定对象属性排序 --其实就是使用Comparable出现的效果，仅此而已）
*/
所以对这个--伪君子的介绍
HashSet:存储无序的、不可重复的数据 ---->（但是要重写--equal方法）
LinkedHashSet：---->（给出的效果是有序的，底层又是无序的）
treeSet：说给我们可以按照属性排序 ---->（就用compareTo和comparator来对“类”进行比较的，仅此而已）下面User类的内容
User类的内容
package _366After.src.javeTeacher.gather.gather_there;
import java.util.Objects;
public class User implements Comparable {
private String name;
private int age;
public User() {
}
public User(String name, int age) {
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
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return age == user.age && Objects.equals(name, user.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
//要String比较所以要进行 --- 重写compareTo方法
@Override
public int compareTo(Object o) {
if (o instanceof User) {
User user = (User) o;
int compare = this.name.compareTo(user.name); //对一样名字，再进行一次处理
//如果名字不一样，不会返回 = 0 ， 所以 = 0的情况就是，名字相同，我们再进行处理
if (compare != 0) {
return compare;
} else {
return Integer.compare(this.age, user.age); //比较Inerger类型，需要这样的形式
}
} else {
throw new RuntimeException("输入的类型不匹配");
}
}
}2- HashSet的使用
package _366After.src.javeTeacher.gather.gather_there;
import org.testng.annotations.Test;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
public class About_Set_understand {
// set接口：存储无序的、不可重复的数据
/*
1- 无序性 != 随机性
存储的数据在底层数组中并非按照数组的索引的顺序添加，而是根据---哈希值
2- 不可重复性 :保证添加的元素按照equals()判断时候，不能返回true，-- 相同的元素只能添加一个
要求：向Set中添加的数据，其所在的类一定要重写 hashCode 和 equal 方法
*/
@Test
public void test1() {
HashSet set = new HashSet();
set.add(123);
set.add(456);
set.add(789);
set.add(new User("张三", 21));
set.add(new User("张三", 21));
set.add(new User("李四", 43));
set.add("AA");
set.add("BB");
set.add("CC");
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
出来的效果，只是，无序的效果 ---仅此而已3-LinkedhashSet的使用
package _366After.src.javeTeacher.gather.gather_there;
import org.testng.annotations.Test;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
public class About_Set_understand {
// LinkedHashSet的使用
/* LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护类两个引用，记录前后两个数据
优点：对于频繁的便利效果，LinkedHashSet效率比hashSet的高
*/
@Test
public void test2() {
HashSet set1 = new LinkedHashSet();
set1.add(123);
set1.add(456);
set1.add(789);
set1.add(new User("张三", 21));
set1.add(new User("张三", 21));
set1.add(new User("李四", 43));
set1.add("AA");
set1.add("BB");
set1.add("CC");
Iterator iterator1 = set1.iterator();
while (iterator1.hasNext()) {
System.out.println(iterator1.next());
}
}
}
出来的效果 --就是（有序的便利），仅此而已3- TreeSet的使用
package _366After.src.javeTeacher.gather.gather_there;
import org.testng.annotations.Test;
import java.util.Iterator;
import java.util.TreeSet;
/*
1- treeSet中添加的数据，要求是 "相同类" 的对象
2-两种（排列）方式
自然排序：比较两个对象是否相同的标准：compareTo返回0，而不是equals
定制排序：比较两个对象是否相同的标准：compare返回0，而不是equals
** 没有写全--建议看Comparable专门的章节
*/
public class TreeSetDemo {
@Test
public void test1() {
/*
1- treeSet中添加的数据，要求是 "相同类" 的对象
*/
//错误示范
// TreeSet set = new TreeSet();
// set.add(3);
// set.add(2);
// set.add(5);
// set.add(1);
// set.add(3);
// set.add(new User("ZZ",12));
// set.add("AA");
// System.out.println(set);
}
@Test
public void test2() {
//举例子一、 调用已经有的Comparable-自带的方法
TreeSet set = new TreeSet();
set.add(3);
set.add(2);
set.add(5);
set.add(1);
set.add(3);
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
@Test
public void test4() {
//使用“自然排序”
//举例二、比较String类型 --- （在Uer类里面要重写 1-继承Comparable 2- 重写ComparableTo方法 ）
//需要回顾 --> comparable的内容
TreeSet set = new TreeSet();
set.add(new User("qq", 2));
set.add(new User("ww", 22));
set.add(new User("ee", 33));
set.add(new User("rr", 44));
set.add(new User("rr", 43));
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}set的使用场景：（配合list去除相同的内容的部分）
package _366After.src.javeTeacher.gather.gather_set.Set_Test;
import org.testng.annotations.Test;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
/*
使用set的场景
1- 让list去除重复的内容
*/
public class Set_test {
public List duplicateList(List list) { //方法
HashSet set = new HashSet(); //设置hashset
set.addAll(list); //把有重复内容的list，放到hashSet里面，去除相同内容
return new ArrayList(set); //因为你开头返回值是List，如果直接写set，返回的是haseSet值，不是list
}
@Test
public void test() {
ArrayList list = new ArrayList(); //1- 创建一个list的集合
list.add(new Integer(1)); //2- 给集合--添加内容
list.add(new Integer(2));
list.add(new Integer(2));
list.add(new Integer(5));
list.add(new Integer(5));
list.add(new Integer(3));
List list1 = duplicateList(list); //3- 把（有重复内容的list）放到hashSet里面
for (Object obj : list1) { //4- 便利
System.out.println(obj);
}
}
}
