java学习笔记（day25）
0x00 Set接口
概述
java.util.Set接口 extends Collection接口
Set接口的特点：
- 不允许存储重复的元素。
- 没有索引，没有带索引的方法，也不能使用普通的for循环遍历。
java.util.HashSet集合 implements Set接口
特点：
- 不允许存储重复的元素。
- 没有索引，没有带索引的方法，也不能使用普通的for循环遍历。
- 是一个无序的集合，存储元素和取出元素的顺序有可能不一致。
- 底层是一个哈希表结构（查询速度非常的快）。
代码演示：
package day25;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class HashSetDemo01 {
public static void main(String[] args) {
Set<Integer> set = new HashSet<>();
//使用add方法往集合中添加元素
set.add(1);
set.add(2);
set.add(3);
//使用迭代器遍历set集合
Iterator<Integer> it = set.iterator();
while (it.hasNext()){
int a = it.next();
System.out.println(a);
}
//使用增强for循环遍历set集合
for (Integer i:set){
System.out.println(i);
}
}
}
哈希获取方法
哈希值：是一个十进制的整数，有系统随机给出（其实就是对象的地址值，是一个逻辑地址，是模拟出来得到的地址，不是数据实际存储的无理地址）
在Objct类中有一个方法，可以获取对象的哈希值。
int hashCode() 返回该对象的哈希码值。
hashCode方法的源码：
public native int hashCode();
native:代表该方法调用的是本地操作系统的方法。
代码演示：
package day25;
import day20.Person;
public class HashCodeDemo02 {
public static void main(String[] args) {
Person p1 = new Person();
int h1 = p1.hashCode();
System.out.println(h1);
Person p2 = new Person();
int h2 = p2.hashCode();
System.out.println(h2);
System.out.println(p1);
System.out.println(p2);
/*
String类的哈希值
String类重写Obejct类的hashcode方法
*/
String s1 = new String();
String s2 = new String();
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
}
}
HashSet集合存储自定义类型的元素
set集合保存元素唯一：
存储的元素（String,Integer,...,Student,Person,...），必须重写hashcode方法和equals方法。
代码演示：
package day25;
/*
要求：把同年龄，同名字的当做一个人
*/
import java.util.HashSet;
public class HashCodeDemo03 {
public static void main(String[] args) {
HashSet<Student> set = new HashSet<>();
Student st1 = new Student("君君",18);
Student st2 = new Student("君君",18);
Student st3 = new Student("君君",19);
System.out.println(st1.hashCode());
System.out.println(st2.hashCode());
set.add(st1);
set.add(st2);
set.add(st3);
System.out.println(set);
}
}
`----------------------
package day25;
import java.util.Objects;
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, 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;
}
}
LinkedHashSer集合
特点：
底层是一个哈希表（数组+链表/红黑树）+链表：多了一条链表，保证元素有序。
可变参数：是JDK1.5之后出现的新特定
使用前提：
当方法的参数列表数据类型已经确定，但是参数的个数不确定，就可以使用可变参数。
使用格式：定义方法时使用
修饰符 返回值类型 方法名（数据类型...变量名）｛｝
可变参数的原理：
可变参数底层就是一个数组，根据传递参数个数不同，会创建不同长度的数组，来存储这些参数。
传递的参数个数，可以是0个（不传递）,1,2,3...多个。
可变参数的注意事项：
- 一个方法的参数列表，只能有一个可变参数。
- 如果方法的参数有多个，那么可变参数必须卸载参数列表的末尾。
Collections工具类
java.util.Collections是集合工具类，用来对集合进行操作。部分方法如下：
- public static
boolean addAll(Collections c,T...elements):往集合中添加一些元素。 - public static void shuffle(list<?> list):打乱集合顺序。
代码演示：
package day25;
import java.util.ArrayList;
import java.util.Collections;
public class CollectionsDemo01 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
System.out.println(list);
Collections.addAll(list,"e","f","g","h");
System.out.println(list);
Collections.shuffle(list);
System.out.println(list);
}
}
sort方法
将集合中元素按照默认规则排序，默认是升序。
代码演示：
package day25;
import java.util.ArrayList;
import java.util.Collections;
public class CollectionsDemo02 {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<>();
list1.add(1);
list1.add(3);
list1.add(2);
System.out.println(list1);
Collections.sort(list1);
System.out.println(list1);
ArrayList<String> list2 = new ArrayList<>();
list2.add("a");
list2.add("c");
list2.add("b");
System.out.println(list2);
Collections.sort(list2);
System.out.println(list2);
}
}
注意：
sort使用前提：
被排序的集合里面存储的元素，必须实现Comparable，重写接口中的方法compareTo定义排序的规则。
Comparable接口的排序规则：
自己（this）-参数：升序
参数-自己（this）：降序
public static void sort(List list,Comarator<? super T>)
将集合中元素按照指定规则排序。
Comparator和Comparable的区别：
Comparable:自己（this）和别人（参数）比较，自己需要实现Comparable接口，重写比较的规则comparaTo方法
Comparator:相当于自己找一个第三方的裁判，比较两个。
Comparator排序规则
- o1-o2:升序
- 02-01:降序
