目录
BufferedInputStream\BufferedOutputStream复制二进制文件
IO流体系结构
文件基础知识
常用的文件操作
获取文件信息方法
@Test
public void info(){
File file = new File("e:\\news1.txt");
System.out.println("文件名字"+file.getName());
System.out.println("文件绝对路径"+file.getAbsolutePath());
System.out.println("文件父目录"+file.getParent());
System.out.println("文件大小"+file.length());
System.out.println("文件是否存在"+file.exists());
System.out.println("是不是一个文件"+file.isFile());
System.out.println("是不是一个目录"+file.isDirectory());
}IO流原理和流的分类
字节流主要用来处理二进制文件（doc、音频、视频），也可以处理文本文件
字符流用来处理字符文件（文本文件）
IO流常用的类
类的继承关系
节点流
FileInputStream 字节输入流
read（）读取文件中的数据
如果文件中有中文，会出现中文乱码问题
@Test
public void readFile01(){
String filePath = "e:\\IoTest\\hello.txt";
int read = 0;
FileInputStream fileInputStream =null;
try {
fileInputStream = new FileInputStream(filePath);
while ((read = fileInputStream.read()) != -1){
System.out.print((char)read);
}
} catch (IOException e) {
e.printStackTrace();
}finally {//关闭流 释放资源
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}read（byte[] b）一次性一个数组长度的字符
@Test //使用read（byte[] b）的方法一次性读取多个字符
public void readFile02(){
String filePath = "e:\\IoTest\\hello.txt";
int read = 0;
//新建个数组
byte[] buf =new byte[8];//一次读取8个字符
int readLen = 0;
FileInputStream fileInputStream =null;
try {
fileInputStream = new FileInputStream(filePath);
//该输入流最多读取b。length字节的数据到字节数组。
//返回值为-1 表示读取完毕
//如果读取正常，返回读取的字符数
while ((readLen = fileInputStream.read(buf)) != -1){
System.out.print(new String(buf,0,readLen));
}
} catch (IOException e) {
e.printStackTrace();
}finally {//关闭流 释放资源
try {
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}FileoutputStream 字节输出流
write（）三种输出到文件方法
@Test
public void writeFile(){
String filePath = "e:\\IoTest\\hello.txt";
FileOutputStream fileOutputStream = null;
try {
fileOutputStream = new FileOutputStream(filePath);
/*fileOutputStream.write('A');//写入一个字节*/ //方法一
/* String string = "hello world";
//get Byte()可以将字符串转成数组
fileOutputStream.write(string.getBytes());//输出一个数组*/ //方法2
//方法3输出指定长度字符串
String string = "hhh hello world";
fileOutputStream.write(string.getBytes(),0,3);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fileOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}上面的方法会覆盖原来的内容，要想追加用
实现拷贝任务。
public class FileCopy {
public static void main(String[] args) {
byte[] buf = new byte[1024];
int fileLen = 0;
FileInputStream fileInputStream =null;
FileOutputStream fileOutputStream =null;
String filePath1 ="e:\\copy.png";
String filePath2 ="d:\\copy.png";
try {
fileInputStream = new FileInputStream(filePath1);
fileOutputStream = new FileOutputStream(filePath2);
while ((fileLen = fileInputStream.read(buf))!= -1){//边读边传
fileOutputStream.write(buf,0,fileLen);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (fileInputStream != null){
fileInputStream.close();
}
if (fileOutputStream != null){
fileOutputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
字符流FileRead和FileWrite
FileRead
单个字符读取
@Test //单个字符读取
public void Reader01(){
FileReader fileReader01 =null;
String filePath = "e:\\hello.txt";
int date = 0;
try {
fileReader01 = new FileReader(filePath);
//单个字符读取
while ((date = fileReader01.read())!= -1){
System.out.print((char) date);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fileReader01 != null){
try {
fileReader01.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}数组读取
@Test //数组读取
public void reader(){
FileReader fileReader02 =null;
char[] buf = new char[10];
int readLen = 0;
String filePath = "e:\\hello.txt";
try {
fileReader02 = new FileReader(filePath);
while ((readLen = fileReader02.read(buf)) != -1){
System.out.println(new String(buf,0,readLen));
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fileReader02 != null){
try {
fileReader02.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}FileWriter
使用方法
@Test
public void writer(){
FileWriter fileWriter = null;
String filePath ="e:\\hello.txt";
char[] buf = {'A','B','C'};
try {
fileWriter = new FileWriter(filePath);
fileWriter.write('擦');//输入单个字符
fileWriter.write("输入整个字符串");//输入
fileWriter.write("输入整个字符串",0,3);
fileWriter.write(buf);//输入整个buf数组
fileWriter.write(buf,0,1);//输入buf数组0-1部分
System.out.println("添加成功");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fileWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}节点流和处理流
缓冲流
BufferedReader
//bufferedReader 使用
public class BufferedReader_ {
public static void main(String[] args) throws Exception {
String filePath = "e:\\hello.txt";
String line;//按行读取
//创建bufferedReader
BufferedReader bufferedReader =new BufferedReader(new FileReader(filePath));
while ((line = bufferedReader.readLine()) != null){//readLine 返回为null时表示为读取完毕
System.out.println(line);
}
bufferedReader.close();//只需要关闭bufferedReader就行，传入的new FileReader(filePath)会在底层关闭
}
}
BufferedWriter
public class BufferedWriter_ {
public static void main(String[] args) throws IOException {
String filePath = "e:\\hello.txt";
char[] buf ={'a','b','c'};
//创建BufferedWriter
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath,true));
bufferedWriter.write("红红火火恍恍惚惚");
bufferedWriter.newLine();//插入一个换行
bufferedWriter.write(buf,1,2);
//关闭外层流
bufferedWriter.close();
}
}复制操作
public class BufferedCopy_ {
public static void main(String[] args) throws IOException {
String filePath = "e:\\hello.txt";
String destFilePath = "d:\\hello.txt";
String line;
BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(destFilePath));
while ((line = bufferedReader.readLine()) != null){
bufferedWriter.write(line);//每读取一行，粘贴一行
bufferedWriter.newLine();//换行
System.out.println("以复制过去一行");
}
bufferedReader.close();
bufferedWriter.close();
}
}
BufferedInputStream\BufferedOutputStream复制二进制文件
public class BufferedCopy02_ {
public static void main(String[] args) throws IOException {
int date = 0;
byte[] buf = new byte[1080];//每次读取1080个字节
String srcFilePath = "e:\\copy.png";//初始路径
String destFilePath = "d:\\copy.png";//复制后路径
BufferedInputStream bufferedReader =
new BufferedInputStream(new FileInputStream(srcFilePath));//使用BufferedInputStream创建对象
BufferedOutputStream bufferedOutputStream =
new BufferedOutputStream(new FileOutputStream(destFilePath));//使用BufferedInputStream创建对象
while ((date = bufferedReader.read(buf)) != -1){//循环取出字节，当bufferedReader.read(buf) = -1时表示取出完毕
bufferedOutputStream.write(buf,0,date);
}
//关闭流
bufferedOutputStream.close();
bufferedReader.close();
}
}对象处理流
ObjectOutputStream 序列化保存
//演示ObjectOutputStream的使用，完成数据的序列化
public class ObjectOutputStream_ {
public static void main(String[] args) throws IOException {
//序列化后，保存的文本格式不是纯文本，而是按照他的格式来保存
String filePath = "e:\\data.dat";
ObjectOutputStream objectOutputStream =
new ObjectOutputStream(new FileOutputStream(filePath));
//序列化数据到指定位置
objectOutputStream.writeInt(100);//int-->Integer(实现了Serializable)
objectOutputStream.writeBoolean(true);//boolean->Boolean(实现了Serializable)
objectOutputStream.writeChar('a');//char -Character
objectOutputStream.writeDouble(0.5);//double Double
objectOutputStream.writeUTF("是是是");//String
objectOutputStream.writeObject(new Dog("旺财",10));
objectOutputStream.close();
System.out.println("数据保存完毕(以序列化形式)");
}
}
class Dog implements Serializable {
private String name;
private int age;
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
}
这些类都实现了Serializable接口，如下图。所有我们要把 Dog类也实现下。
看下保存的文件
出现乱码很正常，因为这个文件不是存文本的。
ObjectInputStream 反序列化
//演示ObjectOutputStream的使用，完成数据的序列化
public class ObjectOutputStream_ {
public static void main(String[] args) throws IOException {
//序列化后，保存的文本格式不是纯文本，而是按照他的格式来保存
String filePath = "e:\\data.dat";
ObjectOutputStream objectOutputStream =
new ObjectOutputStream(new FileOutputStream(filePath));
//序列化数据到指定位置
objectOutputStream.writeInt(100);//int-->Integer(实现了Serializable)
objectOutputStream.writeBoolean(true);//boolean->Boolean(实现了Serializable)
objectOutputStream.writeChar('a');//char -Character
objectOutputStream.writeDouble(0.5);//double Double
objectOutputStream.writeUTF("是是是");//String
objectOutputStream.writeObject(new Dog("旺财",10));
objectOutputStream.close();
System.out.println("数据保存完毕(以序列化形式)");
}
}
反序列化成功 如果要重写toString方法，记得要再序列化一次再反序列化。要不然会抛出异常。
可以理解成dog的存储内容也变了。
3.
加了这句话后如果对Dog类进行修改，程序就不会认为你是个全新的类，会认为只是版本号的修改
标准输入输出流
public static void main(String[] args) {
//System 类的 public final static InputSteam in = null；
//System.in 编译类型 InputStream
//System,in 运行类型 BufferedInputStream
//代表标准输入 键盘
System.out.println(System.in.getClass());
//System.in 编译类型 printStream
//System,in 运行类型 printStream
//代表标准输出 显示器
System.out.println(System.out.getClass());
//用法
System.out.println("hello");
Scanner scanner = new Scanner(System.in);
String next = scanner.next();
System.out.println(next);
}结点和处理流
读取文件如下
public class CodeQuestion {
public static void main(String[] args) throws IOException {
//读取文件
//思路 使用BufferedReader对象读取文件
//默认条件下是按照 utf-8 编码
String filePath = "e:\\hello.txt";
BufferedReader bufferedReader =
new BufferedReader(new FileReader(filePath));
String s = bufferedReader.readLine();
System.out.println(s);
bufferedReader.close();
}
}没有任何问题，但这是读取编码为UTF-8的文件，我们把文件格式换一个读取试试
出现了乱码，结点和处理流就是用来防止乱码的，出现这个问题的根本原因是没有指定这个文件的编码方式。
ImputStreamReader
//用InputStreamReader 解决中文乱码问题
//将字节流 FileStreamReader 转成字符流 InputStreamReader
public class InputStreamReader_ {
public static void main(String[] args) throws IOException {
String filePath ="e:\\hello.txt";
// FileStreamReader 转成字符流 InputStreamReader 将InputStreamReader 转成 BufferedReader指定编码为gdk
BufferedReader br =
new BufferedReader(new InputStreamReader(new FileInputStream(filePath),"gbk"));
String len = br.readLine();
System.out.println(len);
}
}OutputStreamWriter
打印流printStream和printWriter
字节打印流printStream
public class PrentStream {
public static void main(String[] args) throws IOException {
PrintStream out = System.out;
out.println("sdads");//在标准情况下，PrintStream输出数据位置是 标准输出 （显示器）
//因为Print底层用的是write 使用可以直接调用write进行打印
out.write("sdasfasd".getBytes());
//修改打印流输出的位置或设备
System.setOut(new PrintStream("e:\\t1.txt"));
System.out.println("hello zzz");
out.close();
}
}
字符打印流printWriter
public class PrintWriter_ {
public static void main(String[] args) throws IOException {
PrintWriter printWriter = new PrintWriter(//FileWriter(System.in)就是默认输出位置
new FileWriter("e:\\t1.txt"));
printWriter.println("hhhhhh,您好");
printWriter.close();
}
}Properties类
//使用Properties来读取对象
public class Properties1 {
public static void main(String[] args) throws IOException {
//1。创建Properties对象
Properties properties = new Properties();
//2.指定文件
String filePath = "src\\mysql.properties";
properties.load(new FileReader(filePath));
//3.把键值对显示到控制台
//properties.list(System.out);
//根据k 获取对应的值(读取)
String user = properties.getProperty("user");
System.out.println(user);
//创建（如果该文件没有这个key 是成绩，有这个key就是修改
properties.setProperty("charset","utf8");
properties.setProperty("pwd","abc111");
properties.setProperty("name","汤姆");
//将配置文件存储到文件中
properties.store(new FileOutputStream
("src\\mysql.properties"),null);//这里的null代表注释
}
}
849
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
