不可变集合
什么是不可变集合？
不可变集合，就是不可被修改的集合。
集合的数据项在创建的时候提供，并且在整个生命周期中都不可改变。否则报错。
为什么要创建不可变集合？
如果某个数据不能被修改，把它防御性地拷贝到不可变集合中是个很好的实践
或者当集合对象被不可信的库调用时，不可变形式是安全的
如何创建不可变集合？
在List、Set、Map接口中，都存在of方法，可以创建一个不可变的集合
| 方法名称 | 说明 |
| static <E> List<E> of(E…elements) | 创建一个具有指定元素的List集合对象 |
| static <E> Set<E> of(E…elements) | 创建一个具有指定元素的Set集合对象 |
| static <K , V> Map<K，V> of(E…elements) | 创建一个具有指定元素的Map集合对象 |
/**
目标：不可变集合。
*/
public class CollectionDemo {
public static void main(String[] args) {
// 1、不可变的List集合
List<Double> lists = List.of(569.5, 700.5, 523.0, 570.5);
// lists.add(689.0);
// lists.set(2, 698.5);
// System.out.println(lists);
double score = lists.get(1);
System.out.println(score);
// 2、不可变的Set集合
Set<String> names = Set.of("迪丽热巴", "迪丽热九", "马尔扎哈", "卡尔眨巴" );
// names.add("三少爷");
System.out.println(names);
// 3、不可变的Map集合
Map<String, Integer> maps = Map.of("huawei",2, "Java开发", 1 , "手表", 1);
// maps.put("衣服", 3);
System.out.println(maps);
}
}Stream流
在Java 8中，得益于Lambda所带来的函数式编程， 引入了一个全新的Stream流概念。
目的：用于简化集合和数组操作的API
Stream流式思想的核心：
先得到集合或者数组的Stream流（就是一根传送带）
把元素放上去
然后就用这个Stream流简化的API来方便的操作元素
/**
目标：初步体验Stream流的方便与快捷Stream操作集合或者数组的第一步是先得到Stream流，然后才能使用流的功能。
*/
public class StreamTest {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
Collections.addAll(names, "张三丰","张无忌","周芷若","赵敏","张强");
System.out.println(names);
//
// // 1、从集合中找出姓张的放到新集合
// List<String> zhangList = new ArrayList<>();
// for (String name : names) {
// if(name.startsWith("张")){
// zhangList.add(name);
// }
// }
// System.out.println(zhangList);
//
// // 2、找名称长度是3的姓名
// List<String> zhangThreeList = new ArrayList<>();
// for (String name : zhangList) {
// if(name.length() == 3){
// zhangThreeList.add(name);
// }
// }
// System.out.println(zhangThreeList);
// 3、使用Stream实现的
names.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
}
}
bonus +
", punish='" + punish + '\'' +
'}'+"\n";
}
}Stream操作集合或者数组的第一步是先得到Stream流，然后才能使用流的功能。
集合获取Stream流的方式：可以使用Collection接口中的默认方法stream()生成流
default Stream stream() 获取当前集合对象的Stream流
public static Stream stream(T[] array) 获取当前数组的Stream流
public static Stream of(T… values) 获取当前数组/可变数据的Stream流
Stream流的三类方法
获取Stream流
创建一条流水线，并把数据放到流水线上准备进行操作
中间方法
流水线上的操作。一次操作完毕之后，还可以继续进行其他操作。
终结方法
一个Stream流只能有一个终结方法，是流水线上的最后一个操作
/**
目标：Stream流的获取
Stream流式思想的核心：
是先得到集合或者数组的Stream流（就是一根传送带）
然后就用这个Stream流操作集合或者数组的元素。
然后用Stream流简化替代集合操作的API.
集合获取流的API:
(1) default Stream<E> stream();
小结：
集合获取Stream流用: stream();
数组：Arrays.stream(数组) / Stream.of(数组);
*/
public class StreamDemo02 {
public static void main(String[] args) {
/** --------------------Collection集合获取流------------------------------- */
Collection<String> list = new ArrayList<>();
Stream<String> s = list.stream();
/** --------------------Map集合获取流------------------------------- */
Map<String, Integer> maps = new HashMap<>();
// 键流
Stream<String> keyStream = maps.keySet().stream();
// 值流
Stream<Integer> valueStream = maps.values().stream();
// 键值对流（拿整体）
Stream<Map.Entry<String,Integer>> keyAndValueStream = maps.entrySet().stream();
/** ---------------------数组获取流------------------------------ */
String[] names = {"赵敏","小昭","灭绝","周芷若"};
Stream<String> nameStream = Arrays.stream(names);
Stream<String> nameStream2 = Stream.of(names);
}
}Stream流的常用API(中间操作方法)
| 名称 | 说明 |
| Stream<T> filter(Predicate<? super T> predicate) | 用于对流中的数据进行过滤。 |
| Stream<T> limit(long maxSize) | 获取前几个元素 |
| Stream<T> skip(long n) | 跳过前几个元素 |
| Stream<T> distinct() | 去除流中重复的元素。依赖(hashCode和equals方法) |
| static <T> Stream<T> concat(Stream a, Stream b) | 合并a和b两个流为一个流 |
注意：
中间方法也称为非终结方法，调用完成后返回新的Stream流可以继续使用，支持链式编程。
在Stream流中无法直接修改集合、数组中的数据。
Stream流的常见终结操作方法
| 名称 | 说明 |
| void forEach(Consumer action) | 对此流的每个元素执行遍历操作 |
| long count() | 返回此流中的元素数 |
注意：终结操作方法，调用完成后流就无法继续使用了，原因是不会返回Stream了。
package com.itheima.d2_stream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;
/**
目标：Stream流的常用API
forEach : 逐一处理(遍历)
count：统计个数
-- long count();
filter : 过滤元素
-- Stream<T> filter(Predicate<? super T> predicate)
limit : 取前几个元素
skip : 跳过前几个
map : 加工方法
concat : 合并流。
*/
public class StreamDemo03 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张无忌");
list.add("周芷若");
list.add("赵敏");
list.add("张强");
list.add("张三丰");
list.add("张三丰");
// Stream<T> filter(Predicate<? super T> predicate)
list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));
long size = list.stream().filter(s -> s.length() == 3).count();
System.out.println(size);
// list.stream().filter(s -> s.startsWith("张")).limit(2).forEach(s -> System.out.println(s));
list.stream().filter(s -> s.startsWith("张")).limit(2).forEach(System.out::println);
list.stream().filter(s -> s.startsWith("张")).skip(2).forEach(System.out::println);
// map加工方法: 第一个参数原材料 -> 第二个参数是加工后的结果。
// 给集合元素的前面都加上一个：黑马的：
list.stream().map(s -> "黑马的：" + s).forEach(a -> System.out.println(a));
// 需求：把所有的名称 都加工成一个学生对象。
list.stream().map(s -> new Student(s)).forEach(s -> System.out.println(s));
// list.stream().map(Student::new).forEach(System.out::println); // 构造器引用 方法引用
// 合并流。
Stream<String> s1 = list.stream().filter(s -> s.startsWith("张"));
Stream<String> s2 = Stream.of("java1", "java2");
// public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
Stream<String> s3 = Stream.concat(s1 , s2);
s3.distinct().forEach(s -> System.out.println(s));
}
}
案例
需求：某个公司的开发部门，分为开发一部和二部，现在需要进行年中数据结算。
分析：
员工信息至少包含了(名称、性别、工资、奖金、处罚记录)
开发一部有4个员工、开发二部有5名员工
分别筛选出2个部门的最高工资的员工信息，封装成优秀员工对象Topperformer
分别统计出2个部门的平均月收入，要求去掉最高和最低工资。
统计2个开发部门整体的平均工资，去掉最低和最高工资的平均值。
package com.itheima.d2_stream;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
public class StreamDemo04 {
public static double allMoney ;
public static double allMoney2 ; // 2个部门去掉最高工资，最低工资的总和
public static void main(String[] args) {
List<Employee> one = new ArrayList<>();
one.add(new Employee("猪八戒",'男',30000 , 25000, null));
one.add(new Employee("孙悟空",'男',25000 , 1000, "顶撞上司"));
one.add(new Employee("沙僧",'男',20000 , 20000, null));
one.add(new Employee("小白龙",'男',20000 , 25000, null));
List<Employee> two = new ArrayList<>();
two.add(new Employee("武松",'男',15000 , 9000, null));
two.add(new Employee("李逵",'男',20000 , 10000, null));
two.add(new Employee("西门庆",'男',50000 , 100000, "被打"));
two.add(new Employee("潘金莲",'女',3500 , 1000, "被打"));
two.add(new Employee("武大郎",'女',20000 , 0, "下毒"));
// 1、开发一部的最高工资的员工。（API）
// 指定大小规则了
// Employee e = one.stream().max((e1, e2) -> Double.compare(e1.getSalary() + e1.getBonus(), e2.getSalary() + e2.getBonus()))
// .get();
// System.out.println(e);
Topperformer t = one.stream().max((e1, e2) -> Double.compare(e1.getSalary() + e1.getBonus(), e2.getSalary() + e2.getBonus()))
.map(e -> new Topperformer(e.getName(), e.getSalary() + e.getBonus())).get();
System.out.println(t);
// 2、统计平均工资，去掉最高工资和最低工资
one.stream().sorted((e1, e2) -> Double.compare(e1.getSalary() + e1.getBonus(), e2.getSalary() + e2.getBonus()))
.skip(1).limit(one.size() - 2).forEach(e -> {
// 求出总和：剩余员工的工资总和
allMoney += (e.getSalary() + e.getBonus());
});
System.out.println("开发一部的平均工资是：" + allMoney / (one.size() - 2));
// 3、合并2个集合流，再统计
Stream<Employee> s1 = one.stream();
Stream<Employee> s2 = two.stream();
Stream<Employee> s3 = Stream.concat(s1 , s2);
s3.sorted((e1, e2) -> Double.compare(e1.getSalary() + e1.getBonus(), e2.getSalary() + e2.getBonus()))
.skip(1).limit(one.size() + two.size() - 2).forEach(e -> {
// 求出总和：剩余员工的工资总和
allMoney2 += (e.getSalary() + e.getBonus());
});
// BigDecimal
BigDecimal a = BigDecimal.valueOf(allMoney2);
BigDecimal b = BigDecimal.valueOf(one.size() + two.size() - 2);
System.out.println("开发部的平均工资是：" + a.divide(b,2, RoundingMode.HALF_UP));
}
}
public class Topperformer {
private String name;
private double money; // 月薪
public Topperformer() {
}
public Topperformer(String name, double money) {
this.name = name;
this.money = money;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
@Override
public String toString() {
return "Topperformer{" +
"name='" + name + '\'' +
", money=" + money +
'}';
}
}
收集Stream流
收集Stream流的含义：就是把Stream流操作后的结果数据转回到集合或者数组中去。
Stream流：方便操作集合/数组的手段。
集合/数组：才是开发中的目的。
| 名称 | 说明 |
| R collect(Collector collector) | 开始收集Stream流，指定收集器 |
| 名称 | 说明 |
| public static <T> Collector toList() | 把元素收集到List集合中 |
| public static <T> Collector toSet() | 把元素收集到Set集合中 |
| public static Collector toMap(Function keyMapper , Function valueMapper) | 把元素收集到Map集合中 |
package com.itheima.d2_stream;
import java.util.*;
import java.util.function.IntFunction;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
目标：收集Stream流的数据到 集合或者数组中去。
*/
public class StreamDemo05 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张无忌");
list.add("周芷若");
list.add("赵敏");
list.add("张强");
list.add("张三丰");
list.add("张三丰");
Stream<String> s1 = list.stream().filter(s -> s.startsWith("张"));
List<String> zhangList = s1.collect(Collectors.toList()); // 可变集合
zhangList.add("java1");
System.out.println(zhangList);
// List<String> list1 = s1.toList(); // 得到不可变集合
// list1.add("java");
// System.out.println(list1);
// 注意注意注意：“流只能使用一次”
Stream<String> s2 = list.stream().filter(s -> s.startsWith("张"));
Set<String> zhangSet = s2.collect(Collectors.toSet());
System.out.println(zhangSet);
Stream<String> s3 = list.stream().filter(s -> s.startsWith("张"));
// Object[] arrs = s3.toArray();
String[] arrs = s3.toArray(String[]::new); // 可以不管，拓展一下思维！！
System.out.println("Arrays数组内容：" + Arrays.toString(arrs));
}
}
异常
什么是异常？
异常是程序在“编译”或者“执行”的过程中可能出现的问题，注意：语法错误不算在异常体系中。
比如:数组索引越界、空指针异常、 日期格式化异常，等…
为什么要学习异常?
异常一旦出现了，如果没有提前处理，程序就会退出JVM虚拟机而终止.
研究异常并且避免异常，然后提前处理异常，体现的是程序的安全, 健壮性。
异常体系
Error：系统级别问题、JVM退出等，代码无法控制。
Exception：java.lang包下，称为异常类，它表示程序本身可以处理的问题
RuntimeException及其子类：运行时异常，编译阶段不会报错。 (空指针异常，数组索引越界异常)
除RuntimeException之外所有的异常：编译时异常，编译期必须处理的，否则程序不能通过编译。 (日期格式化异常)。
常见的运行时异常
/**
拓展: 常见的运行时异常。（面试题）
运行时异常的概念:
继承自RuntimeException的异常或者其子类，
编译阶段是不会出错的，它是在运行时阶段可能出现的错误，
运行时异常编译阶段可以处理也可以不处理,代码编译都能通过！！
1.数组索引越界异常: ArrayIndexOutOfBoundsException。
2.空指针异常 : NullPointerException。
直接输出没有问题。但是调用空指针的变量的功能就会报错！！
3.类型转换异常：ClassCastException。
4.迭代器遍历没有此元素异常：NoSuchElementException。
5.数学操作异常：ArithmeticException。
6.数字转换异常： NumberFormatException。
小结：
运行时异常继承了RuntimeException ,编译阶段不报错，运行时才可能会出现错误!
*/
public class ExceptionDemo {
public static void main(String[] args) {
System.out.println("程序开始。。。。。。");
/** 1.数组索引越界异常: ArrayIndexOutOfBoundsException。*/
int[] arr = {1, 2, 3};
System.out.println(arr[2]);
// System.out.println(arr[3]); // 运行出错，程序终止
/** 2.空指针异常 : NullPointerException。直接输出没有问题。但是调用空指针的变量的功能就会报错！！ */
String name = null;
System.out.println(name); // null
// System.out.println(name.length()); // 运行出错，程序终止
/** 3.类型转换异常：ClassCastException。 */
Object o = 23;
// String s = (String) o; // 运行出错，程序终止
/** 5.数学操作异常：ArithmeticException。 */
//int c = 10 / 0;
/** 6.数字转换异常： NumberFormatException。 */
//String number = "23";
String number = "23aabbc";
Integer it = Integer.valueOf(number); // 运行出错，程序终止
System.out.println(it + 1);
System.out.println("程序结束。。。。。");
}
}常见的编译时异常
/**
目标：常见的编译时异常认识。
编译时异常：继承自Exception的异常或者其子类，没有继承RuntimeException
"编译时异常是编译阶段就会报错"，
必须程序员编译阶段就处理的。否则代码编译就报错！！
编译时异常的作用是什么：
是担心程序员的技术不行，在编译阶段就爆出一个错误, 目的在于提醒!
提醒程序员这里很可能出错，请检查并注意不要出bug。
编译时异常是可遇不可求。遇到了就遇到了呗。
了解:
*/
public class ExceptionDemo {
public static void main(String[] args) throws ParseException {
String date = "2015-01-12 10:23:21";
// 创建一个简单日期格式化类：
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
// 解析字符串时间成为日期对象
Date d = sdf.parse(date);
//
System.out.println(d);
}
}
异常的产生默认的处理过程解析
/**
目标：异常的产生默认的处理过程解析。(自动处理的过程！)
（1）默认会在出现异常的代码那里自动的创建一个异常对象：ArithmeticException。
（2）异常会从方法中出现的点这里抛出给调用者，调用者最终抛出给JVM虚拟机。
（3）虚拟机接收到异常对象后，先在控制台直接输出异常栈信息数据。
（4）直接从当前执行的异常点干掉当前程序。
（5）后续代码没有机会执行了，因为程序已经死亡。
小结：
异常一旦出现，会自动创建异常对象，最终抛出给虚拟机，虚拟机
只要收到异常，就直接输出异常信息，干掉程序！！
默认的异常处理机制并不好，一旦真的出现异常，程序立即死亡！
*/
public class ExceptionDemo {
public static void main(String[] args) {
System.out.println("程序开始。。。。。。。。。。");
chu(10, 0);
System.out.println("程序结束。。。。。。。。。。");
}
public static void chu(int a , int b){
System.out.println(a);
System.out.println(b);
int c = a / b;
System.out.println(c);
}
}编译时异常是编译阶段就出错的，所以必须处理，否则代码根本无法通过
编译时异常的处理形式有三种：
出现异常直接抛出去给调用者，调用者也继续抛出去。
出现异常自己捕获处理，不麻烦别人。
前两者结合，出现异常直接抛出去给调用者，调用者捕获处理。
package com.itheima.d7_exception_handle;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
目标：编译时异常的处理方式一。
编译时异常：编译阶段就会报错，一定需要程序员处理的，否则代码无法通过！！
抛出异常格式：
方法 throws 异常1 , 异常2 , ..{
}
建议抛出异常的方式：代表可以抛出一切异常，
方法 throws Exception{
}
方式一：
在出现编译时异常的地方层层把异常抛出去给调用者，调用者最终抛出给JVM虚拟机。
JVM虚拟机输出异常信息，直接干掉程序，这种方式与默认方式是一样的。
虽然可以解决代码编译时的错误，但是一旦运行时真的出现异常，程序还是会立即死亡！
这种方式并不好!
小结：
方式一出现异常层层跑出给虚拟机，最终程序如果真的出现异常，程序还是立即死亡！这种方式不好！
*/
public class ExceptionDemo01 {
// public static void main(String[] args) throws ParseException, FileNotFoundException {
// System.out.println("程序开始。。。。。");
// parseTime("2011-11-11 11:11:11");
// System.out.println("程序结束。。。。。");
// }
//
// public static void parseTime(String date) throws ParseException, FileNotFoundException {
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
// Date d = sdf.parse(date);
// System.out.println(d);
//
// InputStream is = new FileInputStream("E:/meinv.jpg");
// }
public static void main(String[] args) throws Exception {
System.out.println("程序开始。。。。。");
parseTime("2011-11-11 11:11:11");
System.out.println("程序结束。。。。。");
}
public static void parseTime(String date) throws Exception {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d = sdf.parse(date);
System.out.println(d);
InputStream is = new FileInputStream("E:/meinv.jpg");
}
}
package com.itheima.d7_exception_handle;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
目标：编译时异常的处理方式二。
方式二：在出现异常的地方自己处理，谁出现谁处理。
自己捕获异常和处理异常的格式：捕获处理
try{
// 监视可能出现异常的代码！
}catch(异常类型1 变量){
// 处理异常
}catch(异常类型2 变量){
// 处理异常
}...
监视捕获处理异常企业级写法：
try{
// 可能出现异常的代码！
}catch (Exception e){
e.printStackTrace(); // 直接打印异常栈信息
}
Exception可以捕获处理一切异常类型！
小结：
第二种方式，可以处理异常，并且出现异常后代码也不会死亡。
这种方案还是可以的。
但是从理论上来说，这种方式不是最好的，上层调用者不能直接知道底层的执行情况！
*/
public class ExceptionDemo02 {
public static void main(String[] args) {
System.out.println("程序开始。。。。");
parseTime("2011-11-11 11:11:11");
System.out.println("程序结束。。。。");
}
public static void parseTime(String date) {
try {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
Date d = sdf.parse(date);
System.out.println(d);
InputStream is = new FileInputStream("E:/meinv.jpg");
} catch (Exception e) {
e.printStackTrace(); // 打印异常栈信息
}
}
// public static void parseTime(String date) {
// try {
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
// Date d = sdf.parse(date);
// System.out.println(d);
//
// InputStream is = new FileInputStream("E:/meinv.jpg");
// } catch (FileNotFoundException|ParseException e) {
// e.printStackTrace(); // 打印异常栈信息
// }
// }
// public static void parseTime(String date) {
// try {
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
// Date d = sdf.parse(date);
// System.out.println(d);
//
// InputStream is = new FileInputStream("E:/meinv.jpg");
// } catch (FileNotFoundException e) {
// e.printStackTrace(); // 打印异常栈信息
// } catch (ParseException e) {
// e.printStackTrace();
// }
// }
// public static void parseTime(String date) {
// try {
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
// Date d = sdf.parse(date);
// System.out.println(d);
// } catch (ParseException e) {
// // 解析出现问题
// System.out.println("出现了解析时间异常哦，走点心！！");
// }
//
// try {
// InputStream is = new FileInputStream("E:/meinv.jpg");
// } catch (FileNotFoundException e) {
// System.out.println("您的文件根本就没有啊，不要骗我哦！！");
// }
// }
}
package com.itheima.d7_exception_handle;
import java.io.FileInputStream;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
目标：编译时异常的处理方式三。
方式三： 在出现异常的地方把异常一层一层的抛出给最外层调用者，
最外层调用者集中捕获处理！！（规范做法）
小结：
编译时异常的处理方式三：底层出现的异常抛出给最外层调用者集中捕获处理。
这种方案最外层调用者可以知道底层执行的情况，同时程序在出现异常后也不会立即死亡，这是
理论上最好的方案。
虽然异常有三种处理方式，但是开发中只要能解决你的问题，每种方式都又可能用到!!
*/
public class ExceptionDemo03 {
public static void main(String[] args) {
System.out.println("程序开始。。。。");
try {
parseTime("2011-11-11 11:11:11");
System.out.println("功能操作成功~~~");
} catch (Exception e) {
e.printStackTrace();
System.out.println("功能操作失败~~~");
}
System.out.println("程序结束。。。。");
}
public static void parseTime(String date) throws Exception {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy、MM-dd HH:mm:ss");
Date d = sdf.parse(date);
System.out.println(d);
InputStream is = new FileInputStream("D:/meinv.jpg");
}
}
运行时异常的处理形式
运行时异常编译阶段不会出错，是运行时才可能出错的，所以编译阶段不处理也可以。
按照规范建议还是处理：建议在最外层调用处集中捕获处理即可。
异常处理使代码更稳健的案例
import java.util.Scanner;
/**
需求：需要输入一个合法的价格为止 要求价格大于 0
*/
public class Test2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (true) {
try {
System.out.println("请您输入合法的价格：");
String priceStr = sc.nextLine();
// 转换成double类型的价格
double price = Double.valueOf(priceStr);
// 判断价格是否大于 0
if(price > 0) {
System.out.println("定价：" + price);
break;
}else {
System.out.println("价格必须是正数~~~");
}
} catch (Exception e) {
System.out.println("用户输入的数据有毛病，请您输入合法的数值，建议为正数~~");
}
}
}
}自定义异常
自定义异常的必要？
Java无法为这个世界上全部的问题提供异常类。
如果企业想通过异常的方式来管理自己的某个业务问题，就需要自定义异常类了。
自定义异常的好处：
可以使用异常的机制管理业务问题，如提醒程序员注意。
同时一旦出现bug，可以用异常的形式清晰的指出出错的地方。
自定义异常的分类
1、自定义编译时异常
定义一个异常类继承Exception.
重写构造器。
在出现异常的地方用throw new 自定义对象抛出，
作用：编译时异常是编译阶段就报错，提醒更加强烈，一定需要处理！！
2、自定义运行时异常
定义一个异常类继承RuntimeException.
重写构造器。
在出现异常的地方用throw new 自定义对象抛出!
作用：提醒不强烈，编译阶段不报错！！运行时才可能出现！！
package com.itheima.d9_exception_custom;
/**
目标:自定义异常(了解)
引入:Java已经为开发中可能出现的异常都设计了一个类来代表.
但是实际开发中,异常可能有无数种情况,Java无法为
这个世界上所有的异常都定义一个代表类。
假如一个企业如果想为自己认为的某种业务问题定义成一个异常
就需要自己来自定义异常类.
需求：认为年龄小于0岁，大于200岁就是一个异常。
自定义异常:
自定义编译时异常.
a.定义一个异常类继承Exception.
b.重写构造器。
c.在出现异常的地方用throw new 自定义对象抛出!
编译时异常是编译阶段就报错，提醒更加强烈，一定需要处理！！
自定义运行时异常.
a.定义一个异常类继承RuntimeException.
b.重写构造器。
c.在出现异常的地方用throw new 自定义对象抛出!
提醒不强烈，编译阶段不报错！！运行时才可能出现！！
*/
public class ExceptionDemo {
public static void main(String[] args) {
// try {
// checkAge(-34);
// } catch (ItheimaAgeIlleagalException e) {
// e.printStackTrace();
// }
try {
checkAge2(-23);
} catch (Exception e) {
e.printStackTrace();
}
}
public static void checkAge2(int age) {
if(age < 0 || age > 200){
// 抛出去一个异常对象给调用者
// throw ：在方法内部直接创建一个异常对象，并从此点抛出
// throws : 用在方法申明上的，抛出方法内部的异常
throw new ItheimaAgeIlleagalRuntimeException(age + " is illeagal!");
}else {
System.out.println("年龄合法：推荐商品给其购买~~");
}
}
public static void checkAge(int age) throws ItheimaAgeIlleagalException {
if(age < 0 || age > 200){
// 抛出去一个异常对象给调用者
// throw ：在方法内部直接创建一个异常对象，并从此点抛出
// throws : 用在方法申明上的，抛出方法内部的异常
throw new ItheimaAgeIlleagalException(age + " is illeagal!");
}else {
System.out.println("年龄合法：推荐商品给其购买~~");
}
}
}
/**
自定义的编译时异常
1、继承Exception
2、重写构造器
*/
public class ItheimaAgeIlleagalException extends Exception{
public ItheimaAgeIlleagalException() {
}
public ItheimaAgeIlleagalException(String message) {
super(message);
}
}
/**
自定义的编译时异常
1、继承RuntimeException
2、重写构造器
*/
public class ItheimaAgeIlleagalRuntimeException extends RuntimeException{
public ItheimaAgeIlleagalRuntimeException() {
}
public ItheimaAgeIlleagalRuntimeException(String message) {
super(message);
}
}日志
希望系统能记住某些数据是被谁操作的，比如被谁删除了？
想分析用户浏览系统的具体情况，以便挖掘用户的具体喜好？
当系统在开发或者上线后出现了bug，崩溃了，该通过什么去分析、定位bug？
日志：用来记录程序运行过程中的信息，并可以进行永久存储。好比生活中的日记，可以记录你生活的点点滴滴。
日志技术应该具备哪些特点和优势
可以将系统执行的信息，方便的记录到指定的位置（控制台、文件中、数据库中）。
可以随时以开关的形式控制是日志的记录和取消，无需侵入到源代码中去进行修改。
| 输出语句 | 日志技术 | |
| 输出位置 | 输出到控制台 | 可以将日志信息写入到文件或者数据库中 |
| 取消日志 | 需要修改代码，灵活性比较差 | 不需要修改代码，灵活性比较好 |
| 多线程 | 性能较差 | 性能较好 |
Logback日志框架 https://logback.qos.ch/index.html
Logback日志框架分为以下模块：
logback-core： 该模块为其他两个模块提供基础代码。 （必须有）
logback-classic：完整实现了slf4j API的模块。（必须有）
logback-access 模块与 Tomcat 和 Jetty 等 Servlet 容器集成，以提供 HTTP 访问日志功能（可选模块，以后接触）
想使用Logback日志框架，至少需要在项目中整合如下三个模块：
slf4j-api：日志接口
logback-core：基础模块
logback-classic：功能模块，它完整实现了slf4j API
对Logback日志框架的控制，都是通过核心配置文件logback.xml来实现的。
Logback日志输出位置、格式设置：
通过logback.xml 中的标签可以设置输出位置。
通常可以设置2个日志输出位置：一个是控制台、一个是系统文件中
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<!--
CONSOLE ：表示当前的日志信息是可以输出到控制台的。
-->
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
<!--输出流对象 默认 System.out 改为 System.err-->
<target>System.out</target>
<encoder>
<!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度
%msg：日志消息，%n是换行符-->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] %c [%thread] : %msg%n</pattern>
</encoder>
</appender>
<!-- File是输出的方向通向文件的 -->
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
<encoder>
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
<charset>utf-8</charset>
</encoder>
<!--日志输出路径-->
<file>C:/code/itheima-data.log</file>
<!--指定日志文件拆分和压缩规则-->
<rollingPolicy
class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
<!--通过指定压缩文件名称，来确定分割文件方式-->
<fileNamePattern>C:/code/itheima-data2-%d{yyyy-MMdd}.log%i.gz</fileNamePattern>
<!--文件拆分大小-->
<maxFileSize>1MB</maxFileSize>
</rollingPolicy>
</appender>
<!--
level:用来设置打印级别，大小写无关：TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF
， 默认debug
<root>可以包含零个或多个<appender-ref>元素，标识这个输出位置将会被本日志级别控制。
-->
<root level="ALL">
<appender-ref ref="CONSOLE"/>
<appender-ref ref="FILE" />
</root>
</configuration>日志级别
ALL 和 OFF分别是打开、及关闭全部日志信息。
除此之外，日志级别还有： TRACE < DEBUG < INFO < WARN < ERROR ; 默认级别是DEBUG，对应其方法
作用：当在logback.xml文件中设置了某种日志级别后，系统将只输出当前级别，以及高于当前级别的日志。
具体在标签的level属性中设置指定系统的日志级别。
File
File类概述
File类的对象代表操作系统的文件（文件、文件夹），File类在java.io.File包下。
File类提供了诸如：创建文件对象代表文件，获取文件信息（大小、修改时间）、删除文件、创建文件（文件夹）等功能
| 方法名称 | 说明 |
| public File(String pathname) | 根据文件路径创建文件对象 |
| public File(String parent, String child) | 根据父路径名字符串和子路径名字符串创建文件对象 |
| public File(File parent, String child) | 根据父路径对应文件对象和子路径名字符串创建文件对象 |
注意
File对象可以定位文件和文件夹
File封装的对象仅仅是一个路径名，这个路径可以是存在的，也可以是不存在的。
import java.io.File;
/**
目标：学会创建File对象定位操作系统的文件（文件 文件夹的）
*/
public class FileDemo {
public static void main(String[] args) {
// 1、创建File对象（指定了文件的路径）
// 路径写法： D:\resources\xueshan.jpeg
// D:/resources/xueshan.jpeg
// File.separator
// File f = new File("D:\\resources\\xueshan.jpeg");
// File f = new File("D:/resources/xueshan.jpeg");
File f = new File("D:" + File.separator+"resources"+ File.separator +"xueshan.jpeg");
long size = f.length(); // 是文件的字节大小
System.out.println(size);
// 2、File创建对象，支持绝对路径 支持相对路径（重点）
File f1 = new File("D:\\resources\\beauty.jpeg"); // 绝对路径
System.out.println(f1.length());
// 相对路径：一般定位模块中的文件的。 相对到工程下！！
File f2 = new File("file-io-app/src/data.txt");
System.out.println(f2.length());
// 3、File创建对象 ，可以是文件也可以是文件夹
File f3 = new File("D:\\resources");
System.out.println(f3.exists()); // 判断这个路径是否存在，这个文件夹存在否
}
}File类的判断文件类型、获取文件信息功能
| 方法名称 | 说明 |
| public boolean isDirectory() | 判断此路径名表示的File是否为文件夹 |
| public boolean isFile() | 判断此路径名表示的File是否为文件 |
| public boolean exists() | 判断此路径名表示的File是否存在 |
| public long length() | 返回文件的大小（字节数量） |
| public String getAbsolutePath() | 返回文件的绝对路径 |
| public String getPath() | 返回定义文件时使用的路径 |
| public String getName() | 返回文件的名称，带后缀 |
| public long lastModified() | 返回文件的最后修改时间（时间毫秒值） |
import java.io.File;
import java.text.SimpleDateFormat;
/**
目标：File类的获取功能的API
- public String getAbsolutePath() ：返回此File的绝对路径名字符串。
- public String getPath() ： 获取创建文件对象的时候用的路径
- public String getName() ： 返回由此File表示的文件或目录的名称。
- public long length() ： 返回由此File表示的文件的长度。
*/
public class FileDemo02 {
public static void main(String[] args) {
// 1.绝对路径创建一个文件对象
File f1 = new File("D:/resources/xueshan.jpeg");
// a.获取它的绝对路径。
System.out.println(f1.getAbsolutePath());
// b.获取文件定义的时候使用的路径。
System.out.println(f1.getPath());
// c.获取文件的名称：带后缀。
System.out.println(f1.getName());
// d.获取文件的大小：字节个数。
System.out.println(f1.length()); // 字节大小
// e.获取文件的最后修改时间
long time = f1.lastModified();
System.out.println("最后修改时间：" + new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(time));
// f、判断文件是文件还是文件夹
System.out.println(f1.isFile()); // true
System.out.println(f1.isDirectory()); // false
System.out.println("-------------------------");
File f2 = new File("file-io-app\\src\\data.txt");
// a.获取它的绝对路径。
System.out.println(f2.getAbsolutePath());
// b.获取文件定义的时候使用的路径。
System.out.println(f2.getPath());
// c.获取文件的名称：带后缀。
System.out.println(f2.getName());
// d.获取文件的大小：字节个数。
System.out.println(f2.length()); // 字节大小
// e.获取文件的最后修改时间
long time1 = f2.lastModified();
System.out.println("最后修改时间：" + new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(time1));
// f、判断文件是文件还是文件夹
System.out.println(f2.isFile()); // true
System.out.println(f2.isDirectory()); // false
System.out.println(f2.exists()); // true
File file = new File("D:/");
System.out.println(file.isFile()); // false
System.out.println(file.isDirectory()); // true
System.out.println(file.exists()); // true
File file1 = new File("D:/aaa");
System.out.println(file1.isFile()); // false
System.out.println(file1.isDirectory()); // false
System.out.println(file1.exists()); // false
}
}File类创建文件的功能
| 方法名称 | 说明 |
| public boolean createNewFile() | 创建一个新的空的文件 |
| public boolean mkdir() | 只能创建一级文件夹 |
| public boolean mkdirs() | 可以创建多级文件夹 |
File类删除文件的功能
| 方法名称 | 说明 |
| public boolean delete() | 删除由此抽象路径名表示的文件或空文件夹 |
delete方法默认只能删除文件和空文件夹，delete方法直接删除不走回收站
import java.io.File;
import java.io.IOException;
/**
目标：File类的创建和删除的方法
- public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，
创建一个新的空文件。 （几乎不用的，因为以后文件都是自动创建的！）
- public boolean delete() ：删除由此File表示的文件或目录。 （只能删除空目录）
- public boolean mkdir() ：创建由此File表示的目录。（只能创建一级目录）
- public boolean mkdirs() ：可以创建多级目录（建议使用的）
*/
public class FileDemo03 {
public static void main(String[] args) throws IOException {
File f = new File("file-io-app\\src\\data.txt");
// a.创建新文件，创建成功返回true ,反之 ,不需要这个，以后文件写出去的时候都会自动创建
System.out.println(f.createNewFile());
File f1 = new File("file-io-app\\src\\data02.txt");
System.out.println(f1.createNewFile()); // （几乎不用的，因为以后文件都是自动创建的！）
// b.mkdir创建一级目录
File f2 = new File("D:/resources/aaa");
System.out.println(f2.mkdir());
// c.mkdirs创建多级目录(重点)
File f3 = new File("D:/resources/ccc/ddd/eee/ffff");
// System.out.println(f3.mkdir());
System.out.println(f3.mkdirs()); // 支持多级创建
// d.删除文件或者空文件夹
System.out.println(f1.delete());
File f4 = new File("D:/resources/xueshan.jpeg");
System.out.println(f4.delete()); // 占用一样可以删除
// 只能删除空文件夹,不能删除非空文件夹.
File f5 = new File("D:/resources/aaa");
System.out.println(f5.delete());
}
}File类的遍历功能
| 方法名称 | 说明 |
| public String[] list() | 获取当前目录下所有的"一级文件名称"到一个字符串数组中去返回。 |
| public File[] listFiles()(常用) | 获取当前目录下所有的"一级文件对象"到一个文件对象数组中去返回（重点） |
import java.io.File;
import java.util.Arrays;
/**
目标：File针对目录的遍历
- public String[] list()：
获取当前目录下所有的"一级文件名称"到一个字符串数组中去返回。
- public File[] listFiles()(常用)：
获取当前目录下所有的"一级文件对象"到一个文件对象数组中去返回（重点）
*/
public class FileDemo04 {
public static void main(String[] args) {
// 1、定位一个目录
File f1 = new File("D:/resources");
String[] names = f1.list();
for (String name : names) {
System.out.println(name);
}
// 2.一级文件对象
// 获取当前目录下所有的"一级文件对象"到一个文件对象数组中去返回（重点）
File[] files = f1.listFiles();
for (File f : files) {
System.out.println(f.getAbsolutePath());
}
// 注意事项
File dir = new File("D:/resources/ddd");
File[] files1 = dir.listFiles();
System.out.println(Arrays.toString(files1));
}
}listFiles方法注意事项：
当文件不存在时或者代表文件时，返回null
当文件对象代表一个空文件夹时，返回一个长度为0的数组
当文件对象是一个有内容的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回
当文件对象是一个有隐藏文件的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏文件
当没有权限访问该文件夹时，返回null
递归搜索文件
import java.io.File;
import java.io.IOException;
/**
目标：去D判断搜索 eDiary.exe文件
*/
public class RecursionDemo05 {
public static void main(String[] args) {
// 2、传入目录 和 文件名称
searchFile(new File("D:/") , "eDiary.exe");
}
/**
* 1、搜索某个目录下的全部文件，找到我们想要的文件。
* @param dir 被搜索的源目录
* @param fileName 被搜索的文件名称
*/
public static void searchFile(File dir,String fileName){
// 3、判断dir是否是目录
if(dir != null && dir.isDirectory()){
// 可以找了
// 4、提取当前目录下的一级文件对象
File[] files = dir.listFiles(); // null []
// 5、判断是否存在一级文件对象，存在才可以遍历
if(files != null && files.length > 0) {
for (File file : files) {
// 6、判断当前遍历的一级文件对象是文件 还是 目录
if(file.isFile()){
// 7、是不是咱们要找的，是把其路径输出即可
if(file.getName().contains(fileName)){
System.out.println("找到了：" + file.getAbsolutePath());
// 启动它。
try {
Runtime r = Runtime.getRuntime();
r.exec(file.getAbsolutePath());
} catch (IOException e) {
e.printStackTrace();
}
}
}else {
// 8、是文件夹，需要继续递归寻找
searchFile(file, fileName);
}
}
}
}else {
System.out.println("对不起，当前搜索的位置不是文件夹！");
}
}
}删除非空文件夹
import java.io.File;
/**
目标：删除非空文件夹
*/
public class RecursionDemo07 {
public static void main(String[] args) {
deleteDir(new File("D:/new"));
}
/**
删除文件夹，无所谓里面是否有内容，都可以删除
* @param dir
*/
public static void deleteDir(File dir){
// 1、判断dir存在且是文件夹
if(dir != null && dir.exists() && dir.isDirectory()){
// 2、提取一级文件对象。
File[] files = dir.listFiles();
// 3、判断是否存在一级文件对象，存在则遍历全部的一级文件对象去删除
if(files != null && files.length > 0){
// 里面有内容
for (File file : files) {
// 4、判断file是文件还是文件夹，文件直接删除
if(file.isFile()){
file.delete();
}else {
// 递归删除
deleteDir(file);
}
}
}
// 删除自己
dir.delete();
}
}
}IO流
此章节需注意项目编码（UTF-8）
I表示intput，把硬盘文件中的数据读入到内存的过程，称之输入，负责读。
O表示output，把内存中的数据写出到硬盘文件的过程，称之输出，负责写。
总结流的四大类:
字节输入流：以内存为基准，来自磁盘文件/网络中的数据以字节的形式读入到内存中去的流称为字节输入流。
字节输出流：以内存为基准，把内存中的数据以字节写出到磁盘文件或者网络中去的流称为字节输出流。
字符输入流：以内存为基准，来自磁盘文件/网络中的数据以字符的形式读入到内存中去的流称为字符输入流。
字符输出流：以内存为基准，把内存中的数据以字符写出到磁盘文件或者网络介质中去的流称为字符输出流。
字节流
文件字节输入流：FileInputStream
作用：以内存为基准，把磁盘文件中的数据以字节的形式读取到内存中去。
| 构造器 | 说明 |
| public FileInputStream(File file) | 创建字节输入流管道与源文件对象接通 |
| public FileInputStream(String pathname) | 创建字节输入流管道与源文件路径接通 |
| 方法名称 | 说明 |
| public int read() | 每次读取一个字节返回，如果字节已经没有可读的返回-1 |
| public int read(byte[] buffer) | 每次读取一个字节数组返回，如果字节已经没有可读的返回-1 |
//每次读取一字节
public class FileInputStreamDemo01 {
public static void main(String[] args) throws Exception {
// 1、创建一个文件字节输入流管道与源文件接通。
// InputStream is = new FileInputStream(new File("file-io-app\\src\\data.txt"));
// 简化写法
InputStream is = new FileInputStream("src//data.txt");
// 2、读取一个字节返回 （每次读取一滴水）
// int b1 = is.read();
// System.out.println((char)b1);
//
// int b2 = is.read();
// System.out.println((char)b2);
//
// int b3 = is.read();
// System.out.println((char)b3);
//
// int b4 = is.read(); // 读取完毕返回-1
// System.out.println(b4);
// 3、使用循环改进
// 定义一个变量记录每次读取的字节 a b 3 爱
// o o o [ooo]
int b;
while (( b = is.read() ) != -1){
System.out.print((char) b);
}
}
}
//每次读取一数组
import java.io.FileInputStream;
import java.io.InputStream;
/**
目标：使用文件字节输入流每次读取一个字节数组的数据。
*/
public class FileInputStreamDemo02 {
public static void main(String[] args) throws Exception {
// 1、创建一个文件字节输入流管道与源文件接通
InputStream is = new FileInputStream("src/com/itheima/data02.txt");
// 2、定义一个字节数组，用于读取字节数组
// byte[] buffer = new byte[3]; // 3B
// int len = is.read(buffer);
// System.out.println("读取了几个字节：" + len);
// String rs = new String(buffer);
// System.out.println(rs);
//
// int len1 = is.read(buffer);
// System.out.println("读取了几个字节：" + len1);
// String rs1 = new String(buffer);
// System.out.println(rs1);
// // buffer = [a b c]
//
// // buffer = [a b c] ==> [c d c]
// int len2 = is.read(buffer);
// System.out.println("读取了几个字节：" + len2);
// // 读取多少倒出多少
// String rs2 = new String(buffer,0 ,len2);
// System.out.println(rs2);
//
// int len3 = is.read(buffer);
// System.out.println(len3); // 读取完毕返回-1
// 3、改进使用循环，每次读取一个字节数组
byte[] buffer = new byte[3];
int len; // 记录每次读取的字节数。
while ((len = is.read(buffer)) != -1) {
// 读取多少倒出多少
System.out.print(new String(buffer, 0 , len , "UTF-8"));
}
}
}
//每次完整读取，解决中文乱码问题
import java.io.*;
/**
目标：使用文件字节输入流一次读完文件的全部字节。可以解决乱码问题。
*/
public class FileInputStreamDemo03 {
public static void main(String[] args) throws Exception {
// 1、创建一个文件字节输入流管道与源文件接通
File f = new File("src/com/itheima/data03.txt");
InputStream is = new FileInputStream(f);
/* BufferedReader br = new BufferedReader(new InputStreamReader(is,"UTF-8"));
String str = null;
while((str = br.readLine()) != null){
System.out.println(str);
}*/
// 2、定义一个字节数组与文件的大小刚刚一样大。
// byte[] buffer = new byte[(int) f.length()];
// int len = is.read(buffer);
// System.out.println("读取了多少个字节：" + len);
// System.out.println("文件大小：" + f.length());
// System.out.println(new String(buffer));
// 读取全部字节数组
byte[] buffer = is.readAllBytes();
System.out.println(new String(buffer,"UTF-8"));
}
}BufferedReader br = null;
try{
// 在FileInputStream中指定编码格式为"GBK"
br = new BufferedReader(new InputStreamReader(new FileInputStream("file"),"GBK"));
String str = null;
while((str = br.readLine()) != null){
System.out.println(str);
}
}catch(FileNotFoundException e){
throw new RuntimeException(e);
}catch(IOException e){
throw new RuntimeException(e);
}
finally {
// 关闭流
if (br == null) {
try {
br.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
文件字节输出流：FileOutputStream
作用：以内存为基准，把内存中的数据以字节的形式写出到磁盘文件中去的流。
| 构造器 | 说明 |
| public FileOutputStream(File file) | 创建字节输出流管道与源文件对象接通 |
| public FileOutputStream(File file，boolean append) | 创建字节输出流管道与源文件对象接通，可追加数据 |
| public FileOutputStream(String filepath) | 创建字节输出流管道与源文件路径接通 |
| public FileOutputStream(String filepath，boolean append) | 创建字节输出流管道与源文件路径接通，可追加数据 |
文件字节输出流（FileOutputStream）写数据出去的API
| 方法名称 | 说明 |
| public void write(int a) | 写一个字节出去 |
| public void write(byte[] buffer) | 写一个字节数组出去 |
| public void write(byte[] buffer , int pos , int len) | 写一个字节数组的一部分出去。 |
流的关闭与刷新
| 方法 | 说明 |
| flush() | 刷新流，还可以继续写数据 |
| close() | 关闭流，释放资源，但是在关闭之前会先刷新流。一旦关闭，就不能再写数据 |
package com.itheima.d4_byte_stream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;
/**
目标：字节输出流的使用。
IO流的体系：
字节流 字符流
字节输入流 字节输出流 字符输入流 字符输出流
InputStream OutputStream Reader Writer (抽象类)
FileInputStream FileOutputStream FileReader FileWriter (实现类)
a.FileOutputStream文件字节输出流。
-- 作用：以内存为基准，把内存中的数据，按照字节的形式写出到磁盘文件中去。
简单来说，把内存数据按照字节写出到磁盘文件中去。
-- 构造器：
public FileOutputStream(File file):创建一个字节输出流管道通向目标文件对象。
public FileOutputStream(String file):创建一个字节输出流管道通向目标文件路径。
public FileOutputStream(File file , boolean append):创建一个追加数据的字节输出流管道通向目标文件对象。
public FileOutputStream(String file , boolean append):创建一个追加数据的字节输出流管道通向目标文件路径。
-- 方法：
public void write(int a):写一个字节出去 。
public void write(byte[] buffer):写一个字节数组出去。
public void write(byte[] buffer , int pos , int len):写一个字节数组的一部分出去。
参数一，字节数组；参数二：起始字节索引位置，参数三：写多少个字节数出去。
小结：
记住。
换行： os.write("\r\n".getBytes()); // 换行
追加数据管道： OutputStream os = new FileOutputStream("day10_demo/out01.txt" , true); // 追加管道！！
*/
public class OutputStreamDemo04 {
public static void main(String[] args) throws Exception {
// 1、创建一个文件字节输出流管道与目标文件接通
OutputStream os = new FileOutputStream("src/out04.txt" , true); // 追加数据管道
// OutputStream os = new FileOutputStream("file-io-app/src/out04.txt"); // 先清空之前的数据，写新数据进入
// 2、写数据出去
// a.public void write(int a):写一个字节出去
os.write('a');
os.write(98);
os.write("\r\n".getBytes()); // 换行
// os.write('徐'); // [ooo]
// b.public void write(byte[] buffer):写一个字节数组出去。
byte[] buffer = {'a' , 97, 98, 99};
os.write(buffer);
os.write("\r\n".getBytes()); // 换行
byte[] buffer2 = "我是中国人".getBytes();
// byte[] buffer2 = "我是中国人".getBytes("GBK");
os.write(buffer2);
os.write("\r\n".getBytes()); // 换行
// c. public void write(byte[] buffer , int pos , int len):写一个字节数组的一部分出去。
byte[] buffer3 = {'a',97, 98, 99};
os.write(buffer3, 0 , 3);
os.write("\r\n".getBytes()); // 换行
// os.flush(); // 写数据必须，刷新数据 可以继续使用流
os.close(); // 释放资源，包含了刷新的！关闭后流不可以使用了
}
}
文件拷贝
需求：
把某个视频复制到其他目录下的“b.avi”
思路：
根据数据源创建字节输入流对象
根据目的地创建字节输出流对象
读写数据，复制视频
释放资源
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
/**
* 目标：学会使用字节流完成文件的复制（支持一切文件类型的复制）
*/
public class CopyDemo05 {
public static void main(String[] args) {
try {
// 1、创建一个字节输入流管道与原视频接通
InputStream is = new FileInputStream("file-io-app/src/out04.txt");
// 2、创建一个字节输出流管道与目标文件接通
OutputStream os = new FileOutputStream("file-io-app/src/out05.txt");
// 3、定义一个字节数组转移数据
byte[] buffer = new byte[1024];
int len; // 记录每次读取的字节数。
while ((len = is.read(buffer)) != -1){
os.write(buffer, 0 , len);
}
System.out.println("复制完成了！");
// 4、关闭流。
os.close();
is.close();
} catch (Exception e){
e.printStackTrace();
}
}
}资源释放的方式
try-catch-finally
finally：放在try-catch后面的，无论是正常执行还是异常执行代码，最后一定要执行，除非JVM退出。
作用：一般用于进行最后的资源释放操作（专业级做法）
package com.itheima.d5_resource;
import java.io.*;
/**
* 目标：学会使用finally释放资源。
*/
public class TryCatchFinallyDemo1 {
public static void main(String[] args) {
InputStream is = null;
OutputStream os = null;
try {
// System.out.println(10/ 0);
// 1、创建一个字节输入流管道与原视频接通
is = new FileInputStream("file-io-app/src/out04.txt");
// 2、创建一个字节输出流管道与目标文件接通
os = new FileOutputStream("file-io-app/src/out05.txt");
// 3、定义一个字节数组转移数据
byte[] buffer = new byte[1024];
int len; // 记录每次读取的字节数。
while ((len = is.read(buffer)) != -1){
os.write(buffer, 0 , len);
}
System.out.println("复制完成了！");
// System.out.println( 10 / 0);
} catch (Exception e){
e.printStackTrace();
} finally {
// 无论代码是正常结束，还是出现异常都要最后执行这里
System.out.println("========finally=========");
try {
// 4、关闭流。
if(os!=null)os.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if(is != null) is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println(test(10, 2));
}
public static int test(int a , int b){
try {
int c = a / b;
return c;
}catch (Exception e){
e.printStackTrace();
return -111111; // 计算出现bug.
}finally {
System.out.println("--finally--");
// 哪怕上面有return语句执行，也必须先执行完这里才可以！
// 开发中不建议在这里加return ，如果加了，返回的永远是这里的数据了，这样会出问题！
return 100;
}
}
}
//JDK7
package com.itheima.d5_resource;
import java.io.*;
/**
* 目标：学会使用JDK 7的新方式释放资源
*/
public class TryCatchResouceDemo2 {
public static void main(String[] args) {
try (
// 这里面只能放置资源对象，用完会自动关闭：自动调用资源对象的close方法关闭资源（即使出现异常也会做关闭操作）
// 1、创建一个字节输入流管道与原视频接通
InputStream is = new FileInputStream("file-io-app/src/out04.txt");
// 2、创建一个字节输出流管道与目标文件接通
OutputStream os = new FileOutputStream("file-io-app/src/out05.txt");
// int age = 23; // 这里只能放资源
MyConnection connection = new MyConnection(); // 最终会自动调用资源的close方法
) {
// 3、定义一个字节数组转移数据
byte[] buffer = new byte[1024];
int len; // 记录每次读取的字节数。
while ((len = is.read(buffer)) != -1){
os.write(buffer, 0 , len);
}
System.out.println("复制完成了！");
} catch (Exception e){
e.printStackTrace();
}
}
}
class MyConnection implements AutoCloseable{
@Override
public void close() throws IOException {
System.out.println("连接资源被成功释放了！");
}
}
//JDK9
package com.itheima.d5_resource;
import java.io.*;
/**
* 目标：JDK 9释放资源的方式：可以了解下。
*/
public class TryCatchResouceDemo3 {
public static void main(String[] args) throws Exception {
// 这里面只能放置资源对象，用完会自动关闭：自动调用资源对象的close方法关闭资源（即使出现异常也会做关闭操作）
// 1、创建一个字节输入流管道与原视频接通
InputStream is = new FileInputStream("file-io-app/src/out04.txt");
// 2、创建一个字节输出流管道与目标文件接通
OutputStream os = new FileOutputStream("file-io-app/src/out05.txt");
try ( is ; os ) {
// 3、定义一个字节数组转移数据
byte[] buffer = new byte[1024];
int len; // 记录每次读取的字节数。
while ((len = is.read(buffer)) != -1){
os.write(buffer, 0 , len);
}
System.out.println("复制完成了！");
} catch (Exception e){
e.printStackTrace();
}
}
}
字符流
文件字符输入流：Reader
作用：以内存为基准，把磁盘文件中的数据以字符的形式读取到内存中去。
| 构造器 | 说明 |
| public FileReader(File file) | 创建字符输入流管道与源文件对象接通 |
| public FileReader(String pathname) | 创建字符输入流管道与源文件路径接通 |
| 方法名称 | 说明 |
| public int read() | 每次读取一个字符返回，如果字符已经没有可读的返回-1 |
| public int read(char[] buffer) | 每次读取一个字符数组，返回读取的字符个数，如果字符已经没有可读的返回-1 |
//一次读取一个字符
package com.itheima.d6_char_stream;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
/**
目标：字符输入流的使用。
IO流的体系：
字节流 字符流
字节输入流 字节输出流 字符输入流 字符输出流
InputStream OutputStream Reader Writer (抽象类)
FileInputStream FileOutputStream FileReader FileWriter (实现类)
c.FileReader:文件字符输入流。
-- 作用：以内存为基准，把磁盘文件的数据以字符的形式读入到内存。
简单来说，读取文本文件内容到内存中去。
-- 构造器：
public FileReader(File file):创建一个字符输入流与源文件对象接通。
public FileReader(String filePath):创建一个字符输入流与源文件路径接通。
-- 方法：
public int read(): 读取一个字符的编号返回！ 读取完毕返回-1
public int read(char[] buffer):读取一个字符数组，读取多少个字符就返回多少个数量，读取完毕返回-1
小结：
字符流一个一个字符的读取文本内容输出，可以解决中文读取输出乱码的问题。
字符流很适合操作文本文件内容。
但是：一个一个字符的读取文本内容性能较差！！
*/
public class FileReaderDemo01 {
public static void main(String[] args) throws Exception {
// 目标：每次读取一个字符。
// 1、创建一个字符输入流管道与源文件接通
Reader fr = new FileReader("src\\data06.txt");
// 2、读取一个字符返回，没有可读的字符了返回-1
// int code = fr.read();
// System.out.print((char)code);
//
// int code1 = fr.read();
// System.out.print((char)code1);
// 3、使用循环读取字符
int code;
while ((code = fr.read()) != -1){
System.out.print((char) code);
}
}
}
//按固定大小读取数组
package com.itheima.d6_char_stream;
import java.io.FileReader;
import java.io.Reader;
/**
目标：字符输入流的使用-按照字符数组读取。
IO流的体系：
字节流 字符流
字节输入流 字节输出流 字符输入流 字符输出流
InputStream OutputStream Reader Writer (抽象类)
FileInputStream FileOutputStream FileReader FileWriter (实现类)
c.FileReader:文件字符输入流。
-- 作用：以内存为基准，把磁盘文件的数据以字符的形式读入到内存。
简单来说，读取文本文件内容到内存中去。
-- 构造器：
public FileReader(File file):创建一个字符输入流与源文件对象接通。
public FileReader(String filePath):创建一个字符输入流与源文件路径接通。
-- 方法：
public int read(): 读取一个字符的编号返回！ 读取完毕返回-1
public int read(char[] buffer):读取一个字符数组，
读取多少个字符就返回多少个数量，读取完毕返回-1
小结：
字符流按照字符数组循环读取数据，可以解决中文读取输出乱码的问题，而且性能也较好！！
*/
public class FileReaderDemo02 {
public static void main(String[] args) throws Exception {
// 1、创建一个文件字符输入流与源文件接通
Reader fr = new FileReader("file-io-app/src/data07.txt");
// 2、用循环，每次读取一个字符数组的数据。 1024 + 1024 + 8
char[] buffer = new char[1024]; // 1K字符
int len;
while ((len = fr.read(buffer)) != -1) {
String rs = new String(buffer, 0, len);
System.out.print(rs);
}
}
}
文件字符输出流：FileWriter
作用：以内存为基准，把内存中的数据以字符的形式写出到磁盘文件中去的流。
| 构造器 | 说明 |
| public FileWriter(File file) | 创建字符输出流管道与源文件对象接通 |
| public FileWriter(File file，boolean append) | 创建字符输出流管道与源文件对象接通，可追加数据 |
| public FileWriter(String filepath) | 创建字符输出流管道与源文件路径接通 |
| public FileWriter(String filepath，boolean append) | 创建字符输出流管道与源文件路径接通，可追加数据 |
文件字符输出流（FileWriter）写数据出去的API
| 方法名称 | 说明 |
| void write(int c) | 写一个字符 |
| void write(char[] cbuf) | 写入一个字符数组 |
| void write(char[] cbuf, int off, int len) | 写入字符数组的一部分 |
| void write(String str) | 写一个字符串 |
| void write(String str, int off, int len) | 写一个字符串的一部分 |
流的关闭与刷新
| 方法 | 说明 |
| flush() | 刷新流，还可以继续写数据 |
| close() | 关闭流，释放资源，但是在关闭之前会先刷新流。一旦关闭，就不能再写数据 |
package com.itheima.d6_char_stream;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
/**
目标：字符输出流的使用。
IO流的体系：
字节流 字符流
字节输入流 字节输出流 字符输入流 字符输出流
InputStream OutputStream Reader Writer (抽象类)
FileInputStream FileOutputStream FileReader FileWriter (实现类)
d.FileWriter文件字符输出流的使用。
-- 作用：以内存为基准，把内存中的数据按照字符的形式写出到磁盘文件中去。
简单来说，就是把内存的数据以字符写出到文件中去。
-- 构造器：
public FileWriter(File file):创建一个字符输出流管道通向目标文件对象。
public FileWriter(String filePath):创建一个字符输出流管道通向目标文件路径。
public FileWriter(File file,boolean append):创建一个追加数据的字符输出流管道通向目标文件对象。
public FileWriter(String filePath,boolean append):创建一个追加数据的字符输出流管道通向目标文件路径。
-- 方法：
a.public void write(int c):写一个字符出去
b.public void write(String c)写一个字符串出去：
c.public void write(char[] buffer):写一个字符数组出去
d.public void write(String c ,int pos ,int len):写字符串的一部分出去
e.public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
小结：
字符输出流可以写字符数据出去，总共有5个方法写字符。
覆盖管道：
Writer fw = new FileWriter("Day10Demo/src/dlei03.txt"); // 覆盖数据管道
追加数据管道：
Writer fw = new FileWriter("Day10Demo/src/dlei03.txt",true); // 追加数据管道
换行：
fw.write("\r\n"); // 换行
结论：读写字符文件数据建议使用字符流。复制文件建议使用字节流。
*/
public class FileWriterDemo03 {
public static void main(String[] args) throws Exception {
// 1、创建一个字符输出流管道与目标文件接通
// Writer fw = new FileWriter("file-io-app/src/out08.txt"); // 覆盖管道，每次启动都会清空文件之前的数据
Writer fw = new FileWriter("file-io-app/src/out08.txt", true); // 覆盖管道，每次启动都会清空文件之前的数据
// a.public void write(int c):写一个字符出去
fw.write(98);
fw.write('a');
fw.write('徐'); // 不会出问题了
fw.write("\r\n"); // 换行
// b.public void write(String c)写一个字符串出去
fw.write("abc我是中国人");
fw.write("\r\n"); // 换行
// c.public void write(char[] buffer):写一个字符数组出去
char[] chars = "abc我是中国人".toCharArray();
fw.write(chars);
fw.write("\r\n"); // 换行
// d.public void write(String c ,int pos ,int len):写字符串的一部分出去
fw.write("abc我是中国人", 0, 5);
fw.write("\r\n"); // 换行
// e.public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
fw.write(chars, 3, 5);
fw.write("\r\n"); // 换行
// fw.flush();// 刷新后流可以继续使用
fw.close(); // 关闭包含刷线，关闭后流不能使用
}
}
缓冲流
缓冲流概述
缓冲流也称为高效流、或者高级流。之前学习的字节流可以称为原始流。
作用：缓冲流自带缓冲区、可以提高原始字节流、字符流读写数据的性能
字节缓冲流性能优化原理：
字节缓冲输入流自带了8KB缓冲池，以后我们直接从缓冲池读取数据，所以性能较好。
字节缓冲输出流自带了8KB缓冲池，数据就直接写入到缓冲池中去，写数据性能极高了。
字节缓冲流
字节缓冲输入流：BufferedInputStream，提高字节输入流读取数据的性能。
字节缓冲输出流：BufferedOutputStream，提高字节输出流读取数据的性能。
| 构造器 | 说明 |
| public BufferedInputStream(InputStream is) | 可以把低级的字节输入流包装成一个高级的缓冲字节输入流管道，从而提高字节输入流读数据的性能 |
| public BufferedOutputStream(OutputStream os) | 可以把低级的字节输出流包装成一个高级的缓冲字节输出流，从而提高写数据的性能 |
import java.io.*;
/**
目标：使用字节缓冲流完成数据的读写操作。
*/
public class
ByteBufferDemo {
public static void main(String[] args) {
try (
// 这里面只能放置资源对象，用完会自动关闭：自动调用资源对象的close方法关闭资源（即使出现异常也会做关闭操作）
// 1、创建一个字节输入流管道与原视频接通
InputStream is = new FileInputStream("D:\\resources\\newmeinv.jpeg");
// a.把原始的字节输入流包装成高级的缓冲字节输入流
InputStream bis = new BufferedInputStream(is);
// 2、创建一个字节输出流管道与目标文件接通
OutputStream os = new FileOutputStream("D:\\resources\\newmeinv222.jpeg");
// b.把字节输出流管道包装成高级的缓冲字节输出流管道
OutputStream bos = new BufferedOutputStream(os);
) {
// 3、定义一个字节数组转移数据
byte[] buffer = new byte[1024];
int len; // 记录每次读取的字节数。
while ((len = bis.read(buffer)) != -1){
bos.write(buffer, 0 , len);
}
System.out.println("复制完成了！");
} catch (Exception e){
e.printStackTrace();
}
}
}字符缓冲输入流
字符缓冲输入流：BufferedReader。
作用：提高字符输入流读取数据的性能，除此之外多了按照行读取数据的功能。
| 构造器 | 说明 |
| public BufferedReader(Reader r) | 可以把低级的字符输入流包装成一个高级的缓冲字符输入流管道，从而提高字符输入流读数据的性能 |
字符缓冲输入流新增功能
| 方法 | 说明 |
| public String readLine() | 读取一行数据返回，如果读取没有完毕，无行可读返回null |
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
/**
目标：学会使用缓冲字符输入流提高字符输入流的性能，新增了按照行读取的方法(经典代码)
*/
public class BufferedReaderDemo1 {
public static void main(String[] args) {
try (
// 1、创建一个文件字符输入流与源文件接通。
Reader fr = new FileReader("io-app2/src/data01.txt");
// a、把低级的字符输入流包装成高级的缓冲字符输入流。
BufferedReader br = new BufferedReader(fr);
){
// 2、用循环，每次读取一个字符数组的数据。 1024 + 1024 + 8
// char[] buffer = new char[1024]; // 1K字符
// int len;
// while ((len = br.read(buffer)) != -1) {
// String rs = new String(buffer, 0, len);
// System.out.print(rs);
// }
String line;
while ((line = br.readLine()) != null){
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}字符缓冲输出流
字符缓冲输出流：BufferedWriter。
作用：提高字符输出流写取数据的性能，除此之外多了换行功能
| 构造器 | 说明 |
| public BufferedWriter(Writer w) | 可以把低级的字符输出流包装成一个高级的缓冲字符输出流管道，从而提高字符输出流写数据的性能 |
字符缓冲输出流新增功能
| 方法 | 说明 |
| public void newLine() | 换行操作 |
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.Writer;
/**
目标：缓冲字符输出流的使用，学会它多出来的一个功能：newLine();
*/
public class BufferedWriterDemo2 {
public static void main(String[] args) throws Exception {
// 1、创建一个字符输出流管道与目标文件接通
Writer fw = new FileWriter("io-app2/src/out02.txt"); // 覆盖管道，每次启动都会清空文件之前的数据
//Writer fw = new FileWriter("io-app2/src/out02.txt", true); // 追加数据
BufferedWriter bw = new BufferedWriter(fw);
// a.public void write(int c):写一个字符出去
bw.write(98);
bw.write('a');
bw.write('徐'); // 不会出问题了
bw.newLine(); // bw.write("\r\n"); // 换行
// b.public void write(String c)写一个字符串出去
bw.write("abc我是中国人");
bw.newLine(); // bw.write("\r\n"); // 换行
// c.public void write(char[] buffer):写一个字符数组出去
char[] chars = "abc我是中国人".toCharArray();
bw.write(chars);
bw.newLine(); // bw.write("\r\n"); // 换行
// d.public void write(String c ,int pos ,int len):写字符串的一部分出去
bw.write("abc我是中国人", 0, 5);
bw.newLine(); // bw.write("\r\n"); // 换行
// e.public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
bw.write(chars, 3, 5);
bw.newLine(); // bw.write("\r\n"); // 换行
// fw.flush();// 刷新后流可以继续使用
bw.close(); // 关闭包含刷线，关闭后流不能使用
}
}复制操作
拷贝出师表到另一个文件，恢复顺序
需求：把《出师表》的文章顺序进行恢复到一个新文件中。
分析：
定义一个缓存字符输入流管道与源文件接通。
定义一个List集合存储读取的每行数据。
定义一个循环按照行读取数据，存入到List集合中去。
对List集合中的每行数据按照首字符编号升序排序。
定义一个缓存字符输出管道与目标文件接通。
遍历List集合中的每个元素，用缓冲输出管道写出并换行。
import java.io.*;
import java.util.*;
/**
目标：完成出师表顺序的恢复，并存入到另一个新文件中去。
*/
public class BufferedCharTest3 {
public static void main(String[] args) {
try(
// 1、创建缓冲字符输入流管道与源文件接通
BufferedReader br = new BufferedReader(new FileReader("io-app2/src/csb.txt"));
// 5、定义缓冲字符输出管道与目标文件接通
BufferedWriter bw = new BufferedWriter(new FileWriter("io-app2/src/new.txt"));
) {
// 2、定义一个List集合存储每行内容
List<String> data = new ArrayList<>();
// 3、定义循环，按照行读取文章
String line;
while ((line = br.readLine()) != null){
data.add(line);
}
System.out.println(data);
// 4、排序
// 自定义排序规则
List<String> sizes = new ArrayList<>();
Collections.addAll(sizes, "一","二","三","四","五","陆","柒","八","九","十","十一");
Collections.sort(data, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
// o1 八.,....
// o2 柒.,....
return sizes.indexOf(o1.substring(0, o1.indexOf(".")))
- sizes.indexOf(o2.substring(0, o2.indexOf(".")));
}
});
System.out.println(data);
// 6、遍历集合中的每行文章写出去，且要换行
for (String datum : data) {
bw.write(datum);
bw.newLine(); // 换行
}
} catch (Exception e) {
e.printStackTrace();
}
}
}转换流
·之前我们使用字符流读取中文是否有乱码？
没有的，因为代码编码和文件编码都是UTF-8。
·如果代码编码和文件编码不一致，使用字符流直接读取还能不乱码吗？
会乱码。
文件编码和读取的编码必须一致才不会乱码。
字符输入转换流
字符输入转换流：InputStreamReader，可以把原始的字节流按照指定编码转换成字符输入流。
| 构造器 | 说明 |
| public InputStreamReader(InputStream is) | 可以把原始的字节流按照代码默认编码转换成字符输入流。几乎不用，与默认的FileReader一样。 |
| public InputStreamReader(InputStream is ，String charset) | 可以把原始的字节流按照指定编码转换成字符输入流，这样字符流中的字符就不乱码了(重点) |
import java.io.*;
/**
目标：字符输入转换流InputStreamReader的使用。
字节流 字符流
字节输入流 字节输出流 字符输入流 字符输出流
InputStream OutputStream Reader Writer (抽象类)
FileInputStream FileOutputStream FileReader FileWriter(实现类)
BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter(实现类，缓冲流)
InputStreamReader OutputStreamWriter
字符输入转换流InputStreamReader:
-- 作用：可以解决字符流读取不同编码乱码的问题。
也可以把原始的字节流按照指定编码转换成字符输入流
-- 构造器：
public InputStreamReader(InputStream is)：可以使用当前代码默认编码转换成字符流，几乎不用！
public InputStreamReader(InputStream is,String charset):可以指定编码把字节流转换成字符流(核心)
小结：
字符输入转换流InputStreamReader:作用：可以解决字符流读取不同编码乱码的问题。
public InputStreamReader(InputStream is,String charset):可以指定编码把字节流转换成字符流(核心)
*/
public class InputStreamReaderDemo01 {
public static void main(String[] args) throws Exception {
// 代码UTF-8 文件 GBK "D:\\resources\\data.txt"
// 1、提取GBK文件的原始字节流。 abc 我
// ooo oo
InputStream is = new FileInputStream("D:\\resources\\data.txt");
// 2、把原始字节流转换成字符输入流
// Reader isr = new InputStreamReader(is); // 默认以UTF-8的方式转换成字符流。 还是会乱码的 跟直接使用FileReader是一样的
Reader isr = new InputStreamReader(is , "GBK"); // 以指定的GBK编码转换成字符输入流 完美的解决了乱码问题
BufferedReader br = new BufferedReader(isr);
String line;
while ((line = br.readLine()) != null){
System.out.println(line);
}
}
}
字符输出转换流
字符输入转换流：OutputStreamWriter，可以把字节输出流按照指定编码转换成字符输出流。
| 构造器 | 说明 |
| public OutputStreamWriter(OutputStream os) | 可以把原始的字节输出流按照代码默认编码转换成字符输出流。几乎不用。 |
| public OutputStreamWriter(OutputStream os，String charset) | 可以把原始的字节输出流按照指定编码转换成字符输出流(重点) |
import java.io.*;
import java.nio.Buffer;
/**
目标：字符输出转换OutputStreamWriter流的使用。
字节流 字符流
字节输入流 字节输出流 字符输入流 字符输出流
InputStream OutputStream Reader Writer (抽象类)
FileInputStream FileOutputStream FileReader FileWriter(实现类)
BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter(实现类，缓冲流)
InputStreamReader OutputStreamWriter
字符输出转换流：OutputStreamWriter
-- 作用：可以指定编码把字节输出流转换成字符输出流。
可以指定写出去的字符的编码。
-- 构造器：
public OutputStreamWriter(OutputStream os) : 用当前默认编码UTF-8把字节输出流转换成字符输出流
public OutputStreamWriter(OutputStream os , String charset):指定编码把字节输出流转换成字符输出流
小结：
字符输出转换流OutputStreamWriter可以指定编码把字节输出流转换成字符输出流。
从而实现指定写出去的字符编码！
*/
public class OutputStreamWriterDemo02 {
public static void main(String[] args) throws Exception {
// 1、定义一个字节输出流
OutputStream os = new FileOutputStream("io-app2/src/out03.txt");
// 2、把原始的字节输出流转换成字符输出流
// Writer osw = new OutputStreamWriter(os); // 以默认的UTF-8写字符出去 跟直接写FileWriter一样
Writer osw = new OutputStreamWriter(os , "GBK"); // 指定GBK的方式写字符出去
// 3、把低级的字符输出流包装成高级的缓冲字符输出流。
BufferedWriter bw = new BufferedWriter(osw);
bw.write("我爱中国1~~");
bw.write("我爱中国2~~");
bw.write("我爱中国3~~");
bw.close();
}
}序列化对象
对象序列化：
作用：以内存为基准，把内存中的对象存储到磁盘文件中去，称为对象序列化。
使用到的流是对象字节输出流：ObjectOutputStream
对象序列化：
使用到的流是对象字节输出流：ObjectOutputStream
| 构造器 | 说明 |
| public ObjectOutputStream(OutputStream out) | 把低级字节输出流包装成高级的对象字节输出流 |
ObjectOutputStream序列化方法
| 方法名称 | 说明 |
| public final void writeObject(Object obj) | 把对象写出去到对象序列化流的文件中去 |
对象反序列化：
使用到的流是对象字节输入流：ObjectInputStream
作用：以内存为基准，把存储到磁盘文件中去的对象数据恢复成内存中的对象，称为对象反序列化
| 构造器 | 说明 |
| public ObjectInputStream(InputStream out) | 把低级字节输如流包装成高级的对象字节输入流 |
ObjectInputStream序列化方法
| 方法名称 | 说明 |
| public Object readObject() | 把存储到磁盘文件中去的对象数据恢复成内存中的对象返回 |
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.PrintStream;
/**
目标：学会对象序列化，使用 ObjectOutputStream 把内存中的对象存入到磁盘文件中。
transient修饰的成员变量不参与序列化了
对象如果要序列化，必须实现Serializable序列化接口。
申明序列化的版本号码
序列化的版本号与反序列化的版本号必须一致才不会出错！
private static final long serialVersionUID = 1;
*/
public class ObjectOutputStreamDemo1 {
public static void main(String[] args) throws Exception {
// 1、创建学生对象
Student s = new Student("陈磊", "chenlei","1314520", 21);
// 2、对象序列化：使用对象字节输出流包装字节输出流管道
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("io-app2/src/obj.txt"));
// 3、直接调用序列化方法
oos.writeObject(s);
// 4、释放资源
oos.close();
System.out.println("序列化完成了~~");
}
}
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.ObjectInputStream;
/**
目标：学会进行对象反序列化：使用对象字节输入流把文件中的对象数据恢复成内存中的Java对象。
*/
public class ObjectInputStreamDemo2 {
public static void main(String[] args) throws Exception {
// 1、创建对象字节输入流管道包装低级的字节输入流管道
ObjectInputStream is = new ObjectInputStream(new FileInputStream("io-app2/src/obj.txt"));
// 2、调用对象字节输入流的反序列化方法
Student s = (Student) is.readObject();
System.out.println(s);
}
}
import java.io.Serializable;
/**
对象如果要序列化，必须实现Serializable序列化接口。
*/
public class Student implements Serializable {
// 申明序列化的版本号码
// 序列化的版本号与反序列化的版本号必须一致才不会出错！
private static final long serialVersionUID = 1;
private String name;
private String loginName;
// transient修饰的成员变量不参与序列化了
private transient String passWord;
private int age ;
public Student(){
}
public Student(String name, String loginName, String passWord, int age) {
this.name = name;
this.loginName = loginName;
this.passWord = passWord;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLoginName() {
return loginName;
}
public void setLoginName(String loginName) {
this.loginName = loginName;
}
public String getPassWord() {
return passWord;
}
public void setPassWord(String passWord) {
this.passWord = passWord;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", loginName='" + loginName + '\'' +
", passWord='" + passWord + '\'' +
", age=" + age +
'}';
}
}打印流
作用：打印流可以实现方便、高效的打印数据到文件中去。打印流一般是指：PrintStream，PrintWriter两个类。
可以实现打印什么数据就是什么数据，例如打印整数97写出去就是97，打印boolean的true，写出去就是true。
PrintStream
| 构造器 | 说明 |
| public PrintStream(OutputStream os) | 打印流直接通向字节输出流管道 |
| public PrintStream(File f) | 打印流直接通向文件对象 |
| public PrintStream(String filepath) | 打印流直接通向文件路径 |
| 方法 | 说明 |
| public void print(Xxx xx) | 打印任意类型的数据出去 |
PrintWriter
| 构造器 | 说明 |
| public PrintWriter(OutputStream os) | 打印流直接通向字节输出流管道 |
| public PrintWriter (Writer w) | 打印流直接通向字符输出流管道 |
| public PrintWriter (File f) | 打印流直接通向文件对象 |
| public PrintWriter (String filepath) | 打印流直接通向文件路径 |
| 方法 | 说明 |
| public void print(Xxx xx) | 打印任意类型的数据出去 |
PrintStream和PrintWriter的区别
打印数据功能上是一模一样的，都是使用方便，性能高效（核心优势）
PrintStream继承自字节输出流OutputStream，支持写字节数据的方法。
PrintWriter继承自字符输出流Writer，支持写字符数据出去。
输出语句重定向
属于打印流的一种应用，可以把输出语句的打印位置改到文件。
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
/**
目标：学会使用打印流 高效 方便写数据到文件。
*/
public class PrintDemo1 {
public static void main(String[] args) throws Exception {
// 1、创建一个打印流对象
// PrintStream ps = new PrintStream(new FileOutputStream("io-app2/src/ps.txt"));
// PrintStream ps = new PrintStream(new FileOutputStream("io-app2/src/ps.txt" , true)); // 追加数据，在低级管道后面加True
// PrintStream ps = new PrintStream("io-app2/src/ps.txt" );
PrintWriter ps = new PrintWriter("io-app2/src/ps.txt"); // 打印功能上与PrintStream的使用没有区别
ps.println(97);
ps.println('a');
ps.println(23.3);
ps.println(true);
ps.println("我是打印流输出的，我是啥就打印啥");
ps.close();
}
}
import java.io.FileOutputStream;
import java.io.PrintStream;
/**
目标：了解改变输出语句的位置到文件
*/
public class PrintDemo2 {
public static void main(String[] args) throws Exception {
System.out.println("锦瑟无端五十弦");
System.out.println("一弦一柱思华年");
// 改变输出语句的位置（重定向）
PrintStream ps = new PrintStream("io-app2/src/log.txt");
System.setOut(ps); // 把系统打印流改成我们自己的打印流
System.out.println("庄生晓梦迷蝴蝶");
System.out.println("望帝春心托杜鹃");
}
}Properties
其实就是一个Map集合，但是我们一般不会当集合使用，因为HashMap更好用。
Properties核心作用：
Properties代表的是一个属性文件，可以把自己对象中的键值对信息存入到一个属性文件中去。
属性文件：后缀是.properties结尾的文件,里面的内容都是 key=value，后续做系统配置信息的。
Properties和IO流结合的方法：
| 构造器 | 说明 |
| void load(InputStream inStream) | 从输入字节流读取属性列表（键和元素对） |
| void load(Reader reader) | 从输入字符流读取属性列表（键和元素对） |
| void store(OutputStream out, String comments) | 将此属性列表（键和元素对）写入此 Properties表中，以适合于使用 load(InputStream)方法的格式写入输出字节流 |
| void store(Writer writer, String comments) | 将此属性列表（键和元素对）写入此 Properties表中，以适合使用 load(Reader)方法的格式写入输出字符流 |
| public Object setProperty(String key, String value) | 保存键值对（put） |
| public String getProperty(String key) | 使用此属性列表中指定的键搜索属性值 (get) |
| public Set<String> stringPropertyNames() | 所有键的名称的集合 (keySet()) |
import java.io.FileWriter;
import java.util.Map;
import java.util.Properties;
import java.util.Scanner;
/**
目标：Properties的概述和使用(框架底层使用，了解这个技术即可)（保存数据到属性文件）
Properties: 属性集对象。
其实就是一个Map集合。也就是一个键值对集合，但是我们一般不会当集合使用，
因为有HashMap。
Properties核心作用：
Properties代表的是一个属性文件，可以把键值对的数据存入到一个属性文件中去。
属性文件：后缀是.properties结尾的文件,里面的内容都是 key=value。
大家在后期学的很多大型框架技术中，属性文件都是很重要的系统配置文件。
users.properties
admin=123456
dlei=dlei
需求：使用Properties对象生成一个属性文件，里面存入用户名和密码信息。
Properties的方法：
-- public Object setProperty(String key, String value) ： 保存一对属性。 (put)
-- public String getProperty(String key) : 使用此属性列表中指定的键搜索属性值 (get)
-- public Set<String> stringPropertyNames() : 所有键的名称的集合 (keySet())
-- public void store(OutputStream out, String comments): 保存数据到属性文件中去
-- public void store(Writer fw, String comments): 保存数据到属性文件中去
小结：
Properties可以保存键值对数据到属性文件
*/
public class PropertiesDemo01 {
public static void main(String[] args) throws Exception {
// 需求：使用Properties把键值对信息存入到属性文件中去。
Properties properties = new Properties();
properties.setProperty("admin", "123456");
properties.setProperty("dlei", "003197");
properties.setProperty("heima", "itcast");
System.out.println(properties);
/**
参数一：保存管道 字符输出流管道
参数二：保存心得
*/
properties.store(new FileWriter("io-app2/src/users.properties")
, "this is users!! i am very happy! give me 100!");
}
}
import java.io.FileReader;
import java.util.Properties;
import java.util.Set;
/**
目标：Properties读取属性文件中的键值对信息。（读取）
Properties的方法：
-- public Object setProperty(String key, String value) ： 保存一对属性。
-- public String getProperty(String key) ：使用此属性列表中指定的键搜索属性值
-- public Set<String> stringPropertyNames() ：所有键的名称的集合
-- public void store(OutputStream out, String comments):保存数据到属性文件中去
-- public synchronized void load(InputStream inStream):加载属性文件的数据到属性集对象中去
-- public synchronized void load(Reader fr):加载属性文件的数据到属性集对象中去
小结：
属性集对象可以加载读取属性文件中的数据!!
*/
public class PropertiesDemo02 {
public static void main(String[] args) throws Exception {
// 需求：Properties读取属性文件中的键值对信息。（读取）
Properties properties = new Properties();
System.out.println(properties);
// 加载属性文件中的键值对数据到属性对象properties中去
properties.load(new FileReader("io-app2/src/users.properties"));
System.out.println(properties);
String rs = properties.getProperty("dlei");
System.out.println(rs);
String rs1 = properties.getProperty("admin");
System.out.println(rs1);
}
}
IO框架
commons-io概述
commons-io是apache开源基金组织提供的一组有关IO操作的类库，可以提高IO功能开发的效率。
commons-io工具包提供了很多有关io操作的类。有两个主要的类FileUtils, IOUtils
FileUtils主要有如下方法:
| 方法名 | 说明 |
| String readFileToString(File file, String encoding) | 读取文件中的数据, 返回字符串 |
| void copyFile(File srcFile, File destFile) | 复制文件。 |
| void copyDirectoryToDirectory(File srcDir, File destDir) | 复制文件夹。 |
导入commons-io-2.6.jar做开发
需求
使用commons-io简化io流读写
分析
在项目中创建一个文件夹：lib
将commons-io-2.6.jar文件复制到lib文件夹
在jar文件上点右键，选择 Add as Library -> 点击OK
在类中导包使用
import org.apache.commons.io.FileUtils;
import java.io.File;
/**
目标:Commons-io包的使用介绍。
什么是Commons-io包？
commons-io是apache开源基金组织提供的一组有关IO操作的类库，
可以挺提高IO功能开发的效率。commons-io工具包提供了很多有关io操作的类，
见下表：
| 包 | 功能描述 |
| ----------------------------------- | :------------------------------------------- |
| org.apache.commons.io | 有关Streams、Readers、Writers、Files的工具类 |
| org.apache.commons.io.input | 输入流相关的实现类，包含Reader和InputStream |
| org.apache.commons.io.output | 输出流相关的实现类，包含Writer和OutputStream |
| org.apache.commons.io.serialization | 序列化相关的类
步骤：
1. 下载commons-io相关jar包；http://commons.apache.org/proper/commons-io/
2. 把commons-io-2.6.jar包复制到指定的Module的lib目录中
3. 将commons-io-2.6.jar加入到classpath中
小结：
IOUtils和FileUtils可以方便的复制文件和文件夹！！
*/
public class CommonsIODemo01 {
public static void main(String[] args) throws Exception {
//// // 1.完成文件复制！
// IOUtils.copy(new FileInputStream("D:\\resources\\hushui.jpeg"),
// new FileOutputStream("D:\\resources\\hushui2.jpeg"));
//// // 2.完成文件复制到某个文件夹下！
// FileUtils.copyFileToDirectory(new File("D:\\resources\\hushui.jpeg"), new File("D:/"));
// 3.完成文件夹复制到某个文件夹下！
// FileUtils.copyDirectoryToDirectory(new File("D:\\resources") , new File("D:\\new"));
// FileUtils.deleteDirectory(new File("D:\\new"));
// JDK1.7 自己也做了一些一行代码完成复制的操作:New IO的技术
// Files.copy(Path.of("D:\\resources\\hushui.jpeg"), Path.of("D:\\resources\\hushui3.jpeg"));
FileUtils.deleteDirectory(new File("D:\\new"));
}
}
Comments NOTHING