20200318Java学习笔记：IO
I/O
JAVA 的FILE类，以及常用方法
1.创建文件对象
package file;
import java.io.File;
public class Demo01 {
public static void main(String[] args) {
File file1=new File("C:\\Users\\Princekin Yan\\Desktop\\Java学习笔记");
System.out.println(file1.getAbsolutePath());//输出C:\Users\Princekin Yan\Desktop\Java学习笔记
//以file1作为父目录，创建文件对象
File file2=new File(file1,"HelloWorld.md");
System.out.println(file2.getAbsolutePath());//C:\Users\Princekin Yan\Desktop\Java学习笔记\HelloWorld.md
}
}
2.常用方法
package file;
import java.io.File;
import java.util.Date;
public class Demo01 {
public static void main(String[] args) {
File file1=new File("C:\\Users\\Princekin Yan\\Desktop\\Java学习笔记");
System.out.println(file1.getAbsolutePath());//输出C:\Users\Princekin Yan\Desktop\Java学习笔记
//以file1作为父目录，创建文件对象
File file2=new File(file1,"HelloWorld.md");
System.out.println(file2.getAbsolutePath());//C:\Users\Princekin Yan\Desktop\Java学习笔记\HelloWorld.md
System.out.println("当前文件是：" +file2);
//文件是否存在
System.out.println("判断是否存在："+file2.exists());
//是否是文件夹
System.out.println("判断是否是文件夹："+file2.isDirectory());
//是否是文件（非文件夹）
System.out.println("判断是否是文件："+file2.isFile());
//文件长度
System.out.println("获取文件的长度："+file2.length());
//文件最后修改时间
file2.setLastModified(0);
long time = file2.lastModified();
Date d = new Date(time);
System.out.println("获取文件的最后修改时间："+d);
//设置文件修改时间为1970.1.1 08:00:00
//重命名文件
File file3=new File(file1,"new HelloWorld.md");
file2.renameTo(file3);
}
}
什么是JAVA 的流 STREAM？
1.什么是流
输入流： InputStream
输出流：OutputStream
当不同的介质之间有数据交互的时候，JAVA就使用流来实现。
以内存为参照，进入内存叫输入，也叫读；从内存中出来叫输出，也叫写。
2. 文件的输入流和输出流
package file;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class Demo02 {
public static void main(String[] args) {
try {
File file=new File("C:\\Users\\Princekin Yan\\Desktop\\Java学习笔记");
//创建基于文件的输入流，通过这个输入流，就可以把数据从硬盘，读取到Java的虚拟机中来，也就是读取到内存中
FileInputStream fileInputStream=new FileInputStream(file);
} catch (IOException e) {
e.printStackTrace();
}
}
}
package file;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo02 {
public static void main(String[] args) {
try {
File file=new File("C:\\Users\\Princekin Yan\\Desktop\\Java学习笔记");
//创建基于文件的输出流用于写文件
FileOutputStream fileInputStream= new FileOutputStream(file);
} catch (IOException e) {
e.printStackTrace();
}
}
}
文件字节流
1.ASCII码 概念
所有的数据存放在计算机中都是以数字的形式存放的。 所以字母就需要转换为数字才能够存放。
比如A就对应的数字65，a对应的数字97. 不同的字母和符号对应不同的数字，就是一张码表。
2. 以字节读写数据
一次读取一个字节byte，八个二进制位。字节流所有文件都可以读取。
InputStream是字节输入流，同时也是抽象类，只提供方法声明，不提供方法的具体实现。
FileInputStream 是InputStream子类，以FileInputStream 为例进行文件读取。上
package file;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class Demo03 {
public static void main(String[] args) {
try {
//准备文件test.txt其中的内容是AB，对应的ASCII分别是65 66
File f = new File("C:\\Users\\Princekin Yan\\Desktop\\test.txt");
//创建基于文件的输入流
FileInputStream fis = new FileInputStream(f);
//创建字节数组，其长度就是文件的长度
byte[] all = new byte[(int) f.length()];
//以字节流的形式读取文件所有内容
for(int i=0;i<all.length;i++){
all[i]= (byte) fis.read();//读文件，把文件内容读进数组中
} //也可直接用fis.read(byte[]b),输入流中最多一次将b.length个字节的数据读入数组;
for (byte b : all) {
//打印出来是65 66
System.out.println(b);
}
//每次使用完流，都应该进行关闭
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/*=========================================================================*/
//另一种程序
package file;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class Demo03 {
public static void main(String[] args) {
FileInputStream fis=null;
try {
File f = new File("C:\\Users\\Princekin Yan\\Desktop\\test.txt");
fis = new FileInputStream(f);
byte[] bytes = new byte[(int) f.length()];
int readCound=0;
while ((readCound=fis.read(bytes))!=-1){
//读到几个转换几个
String str=new String(bytes,0,readCound);
System.out.print(str);
//System.out.print(new String(bytes,0,readCound));
}
} catch (IOException e) {
e.printStackTrace();
}
finally {
if(fis!=null) {
try {
fis.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
package file;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo04 {
public static void main(String[] args) {
try {
File f = new File("C:\\Users\\Princekin Yan\\Desktop\\test.txt");
//创建基于文件的输入流
FileOutputStream fos = new FileOutputStream(f);
// 准备长度是2的字节数组，用88,89初始化，其对应的字符分别是X,Y
byte[] all = {88,89};
// 创建基于文件的输出流
fos.write(all);//88,89对应的XY被写入文件,原有内容会被覆盖
//每次使用完流，都应该进行关闭
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
复制文件的程序练习
package IOstream;
import java.io.*;
//字节流复制一个文件
public class Demo01 {
public static void copyFile(String filePath1,String filePath2){
try {
//新建一个文件，只有文件才能调用长度函数，用于定义字节数组的长度
File file=new File(filePath1);
//定义输入流：读取的源文件，和输出流：被写入的文件，用于读入和写入
FileInputStream fileInputStream=new FileInputStream(file);
FileOutputStream fileOutputStream=new FileOutputStream(filePath2);
//定义一个字节数组
byte[]bytes=new byte[(int)file.length()];
int readCount=0;//读到了几位，没有读到的时候返回-1。
while (-1!=(readCount=fileInputStream.read(bytes))){
//fileInputStream.read(bytes)读入的内容存入bytes数组
//bytes数组的内容写入
fileOutputStream.write(bytes);
}
//把写入内存的数据刷到硬盘。
fileOutputStream.flush();
fileOutputStream.close();
fileInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
copyFile("C:\\Users\\Princekin Yan\\Desktop\\test1.txt","C:\\Users\\Princekin Yan\\Desktop\\test2.txt");
}
}
3. 文件字节输出流：FileOutputStream
文件字符流
一次读取一个字符，方便读取普通的文本。不能读取图片、声音、视频，只能读取普通文本文件，txt。
Reader字符输入流，Writer字符输出流，专门用于字符的形式读取和写入数据。
使用字符流读取和写入文件
package IOstream;
//文件字符流
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class Demo02 {
public static void main(String[] args) {
try {
//准备文件test.txt其中的内容是AB
File file = new File("C:\\Users\\Princekin Yan\\Desktop\\test1.txt");
//创建基于文件的输入流
FileReader fis = new FileReader(file);
//创建字符数组，其长度就是文件的长度
char[] all = new char[(int) file.length()];
//以字符流的形式读取文件所有内容
int readCount=0;
while (-1!=(readCount=fis.read(all)))
{
System.out.println(new String(all));
}
//每次使用完流，都应该进行关闭
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
package file;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class Demo04 {
public static void main(String[] args) {
try {
File f = new File("C:\\Users\\Princekin Yan\\Desktop\\test.txt");
FileWriter fos = new FileWriter(f);
// 准备长度是2的字符数组，用X,Y初始化
char[] all ={'X','Y'};
fos.write(all);//XY被写入文件,原有内容会被覆盖
//每次使用完流，都应该进行关闭
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
字符流复制文本内容编程练习：
package IOstream;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
//文件字符输出流复制文件
public class Demo03 {
public static void main(String[] args) {
fileCopy("C:\\Users\\Princekin Yan\\Desktop\\test1.txt","C:\\Users\\Princekin Yan\\Desktop\\test3.txt");
}
public static void fileCopy(String filePath1,String filePath2){
try {
File file=new File(filePath1);
FileReader fileReader=new FileReader(file);
FileWriter fileWriter=new FileWriter(filePath2);
char[]chars=new char[(int)file.length()];
int readCount=0;
while (-1!=(readCount=fileReader.read(chars))){
fileWriter.write(chars,0,readCount);
}
fileWriter.flush();
fileWriter.close();
fileReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
缓冲流：Buffered
文件字节流和文件字符流都是直接发生在硬盘上的IO操作，读写速度由硬盘的速度决定。
缓冲流可以起到加快读写速度的作用。先把数据缓存到内存中，在对内存进行IO操作。缓冲流的使用要建立在一个文件流的基础上。
用缓冲流复制文件的编程练习：
package IOstream;
import java.io.*;
//缓冲字节流复制文件
public class Demo04 {
public static void main(String[] args) {
copyFile("C:\\Users\\Princekin Yan\\Desktop\\test1.txt","C:\\Users\\Princekin Yan\\Desktop\\test4.txt");
}
public static void copyFile(String filePath1,String filePath2){
//建立缓冲输入流,缓冲流要建立在已有流的基础上
File file=new File(filePath1);
try {
FileInputStream fis=new FileInputStream(file);
BufferedInputStream bis=new BufferedInputStream(fis);
//直接通过匿名对象建立缓冲输入流
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(filePath2));
byte[] bytes=new byte[(int)file.length()];
int readCount=0;
while (-1!=(readCount=bis.read(bytes))){
bos.write(bytes,0,readCount);
}
bos.flush();//把缓存刷到内存中
bos.close();
bis.close();
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/*=============================================================================*/
package IOstream;
import java.io.*;
//缓冲字符流的文件复制
public class Demo05 {
public static void main(String[] args) {
try {
BufferedReader bfr=new BufferedReader(new FileReader("C:\\Users\\Princekin Yan\\Desktop\\test1.txt"));
BufferedWriter bfw=new BufferedWriter(new FileWriter("C:\\Users\\Princekin Yan\\Desktop\\test5.txt"));
char[]chars=new char[100];
int readCount=0;
while (-1!=(readCount=bfr.read(chars))){
bfw.write(chars,0,readCount);
}
bfw.flush();
bfw.close();
bfr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
转换流
将字节流转换为字符流
当字节流文件中的内容都是字符流的时候，将它转换为字符流进行读写，效率更高。
在转换过程中要注意编码的一致，否则会出现乱码。
package IOstream;
import java.io.*;
//字节流转换字符流
public class Demo06 {
public static void testInputStreamReader(String filepath) throws Exception{
//建立一个字节输入流
FileInputStream fileInputStream=new FileInputStream(filepath);
//建立转换流，把字节流转换为字符流
//InputStreamReader inputStreamReader=new InputStreamReader(fileInputStream,"UTF-8");//参数1是输入流，参数2是编码方式
//编码不同，中文输出为乱码,文件的编码要与转换流的编码一致
InputStreamReader inputStreamReader=new InputStreamReader(fileInputStream,"GBK");
char[]chars=new char[100];//本来应该定义为文件的长度，这里简化
int readCount=0;
while (-1!=(readCount=inputStreamReader.read(chars))){
System.out.println(new String(chars,0,readCount));
}
}
public static void testOutputStreamWriter(String filepath) throws Exception{
FileOutputStream fileOutputStream=new FileOutputStream(filepath);
OutputStreamWriter outputStreamWriter=new OutputStreamWriter(fileOutputStream,"GBK");
outputStreamWriter.write("星星你好！");//源文件中的内容会被覆盖
outputStreamWriter.flush();
outputStreamWriter.close();
fileOutputStream.close();
}
public static void main(String[] args) {
try {
testInputStreamReader("C:\\Users\\Princekin Yan\\Desktop\\test1.txt");
testOutputStreamWriter("C:\\Users\\Princekin Yan\\Desktop\\test1.txt");
} catch (Exception e) {
e.printStackTrace();
}
}
}
标准输入输出流
对象流
ObjecInputStream和ObjecOutputStream
将对象转换为一个二进制的字节流，保存在电脑的硬盘上或者通过网络进行传送。要使用这个对象，需要把流转换为对象来使用。保存对象到硬盘（对象的持久化）和对象的网络传输，产生了对象的输入与输出流。
对象写入过程称为对象的序列化，对象的恢复过程称为对象的反序列化。序列化和反序列化针对的是对象的属性，不包括类的属性。
随机存储流(了解)
关闭流
所有的流，无论是输入流还是输出流，使用完毕之后，都应该关闭。 如果不关闭，会产生对资源占用的浪费。 当量比较大的时候，会影响到业务的正常开展。
