系列文章目录
JavaSE进阶01:继承、修饰符
JavaSE进阶02:多态、抽象类、接口
JavaSE进阶03:内部类、Lambda表达式
JavaSE进阶04:API中常用工具类
JavaSE进阶05:包装类、递归、数组的高级操作、异常
JavaSE进阶06:Collection集合、迭代器、List、ArrayList、LinkedList
JavaSE进阶07:泛型、Set集合、TreeSet、二叉树、红黑树
JavaSE进阶08:HashSet、Map集合、HashMap、TreeMap、可变参数、不可变集合
JavaSE进阶09:Stream流、File类
JavaSE进阶10:IO流、字节流、字节缓冲流
JavaSE进阶11:字符流、字符缓冲流、转换流、对象操作流、Properties集合
JavaSE进阶12:多线程、线程同步、线程池
JavaSE进阶13:网络编程入门、UDP通信程序、TCP通信程序、日志、枚举
JavaSE进阶14:类加载器、反射
JavaSE进阶15:XML、注解、单元测试
JavaSE进阶扩充:JDK8 HashMap底层分析(了解)
JavaSE进阶扩充:JDK8 ArrayList线程安全问题和源码分析、集合常见面试题
Java进阶作业
1.HashSet集合
1.1HashSet集合概述和特点【应用】
- 底层数据结构是哈希表
- 存取无序
- 不可以存储重复元素
- 没有索引,不能使用普通for循环遍历
- 哈希元素不可比较
1.2HashSet集合的基本应用【应用】
存储字符串并遍历
import java.util.HashSet;
public class HashSetDemo {
public static void main(String[] args) {
//创建集合对象
HashSet<String> set = new HashSet<String>();
//添加元素
set.add("hello");
set.add("world");
set.add("java");
//不包含重复元素的集合
set.add("world");
//遍历
for(String s : set) {
System.out.println(s);
}
}
}
/*
world
java
hello
*/
1.3哈希值【理解】
- 哈希值简介
哈希值(哈希码值)是JDK根据对象的地址或者属性值算出来的int类型的数值
-
如何获取哈希值
Object类中的public int hashCode():返回对象的地址值算出来的哈希值
-
对象的哈希值的特点
- 如果没有重写hashCode()方法,那么是根据对象的地址值计算出哈希值。
- 同一个对象多次调用hashCode()方法返回的哈希值是相同的
- 如果重写了hashCode()方法,一般通过对象的属性值计算出哈希值。
- 如果不同对象的属性值是一样的,那么计算出的哈希值也是一样的。
- 如果没有重写hashCode()方法,那么是根据对象的地址值计算出哈希值。
1.4哈希表结构【理解】
加载因子决定了什么时候扩容,数组默认长度为16,加载因子默认为0.75。16*0.75=12,也就是当数组存了12个元素的时候,数组会扩容为原先的2倍。
底层扩容非常消耗性能,项目开发中最好指定数组长度initialCapacity。
- JDK1.8以前
数组 + 链表
- JDK1.8即以后
- 优化问题
JDK1.7中的链表如果非常长,又要将链表中所有元素都比较一次,影响性能 - 节点个数少于等于8个
数组 + 链表 - 节点个数多于8个且数组长度>=64
数组 + 红黑树
- 优化问题
1.5HashSet集合存储学生对象并遍历【应用】
-
注意事项
HashSet集合存储自定义类型元素,要想实现元素的唯一,要求必须重写hashCode方法和equals方法
IDEA重写快捷键:Alt+Ins->equals() and hashCode() 后一直下一步。 -
案例需求
- 创建一个存储学生对象的集合,存储多个学生对象,使用程序实现在控制台遍历该集合
- 要求:学生对象的成员变量值相同,我们就认为是同一个对象
/*学生类*/
import java.util.Objects;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(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;
}
//Alt+Ins->equals() and hashCode() 一直下一步。
@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);
}
}
/*测试类*/
import java.util.HashSet;
public class HashSetDemo02 {
public static void main(String[] args) {
//创建HashSet集合对象
HashSet<Student> hs = new HashSet<Student>();
//创建学生对象
Student s1 = new Student("张三", 30);
Student s2 = new Student("李四", 35);
Student s3 = new Student("王五", 33);
Student s4 = new Student("王五", 33);
//把学生添加到集合
hs.add(s1);
hs.add(s2);
hs.add(s3);
hs.add(s4);
//遍历集合(增强for)
for (Student s : hs) {
System.out.println(s.getName() + "," + s.getAge());
}
}
}
/*
王五,33
李四,35
张三,30
*/
1.6 为什么HashSet无序添加整型却输出有序
Hashset实现原理:
Hashset底层使用HashMap来实现的,Set的元素存放在Map的Key上面。
对于hashmap来讲,它的主体是一个Entry数组,Entry又是一个链表。
Hashmap的存储过程如下:
1.计算Key的Hash值
2.把得到的Hash值作为数据下标去存储到Entry的数组中。在这里可能出现不一样的Key的得到的Hash值相等,相同的Hash值存在同一个数组元素下组成链表。(Entry是个结点,多个节点组成链表)
HashSet实际上存储元素的时候进行了获取Hash的操作,整形的Hash值就是自身,所以根据这个hash值得到数组的下标存储元素后,表现出来就是有序的。
TreeSet实现原理
TreeSet的底层使用treemap实现的,Set的元素存放在Map的Key上面.
TreeMap又是用红黑树进行实现,实际上红黑树是一种自平衡二叉查找树,它满足元素的有序性,因此TreeSet的元素是具有有序性的。
TreeSet和TreeMap当泛型是自定义类型时,底层没有相应的比较方法,就必须重写比较方法。
2.Map集合
2.1Map集合概述和特点【理解】
- Map集合概述、
- Map为双列集合,一次存两个元素。
- Map是个接口,只能通过多态的形式实例化。
- (键+值)这个整体称为键值对,在java中又叫Entry对象。
interface Map<K,V> K:键的类型;V:值的类型
-
Map集合的特点
- 双列集合,一个键对应一个值
- 键不可以重复,值可以重复
- put相同键,后值覆盖前值
import java.util.*;
public class MapDemo01 {
public static void main(String[] args) {
//创建集合对象
Map<String,String> map = new HashMap<>();
//V put(K key, V value) 将指定的值与该映射中的指定键相关联
map.put("itheima001","张三");
map.put("itheima002","李四");
map.put("itheima003","王五");
map.put("itheima001","赵六");
map.put(null,"null1");
map.put(null,"null2");
//输出集合对象
System.out.println(map);//{null=null2, itheima003=王五, itheima001=赵六, itheima002=李四}
}
}
2.2Map集合的基本功能【应用】
-
方法介绍
方法名 说明 V put(K key,V value) 添加元素 V remove(Object key) 根据键删除键值对元素 void clear() 移除所有的键值对元素 boolean containsKey(Object key) 判断集合是否包含指定的键 boolean containsValue(Object value) 判断集合是否包含指定的值 boolean isEmpty() 判断集合是否为空 int size() 集合的长度,也就是集合中键值对的个数
import java.util.*;
public class MapDemo02 {
public static void main(String[] args) {
//创建集合对象
Map<String,String> map = new HashMap<String,String>();
//V put(K key,V value):添加元素
map.put("张三","张三老婆");
map.put("李四","李四老婆");
// remove(Object key):根据键删除键值对元素
System.out.println(map.remove("李四"));//李四老婆
System.out.println(map.remove("李哥"));//null
//void clear():移除所有的键值对元素
map.clear();
System.out.println(map);//{}
//boolean containsKey(Object key):判断集合是否包含指定的键
map.put("王五","王五老婆");
System.out.println(map.containsKey("王五"));//true
System.out.println(map.containsKey("王哥"));//false
//boolean isEmpty():判断集合是否为空
System.out.println(map.isEmpty());//false
//int size():集合的长度,也就是集合中键值对的个数
System.out.println(map.size());//1
//输出集合对象
System.out.println(map);//{王五=王五老婆}
}
}
2.3Map集合的获取功能【应用】
-
方法介绍
方法名 说明 V get(Object key) 根据键获取值 Set keySet() 获取所有键的集合 Collection values() 获取所有值的集合 Set<Map.Entry<K,V>> entrySet() 获取所有键值对对象的集合
import java.util.*;
public class MapDemo03 {
public static void main(String[] args) {
//创建集合对象
Map<String, String> map = new HashMap<String, String>();
//添加元素
map.put("1号丈夫", "1号妻子");
map.put("2号丈夫", "2号妻子");
map.put("3号丈夫", "3号妻子");
System.out.println("---keySet():获取所有键的集合---");
System.out.println(map.get("1号丈夫"));
System.out.println(map.get("5号丈夫"));
System.out.println("---keySet():获取所有键的集合---");
Set<String> keySet = map.keySet();
for(String key : keySet) {
System.out.println(key);
}
System.out.println("---Collection<V> values():获取所有值的集合---");
Collection<String> values = map.values();
for(String value : values) {
System.out.println(value);
}
}
}
2.4Map集合的遍历的四种方式【应用】
import java.util.*;
import java.util.function.BiConsumer;
public class MapDemo02 {
public static void main(String[] args) {
//创建集合对象
Map<String, String> map = new HashMap<>();
//添加元素
map.put("张三", "张三老婆");
map.put("李四", "李四老婆");
map.put("王五", "王五老婆");
Set<String> keySet = map.keySet();//获取所有键的集合。用keySet()方法实现
System.out.println("---方式一:增强for(键:键对象)---");
for (String key : keySet) { //遍历键的集合,获取到每一个键。用增强for实现
//根据键去找值。用get(Object key)方法实现
String value = map.get(key);
System.out.println(key + ",,," + value);
}
System.out.println("---方式二:增强for(键值对:键值对对象)---");
Set<Map.Entry<String, String>> entrySet1 = map.entrySet();//获取所有键值对对象的集合
for (Map.Entry<String, String> me : entrySet1) {//遍历键值对对象的集合,得到每一个键值对对象
//根据键值对对象获取键和值
String key = me.getKey();
String value = me.getValue();
System.out.println(key + "。。。" + value);
}
System.out.println("---方式三:迭代器while()---");
Set<Map.Entry<String, String>> entrySet2 = map.entrySet();//获取所有键值对对象的集合
Iterator<Map.Entry<String, String>> iterator = entrySet2.iterator();
while (iterator.hasNext()){
Map.Entry<String, String> entry = iterator.next();
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key + "---" +value);
}
System.out.println("---方式四:forEach(匿名内部类BiConsumer)---");
map.forEach(new BiConsumer<String, String>() {
@Override
public void accept(String s, String s2) {
System.out.println(s+"--->"+s2);
}
});
System.out.println("---方式四:forEach(Lambda表达式)---");
map.forEach((s,s2)-> System.out.println(s+"--->"+s2));
}
}
/*
---方式一:增强for(键:键对象)---
李四,,,李四老婆
张三,,,张三老婆
王五,,,王五老婆
---方式二:增强for(键值对:键值对对象)---
李四。。。李四老婆
张三。。。张三老婆
王五。。。王五老婆
---方式三:迭代器while()---
李四---李四老婆
张三---张三老婆
王五---王五老婆
---方式四:forEach(匿名内部类BiConsumer)---
李四--->李四老婆
张三--->张三老婆
王五--->王五老婆
---方式四:forEach(Lambda表达式)---
李四--->李四老婆
张三--->张三老婆
王五--->王五老婆
*/
forEach在底层实质就是增强for循环。
3.HashMap集合
3.1HashMap集合概述和特点【理解】
- HashMap是Map里面的一个实现类
- HashMap跟HashSet一样底层是哈希表结构的
- 在底层和HashSet一样,1.8以前是数组+链表;1.8及以后是少于等于8个为数组+链表,多余1.8为数组+红黑树;只是存入的是Entry对象。
- 依赖hashCode方法和equals方法保证键的唯一
- 如果键要存储的是自定义对象,需要重写hashCode和equals方法,因为底层是按照自定义对象的地址值比较的,一般需求是按照数值内容比较。
- 值存储的是自定义对象,无所谓重写与否,只用保证键唯一
3.2HashMap集合应用案例【应用】
-
案例需求
- 创建一个HashMap集合,键是学生对象(Student),值是居住地 (String)。存储多个元素,并遍历。
- 要求保证键的唯一性:如果学生对象的成员变量值相同,我们就认为是同一个对象
/*学生类*/
import java.util.Objects;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(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;
}
//Alt+Ins->equals() and hashCode() 一直下一步。
@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);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
/*实现类*/
import java.util.*;
public class HashMapStudentDemo {
public static void main(String[] args) {
//创建HashMap集合对象
HashMap<Student, String> hm = new HashMap<Student, String>();
//创建学生对象
Student s1 = new Student("张三", 30);
Student s2 = new Student("李四", 35);
Student s3 = new Student("王五", 33);
Student s4 = new Student("王五", 33);
//把学生添加到集合
hm.put(s1, "西安");
hm.put(s2, "武汉");
hm.put(s3, "郑州");
hm.put(s4, "北京");
//遍历集合
hm.forEach((Student key,String value)-> System.out.println(key+"----"+value));
}
}
/*
Student{name='王五', age=33}----北京
Student{name='李四', age=35}----武汉
Student{name='张三', age=30}----西安
*/
4.TreeMap集合
4.1TreeMap集合概述和特点【理解】
- TreeMap和TreeSet一样,底层是红黑树结构
- 依赖自然排序或者比较器排序,对键进行排序
- 如果键存储的是自定义对象,需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则
- 自然排序compareTo()原理:
- 如果返回值为负数,表示当前存入的元素是较小值,存左边
- 如果返回值为0,表示当前存入的元素跟集合中元素重复了,不存
- 如果返回值为正数,表示当前存入的元素是较大值,存右边
4.2TreeMap集合应用案例【应用】
- 案例需求
- 创建一个TreeMap集合,键是学生对象(Student),值是籍贯(String),学生属性姓名和年龄,按照年龄进行排序并遍历
- 要求按照学生的年龄进行排序,如果年龄相同则按照姓名进行排序
/*学生类*/
package lesson;
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student() {
}
public Student(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 "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Student o) {
//按照年龄进行排序
int result = o.getAge() - this.getAge();
//次要条件,按照姓名排序。
result = result == 0 ? o.getName().compareTo(this.getName()) : result;
return result;
}
}
/*测试类*/
package lesson;
import java.util.TreeMap;
public class TreeMapStudentDemo {
public static void main(String[] args) {
// 创建TreeMap集合对象
TreeMap<Student,String> tm = new TreeMap<>();
// 创建学生对象
Student s1 = new Student("xiaohei",23);
Student s2 = new Student("dapang",22);
Student s3 = new Student("xiaomei",22);
Student s4 = new Student("xiaomei",22);
// 将学生对象添加到TreeMap集合中
tm.put(s1,"江苏");
tm.put(s2,"北京");
tm.put(s3,"天津");
tm.put(s4,"天津");
// 遍历TreeMap集合,打印每个学生的信息
tm.forEach(
(Student key, String value)->{
System.out.println(key + "---" + value);
}
);
}
}
/*
Student{name='xiaohei', age=23}---江苏
Student{name='xiaomei', age=22}---天津
Student{name='dapang', age=22}---北京
*/
5.可变参数(参数个数不确定)
-
可变参数介绍
- 可变参数又称参数个数可变,用作方法的形参出现,那么方法参数个数就是可变的了
- 方法的参数类型已经确定,个数不确定,我们可以使用可变参数
- 我们在JDK5之前会把所有参数先放到一个数组中,然后在自定义方法的形参值写一个数组就行。而可变参数就是帮我们实现省略了这一步。
-
可变参数定义格式
修饰符 返回值类型 方法名(数据类型… 变量名) { }
- 可变参数的注意事项
- JAVA的可变参数会被编译器转型成一个数组
- 如果一个方法有多个参数,包含可变参数,可变参数要放在最后。
- 由于可变必须最后一个,所以一个方法中最多也只能由一个可变参数
/*
需求:定义一个方法球N个数的和,用可变参数实现
*/
public class MyVariableParameter {
public static void main(String[] args) {
int sum=getSum("123",1,2,3,4,5,6);//多个参数时,可变参数必须放最后
System.out.println(sum);
}
public static int getSum(String s,int...arr){
System.out.println("我是不可变参数"+s);
int sum=0;
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}
return sum;
}
}
/*
我是不可变参数123
21
*/
6.创建不可变集合
- 方法介绍
是JDK9出现的方法。
方法 | 介绍 |
---|---|
static List of(E…elements) | 创建一个具有指定元素的List集合对象 |
static Set of(E…elements) | 创建一个具有指定元素的Set集合对象 |
static <K , V> Map<K,V> of(E…elements) | 创建一个具有指定元素的Map集合对象 |
- 在List、Set、Map接口中,都存在of方法,可以创建一个不可变的集合
- 这个集合不能添加,不能删除,不能修改。
- 但是可以结合集合的带参构造,实现集合的批量添加。
- 在Map接口中,还有一个Map.ofEntries方法可以提高代码的阅读性
- 首先用Map.entry把键值对封装成一个Entry对象,再把这个Entry对象添加到集合当中
- 注意事项
- Set集合中的of方法不能有重复的元素
- Map.ofEntries方法创建的也是不可变集合
package homeWork2;
import java.util.*;
public class MyVariableParameter4 {
public static void main(String[] args) {
method1();//of方法创建的不可变的集合不能整删改
//method2();//Set.off方法不可重复元素
method3();//Map.of创建不可变键值对集合
method4();//Map.entry提高阅读性
method5();//集合批量添加元素
}
private static void method5() {
//首先是通过调用List.of方法来创建一个不可变的集合,of方法的形参就是一个可变参数。
//再创建一个ArrayList集合,并把这个不可变的集合中所有的数据,都添加到ArrayList中。
ArrayList<String> list2 = new ArrayList<>(List.of("a", "b", "c"));
Collections.addAll(list2, "1","2","3");//批量添加方式1
list2.addAll(Arrays.asList("A","B","C"));批量添加方式2
System.out.println(list2);//[a, b, c, 1, 2, 3, A, B, C]
}
private static void method4() {
Map<String, String> map = Map.ofEntries(
Map.entry("zhangsan", "江苏"),
Map.entry("lisi", "北京"));
System.out.println(map);//{lisi=北京, zhangsan=江苏}
}
private static void method3() {
Map<String, String> map = Map.of("zhangsan", "江苏", "lisi", "北京", "wangwu", "天津");
System.out.println(map);//{zhangsan=江苏, lisi=北京, wangwu=天津}
}
private static void method2() {
//传递的参数当中,不能存在重复的元素。
Set<String> set = Set.of("a", "b", "c", "d","a");//报错
}
private static void method1() {
List<String> list = List.of("a", "b", "c", "d");
//list.add("Q");//添加报错
//list.remove("a");//删除报错
//list.set(0,"A");//修改报错
}
}