IO流
（编码和解码使用的字符集不同）
IO流也成为输入输出流 就是用来读写数据的。
I 表示 input 是数据从硬盘文件读入到内存的过程 称之为输入 负责读
O 表示 output 是内存程序的数据从内存写出到硬盘文件的过程，称之为输出，负责写入和出 是相对内存而言
IO流的分类：
按照数据的流向：
IO流分为：输入流和输出流
按照流中数据的最小单位分为： 字节流（可以操作所有的文件：包括音频 视频图片等）和字符流（只能
操作纯文本文件包括.txt文件 .java文件）
IO流可以分为四大类：
字节输入流：以内存为基准，来自磁盘文件/网络中的数据以字节的形式读入到内存中去的流称为
字节输入流
字节输出流：以内存为基准，把内存中的数据以字节为单位写出到磁盘文件或者网络中去的流称之
为字节输出流
字符输入流：以内存为基准，来自磁盘文件或者网络数据以字符为单位读入到内存中的流称之为字
符流
字符输出流：以内存为基准，把内存中的数据以字符为单位写出到磁盘文件或者网络介质中去的流
称之为字符输出流
IO流的体系：
IO流操作文件
文件的字节输入流：FileInputStream
数据的操作相关的API
补充字符集：
计算机底层不可以直接存储字符，计算机的底层只能存储二进制（0，1）
为了使得计算机可以存储人类的字符 因此对所有的字符进行编号存储，这套编号规则就是字符集
ASCII字符集：
- ASCII：美国信息交换标准代码 ：包括了数字 英文字母 符号
- ASCII 使用1个字节存储一个字符，一个字节是8位，总共可以表示128个字符信息。对于英文 数字符号来说是满足的。
char c = 'a';
System.out.println((int)c);//97
GBK:
- window系统默认使用字符集，兼容ASCII码，包含几万汉字 支持繁体字以及包含部分的日韩文字
- GBK是中国的码表，一个汉字以两个字节的形式来存储，不能包含世界上所有国家的文字。
- GBK扩充，GBk-2312
Unicode码表：
- Unicode（统一码 万国码）是计算机领域里字符编码的标准 几乎可以容纳全世界所有已知的文字 和字符
- Unicode会通过UTF-8 UTF-16 UTF-32的编码成二进制存储到计算机， 其中最常见的就是UTF-8
- UTF-8 编码之后一个汉字一般以三个字节的形式存储
- UTF-8 兼容ASCII
- 编码前和编码后的字符集需要一致 否则就会出现中文乱码
public class Test {
public static void main(String[] args) throws UnsupportedEncodingException {
String name="abc我爱中国";
// 编码： 把文字转换成字节 可以指定所使用的字符集
//byte[] bytes = name.getBytes();//以当前代码默认使用的字符集进行编码（UTF-8）
//使用特定的字符集
byte[] bytes = name.getBytes("UTF-8");
System.out.println(Arrays.toString(bytes));
// 解码 把字节数组转换成对应的中文
String rs = new String(bytes);// 使用默认的字符集 UTF-8
System.out.println(rs);
String rs1 = new String(bytes,"GBk");
System.out.println(rs1);//因为编码和解码的字符集不一致 导致中文乱码
String rs2 = new String(bytes, StandardCharsets.UTF_8);
System.out.println(rs2);
}
}
使用文件输入流： 每次读取一个字节
public class FileInputStreamDemo1 {
public static void main(String[] args) throws IOException {
// 创建一个文件字节输入流管道与源文件联通
//InputStream is = new FileInputStream(new
File("day_08/src/cn/sxjzit/RecurisonDemo.java"));
//简化写法
InputStream is = new
FileInputStream("day_08/src/cn/sxjzit/RecursionDemo1.java");
// 每次读取一个字节
// int b1 = is.read();
// System.out.println((char)b1);//112
// int b2 = is.read();
// System.out.println((char)b2);// 如果返回值为-1 则表示文件读到了末尾
int b ;
while((b=is.read())!=-1){
System.out.print((char)b);}}}
问题：
- 性能较低
- 读取的内容中如果包含中文字符，出现乱码
使用文件输入流： 每次读取一个字节数组
public int read(byte[] b) throws IOException
从此输入流 b.length 最多 b.length 个字节的数据读入一个字节数组。 此方法将阻塞，直到某些输入可用。
- 重写：
read 类 InputStream
- 参数
b - 读取数据的缓冲区。
- 结果
读入缓冲区的总字节数，如果由于文件末尾已到达而没有更多数据， -1
public class FileInputDemo2 {
public static void main(String[] args) throws IOException {
InputStream is = new
FileInputStream("day_08/src/cn/sxjzit/RecursionDemo1.java");
// 定义一个字节数组 作为缓冲区
byte[] buffer = new byte[5];
// int len = is.read(buffer);
// System.out.println("读取的字节数：" + len);
// String rs = new String(buffer);//解码
// System.out.println(rs);
//使用循环都进行改进 每次读取一个字节数组
int len;// 记录每次读取的字节数
while((len = is.read(buffer)) != -1){ // 每次读取多少字节 就写出多少字节
System.out.print(new String(buffer,0,len));
}
}
}
问题：
- 读取性能提升
- 但是读取中文的时候 依然无法避免中文乱码的问题
文件字节输入流：一次读完全部字节
1、如何使用字节输入流读取中文内容输出不乱码？
- 定义一个与文件大小一致的字节数组，一次性读取完文件的全部字节
2 、直接把文件的数据全部读取到一个字节数组可以避免乱码，是否存在问题？
- 如果文件过大，字节数组可能会引起内存溢出
byte[] readAllBytes() 从输入流中读取所有剩余字节。
public class FileInputStreamDemo3 {
public static void main(String[] args) throws IOException {
File file = new File("day_08/src/cn/sxjzit/RecursionDemo1.java");
InputStream is = new FileInputStream(file);
// 定义一个字节数组 作为缓冲区
//byte[] buffer = new byte[(int)file.length()];
byte[] buffer = new byte[1024*1024];//定义数组的大小为1024的倍数（推荐）
//使用循环都进行改进 每次读取一个字节数组
int len;// 记录每次读取的字节数
while((len = is.read(buffer)) != -1){ // 每次读取多少字节 就写出多少字节
System.out.print(new String(buffer,0,len));
}
}
}
public static void main(String[] args) throws IOException {
File file = new File("day_08/src/cn/sxjzit/RecursionDemo1.java");
InputStream is = new FileInputStream(file);
// 定义一个字节数组 作为缓冲区
//byte[] buffer = new byte[(int)file.length()];
byte[] buffer = is.readAllBytes();
System.out.println(new String(buffer));
}
}
IO流 写数据到存储介质上
OutputStream实现FileOutputStream
| FileOutputStream(File file) | 创建文件输出流以写入由指定的 File 对象表示的文件。 |
|---|---|
| FileOutputStream(File file, booleanappend) | 创建文件输出流以写入由指定的 File 对象表示的文件。 |
| FileOutputStream(String name) | 创建文件输出流以写入具有指定名称的文件。 |
| FileOutputStream(String name, booleanappend) | 创建文件输出流以写入具有指定名称的文件。 |
写数据的方式
流的关闭和刷新
public static void main(String[] args) throws IOException {
// 1 创建一个文件字节输出流管道与目标文件联通
//第二个参数 表示是否实行追加写
OutputStream os = new FileOutputStream("day_08/src/out.txt",true);
//2 写出数据到目标文件
os.write('a');
os.write(99);
//写一个字节数组
byte[] buff = {'w',98,99,100};//写一个字节数组
os.write(buff);
os.write(buff,1,2);//写字节数组的一部分
os.write("学院".getBytes());
os.flush();//刷新
os.close();//关闭
}
文件的拷贝
需求：将一个视频文件复制到其他的目录下
思路：
- 创建数据输入流 对象
- 创建一个输出流对象 指定目的地
- 进行数据的读写 完成复制
- 释放资源
/**
* 需求：将一个视频文件复制到其他的目录下
*
* 思路：
*
* - 创建数据输入流 对象
* - 创建一个输出流对象 指定目的地
* - 进行数据的读写 完成复制
* - 释放资源
*/
2.5.拷贝文件夹
需求：将某个磁盘的文件夹拷贝到另一个文件夹中，包括文件夹中的全部信息
分析：IO默认的情况是不可以直接拷贝文件夹的
public class FileCopy {
public static void main(String[] args) {
InputStream is = null;
OutputStream os =null;
try {
is = new FileInputStream("D:\\课堂资料\\课堂视频\\day_08\\02_IO流概
述.mp4");
os = new FileOutputStream("day_08/src/io.mp4");
//定义一个字节数组 作为缓冲区
byte[] buff = new byte[1024];
int len;//记录每次读取的字节数
while((len = is.read(buff)) != -1){
// 将缓冲区的数据通过输出流 输出到目标文件
os.write(buff,0,len);
}
System.out.println("文件复制完成");
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}finally {
//关闭流 释放资源
try {
if (os !=null){
os.close();
}
} catch (IOException e) {
throw new RuntimeException(e);
}
try {
if (is !=null){
is.close();
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
拷贝文件夹
需求：将某个磁盘的文件夹拷贝到另一个文件夹中，包括文件夹中的全部信息
分析：IO默认的情况是不可以直接拷贝文件夹的
/**
* ## 拷贝文件夹
* <p>
* 需求：将某个磁盘的文件夹拷贝到另一个文件夹中，包括文件夹中的全部信息
* <p>
* 分析：IO默认的情况是不可以直接拷贝文件夹的
*/
public class CopyDir {
public static void main(String[] args) {
copy(new File("d:\\workSpace"), new File("d://code"));
}
public static void copy(File src, File dest) {
//1 判断源目录是否存在
if (src != null && src.exists() && src.isDirectory()) {
// 在目标路径下 创建一个源目录的文件夹
File destDir = new File(dest, src.getName());
destDir.mkdirs();//创建处复制目录的顶层目录
// 2 判断原目录下是否包含以及目录
File[] files = src.listFiles();
if (files != null && files.length > 0) {
// 3 开始遍历一级目录
for (File file : files) {
// 4 判断是文件还是文件夹 如果是文件 直接复制
if (file.isFile()) {
copyFile(file, new File(destDir, file.getName()));
} else {
// 5 如果是文件夹 则继续递归复制
copy(file, destDir);
}
}
}
}
}
public static void copyFile(File srcFile, File destFile) {
InputStream is = null;
OutputStream os = null;
try {
is = new FileInputStream(srcFile);
os = new FileOutputStream(destFile);
//定义一个字节数组 作为缓冲区
byte[] buff = new byte[1024];
int len;//记录每次读取的字节数
while ((len = is.read(buff)) != -1) {
// 将缓冲区的数据通过输出流 输出到目标文件
os.write(buff, 0, len);
}
System.out.println("文件复制完成");
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
//关闭流 释放资源
try {
if (os != null) {
os.close();
}
} catch (IOException e) {
throw new RuntimeException(e);
}
try {
if (is != null) {
is.close();
}
} catch (IOException e) {
throw new RuntimeException(e);
}}}}
字符流
字节流在读取中文输出会存在问题：会乱码 可能会内存溢出
读取中文输出 ，那个流更合适，为什么？ 字符流更合适 最小单位是按照字符进行读取
字符输入流：Reader
作用：以内存为基准，把磁盘文件中的数据以字符的形式读取到内存中
FileReader 用于读取字符流
| 构造器 | 描述 |
|---|---|
| FileReader(File file) | 使用平台 FileReader ，在 File 读取时创建一个新的FileReader 。 |
| FileReader(File file, Charsetcharset) | 创建一个新的 FileReader ，给出 File 读取和charset。 |
| FileReader(String fileName) | 使用平台 default charset创建一个新的 FileReader，给定要读取的文件的 名称 。 |
| FileReader(String fileName,Charset charset) | 给定要读取的文件的名称和 FileReader ，创建一个新的FileReader 。 |
字符输入流的使用：
public class FileReadDemo {
public static void main(String[] args) throws IOException {
// 1 创建一个字符输入流管道与源文件联通
Reader r = new FileReader("day_08/src/out.txt");
//2 进行都操作
// 每次读取一个字符 没有可读字符时 返回-1
// int code = r.read();
// System.out.println((char)code);
// int code1 = r.read();
// System.out.println((char)code1);
// 使用循环读
int code;
while((code = r.read()) != -1){
System.out.print((char)code);
// System.out.println("\t\n");//回车换行
}
}
}
文件字符数据流 - 一次读取一个字符数组
| String(char[] value) | 分配新的 String ，使其表示当前包含在字符数组参数中的字符序列。 |
|---|---|
| String(char[] value, int offset,int count) | 分配一个新的 String ，其中包含字符数组参数的子数组中的字符。 |
public class FileReadDemo2 {
public static void main(String[] args) throws IOException {
// 1 创建一个字符输入流管道与源文件联通
Reader r = new FileReader("day_08/src/out.txt");
//2 进行都操作
// 每次读取一个字符数组 没有可读字符时 返回-1
char[] cbuff= new char[1024];
// 使用循环读
int len;//每次读取的字符数
while((len = r.read(cbuff)) != -1){
String str = new String(cbuff,0,len);
System.out.print(str);
}}}
字符输出流
文件字符输出流：FileWriter
| 构造器 | 描述 |
|---|---|
| FileWriter(File file) | 给 File 写一个 FileWriter ，使用平台的 defaultcharset |
| FileWriter(File file,boolean append) | 在给出要写入的 FileWriter 下构造 File ，并使用平台的 default charset构造一个布尔值，指示是否附加写入的数据。 |
| FileWriter(File file,Charset charset) | 构造一个 FileWriter 给予 File 编写和charset 。 |
| FileWriter(File file,Charset charset, booleanappend) | 构造 FileWriter 给出 File 写入， charset和一个布尔值，指示是否附加写入的数据。 |
| FileWriter(String fileName) | 构造一个 FileWriter 给出文件名，使用平台的 default |
| FileWriter(String fileName) | 构造一个 FileWriter 给出文件名，使用平台的defaultcharset |
| FileWriter(String fileName,boolean append) | 使用平台的 default charset构造一个 FileWriter 给定一个文件名和一个布尔值，指示是否附加写入的数据。 |
| FileWriter(String fileName,Charset charset) | 构造一个 FileWriter 给出文件名和charset 。 |
| FileWriter(String fileName,Charset charset, booleanappend) | 构造一个 FileWriter 给定一个文件名， charset和一个布尔值，指示是否附加写入的数据。 |
public static void main(String[] args) throws IOException {
Writer fw = new FileWriter("day_08/src/out_file.txt");
fw.write(98);
fw.write('a');
fw.write('山');
fw.write("\r\n");
fw.write("学院");
fw.write("我是中国人",2,3);
fw.write("\r\n");
fw.flush();
fw.close();
}
字节流和字符流如何选择使用？
- 字节流适合做一切文件的数据的拷贝（音频 视频 图片 文本文件 word excel）
- 字节流不适合读取中文内容
- 字符流适合做文本文件的操作（读、写）
使用字符流实现文件的拷贝
public class FileRWCopy {
public static void main(String[] args) {
// 创建文件输入流
Reader fr=null;
Writer fw =null;
try {
fr = new FileReader("day_08/src/cn/sxjzit/CopyDir.java");
fw = new FileWriter("day_08/src/CopyDir_Copy.java");
// 创建缓冲区
char[] cbuff = new char[1024];
int len ;
while((len = fr.read(cbuff)) != -1){
fw.write(cbuff,0,len);
}
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}finally {
if (fw !=null){
try {
fw.close();
} catch (IOException e) {
throw new RuntimeException(e);
}}
if (fr !=null){
try {
fr.close();
} catch (IOException e) {
throw new RuntimeException(e);
}}}}}
内容的使用
缓冲流：提高数据的操作性能：
缓冲流自带8k的缓冲区
需求： 把《出师表》的文章顺序进行恢复到一个新的文件中
思路：
1 定义一个字符缓冲输入流管道与文件联通
2 定义一个List集合存储读取的每行的数据
3 定义一个循环按照行读取数据，存入到List集合中
4 对List集合中的每行数据按照首字符编号升序排序
5 定义一个字符缓冲输出流与目标文件联通
6 遍历List中的每个元素，用缓冲输出流写出数据 并换行
public class BufferedCharTest {
public static void main(String[] args) throws IOException {
// 1 定义一个字符缓冲输入流管道与文件联通
BufferedReader br = new BufferedReader(new
FileReader("day_09/src/csb.txt"));
// 2 定义一个List集合存储读取的每行的数据
List<String> data = new ArrayList<>();
// 3 定义一个循环按照行读取数据，存入到List集合中
String line;
while((line = br.readLine()) !=null){
data.add(line);
}
System.out.println(data);
// 4 对List集合中的每行数据按照首字符编号升序排序
// 自定义排序规则
List<String> sizes = new ArrayList<>();
Collections.addAll(sizes,"一","二","三","四","五","陆","柒","八","九","十","十一");
Collections.sort(data, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
// 截取每行的行号，找到该行号在sizes集合中的索引，然后利用索引进行排序
return sizes.indexOf(o1.substring(0,o1.indexOf("."))) -
sizes.indexOf(o2.substring(0,o2.indexOf(".")));
}
});
System.out.println(data);
// 5 定义一个字符缓冲输出流与目标文件联通
BufferedWriter bw = new BufferedWriter(new
FileWriter("day_09/src/new.txt"));
// 6 遍历List中的每个元素，用缓冲输出流写出数据 并换行
for (String txt: data){
bw.write(txt);
bw.newLine();
}
bw.close();
br.close();
}
}
转换流
- 使用字符流读取中文没有乱码：因为代码编码文件和文件的编码都是UTF-8
文件编码和读取文件的编码必须一致 才不会乱码
案例： 使用不同的编码读取不同编码的文件内内容
需求：分贝使用如下的两种方式读取文件内容：
-
代码编码是UTF_8， 文件的编码也是UTF-8 使用字符流读取观察输出中文字符结果 不会乱码
-
代码编码是UTF-8，文件编码使用GBK，使用字符流读取观察输出的中文字符的结果。 乱码
结论： 字符流直接读取文本内容：必须文件和代码编码一致 才会乱码 ，如果文件和代码的编码不一致，读取就将出现乱码
字符输入转换流
- 如果代码的编码和文件编码不一致，使用字符流直接读取可能会出现乱码，如何解决？
使用字符输入转换流
可以提取文件（GBk）的原始的字节流，原始字节不会存在问题
然后把字节流以指定的编码转换成字符输入流，这样字符输入流中的字符就不会乱码转换流：字节到字符：InputStreamReader（字符输入转换流） OutputStreamWriter（字符输出转 换流）
InputStreamReader作用：把原始的字节流按照指定的编码转换为字符输入流
nputStreamReader是从字节流到字符流的桥接器：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以通过名称指定，也可以明确指定，或者可以接受平台的默认字符集。
| 构造器 | 解释 |
|---|---|
| InputStreamReader(InputStream in) | 创建一个使用默认字符集的InputStreamReader。 |
| InputStreamReader(InputStream in, StringcharsetName) | 创建一个使用指定charset的InputStreamReader。 |
| InputStreamReader(InputStream in,Charset cs) | 创建一个使用给定charset的InputStreamReader。 |
| InputStreamReader(InputStream in,CharsetDecoder dec) | 创建一个使用给定charset解码器的InputStreamReader。 |
public class InputStreamReaderDemo1 {
public static void main(String[] args) throws IOException {
// 1 提取文件的原始字节流 读取的时候采用的字符集是文件的编码字符集
InputStream is= new FileInputStream("day_09/src/csb.txt");
// 2 把原始的字节流转换成字符流
//Reader br = new InputStreamReader(is);//默认使用UTF-8进行转换
Reader br = new InputStreamReader(is,"GBK");
BufferedReader bur = new BufferedReader(br);
String line;
while((line = bur.readLine()) != null){
System.out.println(line);
}}}
总结：
InputStreamReader作用：
可以解决字符流读取不同编码乱码的问题
字符输出转换流
如果需要控制写出的字符使用的编码，怎么办？
可以把字符已指定的编码获取字节然后在使用字节输出流写出
“我爱你中国”.getBytes(“编码”)
可以使用字符输出转换流实现 OutputStreamWriter
OutputStreamWriter是从字符流到字节流的桥接器：使用指定的 charset 将写入其中的字符编码为字
节。 它使用的字符集可以通过名称指定，也可以明确指定，或者可以接受平台的默认字符集。
| 构造器 | 解释 |
|---|---|
| OutputStreamWriter(OutputStream out) | 创建使用默认字符编码的OutputStreamWriter |
| OutputStreamWriter(OutputStream out,String charsetName) | 创建一个使用指定charset的InputStreamReader。 |
| OutputStreamWriter(OutputStream out,Charset cs) | 创建使用给定charset的OutputStreamWriter。 |
| OutputStreamWriter(OutputStream out,CharsetEncoder enc) | 创建使用给定charset编码器的OutputStreamWriter。 |
public class OutputStreamWriterDemo {
public static void main(String[] args) throws IOException {
OutputStream os = new FileOutputStream("day_09/src/out.txt");
Writer w = new OutputStreamWriter(os,"GBK");
BufferedWriter bw = new BufferedWriter(w);
bw.write("我爱你中国1----");
bw.write("我爱你中国2----");
bw.write("我爱你中国3----");
bw.write("我爱你中国4----");
bw.close();
}
}
在编程中，大家都有一个默认的约定成俗的习惯：编码和文件所采用的字符集，一般统一采用UTF-8
序列化对象
对象序列化
对象序列化： 以内存为基准，把内存中的对象存储到磁盘文件中去，成为对象序列化
使用到流： ObjectOutputStream 对象字节输出流 ObjectInputStream 对象字节输入流
要序列化保存对象，需要让对象实现Serializable接口
对象反序列化
以内存为基准，把存储到磁盘文件中的对象恢复成内存中的对象，称之为反序列化
使用到的流：ObjectInputStream
| 构造器 | 解释 |
|---|---|
| ObjectInputStream(InputStreamin) | 创建一个从指定的InputStream读取的ObjectInputStream。 |
| Object | readObject() |
public static void main(String[] args) throws IOException,
ClassNotFoundException {
ObjectInputStream ois= new ObjectInputStream(new
FileInputStream("day_09/src/obj.txt"));
//调用对象字节输入流中的反序列化方法
Student stu = (Student)ois.readObject();
System.out.println(stu);
ois.close();
}
}
总结：对象反序列化的含义：把磁盘中的对象数据恢复到内存中的Java对象
打印流
输出：PrintStream PrintWriter
作用：可以方便、高效的实现打印数据到文件中去
PrintStream 向另一个输出流添加功能，即能够方便地打印各种数据值的表示。 还提供了另外两个功
能。 与其他输出流不同， PrintStream 永远不会抛出 IOException ;
public class PrintDemo {
public static void main(String[] args) throws FileNotFoundException {
//PrintStream ps = new PrintStream(new
FileOutputStream("day_09/src/ps.txt"));
//实现追加写 和自动刷新
//PrintStream ps = new PrintStream(new
FileOutputStream("day_09/src/ps.txt",true),true);
//PrintStream ps = new PrintStream("day_09/src/ps.txt");
PrintWriter ps = new PrintWriter("day_09/src/ps.txt");
ps.println(97);
ps.println('a');
ps.println(2.3);
ps.println(true);
ps.println("这是打印流 打印的数据");
ps.close();
}
}
PrintStream 和PrintWriter的区别：
- 打印数据的功能上一模一样，都方便高效
- PrintStream 继承自字节输出流 OutputStream 支持字节数据的写出
- PrintWriter 继承自字符输出流 Writer 支持字符输出的写出
输出语句的重定向
属于打印流的一种应用，可以把输出语句的打印位置改到文件
public class PrintDemo {
public static void main(String[] args) throws FileNotFoundException {
//PrintStream ps = new PrintStream(new
FileOutputStream("day_09/src/ps.txt"));
//实现追加写 和自动刷新
//PrintStream ps = new PrintStream(new
FileOutputStream("day_09/src/ps.txt",true),true);
//PrintStream ps = new PrintStream("day_09/src/ps.txt");
PrintStream ps = new PrintStream("day_09/src/ps.txt");
ps.println(97);
ps.println('a');
ps.println(2.3);
ps.println(true);
ps.println("这是打印流 打印的数据");
System.setOut(ps);// 把系统打印流修改为我们自己的打印流
System.out.println("山西学院");
System.out.println("大数据学院");
System.setIn(new FileInputStream("day_09/src/csb.txt"));
Scanner sc = new Scanner(System.in);//把系统的输入流改为我们自己的输入流
System.out.println(sc.nextLine());
ps.close();
}
}
补充Properties
Properties属性集对象：
本质就是一个Map集合，但是一般不会当集合使用，因为HashMap更好用
Properties核心作用：
Properties代表一个属性文件，可以把自己对象中的键值对信息存储到一个属性文件中去
属性文件：后缀为.properties结尾的文件，里边的内容都是k=v键值对
public class PropertiesDemo1 {
public static void main(String[] args) throws IOException {
// 使用Properties把键值对信息存储到属性文件中去
Properties prop = new Properties();
prop.setProperty("admin","123456");
prop.setProperty("username","root");
System.out.println(prop);
// 将数据以键值对保存到文件中去
prop.store(new FileWriter("day_09/src/user.properties"),"this is
users!!");
}
}
Properties结合IO流使用：
Properties 类表示一组持久的属性。 Properties 可以保存到流中或从流中加载
public class PropertiesDemo2 {
public static void main(String[] args) throws IOException {
Properties prop= new Properties();
//读取一个属性文件中的键值对
prop.load(new FileReader("day_09/src/user.properties"));
System.out.println(prop);
//通过指定的健 获取对应的值
String v1 = (String) prop.get("admin");
System.out.println(v1);
String v2 = prop.getProperty("username");
System.out.println(v2);
}
}
作业
步骤：
1 将正确的用户名和密码手动保存到本地文件 userInfo.txt文件中
2 保存的格式为：username=zhangsan&password=123456
3 第一次登录让用户键盘输入用户名和密码
4 比较用户输入的用户名和密码是否和文件中保存的一致
5 如果一致则打印登录成功，并将用户登录的数据保存到本地的cookie.txt文件中
保存的格式：username = zhangsan
password=123456
如果不一致，打印登录失败 不需要保存数据搭配cookie.txt
6 再次运行时，则从本地cookie.txt文件中读取第一次保存的数据 实现自动登录
答案
IO框架
commons-io：
时apache开源软件基金组织提供的一组有关IO操作的类库，可以提高io功能开发的效率
主要的类： FileUtils，IOUtils
使用：
- 在项目中创建一个lib文件夹
- 将.jar文件拷贝到lib目录下
- 将添加到类路径下
- 在类中导包使用
public class CommonsIODemo {
public static void main(String[] args) throws IOException {
// 1 完成文件的复制
// IOUtils.copy(new FileInputStream("d://code/1.jpg"),new
FileOutputStream("day_09/src/1.jpg"));
// 2 完成将文件复制到某个文件夹下
// FileUtils.copyFileToDirectory(new File("d://code//2.jpg"),new
File("day_09/src"));
//3 完成文件夹复制到某个文件夹
//FileUtils.copyDirectoryToDirectory(new File("d://code"),new
File("day_09"));
//4 删除目录
// FileUtils.deleteDirectory(new File("day_09/code"));
// 5 jdk7 自己也做了一些代码的升级操作 NIO技术
Files.copy(Path.of("d://code/3.jpg"),Path.of("day_09/src/3.jpg"));
}
}
59
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
