文章目录
- Java SE进阶知识总结-2
- Objects、Math、System、BigDecimal
- Objects
- Math
- System
- BigDecimal
- 包装类
- 基本数据类型对应的包装类
- 自动拆箱和自动装箱
- 包装类常见问题
- 时间类
- JDK8（-）
- JDK8（+）
- 日历类（获取当前时间）
- 日期格式化类（格式化时间）
- 时间类（获取时间）
- 工具类（计算时间间隔）
- 递归
- 异常
- 异常体系
- 异常处理方式
- 默认
- try...catch....
- throw和throws
- Stream流
- 思想
- 流对象获取
- 集合获取流对象
- 数组获取流对象
- 零散的数据获取流对象
- 流的中间操作方法
- 流的终结操作方法
- 流的收集操作
- File类
- File类创建
- 路径概念
- File类常用方法
- File类创建和删除方法
- File类遍历方法
Java SE进阶知识总结-2
Objects、Math、System、BigDecimal
都是讲的方法，常用常新
Objects
所有的类都直接或间接继承该类（祖宗类），其内的方法都可用
Math
包含基本的数字运算方法
System
都是静态方法，可以直接调用
BigDecimal
用于解决小数运算中，出现的不精确问题
包装类
将基本数据类型，转为引用数据类型，就可以方便的使用一些方法
基本数据类型对应的包装类
| 基本数据类型 | 对应的包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| char | Character |
| float | Float |
| double | Double |
| boolean | Boolean |
自动拆箱和自动装箱
JDK5之后，有自动拆、装箱
基本数据类型和对应的包装类可以直接相互赋值运算，不用担心转换问题
包装类常见问题
public static void main(String[] args) {
Integer i1 = 127;
Integer i2 = 127;
System.out.println(i1 == i2); // true
Integer i3 = 129;
Integer i4 = 129;
System.out.println(i3 == i4); // false
Long i11 = 129L;
Long i22 = 129L;
System.out.println(i11 == i22); // false
System.out.println(i11.equals(i22)); // true
}
自动装箱的本质是调用底层装箱方法
数值范围在-128-127，给定指定数组，不会创建新的对象，所以上述比较结果是true
数值范围在-128-127，会创建新的对象，所以上述比较结果是false
时间类
| JDK8以前的时间类 | JDK8以后的时间类 |
|---|---|
| 设计欠妥，使用不方便，已淘汰 | 设计合理，功能丰富，使用方便 |
| 都是可变对象，修改后会丢失原有数据 | 都是不可变对象，修改后返回新的时间对象 |
| 线程不安全 | 线程安全 |
| 只能精确到毫秒 | 可以精确到纳秒 |
JDK8（-）
Date、SimpleDateFormat、Calendar
JDK8（+）
日历类（获取当前时间）
LocalDate、LocalTime、LocalDateTime
日期格式化类（格式化时间）
DateTimeFormatter
时间类（获取时间）
Instant、ZoneId、ZoneDateTime
工具类（计算时间间隔）
Period、Duration、ChronoUnit
递归
方法直接或间接的调用本身
异常
要求：
- 看得懂异常信息
- 了解异常体系结构和分类
- 掌握异常的两种处理方式
- 自定义异常
异常体系
- Error
- 严重级别问题
- Exception
- RuntimeException 及其子类：运行时异常
- 除RuntimeException 之外所有的异常：编译时异常（起提醒作用，要在准备运行前解决）
异常处理方式
默认
- 虚拟机在异常代码位置，自动创建一个异常对象：ArithmeticException
- 在出现异常的地方抛出给调用者，再抛出给JVM虚拟机
- 虚拟机接收到异常对象后，在控制台输出异常信息
- 程序终止，异常点后续代码不再运行
try…catch…
- 可以捕捉异常后，给出处理方案
- 代码可以继续运行
throw和throws
| throw | throws |
|---|---|
| 用在方法中，作用：抛出异常对象 | 用在方法名后面，作用：声明该方法存在异常，需要调用者进行处理 |
| 补：异常是编译型异常，必须用throws；异常是运行时异常，不需要声明 |
Stream流
简化对集合、数据的一些复杂操作
- 集合知识点：Java进阶知识点-3-集合
思想
-
将数据放到流中（获取流对象）
-
中间方法：对流对象进行操作，操作后的返回值依然是流对象
-
终结方法：对流对象的最终操作，操作后的流对象不可再用
- 操作后或没有返回值，或返回值不再是流对象
- 被终结方法操作过的流对象，不能再进行中间方法操作
流对象获取
集合获取流对象
package com.itheima.day12.stream;
import java.util.*;
import java.util.function.Consumer;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class StreamDemo1 {
/*
获取Stream流对象演示
- 将数据放在流水线的传送带上
1. 集合获取 Stream 流对象 (使用Collection接口中的默认方法)
default Stream<E> stream()
* Map集合获取Stream流对象, 需要间接获取
- map.entrySet().stream()
*/
public static void main(String[] args) {
method1();
}
private static void method1() {
Set<String> set = new HashSet<String>();
set.add("张三丰");
set.add("张无忌");
set.add("张翠山");
set.add("王二麻子");
set.add("张良");
set.add("谢广坤");
set.stream().forEach(s -> System.out.println(s));
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("张三丰", 100);
map.put("张无忌", 35);
map.put("张翠山", 55);
map.put("王二麻子", 22);
map.put("张良", 30);
map.put("谢广坤", 55);
Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
entrySet.stream().forEach(s -> System.out.println(s));
}
}
数组获取流对象
package com.itheima.day12.stream;
import java.util.*;
import java.util.function.Consumer;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class StreamDemo1 {
/*
获取Stream流对象演示
- 将数据放在流水线的传送带上
2. 数组获取 Stream 流对象 (使用Arrays数组工具类中的静态方法)
static <T> Stream<T> stream (T[] array)
*/
public static void main(String[] args) {
method1();
}
private static void method1() {
List<String> list = new ArrayList<String>();
list.add("张三丰");
list.add("张无忌");
list.add("张翠山");
list.add("王二麻子");
list.add("张良");
list.add("谢广坤");
list.stream().forEach(s -> System.out.println(s));
}
}
零散的数据获取流对象
package com.itheima.day12.stream;
import java.util.*;
import java.util.function.Consumer;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class StreamDemo1 {
/*
获取Stream流对象演示
- 将数据放在流水线的传送带上
3. 零散的数据获取 Stream 流对象 (使用 Stream 类中的静态方法)
static <T> Stream<T> of(T... values)
*/
public static void main(String[] args) {
Stream.of(1, 2, 3, 4, 5, 6).forEach(s -> System.out.println(s));
Stream.of("张三", "李四", "王五", "赵六").forEach(s -> System.out.println(s));
}
}
流的中间操作方法
package com.itheima.day12.stream;
import java.util.ArrayList;
import java.util.function.Predicate;
import java.util.stream.Stream;
public class StreamDemo2 {
public static void main(String[] args) {
// 需求: 将集合中以 【张】 开头的数据，过滤出来并打印在控制台
ArrayList<String> list = new ArrayList<String>();
list.add("林青霞");
list.add("张曼玉");
list.add("王祖贤");
list.add("柳岩");
list.add("张敏");
list.add("张无忌");
list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
System.out.println("-------------------------------------");
// 需求1: 取前3个数据在控制台输出
list.stream().limit(3).forEach(s -> System.out.println(s));
System.out.println("-------------------------------------");
// 需求2: 跳过3个元素, 把剩下的元素在控制台输出
list.stream().skip(3).forEach(s -> System.out.println(s));
System.out.println("-------------------------------------");
// 需求3: 跳过2个元素, 把剩下的元素中前2个在控制台输出
list.stream().skip(2).limit(2).forEach(s -> System.out.println(s));
System.out.println("-------------------------------------");
// 需求4: 取前4个数据组成一个流
Stream<String> s1 = list.stream().limit(4);
// 需求5: 跳过2个数据组成一个流
Stream<String> s2 = list.stream().skip(2);
// 需求6: 合并需求4和需求5得到的流, 并把结果在控制台输出
Stream<String> s3 = Stream.concat(s1, s2);
// s3.forEach(s -> System.out.println(s));
System.out.println("-------------------------------------");
// 需求7: 合并需求4和需求5得到的流, 并把结果在控制台输出，要求字符串元素不能重复
s3.distinct().forEach(s -> System.out.println(s));
}
}
流的终结操作方法
package com.itheima.day12.stream;
import java.util.stream.Stream;
public class StreamDemo3 {
/*
Stream流的终结操作方法
- 流水线中的最后一道工序
public void forEach (Consumer action) 对此流的每个元素执行遍历操作
public long count () 返回此流中的元素数
*/
public static void main(String[] args) {
long count = Stream.of(1, 2, 3, 4, 5, 6).filter(s -> s % 2 == 0).count();
System.out.println(count);
}
}
流的收集操作
- 将Stream流操作后的结果转回到集合
- 流（中间）操作的返回对象还是流，所以不会对源数据进行修改
package com.itheima.day12.stream;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class StreamDemo4 {
/*
Stream流的收集操作
public R collect (Collector c) : 将流中的数据收集到集合
Collectors
public static <T> Collector toList()
public static <T> Collector toSet()
public static Collector toMap(Function keyMapper , Function valueMapper)
*/
public static void main(String[] args) {
List<Integer> list1 = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).filter(s -> s % 2 == 0).collect(Collectors.toList());
System.out.println(list1);
Set<Integer> list2 = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10).filter(s -> s % 2 == 0).collect(Collectors.toSet());
System.out.println(list2);
}
}
File类
File类代表操作系统的文件对象（文件、文件夹）
File类创建
package com.itheima.day12.file;
import java.io.File;
import java.io.IOException;
public class FileDemo1 {
public static void main(String[] args) throws IOException {
File f1 = new File("D:\\A.txt");
f1.createNewFile();
File f2 = new File("D:\\test");
System.out.println(f2.exists());
File f3 = new File("D:\\", "test");
System.out.println(f3.exists());
File f4 = new File(new File("D:\\"), "test");
System.out.println(f4.exists());
}
}
- File封装的对象可以定位文件和文件夹
- File封装的对象仅仅是一个路径名，路径可以存在，也可以不存在
路径概念
- 相对路径：相对于当前项目
- 绝对路径：从盘符根目录开始，一直到某个具体的文件或文件夹
File类常用方法
-
length()方法，对于文件对象，返回的是正确的字节个数；对于文件夹对象，返回的是错误的字节个数
-
getPath()，返回定义文件时使用的路径，比较鸡肋
package com.itheima.day12.file;
import java.io.File;
import java.util.Date;
public class FileMethodDemo3 {
/*
File类常见方法 :
1. 判断相关
public boolean isDirectory() : 判断是否是文件夹
public boolean isFile() : 判断是否是文件
public boolean exists() : 判断是否存在
2. 获取相关
public long length() : 返回文件的大小(字节数量)
* 文件对象操作, 返回正确的字节个数
* 文件夹对象操作, 返回的是错误的字节个数
public String getAbsolutePath() : 返回文件的绝对路径
public String getPath() : 返回定义文件时使用的路径 比较鸡肋
public String getName() : 返回文件的名称，带后缀
public long lastModified() : 返回文件的最后修改时间（时间毫秒值）
*/
public static void main(String[] args) {
File f1 = new File("D:\\A.txt");
System.out.println(f1.isDirectory()); // false
System.out.println(f1.isFile()); // true
System.out.println(f1.exists()); // true
System.out.println("----------------------");
File f2 = new File("D:\\test");
System.out.println(f1.length());
System.out.println(f2.length());
System.out.println("----------------------");
File f3 = new File("A.txt");
System.out.println(f3.getAbsolutePath());
System.out.println("----------------------");
System.out.println(f1.getName());
System.out.println(f2.getName());
System.out.println(f3.getName());
System.out.println("----------------------");
long time = f1.lastModified();
System.out.println(new Date(time));
}
}
File类创建和删除方法
package com.itheima.day12.file;
import java.io.File;
import java.io.IOException;
public class FileMethodDemo4 {
public static void main(String[] args) throws IOException {
File f1 = new File("src\\com\\itheima\\day12\\B.txt");
System.out.println(f1.createNewFile());
File f2 = new File("src\\com\\itheima\\day12\\aaa");
System.out.println(f2.mkdirs());
File f3 = new File("src\\com\\itheima\\day12\\C.txt"); // 也是创建的文件夹，C.txt就是文件夹的名字
// 创建的是什么，跟路径没关系，跟调用的方法有关
System.out.println(f3.mkdirs());
System.out.println(f1.delete());
System.out.println(f2.delete());
}
}
File类遍历方法
package com.itheima.day12.file;
import java.io.File;
public class FileMethodDemo5 {
/*
File类的遍历方法 :
public File[] listFiles() 获取当前目录下所有的 "一级文件对象" 返回 File 数组
*/
public static void main(String[] args) {
File f = new File("D:\\test");
File[] files = f.listFiles();
for (File file : files) {
System.out.println(file);
}
}
}
- 当调用者File表示的路径不存在时，返回null
- 当调用者File表示的路径是文件时，返回null
- 当调用者File表示的路径是一个空文件夹时，返回一个长度为0的数组
- 当调用者File表示的路径是需要权限才能访问的文件夹时，返回null
