In/Out: 相对于程序而言的输入(读取)和输出(写出)的过程。
即: 通过java程序到磁盘读取数据的过程, 我们称为In的过程, 也就是读取(输入)
将java程序中的数据写入磁盘的过程, 我们称为Out的过程, 也就是写出(输出)
在Java中,根据处理的数据单位不同,分为字节流和字符流。
字节流: 一个字节(byte)一个字节的去读取, 或者写出
字符流: 一个字符一个字符的去读取, 或者写出
JDK核心类库中提供了IO流相关的类, 这些类都在
程序中数据的读取和写入, 可以想象成水流在管道中流动。
– 流只能单方向流动
– 输入流用来读取in
– 输出流用来写出Out
– 数据只能从头到尾顺序的读取一次或写出一次
节点流和处理流按照流是否直接与特定的地方(如磁盘,内存,设备等)相连,分为节点流和处理流两类
节点流可以从或向一个特定的地方(节点)读写数据
处理流是对一个已存在的流的连接和封装,通过所封装的流的功能调用实现数据读写
处理流特点处理流的构造方法总是要带一个其他的流对象做参数,一个流对象经过其他流的多次包装,成为流的链接.
通常节点流也被称之为低级流.处理流也被称之为高级流或者过滤流
节点流 OutputStream抽象类此抽象类是表示输出字节流的所有类的超类。输出流接受输出字节并将这些字节发送到某个接收器。
FileOutputStream字节输出流直接插在文件上,直接写出文件数据
创建对象:
FileOutputStream(String name) 创建一个向具有指定名称的文件中写入数据的输出文件流。 FileOutputStream(File file) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。 FileOutputStream(File file, boolean append) –追加 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
注意: 以上构造方法中, 如果参数指向的文件以及父目录都不存在, 将会抛出FileNotFoundException异常!
如果参数指向的文件不存在, 但文件的所在目录存在, 将不会抛异常, 程序会自动创建该文件!
FileOutputStream代码案例package Part02IO;
import java.io.*;
public class FOSDemo {
public static void main(String[] args) throws IOException {
// alt + enter + enter
//第一种:
FileOutputStream fos = new FileOutputStream("./fos.dat");
// //第二种:
// File file = new File("./fos.dat");
// FileOutputStream fos1 = new FileOutputStream(file);
//给 fos.dat 写入 00000001
fos.write(1);//写入int的数据 --1
//因为在上面已经为fos.dat写入 00000001 所以继续往后写入的话 会在后面追加
// 00000001 00000010
fos.write(2);
fos.close();//释放 (关闭流体)
}
}
InputStream抽象类
此抽象类是表示字节输入流的所有类的超类/抽象类。
FileInputStream子类直接插在文件上,直接读取文件数据。
创建对象
FileInputStream(File file)
通过打开一个到实际文件的连接来创建一个 FileInputStream,该文件通过文件系统中的 File 对象 file 指定。
FileInputStream(String pathname)
通过打开一个到实际文件的连接来创建一个 FileInputStream,该文件通过文件系统中的路径名 name 指定。
FileInputStream代码案例package Part02IO;
import java.io.FileInputStream;
import java.io.IOException;
public class FISDemo {
public static void main(String[] args) throws IOException {
//创建文件输入流 并指定 要处理的文件路径
FileInputStream fis = new FileInputStream("./fos.dat");
// d :00000000 00000000 00000000 00000001
int d = fis.read();
System.out.println(d);
// d:00000000 00000000 00000000 00000010
d = fis.read();
System.out.println(d);
// d:11111111 11111111 11111111 11111111
d = fis.read(); //文件末尾 -1
System.out.println(d);
fis.close();//需要释放
}
}
复制文件
复制文件代码案例
package Part02IO;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyDemo {
public static void main(String[] args) throws IOException {
//1.输入流
FileInputStream fis = new FileInputStream("./paimeng.jpg");//获取源图片
//2.输出流
FileOutputStream fos = new FileOutputStream("./paimeng_Copy.jpg");//目标图片位置
//如果读到的数据 为 -1 读到文件末尾
//不明确循环次数, 已知循环条件
int d; //alt + enter + enter
while ((d = fis.read()) != -1) { //如果读到的内容不为 -1的话
//获取当前读到的字节内容
fos.write(d);//写入到 目标文件中
}
System.out.println("拷贝完毕!");
fis.close(); //释放
fos.close();//释放
}
}
快读写优化代码案例
package Part02IO;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyDemo2 {
public static void main(String[] args) throws IOException {
//1.输入流
FileInputStream fis = new FileInputStream("./1.pptx");//获取源图片
//2.输出流
FileOutputStream fos = new FileOutputStream("./1_copy.pptx");//目标图片位置
int d;
byte[] data = new byte[1024*10]; //10kb
long start = System.currentTimeMillis();//获取当前系统时间 毫秒单位
while ((d = fis.read(data)) != -1) { //块读
fos.write(data);//块写入
}
long end = System.currentTimeMillis();
System.out.println("拷贝完毕!拷贝时长:"+ (end - start)+"ms");
fis.close();//释放
fos.close();//释放
}
}
写入字符串
package Part02IO;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class WriteStringDemo {
public static void main(String[] args) throws IOException {
//向一个文件名为demo1.txt写入文本数据
//crtl+alt+v 快速生成变量名
FileOutputStream fos = new FileOutputStream("demo1.txt");
String line = "beep,beep,i'm sheep~beep,beep,i'm sheep~";
byte[] data = line.getBytes(StandardCharsets.UTF_8);
fos.write(data);
fos.write("哔,哔,安慕希~哔,哔,安慕希~".getBytes(
StandardCharsets.UTF_8));
System.out.println("写出完毕!!!");
fos.close();
}
}
简易笔记本
package Part02IO;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
public class TestNotes {
public static void main(String[] args) throws IOException {
Scanner scanner = new Scanner(System.in);
System.out.println("请开始输入内容,单独输入exit退出~~");
//绑定要写出的文件是note.txt
FileOutputStream fos = new FileOutputStream("note.txt");
while (true){//一直循环接收用户输入的内容
//接收用户每次在控制台输入的字符串
String line = scanner.nextLine();
//如果输入的内容line是exit,退出程序(退出循环)
//不建议这种写法,因为line作为对象,可能会是null,就会引发空指针
//if (line.equals("exit")){}
//equalsIgnoreCase() 忽略大小写比较字符串
if ("exit".equals(line)){
break;//跳出当前循环
}
//将输入的内容写出到note.txt文件中
fos.write(line.getBytes(StandardCharsets.UTF_8));
}
// String line;
// while (!"exit".equals(line =scanner.nextLine())){
// fos.write(line.getBytes(StandardCharsets.UTF_8));
// }
fos.close();
}
}
文件追加模式案例
package Part02IO;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;
public class TestNotes2 {
public static void main(String[] args) throws Exception {
FileOutputStream fos = new FileOutputStream("fos.txt", true);
String line = "你叉叉,穷哈哈~哈利波特骑着扫帚飞~~~sorry,sorry";
fos.write(line.getBytes(StandardCharsets.UTF_8));
System.out.println("写出完毕");
fos.close();
}
}
处理流
缓冲流
- BufferedOutputStream缓冲输出流
- BufferedInputStream 缓冲输入流
package Part02IO;
import java.io.*;
public class CopyDemo3 {
public static void main(String[] args) throws Exception {
//创建一个文件字节输入流(低级流)
FileInputStream fis = new FileInputStream("1.pptx");
//创建一个缓冲字节输入流(高级流) 加快读取效率
BufferedInputStream bis = new BufferedInputStream(fis);
//创建一个文件字节输出流(低级流)
FileOutputStream fos = new FileOutputStream("1_copy2.pptx");
//创建一个缓冲字节输出流(高级流) 加快写出效率
BufferedOutputStream bos = new BufferedOutputStream(fos);
int d;
long start = System.currentTimeMillis();
//此处需要使用高级流对象bis获取内容
while ((d = bis.read())!=-1){
//此处需要使用高级流对象bos写入内容
bos.write(d);
}
long end = System.currentTimeMillis();
System.out.println("耗时:"+(end-start)+"ms");
//释放流资源 关闭流的顺序随意,而且只需要关闭高级流即可,会自动关闭连接的流
bis.close();
bos.close();
}
}
flush代码案例
package Part02IO;
import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class BOSFlushDemo {
public static void main(String[] args) throws IOException {
FileOutputStream fos = new FileOutputStream("bos.txt");
//缓冲流内部维护了一个8K的字节数组,写出的数据都会先存入到这个数组中,
//只有数组存满时,才会写出
BufferedOutputStream bos = new BufferedOutputStream(fos);
bos.write("听我说谢谢你~因为有你,温暖了四季~~~".getBytes(StandardCharsets.UTF_8));
System.out.println("写出完毕!");
//flush 冲水 方法的作用是让缓冲输出流将其中的缓冲区中已经缓存的数据立即写出
bos.flush();
//bos.close();
}
}
对象流
Person代码
package Part02IO;
import java.io.Serializable;
import java.util.Arrays;
public class Person implements Serializable {
static final long serialVersionUID = 1L;
private String name;//姓名
private int age;//年龄
private String gender;//性别
private transient String[] othreInfo;//其他信息
private int salary;//工资
//生成构造方法
public Person(String name, int age, String gender, String[] othreInfo) {
this.name = name;
this.age = age;
this.gender = gender;
this.othreInfo = othreInfo;
}
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 getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String[] getOthreInfo() {
return othreInfo;
}
public void setOthreInfo(String[] othreInfo) {
this.othreInfo = othreInfo;
}
//生成toString方法
@Override
public String toString() {
return "Person{" +
"name='" + name + ''' +
", age=" + age +
", gender='" + gender + ''' +
", othreInfo=" + Arrays.toString(othreInfo) +
", salary=" + salary +
'}';
}
}
OOSDemo案例
package Part02IO;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class OOSDemo {
public static void main(String[] args) throws IOException {
String name = "巨松";
int age = 18;
String gender = "男";
String[] otherInfo = {"是一个帅哥","来自于太原","爱好不明","广大男性之友"};
Person p = new Person(name, age, gender, otherInfo);
System.out.println(p);//p.toString()
FileOutputStream fos = new FileOutputStream("person.obj");
//创建一个对象输出流,也是序列化流,是一个高级流
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(p);
System.out.println("写出完毕!!!");
oos.close();
}
}
OISDemo案例
package Part02IO;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
public class OISDemo {
public static void main(String[] args) throws IOException, ClassNotFoundException {
FileInputStream fis = new FileInputStream("person.obj");
ObjectInputStream ois = new ObjectInputStream(fis);
Person p = (Person)ois.readObject();
System.out.println(p);
ois.close();
}
}
字节流和字符流
在Java中,根据处理的数据单位不同,分为字节流和字符流。
字节流: 一个字节(byte)一个字节的去读取, 或者写出
字符流: 一个字符一个字符的去读取, 或者写出
字节流字节流(stream):针对二进制文件(文本,图片,音频,视频…等)
InputStream(包含input都是输入流)
– FileInputStream
– BufferedInputStream
– ObjectInputStream
OutputStream(包含output都是输出流)
– FileOutputStream
– BufferedOutputStream
– ObjectOutputStream
字符流字符流(Reader,Writer):针对文本文件,读写容易发生乱码现象,在读写时最好指定编码集为utf-8
Reader(Reader结尾的都是字符输入流)
– FileReader
– BufferedReader
– InputStreamReader
Writer(Writer结尾的都是字符输出流)
– FileWriter
– BufferedWriter
– OutputStreamWriter
– PrintWriter/PrintStream
转换字符流 OutputStreamWriter 代码案例package Part02IO;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;
public class OSWDemo {
public static void main(String[] args) throws IOException {
//向文件osw.txt中写入文本数据
//文件字节输出流(低级流)
FileOutputStream fos = new FileOutputStream("osw.txt");
// String line = "我欲成仙,法力无边!";
// byte[] data = line.getBytes(StandardCharsets.UTF_8);
// fos.write(data);
//字节字符转换流(高级流)
//在创建转换流时,通常需要指定第二个参数,明确使用的字符集
OutputStreamWriter osw = new OutputStreamWriter(fos,StandardCharsets.UTF_8);
osw.write("我欲成仙,法力无边!");
osw.write("欲练此功,必先自宫!");
System.out.println("写出完毕!");
osw.close();
}
}
InputStreamReader
代码案例
package Part02IO;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
public class ISRDemo {
public static void main(String[] args) throws IOException {
//将osw.txt中的所有内容读取出来,并输出到控制台
//文件字节输入流(低级流)
FileInputStream fis = new FileInputStream("osw.txt");
//字符转换流(高级流)
//InputStreamReader
InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8);
//读取一个字符,返回的int值是一个char
//但是若返回的是-1,表示读取到了末尾
// int d = isr.read();
// System.out.println((char)d);
int d;
while ((d=isr.read())!=-1){
//println 自带换行 print不带换行
System.out.print((char)d);
}
isr.close();
}
}
缓冲字符流
PrintWriter
代码案例
package Part02IO;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
public class PWDemo {
public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
PrintWriter pw = new PrintWriter("./pw.txt","UTF-8");
pw.println("上课重点是听,不要写注释!");
pw.println("如果你是快男,那当我没说!");
System.out.println("写出完毕");
pw.close();
}
}
代码案例2
package Part02IO;
import java.io.*;
import java.util.Scanner;
public class PWDemo2 {
public static void main(String[] args) throws FileNotFoundException {
//文件字节输出流(低级流),向文件中写入字节数据
FileOutputStream fos = new FileOutputStream("pw2.txt",true);
//转换输出流(高级流,且是一个字符流),1.衔接字符与字节流 2.将写出的字符转换成字节
OutputStreamWriter osw = new OutputStreamWriter(fos);
//缓冲字符输出流(高级流),快读写加快效率
BufferedWriter bw = new BufferedWriter(osw);
PrintWriter pw = new PrintWriter(bw,true);
//完成简易的记事本,控制台输入的每行字符串都按行写入文件,输入exit时,退出
Scanner scanner = new Scanner(System.in);
while (true){
String line = scanner.nextLine();
//当输入的内容是exit时,不论大小写,就跳出循环
if ("exit".equalsIgnoreCase(line)){
break;
}
pw.println(line);
}
pw.close();
}
}



