目录
1.Set集合
1.1set集合概述和特点
set集合特点
- 不包含重复元素的集合
- 没有带索引的方法（因此不能使用普通for循环实现遍历）
- 通过HashSet创建对象，因此和HashSet一样，对集合的迭代顺序不做任何保证（不保证存储和取出的元素顺序一致）
set集合练习：存储字符串并遍历
package heima;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/*
HashSet对集合的迭代顺序不做任何保证
*/
public class sets {
public static void main(String[] args) {
//创建集合对象
Set<String> set=new HashSet<String>();
set.add("hello");
set.add("world");
set.add("java");
//不包含重复元素的集合
set.add("java");
//set中没有带索引的方法，因此不能使用普通for循环实现遍历
//增强for循环遍历
for(String s:set){
System.out.println(s);
}
System.out.println("-------");
//寄存器遍历
Iterator<String> it=set.iterator();
while(it.hasNext()){
String s=it.next();
System.out.println(s);
}
}
}
1.2哈希值
哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
Object类中有一个方法可以获取对象的哈希值
- public int hashCode():返回对象的哈希码值
- 方法的调用：对象名.hashCode();
对象的哈希值特点：
- 同一个对象多次调用hashCode()方法返回的哈希值是相同的
- 默认情况下，不同对象的哈希值是不同的，而重写hashCode()方法，可以实现让不同对象的哈希值相同
1.3HashSet集合概述和特点
- 底层数据结构是哈希表
- 对集合的迭代顺序不做任何保证，也就是说不保证存储和取出的元素顺序一致
- 没有带索引的方法，所以不能使用普通for循环遍历
- 由于是set集合，所以是不包含重复元素的集合
1.4HashSet集合保证元素唯一性源码分析
1.5常见数据结构之哈希表
哈希表
- JDK8之前，底层采用数组加链表实现，可以说是一个元素为链表的数组
- JDK8之后，在长度比较长的时候，底层实现了优化
案例：创建一个存储学生对象的集合，存储多个学生对象，实用程序实现在控制台遍历该集合。要求：学生对象的成员变量值相同，我们就认为是同一个对象
思路：1、定义学生类2、创建HashSet集合对象3、创建学生对象4、把学生添加到集合5、遍历集合
students类：
package heima;
public class students {
private String name;
private int age;
public students() {
}
public students(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;
}
//重写equals方法和hashCode方法，使对象相同时不能加入到set集合中
//String a="hello";方式创建的对象相同时，他们的地址也会相同，因此set不会将相同的对象加入集合；而通过new创建的对象，即使相同，但他们的地址不同，set会自动加入集合中，因此需要重写hashCode方法和equals方法
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
students students = (students) o;
if (age != students.age) return false;
return name != null ? name.equals(students.name) : students.name == null;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
}测试类：
package heima;
import java.util.HashSet;
public class HashSetDemo01 {
public static void main(String[] args) {
HashSet<students> tt=new HashSet<students>();
students st1=new students("凌翔夏",30);
students st2=new students("张曼玉",20);
students st3=new students("王祖贤",35);
students st4=new students("凌翔夏",30);
tt.add(st1);
tt.add(st2);
tt.add(st3);
tt.add(st4);
for(students s:tt){
System.out.println(s.getName()+","+s.getAge());
}
}
}
运行结果：
王祖贤,35
张曼玉,20
凌翔夏,30
1.6LinkedHashSet集合概述和特点
LinkedHashSet集合特点
- 哈希表和链表实现的Set接口，具有可预测的迭代次序
- 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
- 由哈希表保证元素唯一，也就是说没有重复的元素
1.7TreeSet集合概述和特点
TreeSet集合特点：
1）元素有序，这里的有序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法
TreeSet（）：根据元素的自然排序进行排序
TreeSet（Comparator comparator):根据指定的比较器进行排序
2）没有带索引的方法，所以不能使用普通for循环遍历
3）由于是Set集合，所以不包含重复元素的集合
1.8自然排序Comparable的使用
- 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
- 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
student类：
测试类：
1.9比较器Comparator的使用
- 存储学生对象并遍历，创建TreeSet集合使用带参构造方法
- 要求：按照年龄从小到大排序，年龄相同时按照姓名的字母顺序排序
student类：
测试类：
结论：
- 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
- 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写Comparator(To 1,To 2)方法
- 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
2.泛型
2.1泛型概述
泛型：使JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型，它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参那么参数化类型怎么理解呢？顾名思义就是将类型由原来的具体的类型参数化，然后再使用/调用时传入具体的类型。这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口
泛型定义格式：
- <类型>:指定一种类型的格式，这里的类型可以看成是形参
- <类型1，类型2....>:指定多种类型的格式，多种类型之间用逗号隔开，这里的类型可以看成是形参
- 将来具体调用的时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型
泛型的好处：
- 把运行时期的问题提前到了编译时期
- 避免了强制类型转换
2.2泛型类
泛型类的定义格式：
- 格式：修饰符 class 类名<类型>{}
- 范例：public class Generic<T>{}（此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
泛型类：
package heima;
public class Geniric<T> {
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
测试类：
package heima;
public class GeniricDemo {
public static void main(String[] args) {
Geniric<String> s=new Geniric<String>();
s.setT("零星夏");
System.out.println(s.getT());
Geniric<Integer> i=new Geniric<Integer>();
i.setT(30);
System.out.println(i.getT());
Geniric<Boolean> b=new Geniric<Boolean>();
b.setT(true);
System.out.println(b.getT());
}
}
运行结果：
零星夏
30
true
2.3泛型方法
泛型方法的定义格式：
- 格式：修饰符<类型>返回值类型 方法名（类型 变量名）{}
- 范例：public<T> void show(T t){}
泛型方法：
package heima;
public class Generics {
public <T> void show(T t){
System.out.println(t);
}
}
测试类：
package heima;
public class GenericsDemo {
public static void main(String[] args) {
Generics g=new Generics();
g.show("林青霞");
g.show(30);
g.show(true);
}
}
输出结果：
林青霞
30
true
2.4泛型接口
泛型接口的定义格式：
- 格式：修饰符 interface 接口名<类型>{}
- 范例：public interface Generic<T>{}
泛型接口：
package heima;
public interface Genericc <T>{
void show(T t);
}
接口的实现类：
package heima;
public class GenericcImp<T> implements Genericc<T> {
@Override
public void show(T t) {
System.out.println(t);
}
}
测试类：
package heima;
public class GenericcDemo {
public static void main(String[] args) {
Genericc<String> g1=new GenericcImp<String>();
g1.show("林青霞");
Genericc<Integer> g2=new GenericcImp<>() ;
g2.show(30);
}
}
2.5类型通配符
为了表示各种泛型List的父类，可以使用类型通配符
- 类型通配符<?>
- List<?>:表示元素类型未知的List，它的元素可以匹配任何的类型
- 这种带通配符的List仅代表它是各种泛型List的父类，并不能把元素添加到其中
如果说我们不希望List<?>是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上限
- 类型通配符的上限：<?extends 类型>
- List<?extends Number>:它表示的类型是Number或者其子类型
除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限
- 类型通配符下限：<?super 类型>
- List<? super Number>:它表示的类型是Number或者其父类型
package heima;
import java.util.ArrayList;
import java.util.List;
//继承关系：Object>Number>Integer
public class Generi {
public static void main(String[] args) {
//类型通配符<?>可以匹配任意类型
List<?> list1=new ArrayList<Object>();
List<?> list2=new ArrayList<Number>();
List<?> list3=new ArrayList<Integer>();
System.out.println("-------");
//类型通配符上限<?extends 类型>
//List<?extends Number> list4=new ArrayList<Object>();//报错
List<?extends Number> list5=new ArrayList<Number>();
List<?extends Number> list6=new ArrayList<Integer>();
System.out.println("-------");
//类型通配符下限<?super 类型>
List<?super Number> list7=new ArrayList<Object>();
List<?super Number> list8=new ArrayList<Number>();
//List<?super Number> list9=new ArrayList<Integer>();//报错
}
}
2.6可变参数
可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了
- 格式：修饰符 返回值类型 方法名（数据类型...变量名）{}
- 范例：public static int sum(int...a){}
package heima;
public class ArgsDemo {
public static void main(String[] args) {
System.out.println(sum(10,10));
System.out.println(sum(20,20,20));
System.out.println(sum(10,10,10,10,10));
System.out.println(sum(10,10,10,10,10,10,10));
}
/* //a相当于一个数组
public static int sum(int...a){
int sum=0;
for(int i:a){
sum+=i;
}
return sum;
*/
//有多个参数时，包含可变参数，可变参数要放在后面
public static int sum(int b,int...a){
return 0;
}
}
输出结果：
0
0
0
0
可变参数的注意事项：
- 这里的变量其实是一个数组
- 如果一个方法有多个参数，包含可变参数，可变参数要放在后面
2.7可变参数的使用
Arrays工具类中有一个静态方法：
- public static<T> List<T> asList(T...a):返回由指定数组支持的固定大小的列表
- 返回的集合不能做增删操作，可以做修改操作
List集合中有一个静态方法：
- public static <E> List<E> of(E...elements):返回包含任意数量元素的不可变列表
- 返回的集合不能做增删改操作
Set接口中有一个静态方法：
- public static<E> Set<E> of(E...elements):返回一个包含任意数量元素的不可变集合
- 在给元素的时候，不能给重复的元素
- 返回的集合不能做增删操作，没有修改方法