day10 - Lambda,Stream,File,递归
约 10801 字大约 36 分钟
day10 - Lambda,Stream,File,递归
今日目标
1 Lambda表达式
1.1 体验Lambda表达式
package com.itheima.lambda_demo; /* Lambda表达式体验 : */ public class LambdaDemo { public static void main(String[] args) { // 匿名内部类方式完成 goSwimming(new Swimming() { @Override public void swim() { System.out.println("铁汁 , 我们去游泳吧...."); } }); // lambda表达式的方式完成 goSwimming(() -> System.out.println("铁汁 , 我们去游泳吧....")); } public static void goSwimming(Swimming swimming) { swimming.swim(); } } interface Swimming { public abstract void swim(); }lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的
面向对象思想 :
- 强调的是用对象去完成某些功能
函数式编程思想 :
- 强调的是结果 , 而不是怎么去做
1.2 函数式接口
- 只有一个抽象方法需要重写的接口，函数式接口。函数式接口是允许有其他的非抽象方法的存在例如静态方法，默认方法，私有方法。
- 为了标识接口是一个函数式接口，可以在接口之上加上一个注解： @FunctionalInterface 以示区别
- 在JDK中 java.util.function 包中的所有接口都是函数式接口。我们之前学习线程时学习的Runnable也是函数式接口
1.3 Lambda表达式的使用
使用前提
- 必须存在一个接口
- 接口中有且只有一个抽象方法
格式 : ( 形式参数 ) -> { 代码块 }
- 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
- ->：由英文中画线和大于符号组成，固定写法。代表指向动作
- 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容
1.4 Lambda表达式的案例
package com.itheima.lambda_test;
/*
练习1：
1 编写一个接口（ShowHandler）
2 在该接口中存在一个抽象方法（show），该方法是无参数无返回值
3 在测试类（ShowHandlerDemo）中存在一个方法（useShowHandler）
方法的的参数是ShowHandler类型的，在方法内部调用了ShowHandler的show方法
*/
public class LambdaTest1 {
public static void main(String[] args) {
useShowHandler(() -> {
System.out.println("我是一个lambda表达式....");
});
}
public static void useShowHandler(ShowHandler showHandler) {
showHandler.show();
}
}
interface ShowHandler {
public abstract void show();
}package com.itheima.lambda_test;
/*
1 首先存在一个接口（StringHandler）
2 在该接口中存在一个抽象方法（printMessage），该方法是有参数无返回值
3 在测试类（StringHandlerDemo）中存在一个方法（useStringHandler），
方法的的参数是StringHandler类型的，
在方法内部调用了StringHandler的printMessage方法
*/
public class LambdaTest2 {
public static void main(String[] args) {
useStringHandler((String msg) -> {
System.out.println(msg);
});
}
public static void useStringHandler(StringHandler stringHandler){
stringHandler.printMessage("今天天气不错 , 挺风和日丽的...");
}
}
@FunctionalInterface
interface StringHandler {
public abstract void printMessage(String msg);
}package com.itheima.lambda_test;
import java.util.Random;
/*
1 首先存在一个接口（RandomNumHandler）
2 在该接口中存在一个抽象方法（getNumber），该方法是无参数但是有返回值
3 在测试类（RandomNumHandlerDemo）中存在一个方法（useRandomNumHandler），方法的的参数是RandomNumHandler类型的
在方法内部调用了RandomNumHandler的getNumber方法
*/
public class LambdaTest3 {
public static void main(String[] args) {
useRandomNumHandler(() -> {
return new Random().nextInt(10) + 1;
});
}
public static void useRandomNumHandler(RandomNumHandler randomNumHandler) {
int number = randomNumHandler.getNumber();
System.out.println(number);
}
}
interface RandomNumHandler {
public abstract int getNumber();
}package com.itheima.lambda_test;
/*
1 首先存在一个接口（Calculator）
2 在该接口中存在一个抽象方法（calc），该方法是有参数也有返回值
3 在测试类（CalculatorDemo）中存在一个方法（useCalculator）
方法的的参数是Calculator类型的
在方法内部调用了Calculator的calc方法
*/
public class LambdaTest4 {
public static void main(String[] args) {
useCalculator((int a , int b) -> { return a + b;});
}
public static void useCalculator(Calculator calculator) {
int calc = calculator.calc(10, 20);
System.out.println(calc);
}
}
@FunctionalInterface
interface Calculator {
public abstract int calc(int a, int b);
}2 Stream流
2.1 Stream的体验
package com.itheima.stream_demo;
import java.util.ArrayList;
/*
体验Stream流的好处
需求：按照下面的要求完成集合的创建和遍历
1 创建一个集合，存储多个字符串元素
"张无忌" , "张翠山" , "张三丰" , "谢广坤" , "赵四" , "刘能" , "小沈阳" , "张良"
2 把集合中所有以"张"开头的元素存储到一个新的集合
3 把"张"开头的集合中的长度为3的元素存储到一个新的集合
4 遍历上一步得到的集合
*/
public class StreamDemo {
public static void main(String[] args) {
// 传统方式完成
ArrayList<String> list = new ArrayList<>();
list.add("张无忌");
list.add("张翠山");
list.add("张三丰");
list.add("谢广坤");
list.add("赵四");
list.add("刘能");
list.add("小沈阳");
list.add("张良");
// 把集合中所有以"张"开头的元素存储到一个新的集合
ArrayList<String> list2 = new ArrayList<>();
for (String s : list) {
if (s.startsWith("张")) {
list2.add(s);
}
}
// 把"张"开头的集合中的长度为3的元素存储到一个新的集合
ArrayList<String> list3 = new ArrayList<>();
for (String s : list2) {
if (s.length() == 3) {
list3.add(s);
}
}
// 遍历list3集合
for (String s : list3) {
System.out.println(s);
}
System.out.println("================================");
// Stream流的方式
list.stream().filter(s -> s.startsWith("张") && s.length() == 3).forEach(s -> System.out.println(s));
}
}2.2 Stream流的三类方法
- 获取Stream流
- 创建一条流水线，并把数据放到流水线上准备进行操作
- 中间方法
- 流水线上的操作。
- 一次操作完毕之后，还可以继续进行其他操作
- 终结方法
- 一个Stream流只能有一个终结方法
- 是流水线上的最后一个操作
2.3 第一类 : 获取方法
package com.itheima.stream_demo;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
/*
Stream流中三类方法之一 : 获取方法
1 单列集合
可以使用Collection接口中的默认方法stream()生成流
default Stream<E> stream()
2 双列集合
双列集合不能直接获取 , 需要间接的生成流
可以先通过keySet或者entrySet获取一个Set集合，再获取Stream流
3 数组
Arrays中的静态方法stream生成流
*/
public class StreamDemo2 {
public static void main(String[] args) {
// 单列集合的获取
// method1();
// 双列集合的获取
// method2();
// 数组获取
// method3();
}
private static void method3() {
int[] arr = {1, 2, 3, 4, 5, 6};
Arrays.stream(arr).forEach(s -> System.out.println(s));
}
private static void method2() {
HashMap<String, String> hm = new HashMap<>();
hm.put("it001", "曹植");
hm.put("it002", "曹丕");
hm.put("it003", "曹熊");
hm.put("it004", "曹冲");
hm.put("it005", "曹昂");
// 获取map集合的健集合 , 在进行输出打印
hm.keySet().stream().forEach(s -> System.out.println(s));
// 获取map集合的entry对象 , 在输出打印
hm.entrySet().stream().forEach(s -> System.out.println(s));
}
private static void method1() {
// 可以使用Collection接口中的默认方法stream()生成流
ArrayList<String> list = new ArrayList<>();
list.add("迪丽热巴");
list.add("古力娜扎");
list.add("马尔扎哈");
list.add("欧阳娜娜");
list.stream().forEach(s -> System.out.println(s));
}
}2.4 第二类 : 中间方法
package com.itheima.stream_demo;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Predicate;
import java.util.stream.Stream;
/*
Stream流中三类方法之一 : 中间方法
1 Stream<T> filter(Predicate predicate)：用于对流中的数据进行过滤
Predicate接口中的方法 : boolean test(T t)：对给定的参数进行判断，返回一个布尔值
2 Stream<T> limit(long maxSize)：截取指定参数个数的数据
3 Stream<T> skip(long n)：跳过指定参数个数的数据
4 static <T> Stream<T> concat(Stream a, Stream b)：合并a和b两个流为一个流
5 Stream<T> distinct()：去除流中重复的元素。依赖(hashCode和equals方法)
6 Stream<T> sorted () : 将流中元素按照自然排序的规则排序
7 Stream<T> sorted (Comparator<? super T> comparator) : 将流中元素按照自定义比较器规则排序
*/
public class StreamDemo3 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张无忌");
list.add("张翠山");
list.add("张三丰");
list.add("谢广坤");
list.add("赵四");
list.add("刘能");
list.add("小沈阳");
list.add("张良");
list.add("张良");
list.add("张良");
list.add("张良");
// Stream<T> limit(long maxSize)：截取指定参数个数的数据
// list.stream().limit(3).forEach(s -> System.out.println(s));
// Stream<T> skip(long n)：跳过指定参数个数的数据
// list.stream().skip(3).forEach(s-> System.out.println(s));
// Stream<T> distinct()：去除流中重复的元素。依赖(hashCode和equals方法)
// list.stream().distinct().forEach(s->{System.out.println(s);});
}
// // Stream<T> sorted (Comparator<? super T> comparator) : 将流中元素按照自定义比较器规则排序
private static void method3(ArrayList<String> list) {
list.stream().sorted(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.length() - o2.length();
}
}).forEach(s->{
System.out.println(s);
});
}
// Stream<T> sorted () : 将流中元素按照自然排序的规则排序
private static void method3() {
ArrayList<Integer> list2 = new ArrayList<>();
list2.add(3);
list2.add(1);
list2.add(2);
list2.stream().sorted().forEach(s->{
System.out.println(s);
});
}
// // static <T> Stream<T> concat(Stream a, Stream b)：合并a和b两个流为一个流
private static void method2(ArrayList<String> list) {
ArrayList<String> list2 = new ArrayList<>();
list2.add("迪丽热巴");
list2.add("古力娜扎");
list2.add("欧阳娜娜");
list2.add("马尔扎哈");
Stream.concat(list.stream(), list2.stream()).forEach(s -> {
System.out.println(s);
});
}
// Stream<T> filter(Predicate predicate)：用于对流中的数据进行过滤
private static void method1(ArrayList<String> list) {
// filter方法会获取流中的每一个数据
// s就代表的是流中的每一个数据
// 如果返回值为true , 那么代表的是数据留下来
// 如果返回值的是false , 那么代表的是数据过滤掉
// list.stream().filter(new Predicate<String>() {
// @Override
// public boolean test(String s) {
// boolean result = s.startsWith("张");
// return result;
// }
// }).forEach(s -> System.out.println(s));
list.stream().filter(s ->
s.startsWith("张")
).forEach(s -> System.out.println(s));
}
}2.5 第三类 : 终结方法
package com.itheima.stream_demo;
import java.util.ArrayList;
import java.util.function.Consumer;
/*
Stream流中三类方法之一 : 终结方法
1 void forEach(Consumer action)：对此流的每个元素执行操作
Consumer接口中的方法 void accept(T t)：对给定的参数执行此操作
2 long count()：返回此流中的元素数
*/
public class StreamDemo4 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张无忌");
list.add("张翠山");
list.add("张三丰");
list.add("谢广坤");
// long count()：返回此流中的元素数
long count = list.stream().count();
System.out.println(count);
}
// void forEach(Consumer action)：对此流的每个元素执行操作
private static void method1(ArrayList<String> list) {
// 把list集合中的元素放在stream流中
// forEach方法会循环遍历流中的数据
// 并循环调用accept方法 , 把数据传给s
// 所以s就代表的是流中的每一个数据
// 我们只要在accept方法中对数据做业务逻辑处理即可
list.stream().forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
System.out.println("=====================");
list.stream().forEach( (String s) -> {
System.out.println(s);
});
System.out.println("=====================");
list.stream().forEach( s -> { System.out.println(s); });
}
}2.6 Stream流中的收集方法
package com.itheima.stream_demo;
import java.util.ArrayList;
/*
Stream流的收集操作 : 第一部分
需求：过滤元素并遍历集合
定义一个集合，并添加一些整数1，2，3，4，5，6，7，8，9，10
将集合中的奇数删除，只保留偶数。
遍历集合得到2，4，6，8，10
结论：在Stream流中无法直接修改集合,数组等数据源中的数据。
*/
public class StreamDemo5 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
for (int i = 1; i <= 10; i++) {
list.add(i);
}
list.stream().filter(num -> num % 2 == 0).forEach(num -> System.out.println(num));
System.out.println("=============");
// 结论：在Stream流中无法直接修改集合,数组中的数据。
System.out.println(list);
}
}package com.itheima.stream_demo;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
/*
Stream流的收集操作 : 第二部分
使用Stream流的方式操作完毕之后，我想把流中的数据起来，该怎么办呢？
Stream流的收集方法
R collect(Collector collector) : 此方法只负责收集流中的数据 , 创建集合添加数据动作需要依赖于参数
工具类Collectors提供了具体的收集方式
public static <T> Collector toList()：把元素收集到List集合中
public static <T> Collector toSet()：把元素收集到Set集合中
public static Collector toMap(Function keyMapper,Function valueMapper)：把元素收集到Map集合中
需求 :
定义一个集合，并添加一些整数1，2，3，4，5，6，7，8，9，10
将集合中的奇数删除，只保留偶数。
遍历集合得到2，4，6，8，10
*/
public class StreamDemo6 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
for (int i = 1; i <= 10; i++) {
list.add(i);
}
list.add(10);
list.add(10);
list.add(10);
list.add(10);
list.add(10);
// collect只负责收集流中的数据
// Collectors.toList()会负责在底层创建list集合 ,并把数据添加到集合中 , 返回集合对象
List<Integer> list2 = list.stream().filter(num -> num % 2 == 0 ).collect(Collectors.toList());
System.out.println(list2);
Set<Integer> set = list.stream().filter(num -> num % 2 == 0 ).collect(Collectors.toSet());
System.out.println(set);
}
}package com.itheima.stream_demo;
import java.util.ArrayList;
import java.util.Map;
import java.util.stream.Collectors;
/*
Stream流的收集操作 : 第三部分
1 创建一个ArrayList集合，并添加以下字符串。字符串中前面是姓名，后面是年龄
"zhangsan,23"
"lisi,24"
"wangwu,25"
2 保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值
收集方法 :
public static Collector toMap(Function keyMapper , Function valueMapper)：把元素收集到Map集合中
*/
public class StreamDemo7 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("zhangsan,23");
list.add("lisi,24");
list.add("wangwu,25");
// collect 只负责收集数据
// Collectors.toMap负责在底层创建集合对象 , 添加元素
// toMap方法中的s就是代表的是集合中的每一个元素
// 第一个参数 : 如何获取map集合中的键
// 第二个参数 : 如何获取map集合中的值
Map<String, String> map = list.stream().filter(s -> Integer.parseInt(s.split(",")[1]) > 23).collect(
Collectors.toMap(
(String s) -> {
return s.split(",")[0];
}
,
(String s) -> {
return s.split(",")[1];
}
)
);
System.out.println(map);
}
}3 File类
3.1 File类的介绍
- java.io.File 类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作
3.2 构造方法
package com.itheima.file_demo;
import java.io.File;
/*
File：它是文件和目录路径名的抽象表示
文件和目录可以通过File封装成对象
File封装的对象仅仅是一个路径名。它可以是存在的，也可以是不存在的。
构造方法 :
1 File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
2 File(String parent, String child) 从父路径名字符串和子路径名字符串创建新的 File实例
3 File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的 File实例
*/
public class FileDemo1 {
public static void main(String[] args) {
// 1 File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
File f1 = new File("D:\\abc.txt");
System.out.println(f1);
// 2 File(String parent, String child) 从父路径名字符串和子路径名字符串创建新的 File实例
File f2 = new File("D:\\aaa", "bbb.txt");
System.out.println(f2);
// 3 File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的 File实例
File f3 = new File(new File("D:\\aaa"), "bbb.txt");
System.out.println(f3);
}
}3.3 File类的创建功能
package com.itheima.file_demo;
import java.io.File;
import java.io.IOException;
/*
File类的创建功能 :
1 public boolean createNewFile() : 创建一个新的空的文件
2 public boolean mkdir() : 创建一个单级文件夹
3 public boolean mkdirs() : 创建一个多级文件夹
*/
public class FileDemo2 {
public static void main(String[] args) throws IOException {
File f1 = new File("D:\\a.txt");
// 1 public boolean createNewFile() : 创建一个新的空的文件
System.out.println(f1.createNewFile());
File f2 = new File("day10_demo\\aaa");
// 2 public boolean mkdir() : 创建一个单级文件夹
System.out.println(f2.mkdir());
File f3 = new File("day10_demo\\bbb\\ccc");
// 3 public boolean mkdirs() : 创建一个多级文件夹
System.out.println(f3.mkdirs());
}
}3.4 File类的删除功能
package com.itheima.file_demo;
import java.io.File;
import java.io.IOException;
/*
File类删除功能 :
public boolean delete() 删除由此抽象路径名表示的文件或目录
注意 :
1 delete方法直接删除不走回收站。
2 如果删除的是一个文件，直接删除。
3 如果删除的是一个文件夹，需要先删除文件夹中的内容，最后才能删除文件夹
*/
public class FileDemo3 {
public static void main(String[] args) throws IOException {
File f1 = new File("D:\\a.txt");
// 1 public boolean createNewFile() : 创建一个新的空的文件
System.out.println(f1.delete());
File f2 = new File("day10_demo\\aaa");
// 2 public boolean mkdir() : 创建一个单级文件夹
System.out.println(f2.delete());
File f3 = new File("day10_demo\\bbb");
// 3 public boolean mkdirs() : 创建一个多级文件夹
System.out.println(f3.delete());
}
}3.5 File类的判断和获取功能
package com.itheima.file_demo;
import java.io.File;
/*
File类判断和获取功能
public boolean isDirectory() 测试此抽象路径名表示的File是否为目录
public boolean isFile() 测试此抽象路径名表示的File是否为文件
public boolean exists() 测试此抽象路径名表示的File是否存在
public String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串
public String getPath() 将此抽象路径名转换为路径名字符串
public String getName() 返回由此抽象路径名表示的文件或目录的名称
*/
public class FileDemo4 {
public static void main(String[] args) {
File f1 = new File("day10_demo\\aaa");
File f2 = new File("day10_demo\\a.txt");
// public boolean isDirectory() 测试此抽象路径名表示的File是否为目录
System.out.println(f1.isDirectory());
System.out.println(f2.isDirectory());
// public boolean isFile() 测试此抽象路径名表示的File是否为文件
System.out.println(f1.isFile());
System.out.println(f2.isFile());
// public boolean exists() 测试此抽象路径名表示的File是否存在
System.out.println(f1.exists());
// public String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串
System.out.println(f1.getAbsolutePath());
// public String getPath() 将此抽象路径名转换为路径名字符串
System.out.println(f1.getPath());
// public String getName() 返回由此抽象路径名表示的文件或目录的名称
System.out.println(f2.getName());
}
}3.6 File类高级获取功能
package com.itheima.file_demo;
import java.io.File;
/*
File类高级获取功能
public File[] listFiles() 返回此抽象路径名表示的目录中的文件和目录的File对象数组
listFiles方法注意事项：
1 当调用者不存在时，返回null
2 当调用者是一个文件时，返回null
3 当调用者是一个空文件夹时，返回一个长度为0的数组
4 当调用者是一个有内容的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回
5 当调用者是一个有隐藏文件的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏内容
*/
public class FileDemo5 {
public static void main(String[] args) {
File file = new File("day10_demo\\bbb\\ccc");
// 返回此抽象路径名表示的目录中的文件和目录的File对象数组
File[] files = file.listFiles();
// 遍历File类的数组
for (File f : files) {
// 拿到每一个文件的文字
System.out.println(f.getName());
}
}
}练习 :
package com.itheima.file_demo;
import java.io.File;
import java.util.HashMap;
/*
练习二 ：统计一个文件夹中每种文件的个数并打印。
打印格式如下：
txt:3个
doc:4个
jpg:6个
…
*/
public class FileTest2 {
public static void main(String[] args) {
File file = new File("day10_demo\\统计文件个数文件夹");
getFileCount(file);
}
public static void getFileCount(File f) {
HashMap<String, Integer> hm = new HashMap<>();
// 是文件夹在获取所有的子文件
if (f.isDirectory()) {
File[] files = f.listFiles();
// 遍历数组
for (File file : files) {
String fileName = file.getName();
String name = fileName.split("\\.")[1];
if (hm.containsKey(name)) {
hm.put(name, hm.get(name));
} else {
hm.put(name, 1);
}
}
}
System.out.println(hm);
}
}4 递归
概述
- 递归概述：以编程的角度来看，递归指的是方法定义中调用方法本身的现象
好处
- 把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
小的问题解决 , 大的问题也会逐一进行解决
- 把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
注意
- 递归出口：否则会出现内存溢出
- 递归规则：需要找到与原问题相似的规模较小的问题
案例
package com.itheima.recursion_demo; /* 需求：用递归求5的阶乘，并把结果在控制台输出 思路： 1 定义一个方法，用于递归求阶乘，参数为一个int类型的变量 2 在方法内部判断该变量的值是否是1 是：返回1 不是：返回n*(n-1)! 3 调用方法 4 输出结果 */ public class Demo1 { public static void main(String[] args) { int result = jc(5); System.out.println("5的阶乘是:" + result); } private static int jc(int n) { if (n == 1) { return 1; } return n * jc(n - 1); } }package com.itheima.recursion_demo; import java.io.File; /* 需求 : 使用递归删除计算机中指定的文件夹 删除D盘中的aaa文件夹! */ public class Demo2 { public static void main(String[] args) { File f = new File("D:\\aaa"); deleteFiles(f); } private static void deleteFiles(File f) { File[] files = f.listFiles(); for (File file : files) { if (file.isDirectory()) { // 递归 deleteFiles(file); } else { // 删除文件 file.delete(); } } // 删除当前文件夹 f.delete(); } }day11-IO流,Properties集合,IO工具类
今日目标
1 IO流的介绍
1.1 为什么要学习IO流
- 通过变量,数组,或者集合存储数据
- 都是不能永久化存储 , 因为数据都是存储在内存中
- 只要代码运行结束，所有数据都会丢失
- 使用IO流
- 1，将数据写到文件中，实现数据永久化存储
- 2，把文件中的数据读取到内存中(Java程序)
1.2 什么是IO流
- I 表示intput ，是数据从硬盘进内存的过程，称之为读。
- O 表示output ，是数据从内存到硬盘的过程。称之为写
- IO的数据传输，可以看做是一种数据的流动，按照流动的方向，以内存为参照物，进行读写操作
- 简单来说：内存在读，内存在写
1.3 IO流的分类
- 按照流向区分
- 输入流 : 用来读数据
- 输出流 : 用来写数据
- 按照类型区分
- 字节流
- 字符流
- 注意 :
- 字节流可以操作任意文件
- 字符流只能操作纯文本文件
- 用windows记事本打开能读的懂，那么这样的文件就是纯文本文件。
2 字节流输出流
2.1 字节输出流入门
FileOutputStream类 :
OutputStream有很多子类，我们从最简单的一个子类开始。java.io.FileOutputStream类是文件输出流，用于将数据写出到文件
构造方法 :
public FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。public FileOutputStream(String name)： 创建文件输出流以指定的名称写入文件。
public class FileOutputStreamConstructor throws IOException { public static void main(String[] args) { // 使用File对象创建流对象 File file = new File("a.txt"); FileOutputStream fos = new FileOutputStream(file); // 使用文件名称创建流对象 FileOutputStream fos = new FileOutputStream("b.txt"); } }字节输出流写数据快速入门
- 创建字节输出流对象。
- 写数据
- 释放资源
package com.itheima.outputstream_demo; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; /* 字节输出流写数据快速入门 : 1 创建字节输出流对象。 2 写数据 3 释放资源 */ public class OutputStreamDemo1 { public static void main(String[] args) throws IOException { // 创建字节输出流对象 // 如果指定的文件不存在 , 会自动创建文件 // 如果文件存在 , 会把文件中的内容清空 FileOutputStream fos = new FileOutputStream("day11_demo\\a.txt"); // 写数据 // 写到文件中就是以字节形式存在的 // 只是文件帮我们把字节翻译成了对应的字符 , 方便查看 fos.write(97); fos.write(98); fos.write(99); // 释放资源 // while(true){} // 断开流与文件中间的关系 fos.close(); } }
2.2 字节输出流写数据的方法
字节流写数据的方法
- 1 void write(int b) 一次写一个字节数据
- 2 void write(byte[] b) 一次写一个字节数组数据
- 3 void write(byte[] b, int off, int len) 一次写一个字节数组的部分数据
package com.itheima.outputstream_demo; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; /* 字节流写数据的3种方式 1 void write(int b) 一次写一个字节数据 2 void write(byte[] b) 一次写一个字节数组数据 3 void write(byte[] b, int off, int len) 一次写一个字节数组的部分数据 */ public class OutputStreamDemo2 { public static void main(String[] args) throws IOException { // 创建字节输出流对象 FileOutputStream fos = new FileOutputStream("day11_demo\\a.txt"); // 写数据 // 1 void write(int b) 一次写一个字节数据 fos.write(97); fos.write(98); fos.write(99); // 2 void write(byte[] b) 一次写一个字节数组数据 byte[] bys = {65, 66, 67, 68, 69}; fos.write(bys); // 3 void write(byte[] b, int off, int len) 一次写一个字节数组的部分数据 fos.write(bys, 0, 3); // 释放资源 fos.close(); } }
2.3 写数据的换行和追加写入
package com.itheima.outputstream_demo;
import java.io.FileOutputStream;
import java.io.IOException;
/*
字节流写数据的换行和追加写入
1 字节流写数据如何实现换行呢？
写完数据后，加换行符
windows : \r\n
linux : \n
mac : \r
2 字节流写数据如何实现追加写入呢？
通过构造方法 : public FileOutputStream(String name，boolean append)
创建文件输出流以指定的名称写入文件。如果第二个参数为true ，不会清空文件里面的内容
*/
public class OutputStreamDemo3 {
public static void main(String[] args) throws IOException {
// 创建字节输出流对象
FileOutputStream fos = new FileOutputStream("day11_demo\\a.txt");
// void write(int b) 一次写一个字节数据
fos.write(97);
// 因为字节流无法写入一个字符串 , 把字符串转成字节数组写入
fos.write("\r\n".getBytes());
fos.write(98);
fos.write("\r\n".getBytes());
fos.write(99);
fos.write("\r\n".getBytes());
// 释放资源
fos.close();
}
}package com.itheima.outputstream_demo;
import java.io.FileOutputStream;
import java.io.IOException;
/*
字节流写数据的换行和追加写入
1 字节流写数据如何实现换行呢？
写完数据后，加换行符
windows : \r\n
linux : \n
mac : \r
2 字节流写数据如何实现追加写入呢？
通过构造方法 : public FileOutputStream(String name，boolean append)
创建文件输出流以指定的名称写入文件。如果第二个参数为true ，不会清空文件里面的内容
*/
public class OutputStreamDemo3 {
public static void main(String[] args) throws IOException {
// 创建字节输出流对象
// 追加写数据
// 通过构造方法 : public FileOutputStream(String name，boolean append) : 追加写数据
FileOutputStream fos = new FileOutputStream("day11_demo\\a.txt" , true);
// void write(int b) 一次写一个字节数据
fos.write(97);
// 因为字节流无法写入一个字符串 , 把字符串转成字节数组写入
fos.write("\r\n".getBytes());
fos.write(98);
fos.write("\r\n".getBytes());
fos.write(99);
fos.write("\r\n".getBytes());
// 释放资源
fos.close();
}
// 写完数据换行操作
private static void method1() throws IOException {
// 创建字节输出流对象
FileOutputStream fos = new FileOutputStream("day11_demo\\a.txt");
// void write(int b) 一次写一个字节数据
fos.write(97);
// 因为字节流无法写入一个字符串 , 把字符串转成字节数组写入
fos.write("\r\n".getBytes());
fos.write(98);
fos.write("\r\n".getBytes());
fos.write(99);
fos.write("\r\n".getBytes());
// 释放资源
fos.close();
}
}3 字节输入流
3.1 字节输入流介绍
字节输入流类
- InputStream类 : 字节输入流最顶层的类 , 抽象类
--- FileInputStream类 : FileInputStream extends InputStream
- InputStream类 : 字节输入流最顶层的类 , 抽象类
构造方法
- public FileInputStream(File file) : 从file类型的路径中读取数据
- public FileInputStream(String name) : 从字符串路径中读取数据
步骤
- 创建输入流对象
- 读数据
- 释放资源
package com.itheima.inputstream_demo; import java.io.FileInputStream; import java.io.IOException; /* 字节输入流写数据快速入门 : 一次读一个字节 第一部分 : 字节输入流类 InputStream类 : 字节输入流最顶层的类 , 抽象类 --- FileInputStream类 : FileInputStream extends InputStream 第二部分 : 构造方法 public FileInputStream(File file) : 从file类型的路径中读取数据 public FileInputStream(String name) : 从字符串路径中读取数据 第三部分 : 字节输入流步骤 1 创建输入流对象 2 读数据 3 释放资源 */ public class FileInputStreamDemo1 { public static void main(String[] args) throws IOException { // 创建字节输入流对象 // 读取的文件必须存在 , 不存在则报错 FileInputStream fis = new FileInputStream("day11_demo\\a.txt"); // 读数据 , 从文件中读到一个字节 // 返回的是一个int类型的字节 // 如果想看字符, 需要强转 int by = fis.read(); System.out.println((char) by); // 释放资源 fis.close(); } }
3.2 字节输入流读多个字节
package com.itheima.inputstream_demo;
import java.io.FileInputStream;
import java.io.IOException;
/*
字节输入流写数据快速入门 : 读多个字节
第一部分 : 字节输入流类
InputStream类 : 字节输入流最顶层的类 , 抽象类
--- FileInputStream类 : FileInputStream extends InputStream
第二部分 : 构造方法
public FileInputStream(File file) : 从file类型的路径中读取数据
public FileInputStream(String name) : 从字符串路径中读取数据
第三部分 : 字节输入流步骤
1 创建输入流对象
2 读数据
3 释放资源
*/
public class FileInputStreamDemo2 {
public static void main(String[] args) throws IOException {
// 创建字节输入流对象
// 读取的文件必须存在 , 不存在则报错
FileInputStream fis = new FileInputStream("day11_demo\\a.txt");
// 读数据 , 从文件中读到一个字节
// 返回的是一个int类型的字节
// 如果想看字符, 需要强转
// int by = fis.read();
// System.out.println(by);
// by = fis.read();
// System.out.println(by);
// by = fis.read();
// System.out.println(by);
//
// by = fis.read();
// System.out.println(by);
// by = fis.read();
// System.out.println(by);
// by = fis.read();
// System.out.println(by);
// 循环改进
int by;// 记录每次读到的字节
while ((by = fis.read()) != -1) {
System.out.print((char) by);
}
// 释放资源
fis.close();
}
}3.3 图片的拷贝
package com.itheima.inputstream_demo;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
需求 : 把 "图片路径\xxx.jpg" 复制到当前模块下
分析：
复制文件，其实就把文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目的地)
数据源：
xxx.jpg --- 读数据 --- FileInputStream
目的地：
模块名称\copy.jpg --- 写数据 --- FileOutputStream
*/
public class FileInputStreamDemo2 {
public static void main(String[] args) throws IOException {
// 创建字节输入流对象
FileInputStream fis = new FileInputStream("D:\\传智播客\\安装包\\好看的图片\\liqin.jpg");
// 创建字节输出流
FileOutputStream fos = new FileOutputStream("day11_demo\\copy.jpg");
// 一次读写一个字节
int by;
while ((by = fis.read()) != -1) {
fos.write(by);
}
// 释放资源
fis.close();
fos.close();
}
}3.4 异常的捕获处理
JDK7版本之前处理方式 : 手动释放资源
package com.itheima.inputstream_demo; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; /* 需求 : 对上一个赋值图片的代码进行使用捕获方式处理 */ public class FileInputStreamDemo4 { public static void main(String[] args) { FileInputStream fis = null ; FileOutputStream fos = null; try { // 创建字节输入流对象 fis = new FileInputStream("D:\\传智播客\\安装包\\好看的图片\\liqin.jpg"); // 创建字节输出流 fos = new FileOutputStream("day11_demo\\copy.jpg"); // 一次读写一个字节 int by; while ((by = fis.read()) != -1) { fos.write(by); } } catch (IOException e) { e.printStackTrace(); } finally { // 释放资源 if(fis != null){ try { fis.close(); } catch (IOException e) { e.printStackTrace(); } } // 释放资源 if(fos != null){ try { fos.close(); } catch (IOException e) { e.printStackTrace(); } } } } }JDK7版本优化处理方式 : 自动释放资源
JDK7优化后可以使用 try-with-resource 语句 , 该语句确保了每个资源在语句结束时自动关闭。
简单理解 : 使用此语句,会自动释放资源 , 不需要自己在写finally代码块了格式 :
格式 : try (创建流对象语句1 ; 创建流对象语句2 ...) { // 读写数据 } catch (IOException e) { 处理异常的代码... } 举例 : try ( FileInputStream fis1 = new FileInputStream("day11_demo\\a.txt") ; FileInputStream fis2 = new FileInputStream("day11_demo\\b.txt") ) { // 读写数据 } catch (IOException e) { 处理异常的代码... }
代码实践
package com.itheima.inputstream_demo; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; /* JDK7版本优化处理方式 需求 : 对上一个赋值图片的代码进行使用捕获方式处理 */ public class FileInputStreamDemo5 { public static void main(String[] args) { try ( // 创建字节输入流对象 FileInputStream fis = new FileInputStream("D:\\传智播客\\安装包\\好看的图片\\liqin.jpg"); // 创建字节输出流 FileOutputStream fos = new FileOutputStream("day11_demo\\copy.jpg") ) { // 一次读写一个字节 int by; while ((by = fis.read()) != -1) { fos.write(by); } // 释放资源 , 发现已经灰色 , 提示多余的代码 , 所以使用 try-with-resource 方式会自动关流 // fis.close(); // fos.close(); } catch (IOException e) { e.printStackTrace(); } } }
3.4 字节输入流一次读一个字节数组
FileInputStream类 :
- public int read(byte[] b) : 从输入流读取最多b.length个字节的数据, 返回的是真实读到的数据个数
package com.itheima.inputstream_demo; import javax.sound.midi.Soundbank; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; /* FileInputStream类 : public int read(byte[] b)： 1 从输入流读取最多b.length个字节的数据 2 返回的是真实读到的数据个数 */ public class FileInputStreamDemo6 { public static void main(String[] args) throws IOException { // 创建字节输入流对象 FileInputStream fis = new FileInputStream("day11_demo\\a.txt"); // public int read(byte[] b)： // 1 从输入流读取最多b.length个字节的数据 // 2 返回的是真实读到的数据个数 byte[] bys = new byte[3]; // int len = fis.read(bys); // System.out.println(len);// 3 // System.out.println(new String(bys));// abc // // len = fis.read(bys); // System.out.println(len);// 2 // System.out.println(new String(bys));// efc System.out.println("==========代码改进==============="); // int len = fis.read(bys); // System.out.println(len);// 3 // System.out.println(new String(bys, 0, len));// abc // // len = fis.read(bys); // System.out.println(len);// 2 // System.out.println(new String(bys, 0, len));// ef System.out.println("==========代码改进==============="); int len; while ((len = fis.read(bys)) != -1) { System.out.print(new String(bys , 0 , len)); } fis.close(); } }对复制图片的代码进行使用一次读写一个字节数组的方式进行改进
package com.itheima.inputstream_demo; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; /* 需求 : 对复制图片的代码进行使用一次读写一个字节数组的方式进行改进 FileInputStream类 : public int read(byte[] b)： 1 从输入流读取最多b.length个字节的数据 2 返回的是真实读到的数据个数 */ public class FileInputStreamDemo7 { public static void main(String[] args) throws IOException { // 创建字节输入流对象 FileInputStream fis = new FileInputStream("D:\\传智播客\\安装包\\好看的图片\\liqin.jpg"); // 创建字节输出流 FileOutputStream fos = new FileOutputStream("day11_demo\\copy.jpg"); byte[] bys = new byte[1024]; int len;// 每次真实读到数据的个数 int by; while ((len = fis.read(bys)) != -1) { fos.write(bys, 0, len); } // 释放资源 fis.close(); fos.close(); } }
4 字节缓冲区流
4.1 字节缓冲流概述
字节缓冲流：
- BufferOutputStream：缓冲输出流
- BufferedInputStream：缓冲输入流
构造方法：
- 字节缓冲输出流：BufferedOutputStream(OutputStream out)
- 字节缓冲输入流：BufferedInputStream(InputStream in)
为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？
- 字节缓冲流仅仅提供缓冲区，不具备读写功能 , 而真正的读写数据还得依靠基本的字节流对象进行操作
4.2 字节缓冲流案例
package com.itheima.bufferedstream_demo;
import java.io.*;
/*
字节缓冲流：
BufferOutputStream：缓冲输出流
BufferedInputStream：缓冲输入流
构造方法：
字节缓冲输出流：BufferedOutputStream(OutputStream out)
字节缓冲输入流：BufferedInputStream(InputStream in)
为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？
字节缓冲流仅仅提供缓冲区，不具备读写功能 , 而真正的读写数据还得依靠基本的字节流对象进行操作
需求 : 使用缓冲流进行复制文件
*/
public class BufferedStreamDemo1 {
public static void main(String[] args) throws IOException {
// 创建高效的字节输入流对象
// 在底层会创建一个长度为8192的数组
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\传智播客\\安装包\\好看的图片\\liqin.jpg"));
// 创建高效的字节输出流
// 在底层会创建一个长度为8192的数组
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day11_demo\\copy.jpg"));
// 使用高效流 , 一次读写一个字节
int by;
while ((by = bis.read()) != -1) {
bos.write(by);
}
// byte[] bys = new byte[1024];
// int len;// 每次真实读到数据的个数
// while ((len = bis.read(bys)) != -1) {
// bos.write(bys, 0, len);
// }
// 释放资源
// 在底层会把基本的流进行关闭
bis.close();
bos.close();
}
}4.3 缓冲流一次读写一个字节原理
4.4 缓冲流一次读写一个字节数组原理
package com.itheima.bufferedstream_demo;
import java.awt.image.DataBufferDouble;
import java.io.*;
/*
需求：把“xxx.avi”复制到模块目录下的“copy.avi” , 使用四种复制文件的方式 , 打印所花费的时间
四种方式：
1 基本的字节流一次读写一个字节 : 花费的时间为:196662毫秒
2 基本的字节流一次读写一个字节数组 : 花费的时间为:383毫秒
3 缓冲流一次读写一个字节 : 花费的时间为:365毫秒
4 缓冲流一次读写一个字节数组 : 花费的时间为:108毫秒
分析 :
数据源 : "D:\a.wmv"
目的地 : "day11_demo\copy.wmv"
*/
public class BufferedStreamDemo2 {
public static void main(String[] args) throws IOException {
long startTime = System.currentTimeMillis();
// method1();
// method2();
// method3();
method4();
long endTime = System.currentTimeMillis();
System.out.println("花费的时间为:" + (endTime - startTime) + "毫秒");
}
// 4 缓冲流一次读写一个字节数组
private static void method4() throws IOException {
// 创建高效的字节输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\a.wmv"));
// 创建高效的字节输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day11_demo\\copy.wmv"));
// 一次读写一个字节数组
byte[] bys = new byte[1024];
int len;// 每次真实读到数据的个数
while ((len = bis.read(bys)) != -1) {
bos.write(bys, 0, len);
}
// 释放资源
bis.close();
bos.close();
}
// 3 缓冲流一次读写一个字节
private static void method3() throws IOException {
// 创建高效的字节输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\a.wmv"));
// 创建高效的字节输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("day11_demo\\copy.wmv"));
// 一次读写一个字节
int by;
while ((by = bis.read()) != -1) {
bos.write(by);
}
// 释放资源
bis.close();
bos.close();
}
// 2 基本的字节流一次读写一个字节数组
private static void method2() throws IOException {
// 创建基本的字节输入流对象
FileInputStream fis = new FileInputStream("D:\\a.wmv");
// 创建基本的字节输出流对象
FileOutputStream fos = new FileOutputStream("day11_demo\\copy.wmv");
// 一次读写一个字节数组
byte[] bys = new byte[1024];
int len;// 每次真实读到数据的个数
while ((len = fis.read(bys)) != -1) {
fos.write(bys, 0, len);
}
// 释放资源
fis.close();
fos.close();
}
// 1 基本的字节流一次读写一个字节
private static void method1() throws IOException {
// 创建基本的字节输入流对象
FileInputStream fis = new FileInputStream("D:\\a.wmv");
// 创建基本的字节输出流对象
FileOutputStream fos = new FileOutputStream("day11_demo\\copy.wmv");
// 一次读写一个字节
int by;
while ((by = fis.read()) != -1) {
fos.write(by);
}
// 释放资源
fis.close();
fos.close();
}
}5.1 Properties集合的概述
properties是一个Map体系的集合类
public class Properties extends Hashtable <Object,Object>
为什么在IO流部分学习Properties
- Properties中有跟IO相关的方法
当做双列集合使用
- 不需要加泛型 , 工作中只存字符串
package com.itheima.properties_demo; import java.util.Map; import java.util.Properties; import java.util.Set; /* 1 properties是一个Map体系的集合类 - `public class Properties extends Hashtable <Object,Object>` 2 为什么在IO流部分学习Properties - Properties中有跟IO相关的方法 3 当做双列集合使用 - 不需要加泛型 , 工作中只存字符串 */ public class PropertiesDemo1 { public static void main(String[] args) { // 创建集合对象 Properties properties = new Properties(); // 添加元素 properties.put("it001" , "张三"); properties.put("it002" , "李四"); properties.put("it003" , "王五"); // 遍历集合 : 键找值 Set<Object> set = properties.keySet(); for (Object key : set) { System.out.println(key + "---" + properties.get(key)); } System.out.println("========================"); // 遍历集合 : 获取对对象集合 , 获取键和值 Set<Map.Entry<Object, Object>> set2 = properties.entrySet(); for (Map.Entry<Object, Object> entry : set2) { Object key = entry.getKey(); Object value = entry.getValue(); System.out.println(key + "---" + value); } } }
5.2 Properties作为集合的特有方法
Object setProperty(String key, String value)设置集合的键和值，都是String类型，相当于put方法String getProperty(String key)使用此属性列表中指定的键搜索属性 , 相当于get方法Set<String> stringPropertyNames()从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串 , 相当于keySet方法
package com.itheima.properties_demo;
import java.util.Properties;
import java.util.Set;
/*
Properties作为集合的特有方法
Object setProperty(String key, String value) 设置集合的键和值，都是String类型，相当于put方法
String getProperty(String key) 使用此属性列表中指定的键搜索属性 , 相当于get方法
Set<String> stringPropertyNames() 从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串 , 相当于keySet方法
*/
public class PropertiesDemo2 {
public static void main(String[] args) {
// 创建集合对象
Properties properties = new Properties();
// 添加元素
properties.setProperty("it001", "张三");
properties.setProperty("it002", "李四");
properties.setProperty("it003", "王五");
// 遍历集合 : 键找值
Set<String> set = properties.stringPropertyNames();
for (String key : set) {
System.out.println(key + "---" + properties.getProperty(key));
}
}
}5.3 properties中和IO相关的方法
- void load(InputStream inStream) 以字节流形式 , 把文件中的键值对, 读取到集合中
- void load(Reader reader) 以字符流形式 , 把文件中的键值对, 读取到集合中
- void store(OutputStream out, String comments) 把集合中的键值对,以字节流形式写入文件中 , 参数二为注释
- void store(Writer writer, String comments) 把集合中的键值对,以字符流形式写入文件中 , 参数二为注释
package com.itheima.properties_demo;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;
/*
Properties和IO流结合的方法
void load(InputStream inStream) 以字节流形式 , 把文件中的键值对, 读取到集合中
//void load(Reader reader) 以字符流形式 , 把文件中的键值对, 读取到集合中
void store(OutputStream out, String comments) 把集合中的键值对,以字节流形式写入文件中 , 参数二为注释
//void store(Writer writer, String comments) 把集合中的键值对,以字符流形式写入文件中 , 参数二为注释
*/
public class PropertiesDemo3 {
public static void main(String[] args) throws IOException {
// 创建Properties集合对象
Properties properties = new Properties();
// void load(InputStream inStream) 以字节流形式 , 把文件中的键值对, 读取到集合中
properties.load(new FileInputStream("day11_demo\\prop.properties"));
// 打印集合中的数据
System.out.println(properties);
}
}package com.itheima.properties_demo;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
/*
Properties和IO流结合的方法
void load(InputStream inStream) 以字节流形式 , 把文件中的键值对, 读取到集合中
//void load(Reader reader) 以字符流形式 , 把文件中的键值对, 读取到集合中
void store(OutputStream out, String comments) 把集合中的键值对,以字节流形式写入文件中 , 参数二为注释
//void store(Writer writer, String comments) 把集合中的键值对,以字符流形式写入文件中 , 参数二为注释
*/
public class PropertiesDemo3 {
public static void main(String[] args) throws IOException {
Properties properties = new Properties();
properties.setProperty("zhangsan" , "23");
properties.setProperty("lisi" , "24");
properties.setProperty("wangwu" , "25");
properties.store(new FileOutputStream("day11_demo\\prop2.properties") , "userMessage");
}
private static void method1() throws IOException {
// 创建Properties集合对象
Properties properties = new Properties();
// void load(InputStream inStream) 以字节流形式 , 把文件中的键值对, 读取到集合中
properties.load(new FileInputStream("day11_demo\\prop.properties"));
// 打印集合中的数据
System.out.println(properties);
}
}6 ResourceBundle加载属性文件
学习目标
- 能够熟练使用ResourceBundle工具类快速读取属性文件的值
内容讲解
【1】API介绍
java.util.ResourceBundle它是一个抽象类，我们可以使用它的子类PropertyResourceBundle来读取以.properties结尾的配置文件。
通过静态方法直接获取对象：
static ResourceBundle getBundle(String baseName) 可以根据名字直接获取默认语言环境下的属性资源。
参数注意: baseName
1.属性集名称不含扩展名。
2.属性集文件是在src目录中的
比如：src中存在一个文件 user.properties
ResourceBundle bundle = ResourceBundle.getBundle("user");ResourceBundle中常用方法：
String getString(String key) : 通过键，获取对应的值【2】代码实践
通过ResourceBundle工具类
将一个属性文件 放到src目录中，使用ResourceBundle去获取键值对数据
package com.itheima.resourcebundle_demo;
import java.util.ResourceBundle;
/*
1 java.util.ResourceBundle : 它是一个抽象类
我们可以使用它的子类PropertyResourceBundle来读取以.properties结尾的配置文件
2 static ResourceBundle getBundle(String baseName) 可以根据名字直接获取默认语言环境下的属性资源。
参数注意: baseName
1.属性集名称不含扩展名。
2.属性集文件是在src目录中的
比如：src中存在一个文件 user.properties
ResourceBundle bundle = ResourceBundle.getBundle("user");
3 ResourceBundle中常用方法：
String getString(String key) : 通过键，获取对应的值
优点 : 快速读取属性文件的值
需求 :
通过ResourceBundle工具类
将一个属性文件 放到src目录中，使用ResourceBundle去获取键值对数据
*/
public class ResourceBundleDemo {
public static void main(String[] args) {
// public static final ResourceBundle getBundle(String baseName)
// baseName : properties文件的名字 , 注意 : 扩展名不需要加上 , properties必须在src的根目录下
ResourceBundle resourceBundle = ResourceBundle.getBundle("user");
// String getString(String key) : 通过键，获取对应的值
String value1 = resourceBundle.getString("username");
String value2 = resourceBundle.getString("password");
System.out.println(value1);
System.out.println(value2);
}
}内容小结
如果要使用ResourceBundle加载属性文件，属性文件需要放置在哪个位置？
src的根目录请描述使用ResourceBundle获取属性值的大致步骤是怎样的？
1 获取ResourceBundle对象 2 通过ResourceBundle类中的getString(key) : 根据键找值