本文列举了javaIO框架的常用API，希望对你有帮助！
一、流的概念
拿计算机中的内存和硬盘来举例，当我们要读取文件时，需要把文件从硬盘拿到内存中来，cpu才能进行读操作，这里"硬盘->内存"就可以看成一条输入流；当我们要写入文件时，需要把内存中写好的文件写到硬盘中去以永久保存，这里"内存->硬盘"就可以看成一条输出流。
二、流的分类
1.按方向分：
①输入流：将<存储设备>中的内容读到<内存>中。
②输出流：将<内存>中的内容写到<存储设备>中。
2.按单位分：
①字节流：以字节为单位，可以读取所有数据。
②字符流：以字符为单位，只能读取文本数据。
3.按功能分：
①节点流：具有实际传输数据的读写功能。
②过滤流：在节点流的基础之上增强功能。
三、字节流API
1.FileInputStream(节点流)
package com.fs.io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Demo01 {
public static void main(String[] args) throws IOException {
FileInputStream fileInputStream = new FileInputStream("E:\\a.txt");//从该文件中读取内容
//读取单个字节
int count = 0;
while ((count=fileInputStream.read())!=-1){
System.out.print((char)count);
}
//数组作为参数,读取数组长度个字节存入数组
byte[] buffer = new byte[1024];
int count = 0;
while ( (count = fileInputStream.read(buffer))!=-1){
System.out.print(new String(buffer,0,count));
}
//关闭输入流
fileInputStream.close();
}
}
//两种读取结果是一样的
2.FileOutputStream(节点流)
package com.fs.io;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo02 {
public static void main(String[] args) throws IOException {
FileOutputStream fileOutputStream = new FileOutputStream("E://b.txt",true);//将写数据到该文件中，true表示在文件之后追加内容
String s = "hello,world!";
fileOutputStream.write(s.getBytes());//参数是字节数组
//关闭输出流
fileOutputStream.close();
}
}
3.用FileInputStream和FileOutPutStream实现文件复制
package com.fs.io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* @author kiddo
* 文件复制
*/
//文件的复制本质就是先用输入流读取数据，再用输出流写出数据。
public class Demo03 {
public static void main(String[] args) throws IOException {
FileInputStream fileInputStream = new FileInputStream("E:\\pct1.jpg");//被复制的文件
FileOutputStream fileOutputStream = new FileOutputStream("E:\\pct2.jpg");//输出的文件
byte[] buffer = new byte[1024];
int count = 0;
while ((count=fileInputStream.read(buffer))!=-1){
fileOutputStream.write(buffer,0,count);
}
//关闭资源的顺序与创建顺序相反
fileInputStream.close();
fileOutputStream.close();
}
}
注意：图片、.mp3、.mp4等二进制文件只能用字节流复制，如果用字符流复制文件会乱码、损坏文件。因为字符流读取文件时是按几个字节读，读后再对照编码表转成字符，这时已经出现了错误。
4.BufferedInputStream(过滤流)
package com.fs.io;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
//即字节输入缓冲流，先将数据读取到缓冲区中，再从缓冲区读取数据，减少了直接IO的次数
public class Demo04 {
public static void main(String[] args) throws IOException {
FileInputStream fileInputStream = new FileInputStream("E:\\a.txt");
BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
int count = 0;
while((count=bufferedInputStream.read())!=-1){
System.out.print((char)count);
}
//关闭过滤流即可
bufferedInputStream.close();
}
}
5.BufferedOutputStream(过滤流)
package com.fs.io;
import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
//即字节输出缓冲流，现将数据写入到缓冲区，写完后直接把缓冲区的内容刷新到存储设备中，减少了直接IO的次数
public class Demo05 {
public static void main(String[] args) throws IOException {
FileOutputStream fileOutputStream = new FileOutputStream("E://b.txt",true);
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
String str = "~hey~";
bufferedOutputStream.write(str.getBytes());
//关闭过滤流即可
bufferedOutputStream.close();//close()会执行flush(),才会把缓冲区内容写到存储设备中去，否则无效
}
}
6.序列化ObjectOutputStream(过滤流)
package com.fs.io;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
/**
* @author kiddo
* 序列化
*/
//可以将对象存储到存储设备中去 前提：对象所属类必须实现Serializable接口(标记此类是可序列化的，即可IO)
public class Demo06 {
public static void main(String[] args) throws IOException {
FileOutputStream fileOutputStream = new FileOutputStream("E:\\stu.bin");
ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
Student s1 = new Student("张三", 20);
Student s2 = new Student("李四", 22);
List<Student> list = new ArrayList<>();
list.add(s1);
list.add(s2);
objectOutputStream.writeObject(list);
System.out.println("序列化完毕");
objectOutputStream.close();
}
}
package com.fs.io;
import java.io.Serializable;
//Student类
public class Student implements Serializable {
private static final long serialVersionUID = 1868632624580L;
private String name;
private transient int age;//+transient后该属性无法序列化
public Student(String name, int age) {
this.name = name;
this.age = age;
}
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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
7.反序列化ObjectOutputStream(过滤流)
package com.fs.io;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
//反序列化即与序列化相反的操作,从存储设备中读取对象
public class Demo07 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
FileInputStream fileInputStream = new FileInputStream("E:\\stu.bin");
ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
List<Student> list = (List<Student>) objectInputStream.readObject();
System.out.println(list);
objectInputStream.close();
}
}
四、字符流API
1.FileReader(节点流)
package com.fs.io;
/**
* @author kiddo
* 字符输入流
*/
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class Demo08 {
public static void main(String[] args) throws IOException {
FileReader fileReader = new FileReader("E:\\c.txt");
int count = 0;
//方法1.读取单个字符
while ((count=fileReader.read())!=-1){
System.out.println((char)count);
}
//方法2.读取尽可能多个字符存入数组
char[] buffer = new char[1024];
while ((count=fileReader.read(buffer))!=-1){
System.out.println(new String(buffer,0,count));
}
fileReader.close();
}
}
2.FileWriter
package com.fs.io;
import java.io.FileWriter;
import java.io.IOException;
public class Demo09 {
public static void main(String[] args) throws IOException {
FileWriter fileWriter = new FileWriter("E:\\d.txt");
fileWriter.write("中国人民真争气!");//写字符串
String str = "实现中国梦";
fileWriter.write(str.toCharArray());//写字符数组
fileWriter.close();
System.out.println("写入完毕");
}
}
3.使用FileReader和FileWriter(字节流也可以)复制文本文件
package com.fs.io;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
* @author kiddo
* 字符输入流、输出流复制文本文件
*/
public class Demo10 {
public static void main(String[] args) throws IOException {
FileReader fileReader = new FileReader("E:\\c.txt");//文本文件
FileWriter fileWriter = new FileWriter("E:\\f.txt");
int count = 0;
while ((count=fileReader.read())!=-1){
fileWriter.write(count);
}
fileReader.close();
fileWriter.close();
System.out.println("复制完毕");
}
}
4.BufferedReader(过滤流)
package com.fs.io;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
//字符输入缓冲流，效果类似BufferedInputStream，只是读取单位不同
public class Demo11 {
public static void main(String[] args) throws IOException {
FileReader fileReader = new FileReader("E:\\f.txt");
BufferedReader bufferedReader = new BufferedReader(fileReader);
int count = 0;
char[] chars = new char[1024];
String str = null;
while ((str=bufferedReader.readLine())!=null){//readLine()读取一行
System.out.println(str);
//System.out.println(new String(chars,0,count));
}
bufferedReader.close();
}
}
5.BufferedWriter(过滤流)
package com.fs.io;
/**
* @author kiddo
* 字符缓冲输出流,效果类似BufferedOutputStream，只是读取单位不同
*/
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class Demo12 {
public static void main(String[] args) throws IOException {
FileWriter fileWriter = new FileWriter("E:\\f.txt");
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
for (int i = 0; i < 5; i++) {
bufferedWriter.write("好好学习，天天向上!");
bufferedWriter.newLine();//自动填充换行符
}
bufferedWriter.close();
System.out.println("写入完毕");
}
}
5.InputStreamReader:字节流到字符流的桥梁(过滤流)
package com.fs.io;
import java.io.*;
public class Demo13 {
public static void main(String[] args) throws IOException {
FileInputStream fileInputStream = new FileInputStream("E:\\e.txt");
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"UTF-8");//可指定编码方式
int count = 0;
char[] chars = new char[1024];
while ((count=inputStreamReader.read(chars))!=-1){
//System.out.println(count);
System.out.println(new String(chars,0,count));
//System.out.print((char)count);
}
inputStreamReader.close();
}
}
6.OutputStreamWriter:字符流到字节流的桥梁
package com.fs.io;
import java.io.*;
public class Demo14 {
public static void main(String[] args) throws IOException {
FileOutputStream fileOutputStream = new FileOutputStream("E:\\c.txt",true);
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream,"utf-8");//可指定编码方式
for (int i = 0; i < 10; i++) {
outputStreamWriter.write("java是一门面向对象的编程语言\r\n");
}
outputStreamWriter.close();
System.out.println("写入完毕");
}
}
7.PrintWriter(将对象的格式表示打印到文本输出流。)
package com.fs.io;
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.io.PrintWriter;
//可将数据原样写入到文件中
public class Demo15 {
public static void main(String[] args) throws FileNotFoundException {
PrintWriter printStream = new PrintWriter("E:\\printWriter.txt");
printStream.printf("%.2f",3.1415926);
printStream.println("hello");
printStream.print("h^_^");
printStream.close();
}
}
五、File类(文件和目录路径名的抽象表示)
1、文件
package com.fs.io;
import java.io.File;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
public class Demo16 {
public static void main(String[] args) throws IOException, InterruptedException {
File file = new File("file.txt");
// System.out.println(file.list());
System.out.println("文件是否存在"+file.exists());
System.out.println("文件是否创建成功?"+file.createNewFile());
System.out.println("删除文件是否成功"+file.delete());
// file.deleteOnExit();//文件在JVM退出时删除
// System.out.println("文件是否存在"+file.exists());
// System.out.println("文件的创建路径是"+file.getPath());
// System.out.println("文件的绝对路径为"+file.getAbsolutePath());
// System.out.println("文件的父目录是"+file.getParent());
// System.out.println("文件名为"+file.getName());
//TimeUnit.SECONDS.sleep(3);
}
}
2.文件夹
package com.fs.io;
import java.io.File;
import java.io.FileFilter;
public class Demo17 {
public static void main(String[] args) {
File file = new File("D:\\T");
if (!file.exists()){
System.out.println("是否创建成功"+file.mkdirs());//创建多级目录
}
System.out.println(file.getPath());
System.out.println(file.getParent());
System.out.println(file.getName());
//用lambda表达式遍历该目录下的文本文件
File[] files = file.listFiles((fileName) -> {
if(fileName.getName().endsWith(".txt"))
return true;
return false;
});
for (File f:files) {
System.out.println(f.getName());
}
}
}
递归删除含有文件的文件夹(注意：只有空文件夹才能直接删除)
package com.fs.io;
import java.io.File;
public class Demo18 {
public static void main(String[] args) {
File file = new File("E:\\a");//删除a目录
delete(file);
}
public static void delete(File file) {
if (file.exists() && file.isDirectory() && file.list().length>0) {
//非空文件夹
for (File f:file.listFiles()) {
delete(f);
}
}else {
//空文件夹/文件
System.out.println(file.getPath()+"删除了");
file.delete();
return;
}
System.out.println(file.getPath()+"删除了");
file.delete();
}
}
![Java小案例——随机数猜测随机数猜测[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)