JAVA 集合二
Set集合
特点：无索引，不可重复，无序，存取不一致
public static void main(String[] args){
// Set集合无索引，不可重复，无序，存取不一致，
HashSet<String> hs = new HashSet<>();
boolean b1 = hs.add("a"); // true
boolean b2 = hs.add("b"); // true
boolean b3 = hs.add("a"); // false
System.out.println(hs); // [a, b] HashSet类有父类(AbstractCollection)重写了toString方法
for (String string : hs) {
System.out.println(string); // a b 所有能用迭代器遍历的都可以使用增强for循环
}
}
HashSet类
HashSet原理: 我们使用Set集合都是需要去掉重复元素的, 如果在存储的时候逐个equals()比较, 效率较低,哈希算法提高了去重复的效率, 降低了使用equals()方法的次数
当HashSet调用add()方法存储对象的时候, 先调用对象的hashCode()方法得到一个哈希值, 然后在集合中查找是否有哈希值相同的对象,如果没有哈希值相同的对象就直接存入集合,如果有哈希值相同的对象, 就和哈希值相同的对象逐个进行equals()比较,比较结果为false就存入, true则不存
将自定义类的对象存入HashSet去重复:类中必须重写hashCode()和equals()方法
public class Student {
public static void main(String[] args){
// Set集合无索引，不可重复，无序，存取不一致，
HashSet<Person> hs = new HashSet<>();
hs.add(new Person("张三",11));
hs.add(new Person("张三",11));
hs.add(new Person("李四",11));
hs.add(new Person("王五",11));
System.out.println(hs);//[Person [age=11, name=王五], Person [age=11, name=张三], Person [age=11, name=李四]]
}
}
class Person{
private int age;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Person(String name,int age){
this.age = age;
this.name = name;
}
@Override
public int hashCode() {
final int prime = 31; //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;
Person other = (Person) 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;
}
@Override
public String toString() {
return "Person [age=" + age + ", name=" + name + "]";
}
}
LinkedHashSet类
LinkedHashSet是HashSet子类，是Set集合中唯一一个保证怎么存就怎么取的集合对象，原理和HashSet类似，同样不能保存重复数据
public static void main(String[] args){
LinkedHashSet<String> li = new LinkedHashSet<>();
li.add("a");
li.add("b");
li.add("c");
li.add("a");
System.out.println(li); // [a b c]
}
练习:
// 练习一
public static void main(String[] args){
// 使用Scanner从键盘读取一行输入,去掉其中重复字符, 打印出不同的那些字符
Scanner sc = new Scanner(System.in); //创建键盘录入对象
System.out.println("请输入一行字符串:");
String line = sc.nextLine(); //将键盘录入的字符串存储在line中
char[] arr = line.toCharArray(); //将字符串转换成字符数组
HashSet<Character> hs = new HashSet<>(); //创建HashSet集合对象
for(char c : arr) { //遍历字符数组
hs.add(c); //将字符数组中的字符添加到集合中
}
for (Character ch : hs) { //遍历集合
System.out.println(ch);
}
}
// 练习二
public static void main(String[] args){
// 获取10个1至20的随机数，要求随机数不能重复。
HashSet<Integer> hs = new HashSet<>(); //创建集合对象
Random r = new Random(); //创建随机数对象
while(hs.size() < 10) {
int num = r.nextInt(20) + 1; //生成1到20的随机数
hs.add(num);
}
for (Integer integer : hs) { //遍历集合
System.out.println(integer); //打印每一个元素
}
}
// 练习三
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("a");
list.add("a");
list.add("b");
list.add("b");
list.add("b");
list.add("b");
list.add("c");
list.add("c");
list.add("c");
list.add("c");
System.out.println(list);
System.out.println("去除重复后:");
getSingle(list);
System.out.println(list);
}
/*
* 将集合中的重复元素去掉
* 1,void
* 2,List<String> list
*/
public static void getSingle(List<String> list) {
LinkedHashSet<String> lhs = new LinkedHashSet<>();
lhs.addAll(list); //将list集合中的所有元素添加到lhs
list.clear(); //清空原集合
list.addAll(lhs); //将去除重复的元素添回到list中
}
TreeSet类
TreeSet是用来排序的, 可以指定一个顺序, 对象存入之后会按照指定的顺序排列
使用方式:
-
自然顺序(Comparable)
- TreeSet类的add()方法中会把存入的对象提升为Comparable类型
- 调用对象的compareTo()方法和集合中的对象比较
- 根据compareTo()方法返回的结果进行存储
public class Student { public static void main(String[] args){ TreeSet<Integer> ts = new TreeSet<>(); ts.add(3); ts.add(1); ts.add(2); ts.add(1); System.out.println(ts); // [1, 2, 3] 二插搜索树排 TreeSet<Person> ts1 = new TreeSet<>(); ts1.add(new Person("张三",13)); ts1.add(new Person("李四",14)); ts1.add(new Person("张三",15)); ts1.add(new Person("赵六",15)); System.out.println(ts1); // 报错com.test.Person cannot be cast to java.lang.Comparable // 不添加重复项是因为会调用实现的Comparable接口的compareTo方法，上面的Integer可以是因为Integer类实现了Comparable接口， // 但是我们自定义的对象是没有继承Comparable接口，没有重写compareTo方法，所以会报错，所以我们自定义的类需要实现Comparable接口 // compareTo方法有个返回值，TreeSet则是根据这个返回值判断是否需要加入集合的方式，0 则不加，小于0则反着排，大于0则正向排序 } } class Person implements Comparable<Person>{ private int age; private String name; public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Person(String name,int age){ this.age = age; this.name = name; } @Override public String toString() { return "Person [age=" + age + ", name=" + name + "]"; } @Override public int compareTo(Person o) { //return -1; // 反向排序添加 // return 1; // 正向排序添加 // return 0; // 不添加 // return this.age - o.getAge(); // 根据年龄大小排序 //[Person [age=13, name=张三], Person [age=14, name=李四], Person [age=15, name=张三]] int num = this.age - o.getAge(); // 优先根据年龄排序 int sum = num == 0 ? this.name.compareTo(o.getName()):num; // 年龄若相同，则根据姓名排序 return sum; //[Person [age=13, name=张三], Person [age=14, name=李四], Person [age=15, name=张三], Person [age=15, name=赵六]] } -
比较器顺序(Comparator)
- 创建TreeSet的时候可以制定 一个Comparator
- 如果传入了Comparator的子类对象, 那么TreeSet就会按照比较器中的顺序排序
- add()方法内部会自动调用Comparator接口中compare()方法排序
- 调用的对象是compare方法的第一个参数,集合中的对象是compare方法的第二个参数
public class Student { public static void main(String[] args){ // 将字符串按照字符串长度排序 TreeSet<String> ts = new TreeSet<>(); ts.add("aaaaa"); ts.add("bcd"); ts.add("dc"); ts.add("a"); System.out.println(ts); // [a, aaaaa, bcd, dc]这是按照ASIIC码排序 TreeSet<String> ts2 = new TreeSet<>(new Comparator<String>(){ @Override //匿名内部内， public int compare(String o1, String o2) { int num = o1.length() - o2.length(); // 优先按照字符串长度排序 int sum = num == 0? o1.compareTo(o2):num; // 字符串长度一致则按照ASIIC码排序 return sum; } }); ts2.add("aaaaa"); ts2.add("bcd"); ts2.add("dc"); ts2.add("a"); System.out.println(ts2); //[a, dc, bcd, aaaaa] 这是按照字符串长度排序的 } }
两种方式的区别:
TreeSet构造函数什么都不传, 默认按照类中Comparable的顺序, TreeSet如果传入Comparator, 就优先按照Comparator
练习：键盘输入: helloworld程序打印:dehllloorw
