目录
3.处理流BufferReader和BufferWriter
4.对象处理流ObjectOutputStream和ObjectInputStream 序列化与反序列化
5.标准输入与输出流System.in 和System.out
6.转换流InputStreamReader和OutputStreamWriter
一.文件基础知识
前情提要：Io最主要的是区分不同流的作用和使用规范
1.文件基础知识铺垫
1.1什么是文件
文件就是保存数据的地方，图片，音乐，视频等等。
1.2文件流的概念
输入与输出是针对内存的，磁盘内容输入到java程序当中，Java程序处理的结果输出到磁盘当中。
类比：
IO流的整个类图
2.创建文件的三种方式
案例
代码
package com.file;
import org.junit.jupiter.api.Test;
import java.io.File;
import java.io.IOException;
public class FileCrate {
public static void main(String[] args) {
}
@Test
public void create01(){
// 指定文件的路径
String filePath = "d:\\one.txt";
// 还没有进行创建，相当于对文件进行声明
File file = new File(filePath);
// 进行创建
try {
file.createNewFile();
System.out.println("文件创建成功！");
} catch (IOException e) {
e.printStackTrace();
}
}
@Test
// 方法二，通过父文件和子路径来进行创建 参数为File，String File有三种创建对象的构造器
public void create02(){
File parentFile = new File("d:\\");
String path = "next.txt";
// 在java程序（内存）当中创建的对象，使用方法，将内存当中的对象，输出到硬盘上
File file = new File(parentFile, path);
// 创建文件
try {
file.createNewFile();
System.out.println("文件创建成功");
} catch (IOException e) {
e.printStackTrace();
}
}
// public File(String parent, String child) 第三种方法
@Test
public void create03(){
String parent = "d:\\";
String path = "next01.txt";
// 在java程序（内存）当中创建的对象，使用方法，将内存当中的对象，输出到硬盘上
File file = new File(parent, path);
// 创建文件
try {
file.createNewFile();
System.out.println("文件创建成功");
} catch (IOException e) {
e.printStackTrace();
}
}
}
运行结果
指定路径下就会出现我们想要的文件了
3.获取文件信息
常用的方法
案例演示
代码
package com.file;
import java.io.File;
import java.io.IOException;
public class FileInformation {
public static void main(String[] args) {
// 先创建文件
File file = new File("d:\\no1.txt");
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
// 调用相应的方法得到相应的信息
System.out.println("文件的名字 "+file.getName());
System.out.println("文件的父级目录 "+file.getParent());
System.out.println("文件的绝对路径 "+file.getPath());
System.out.println("文件的大小（字节） "+file.length());
System.out.println("文件是否存在 "+file.exists());
System.out.println("是不是一个文件 "+file.isFile());
System.out.println("是不是一个目录 "+file.isDirectory());
}
}运行结果
文件的名字 no1.txt
文件的父级目录 d:\
文件的绝对路径 d:\no1.txt
文件的大小（字节） 6
4.目录操作
用到的方法
代码
package com.file;
import org.junit.jupiter.api.Test;
import java.io.File;
public class Directory_ {
public static void main(String[] args) {
}
// 判断m1是否存在，存在就删除
@Test
public void m1(){
String filePath = "d:\\no1.txt";
File file = new File(filePath);
if (file.exists()){
if (file.delete()){
System.out.println(filePath+"文件删除成功");
}else {
System.out.println(filePath+"文件删除失败");
}
}else {
System.out.println("该文件不存在");
}
}
// 判断demo01.txt是否存在，不存在打印不存在 在java当中，目录也被当成一种文件
@Test
public void m2(){
String filePath = "d:\\demo01";
File file = new File(filePath);
if (file.exists()){
if (file.delete()){
System.out.println(filePath+"文件删除成功");
}else {
System.out.println(filePath+"文件删除失败");
}
}else {
System.out.println("该文件不存在");
}
}
// 判断文件夹有没有，没有就创建文件夹
@Test
public void m3(){
String filePath = "d:\\demo01";
File file = new File(filePath);
if (file.exists()){
System.out.println(filePath+"文件存在");
}else {
// 创建一个目录
if (file.mkdirs()){
System.out.println(filePath+"文件夹创建成功。");
}else{
System.out.println(filePath+"文件夹创建失败。");
}
}
}
}
m3运行结果
二.IO流原理及流的分类
1.IO流的原理
2.流的分类
三.InputStream字节输入流
1.InputStream的简介
类图结构
2.FileInputStream类方法
代码
package com.inputstream;
import org.junit.jupiter.api.Test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileInputStream_ {
public static void main(String[] args) {
}
// 单个读取的效率太低，使用public int read(byte b[])方法。
@Test
public void readFile01() throws IOException {
String filePath = "d:\\hello.txt";
int read =0 ;
// 创建输入流
FileInputStream fileInputStream = null;
try {
fileInputStream = new FileInputStream(filePath);
// 对数据进行循环的读取，当返回值为-1时，表示读取完毕
while ((read = fileInputStream.read())!=-1){
System.out.print((char)read);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally {
// 关闭流，进行资源的释放
fileInputStream.close();
}
}
@Test
public void readFile02() throws IOException {
String filePath = "d:\\hello.txt";
int readLen =0 ;
// 创建字节数组，一次读取八个字节
byte[] bytes = new byte[8];
// 创建输入流
FileInputStream fileInputStream = null;
try {
fileInputStream = new FileInputStream(filePath);
// 方法进行优化
while ((readLen = fileInputStream.read(bytes))!=-1){
// 讲字节转化为字符串进行输出
System.out.print(new String(bytes,0,readLen));
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally {
// 关闭流，进行资源的释放
fileInputStream.close();
}
}
}Test2对读取的方式进行了优化
四.OutputSteam字节输出流
1.OutputSteam类的简介
类图
2..FileOutPutStream类
常用的方法
应用实例1
在代码指定的位置创建文件
代码
package com.outputstream;
import org.junit.jupiter.api.Test;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStream01 {
public static void main(String[] args) {
}
/*
* 使用FileOutputStream将文件写入内存当中*/
@Test
public void writeFile() {
String filePath = "d:\\a.txt";
// 创建文件输出流对象
FileOutputStream fileOutputStream = null;
try {
// new FileOutputStream(filePath)写入内容时会覆盖原来的内容
// new FileOutputStream(filePath,true)进行追加而不是覆盖
fileOutputStream = new FileOutputStream(filePath,true);
// write方法的三种使用
// 1.输出数据 单个字符数据
fileOutputStream.write('H');
// 2.写入字符串数据
String str = "hello.word!";
// 将String变成byte数组的形式在传入 使用string自带的方法
fileOutputStream.write(str.getBytes());
// 3.写入一段字符串 public void write(byte b[], int off, int len) off为开始截取的位置，len为截取的长度
fileOutputStream.write(str.getBytes(),0,3);
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}运行结果：指定文件当中的文本内容被修改
注意：new FileOutputStream(filePath,true)这样创建的流，在下次运行的时候不会清空文件当中的文本，而是进行末尾的追加。
应用实例2拷贝文件
要求
大体的思路
代码
package com.outputstream;
import org.junit.jupiter.api.Test;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileCopy {
public static void main(String[] args) {
}
@Test
public void FileCopy(){
// 字节数组 一个一个字节数组读取
byte[] bytes = new byte[8];
// 读取文件的路径
String filePath = "d:\\1.jpg";
// 输出文件的路径
String aimPath = "src\\1.jpg";
FileOutputStream fileOutputStream = null;
FileInputStream fileInputStream = null;
try {
// 1.输入到内存当中
//
fileInputStream = new FileInputStream(filePath);
// 输出到硬盘当中
fileOutputStream =new FileOutputStream(aimPath);
// 定义一个数组提高读取的效率
byte[] bytes1 = new byte[1024];
int readLen =0;
while ((readLen = fileInputStream.read(bytes1))!=-1){
// 一遍读一边写
fileOutputStream.write(bytes1,0,readLen);//一定要使用这个方法，不然：最后面数据达不到1024个字节，就是出现文件损失
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
// 关闭输入流和输出流
if (fileOutputStream!=null){
fileOutputStream.close();
}
if (fileOutputStream!=null){
fileInputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}运行前：
运行后：
提示：转移到c盘，需要管理员的权限，会出现警告。
java.io.FileNotFoundException: c:\1.jpg (拒绝访问。)
五.writer字符输出流
1.writer简介
类图
2. FileWriter类
继承关系
常用方法
案例练习
代码
package com.writer_;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriter_ {
public static void main(String[] args) {
String path = "src\\node.txt";
// 创建文件
// File file = new File(path);
// try {
// file.createNewFile();
// } catch (IOException e) {
// e.printStackTrace();
// }
char[] chars = {'a','b','c'};
FileWriter fileWriter = null;
try {
fileWriter = new FileWriter(path);
// 写入单个字符
fileWriter.write('A');
// 写入字符数组
fileWriter.write(chars);
// 写入字符数组指定的部分
fileWriter.write("你好，世界！".toCharArray(),0,3);
// 写入整个字符串 较为常用
fileWriter.write("我爱你中国。");
fileWriter.write("风雨之后，定见彩虹！！");
// 写入字符串的指定部分 较为常用
fileWriter.write("最终的胜利一定属于英勇的人民！！",0,5);
// 在数据量大的情况下可以使用循环操作
} catch (IOException e) {
e.printStackTrace();
}finally {
// 只有关闭流之后才可以将文件真正的写入
if (fileWriter!=null){
try {
// 关闭文件流等价于flush+关闭
fileWriter.close();
// close源码，到底是什么原理
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}运行结果
补充：为什么close之后写入数据才算完成数据的传输
在close方法的最后，调用FileOutputStream，才将数据写入 ,字符流的底层是字节流
六.reader字符输入流
1.reader类的简介
类图
2.FileReader类
相关方法
课堂练习
代码
package com.reader_;
import org.junit.jupiter.api.Test;
import java.io.FileReader;
import java.io.IOException;
public class FileReader_ {
public static void main(String[] args) {
}
// 对单个字符读取文件 基本不用
@Test
public void FileReader01(){
String path = "d:\\story.txt";
FileReader fileReader = null;
int data = 0;
// 创建
try {
fileReader = new FileReader(path);
//
while ((data = fileReader.read())!=-1){
System.out.print((char)data);
}
} catch (Exception e) {
e.printStackTrace();
}finally {
if (fileReader!=null){
try {
fileReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
// 指定字符长度的读取文件
@Test
public void FileReader02(){
String path = "d:\\story.txt";
FileReader fileReader = null;
int readLen = 0;
char[] chars = new char[8];
// 创建
try {
fileReader = new FileReader(path);
// 字符流所以使用的char数组
while ((readLen = fileReader.read(chars))!=-1){
System.out.print(new String(chars,0,readLen));
}
} catch (Exception e) {
e.printStackTrace();
}finally {
if (fileReader!=null){
try {
fileReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}两个方法的运行结果都一样
21世纪历史爱好者林枫，熬夜刷历史小说突然猝死，然后穿越到东汉末年，成为了玉门关守将。
作为一个穿越者，林枫正在想自己未来出路在何方的时候，拥有各种功能的逆天系统出现了。
人口功能：可以兑换无数人口、..
七.节点流和处理流
1.相关概念
涉及到的类
节点流使用场景
注意：节点流是比较底层的数据流没有进行过多的封装，功能性并不是很强大，如图：操作文件与操作数组需要使用两种不同的类。
writer的类图
多样的类，使得BufferWriter拥有了更多的功能，更加灵活的使用方法。
处理流的功能相对更强大一些
注意：BufferReader当中有一个Reader属性，BufferReader可以拥有Reader所有子类的功能，例如FileReader，BufferWriter一样可以实现Writer所有子类的功能。
节点流和处理流的区别
2.处理流的设计模式
代码举例
抽象类
package com.reader_;
public abstract class Reader_ {
public void readString(){}
public void readFile(){}
// 也可以使用read方法进行统一的管理，通过传入的子类对象不同，调用不同的子类实现方法
}
根据功能划分的抽象类的子类
FileReader_类
package com.reader_;
public class FileReader_ extends Reader_{
public void readFile(){
System.out.println("读取文件......");
}
}
StringReader_类
package com.reader_;
public class StringReader_ extends Reader_{
public void readString(){
System.out.println("读取字符串。。。。");
}
}
使用子类来处理数据的包装类
package com.reader_;
public class BufferReader_ extends Reader_{
private Reader_ reader_;
public Reader_ getReader_() {
return reader_;
}
// 穿传入子类也可以
public BufferReader_(Reader_ reader_) {
this.reader_ = reader_;
}
// 让方法更加的灵活，多次读取文件
public void readFiles(int num){
// 这里调用的是子类的方法
for (int i =0;i<num;i++){
reader_.readFile();
}
}
// 多次读取字符串
public void readStrings(int num){
// 通过方法来调用 而不是直接通过对象调用
for (int i =0;i<num;i++){
reader_.readString();
}
}
// 读取一次
public void readString(){
// 通过方法来调用 而不是直接通过对象调用
reader_.readString();
}
}
实际使用，传入抽象类的子类，指定使用的方法
package com.reader_;
public class Test_ {
public static void main(String[] args) {
BufferReader_ bufferReader_ = new BufferReader_(new FileReader_());
bufferReader_.readFiles(10);
BufferReader_ bufferReader_1 = new BufferReader_(new StringReader_());
bufferReader_1.readString();
}
}
运行结果
读取文件......
读取文件......
读取文件......
读取文件......
读取文件......
读取文件......
读取文件......
读取文件......
读取文件......
读取文件......
读取字符串。。。。
3.处理流BufferReader和BufferWriter
当然这两也是字符流
真正处理数据还是节点流，处理流是将处理流进行了包装
应用案例1 读取指定文件当中的文本到程序当中
代码
package com.reader_;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class BufferReader01 {
public static void main(String[] args) {
String path = "d:\\story.txt";
BufferedReader bufferedReader =null;
try {
// 字符流在处理一些二进制文件的时候可能会出现文件的损失
bufferedReader = new BufferedReader(new FileReader(path));
String string ;
// 按行进行文件的读取 读取完后返回null
while ((string =bufferedReader.readLine())!=null) {
System.out.println(string);
}
} catch (Exception e) {
e.printStackTrace();
}finally {
if (bufferedReader!=null){
try {
// 不用关闭节点流，因为包装流底层会自动关闭节点流
bufferedReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
运行结果
21世纪历史爱好者林枫，熬夜刷历史小说突然猝死，然后穿越到东汉末年，成为了玉门关守将。
作为一个穿越者，林枫正在想自己未来出路在何方的时候，拥有各种功能的逆天系统出现了。
人口功能：可以兑换无数人口、..
将指定文件的内容以字符的形式打印到了控制台
应用案例2 使用字符流，将文本输入到指定文件
代码
package com.writer_;
import java.io.BufferedWriter;
import java.io.FileWriter;
public class BufferReader01 {
public static void main(String[] args) throws Exception {
String path = "d:\\story.txt";
// 在节点流上写true进行追加 最终执行的还是节点流的代码 处理流只是方便我们使用节点流创建的工具 类似于工具箱
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(path));
bufferedWriter.write("韩顺平教育。");
// 插入一个换行符
bufferedWriter.newLine();
bufferedWriter.write("你好，我正在向文本当中书写内容。");
bufferedWriter.close();
}
}
执行结果
应用案例3 使用字符流拷贝文件
代码
package com.writer_;
import java.io.*;
public class BufferCopy {
public static void main(String[] args) throws IOException {
String path = "d:\\story.txt";
// 写入文件的时候，如果找不到文件，他会自动的创建文件
String aimPath = "src\\test01.txt";
BufferedWriter bufferedWriter = null;
BufferedReader bufferedReader = null;
bufferedReader = new BufferedReader(new FileReader(path));
bufferedWriter = new BufferedWriter(new FileWriter(aimPath));
String len = "";
while ((len = bufferedReader.readLine())!=null){
// 读一行写一行
bufferedWriter.write(len);
// 写完之后记得换行
bufferedWriter.newLine();
}
if (bufferedWriter!=null){
bufferedWriter.close();
}
if (bufferedReader!=null){
bufferedReader.close();
}
}
}
运行结果
在创建文档的时候将文本写入
注意：doc，pdf，word文档都属于二进制文档
案例4 使用字节流拷贝文件
使用的是BufferInputString和BufferOutputStream
代码
package com.buffer_;
import java.io.*;
public class BufferCopy01 {
public static void main(String[] args) throws IOException {
// 读取文件的路径
String filePath = "d:\\01.jpg";
// 输出文件的路径
String aimPath = "src\\01.jpg";
BufferedInputStream bufferedInputStream = null;
BufferedOutputStream bufferedOutputStream =null;
bufferedInputStream = new BufferedInputStream(new FileInputStream(filePath));
bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(aimPath));
byte[] bytes = new byte[1024];
int readLen = 0;
while ((readLen = bufferedInputStream.read(bytes))!=-1){
// 三个参数的含义 数据 数据开始读取位置 数据结束读取位置
bufferedOutputStream.write(bytes,0,readLen);
}
if (bufferedInputStream!=null){
bufferedInputStream.close();
}
if (bufferedOutputStream!=null){
bufferedOutputStream.close();
}
}
}运行结果
图片文件拷贝成功
字节流什么文件都可以拷贝，因为计算机上的所有文件的底层都是由二级制源码构成的。可能效率上比较低一些。处理流和节点流的使用方式是差不多的，只是封装了的处理流，使用起来更加的方便一些，效率也更高一些。
4.对象处理流ObjectOutputStream和ObjectInputStream 序列化与反序列化
对象处理流的作用
保存java数据到文件当中，并且能从文件当中取出，转化为java形式的文件
保存值外加保存数据类型
两个对象流属于处理流和字节流
ObjectInputStream类图结构
ObjectOutputStream类图
序列化ObjectOutputStream
案例
代码
package com.outputstream;
import java.io.*;
public class ObjectOutputStream_ {
public static void main(String[] args) throws Exception {
// 序列化之后，保存的文件格式不是纯文本的形式，而是按照他的格式来保存的
String filePath = "d:\\data.dat";
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(filePath));
// 序列化文件到指定路径
objectOutputStream.write(100); //会进行自动的装箱 类型为Integer 并且实现了序列化接口
objectOutputStream.writeBoolean(true);
objectOutputStream.writeChar('a');
objectOutputStream.writeUTF("韩顺平教育");
// 保存一个对象
objectOutputStream.writeObject(new Dog(10,"旺财"));
objectOutputStream.close();
}
}
// 如果需要序列化就实现接口
class Dog implements Serializable{
private int age;
private String name;
public Dog(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}运行结果
反序列化ObjectInputStream
创建公共类Dog
package com.outputstream;
import java.io.Serializable;
public class Dog implements Serializable{
private int age;
private String name;
public Dog(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Dog{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}ObjectInputStream_类
package com.inputstream;
import com.outputstream.Dog;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class ObjectInputStream_ {
public static void main(String[] args) throws Exception {
// 指定反序列化的文件
String filePath = "d:\\data.dat";
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filePath));
// 注意，读取的顺序应当与序列化的顺序是一致的 因为是一一对应的关系
// 在反序列化之前，一定要将方法重新执行一边 不然可能会不匹配
System.out.println(objectInputStream.readInt());
System.out.println(objectInputStream.readBoolean());
System.out.println(objectInputStream.readChar());
System.out.println(objectInputStream.readUTF());
Object dog = objectInputStream.readObject();
// 重要的细节 如果我们想要执行类当中的方法 应当将类拷贝到可以引用的地方 存放的类最好是公开的
Dog dog1 = (Dog)dog;
System.out.println(dog1.getName());
System.out.println(dog.getClass());
System.out.println(dog);
objectInputStream.close();
}
}
运行结果
100
true
a
韩顺平教育
旺财
class com.outputstream.Dog
Dog{age=10, name='旺财'}
注意事项
1.顺序不一致，会导致类型不一致，会报错
2. 兼容性，类修改之后，仍旧会被当成一个类来进行处理
3.static和transient不会被序列化，但是transient不能被序列化不是绝对的
4.对一个对象进行序列化，要求对象的所有属性都可以被序列化
5.序列化具有可继承性
transient关键字详解
https://www.runoob.com/w3cnote/java-transient-keywords.html
5.标准输入与输出流System.in 和System.out
属于字节流。代表着两个流，一个对应的位置是键盘，一个对应的位置是显示器
代码
package com.standard;
import java.util.Scanner;
public class InputAndOutput {
public static void main(String[] args) {
// System 当中的in属性 public final static InputStream in = null;
// 编译类型为InputStream运行类型为BufferInputStream 表示标准输出键盘
System.out.println(System.in.getClass());
// 运行类型和编译类型都是PrintStream 表示标准输出显示器
System.out.println(System.out.getClass());
System.out.println("韩顺平教育~~~~~~");
// 键盘输入的内容
Scanner scanner = new Scanner(System.in);
String next = scanner.next();
System.out.println(next);
}
}
运行结果
class java.io.BufferedInputStream
class java.io.PrintStream
韩顺平教育~~~~~~
nihao
nihao
6.转换流InputStreamReader和OutputStreamWriter
运行类型是字符流，
转换流的作用，将字节流转化为字符流
解决读取文件乱码问题
代码
package com.transformation;
import java.io.*;
public class CodeQuestion {
public static void main(String[] args) throws Exception {
// 读取指定路径的文件到程序当中
String path = "d:\\test.txt";
// 创建流进行指定文件当中信息的读取
BufferedReader bufferedReader = null;
bufferedReader = new BufferedReader(new FileReader(path));
String s = bufferedReader.readLine();
// 输出的文件没有任何的问题 默认情况下是按照UTF-8进行解析的 使用其他编码表可能会出现问题
System.out.println(s);
// 出现乱码的根本问题是因为你没有指定解析你密码的格式
}
}
结果
为这世间的一切献上美好的祝福
没有问题是因为使用的编码表是UTF-8
进行格式更换
再次运行程序
Ϊ�������һ���������õ�ף��
出现乱码
转换流可以指定编码的形式
介绍
InputStreamReader类
类图
案例
代码
package com.transformation;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
public class InputStreamReader_ {
public static void main(String[] args) throws Exception {
// 将FileInputStream字节流转化为InputStreamReader字符流 字符流处理文本的效率更b高
String path = "d:\\test.txt";
InputStreamReader jbk = new InputStreamReader(new FileInputStream(path), "gbk");
// 最后还是用处理流BufferedReader进行信息的处理 进行了两次包装 一次指定编码表 一次指定信息处理的处理流
BufferedReader bufferedReader = new BufferedReader(jbk);
// bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(path)));
// 可以将上面的代码合成一句话，因为InputStreamReader是Reader的子类
// 进行读取
String s = bufferedReader.readLine();
System.out.println(s);
}
}
运行结果
璁╂垜浠潵璧炵編杩欎釜涓栫晫鐨勭編濂藉惂
第一次为乱码，当我们修改txt文件的编码表为我们指定的时候，输出
让我们来赞美这个世界的美好吧
正常输出
OutputStreamWriter
类图
案例
代码
package com.transformation;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
public class OutputStreamWriter_ {
public static void main(String[] args) throws Exception {
String path = "d:\\test.txt";
String charSet = "gbk";
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(path),charSet);
outputStreamWriter.write("你好，艾莉西亚");
outputStreamWriter.close();
}
}运行结果
7.打印流PrintStream和PrintWriter
字节流PrintStream
类图
构造方法
可以将文件打印到一个指定的文件当中
代码
package com.printStream_;
import java.io.IOException;
import java.io.PrintStream;
public class PrintStream_ {
public static void main(String[] args) throws IOException {
PrintStream ps = System.out;
// 默认情况下PrintStream输出的位置是控制台也就是显示器
ps.print("如果真爱有颜色那么一定是蓝色的。");
// 因为print底层使用的是write所以我们可以直接使用write进行输出
ps.write("感觉不如惠".getBytes());
ps.close();
// 修改文本输出的位置
System.setOut(new PrintStream("d:\\test.txt"));
System.out.println("薇尔莉特是世界上最好看的女性");
}
}前两句输出的位置
修改输出路径之后的情况
字符流PrintWriter
类图
构造方法
案例
package com.printStream_;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class PrintWriter_ {
public static void main(String[] args) throws IOException {
String path = "d:\\test01.txt";
PrintWriter printWriter = new PrintWriter(new FileWriter(path));
printWriter.write("世界上最美好的语言是谎言。");
printWriter.close(); //这里边才是真正写数据的
}
}运行结果
依旧是close的时候真正的输出完成信息
之前追过这个方法
七.配置文件Properties
1.引出配置文件
代码
package com.propertise;
import java.io.BufferedReader;
import java.io.FileReader;
public class Properties_ {
public static void main(String[] args) throws Exception {
// 传统的方式比较麻烦
BufferedReader bufferedReader = new BufferedReader(new FileReader("src\\mysql.properties"));
String lin = "";
while ((lin = bufferedReader.readLine())!=null){
String[] split = lin.split("=");
System.out.println(split[0]+"的值是："+split[1]);
}
bufferedReader.close();
}
}
运行结果
ip 的值是： 192.127.100.100
user 的值是： root
pwd 的值是：12345
获取信息不是很方便 properties当中的属性
以后会有个更方便的xml实现方法
2.基本的使用
使用方法
应用案例1 读文件
package com.propertise;
import java.io.FileReader;
import java.util.Properties;
public class Properties01 {
public static void main(String[] args) throws Exception {
Properties properties = new Properties();
properties.load(new FileReader("src\\mysql.properties"));
// 将k-v显示到控制台
properties.list(System.out);
// 根据key获得对应的值
String user = properties.getProperty("user");
System.out.println(user);
}
}
运行结果
-- listing properties --
user=root
pwd=12345
ip=192.127.100.100
root
应用案例2 写文件
代码
package com.propertise;
import java.io.FileOutputStream;
import java.util.Properties;
public class Properties02 {
public static void main(String[] args) throws Exception {
Properties properties = new Properties();
// 进行添加信息 如果key存在就替换 底层的父类是HashCode
properties.setProperty("charSet","utf-8");
properties.setProperty("user","tom");
properties.setProperty("pwd","abc111");
// 将内容写入文件 后面的参数是文件得注释
properties.store(new FileOutputStream("src\\mysql01.properties"),null);
System.out.println("保存配置文件成功。。。");
}
}
运行结果
八.家庭作业
1.家庭作业一
代码
package com.homework;
import java.io.*;
public class HomeWork01 {
public static void main(String[] args) throws IOException {
// 创建文件夹
String directoryPath = "d:\\mytemp";
File file = new File(directoryPath);
if (!file.exists()){
if (file.mkdirs()){
System.out.println(directoryPath+"创建成功");
}else {
System.out.println(directoryPath+"创建失败");
}
}
String filePath = directoryPath+"\\hello.txt";
file =new File(filePath);
// 不存在的话 返回true
if (!file.exists()){
// 创建文件夹
if (file.createNewFile()){
System.out.println(filePath + "文件创建文件");
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));
bufferedWriter.write("你好，但愿我能看见世界的美好。。");
bufferedWriter.close();
}else {
System.out.println(filePath + "文件创建失败");
}
}else {
System.out.println(filePath + "已经存在，不再重复的创建");
}
}
}
控制台输出结果
d:\mytemp创建成功
d:\mytemp\hello.txt文件创建文
文件
2.家庭作业二
代码
package com.homework;
import java.io.BufferedReader;
import java.io.FileReader;
public class HomeWork02 {
public static void main(String[] args) throws Exception {
String filePath = "d:\\test.txt";
BufferedReader bufferedReader = null;
String lin = " ";
int i = 0;
bufferedReader = new BufferedReader(new FileReader(filePath));
while ((lin = bufferedReader.readLine())!=null){
System.out.println(++i+":"+lin);
}
if (bufferedReader!=null){
bufferedReader.close();
}
}
}
运行结果
1:如果天空总是黑暗的，那就摸黑生存；
2:如果发出声音是危险的，那就保持沉默；
3:如果自觉无力发光，那就蜷伏于墙角。
4:但不要习惯了黑暗就为黑暗辩护；
5:也不要为自己的苟且而得意；
6:不要嘲讽那些比自己更勇敢的人们。
7:我们可以卑微如尘土，但不可扭曲如蛆虫。
修改文件存储的编码，利用转换流进行转化，才能正常输出
package com.homework;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
public class HomeWork02 {
public static void main(String[] args) throws Exception {
String filePath = "d:\\test.txt";
BufferedReader bufferedReader = null;
String lin = " ";
int i = 0;
// 修改编码之后的操作
bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(filePath),"gbk"));
while ((lin = bufferedReader.readLine())!=null){
System.out.println(++i+":"+lin);
}
if (bufferedReader!=null){
bufferedReader.close();
}
}
}
3.家庭作业三
代码
package com.homework;
import java.io.*;
import java.util.Properties;
public class HomeWork03 {
public static void main(String[] args) throws Exception {
String filePath = "src\\dog.properties";
Properties properties = new Properties();
properties.load(new FileReader(filePath));
String name = properties.get("name")+" ";
int age = Integer.parseInt(properties.get("age")+"");
String color = properties.get("color")+" ";
Dog dog = new Dog(name, age, color);
System.out.println(dog);
String serFilePath = "d:\\dog.dat";
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(serFilePath));
objectOutputStream.writeObject(dog);
objectOutputStream.close();
System.out.println("dog序列化完成。。");
}
}
class Dog implements Serializable{
private String name;
private int age;
private String color;
public Dog(String name, int age, String color) {
this.name = name;
this.age = age;
this.color = color;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", age=" + age +
", color='" + color + '\'' +
'}';
}
}
运行结果
Dog{name='tom ', age=5, color='red '}
dat文件
本文含有隐藏内容，请 开通VIP 后查看