java之IO流
File类
package file.io;
import java.io.File;
/**
* @author
* 文件和目录路径名的抽象表示形式，与平台无关
* 能新建、删除、重命名文件和目录，但不能访问文件内容本身
* 常见构造方法
* public File(String pathname)
* 通过将给定的路径名字符串转换为抽象路径名来创建新的File实例。
* public File(String parent,String child)
* 从父路径名字符串和子路径名字符串创建新的File实例。
*
* 注意在java只能两个\\才是\的意思
*/
public class MyFile {
public static void main(String[] args) {
//括号里面要写路径，而且要注意斜杠,这个是对象file就是测试一号.txt文件
File file = new File("E:\\javaIO测试\\测试一号.txt");
// 这个file1也是测试一号.txt文件，这种了解就行
// File file1 = new File("E:\\","javaIO测试\\测试一号.txt");
// 也可以用File.separator作为文件分隔符，没有盘符的是相对路径
File file2 = new File(File.separator+"javaIO测试");
// 获取文件名或获取目录（文件夹）
System.out.println(file.getName());
System.out.println(file2.getName());
// 获取当前路径或文件夹的路径,是绝对路径就获取绝对路径
System.out.println(file2.getPath());
// 获取当前文件的绝对路径
System.out.println(file2.getAbsolutePath());
// 返回一个用当前文件的绝对路径构建的对象 ，相当于new File(this. getAbsolutePath ) 。
System.out.println(file2);
System.out.println(file2.getAbsoluteFile());
// 返回当前文件夹或文件的父级路径（就是上一级）
System.out.println(file.getParent());
// 给文件或文件夹重命名
file.renameTo(new File("E:\\javaIO测试\\测试一号.txt"));
File f6 = new File("E:\\javaIO测试\\测试一号.txt");
// 判断文件或文件夹是否存在
System.out.println(f6.exists());
// 判断文件是否可写
System.out.println(f6.canWrite());
// 判断文件是否可读
System.out.println(f6.canRead());
// 判断当前f6对象是否是文件
System.out.println(f6.isFile());
// 判断当前f6对象是否是目录或文件夹
System.out.println(f6.isDirectory());
// 获取文件的最后修改数据，返回的是毫秒
System.out.println(f6.lastModified());
// 返回文件的长度，单位是字节
System.out.println(f6.length());
File f2 = new File("E:\\javaIO测试");
System.out.println(f2.exists());//判断文件是否存在
// if (!f2.exists()){}//会有异常，需要捕获
// try {
// f2.createNewFile();//创建一个文件
// } catch (IOException e) {
// e.printStackTrace();
// }
// 删除文件
f2.delete();
File f3 = new File("E:\\javaIO测试\\aa");
// 创建单层目录，如果用这个方法要创建多级目录那么就要重复多次这个方法
f3.mkdir();
File f4 = new File("E:\\javaIO测试\\bb\\v\\");
// 直接创建多级目录
f4.mkdirs();
String[] list = f2.list();//返回当前文件夹的子集的名字，包括目录和文件
for (String s : list){
System.out.println(s);
}
// 返回的是数组
File[] files = f2.listFiles();//返回当前文件夹的子集的对象，包括目录和文件
for (File g :files){
System.out.println(g);
}
File f5 = new File("E:\\javaIO测试");
new MyFile().test(f5);
}
/**
* 递归遍历文件
*/
public void test(File f5) {
if (f5.isFile()) {
System.out.println(f5.getAbsolutePath() + "文件");
} else {
System.out.println(f5.getAbsolutePath() + "文件夹");
//是文件夹那么里面还有可能有文件或文件夹
File[] files = f5.listFiles();//获取当前文件夹下的子文件夹或文件的对象
if (files != null && files.length > 0) {
for (File h : files) {
test(h);
}
}
}
} }
所有文件都有编码格式
txt和java文件一般有三种编码
西欧编码是纯粹英文的，不适用中文
GBK和UTF-8是中文和英文都适用
IO与IO流体系
Input|Output java的输入和输出系统
**方向：**输入：如果数据进入内存，使用输入流
输出：如果数据有内存往外走，使用的输出流
单位：
字节流：每次读写一个字节
字符流：每次读写一个字符
功能：
**节点流：**建立起应用程序和数据源之间的连接
**处理流：**在节点流的基础上工作，加快读写的速度，提高读写的安全性
处理流之外的功能
| IO流体系 | ||||
|---|---|---|---|---|
| 分类 | 字符输入流 | 字节输出流 | 字符输入流 | 字符输出流 |
| 抽象基类 | InputStream | OutputStream | Reader | Writer |
| 访问文件 | FileInputStream | FileOutputStream | FileReader | FileWriter |
| 访问数组 | ByteArrayInputStream | ByteArrayOutputStream | CharArrayReader | CharArrayWriter |
| 访问管道 | PipedInputStream | PipedOutputStream | PipedReader | PipedWriter |
| 访问字符串 | StringReader | StringWriter | ||
| 缓冲流 | BufferedInputStream | BufferedOutputStream | BufferedReader | BufferedWriter |
| 转换流 | InputStreamReader | OutputStreamWriter | ||
| 对象流 | ObjectInputStream | ObjectOutputStream | ||
| FilterInputStream | FilterOutputStream | FilterReader | FilterWriter | |
| 打印流 | PrintStream | PrintWriter | ||
| 推回输入流 | PushbackInputStream | PushbackReader | ||
| 特殊流 | DataInputStream | DataOutputStream |
文件流
都是计算机与硬盘之间发生的io操作，读写相对较慢（基于硬盘）
字节输入流（InputStream）
package file.io;
import java.io.FileInputStream;
/**
* @author
*/
public class MyTset {
public static void main(String[] args) {
try {
FileInputStream f = new FileInputStream("E:\\javaIO测试\\测试一号.txt");//创建要访问的文件,然后要捕获异常
byte[] b = new byte[10];//因为是字节，使用要设置一个数组来接收
f.read(b);//读取内容,这个方法会有一个返回值，返回值是读取数据的长度，如果读取到最后一个，那么还会往后读取一位，也就是说返回值为-1时，读取结束
System.out.println(new String(b));//打印内容
f.close();//注意，流使用完毕后一定要关闭
} catch (Exception e) {
e.printStackTrace();
}
}
}
字节输出流（OutputStream）
package file.io;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
/**
* @author
* OutputStream:这个抽象类是表示字节输出流的所有类的超类
* 成员方法：
* public void close()关闭此输出流并释放与此流相关联的任何系统资源。
* public void flush()刷新此输出流并强制任何缓冲的输出字节被写出。
* public void write(byte[] b,nt off,int len)从指定的字节数组写入len字节，从偏移off开始输出到此输出流。
* public abstract void write(int b)将指定的字节写入此输出流。 write的一般合同是将一个字节写入输出流。
* public void write(byte[] b)将b.length字节从指定的字节数组写入此输出流。
*
* FilterOutputStream：文件字节输出流
* 将内存中的数据写入到硬盘文件中
*
* 构造方法：
* FileOutputStream(File file)目的地是一个文件
* 创建文件输出流以写入由指定的 File对象表示的文件。
* FileOutputStream(String name)目的地是一个文件的路径
* 创建文件输出流以指定的名称写入文件。
*
*
* 作用：会根据路径创建一个空文件
* 流会占用空间，所以使用结束要清空
*
* UTF-8是三个字节为一个中文
* */
public class MyTest1 {
public static void main(String[] args) {
try {
// 创建对象
FileOutputStream f = new FileOutputStream("E:\\javaIO测试\\a.txt");
// 调用write方法，写入数据
f.write(97);//把存进去的数字转成二进制的数字，然后变成ascll表里面的值
// 结束
f.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
class T{
public static void main(String[] args) throws IOException {
// 绑定路径
FileOutputStream f = new FileOutputStream(new File("E:\\javaIO测试\\b.txt"));//一次写多个
f.write(97);
f.write(97);
/*
* 一次写多个字节
* 如果第一个字节是负数，那么第一个字节和第二个字节会组成一个中文显示
* 如果是正数就会查询ASCLL码
*/
byte[] b = {43,45,88,88};
f.write(b);
/*
* 把字节数的一部分写入文件中*/
byte[] b1 = {43,45,88,88};
f.write(b,1,2);//off：从哪一个开始 len:写几个进去
;
/*
* 把字符串转化为字节数组
* */
byte[] s = "妙不可言".getBytes();
System.out.println(Arrays.toString(s));
f.write(s);
f.flush();//将文件写到硬盘
f.close();
}
}
/*
*追加写和续写：
* public FileOutputStream(File file,boolean append)创建文件输出流以写入由指定的File对象表示的文件。
*public FileOutputStream(File file,boolean append)创建文件输出流以指定的名称写入文
*
* File file，File file：路径
* boolean append：ture:创建对象不会覆盖源文件，继续在文件后面追写数据
* false:创建一个新文件，覆盖源文件
*
* 换行
* \r\n
*
* */
class B{
public static void main(String[] args) throws IOException {
FileOutputStream g = new FileOutputStream("E:\\javaIO测试\\c.txt",true);
g.write("干嘛".getBytes());
for (int i = 0; i < 10; i++) {
g.write("干嘛".getBytes());
g.write("\r\n".getBytes());
}
g.close();
}
}
复制
package file.io;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class Testj {
public static void main(String[] args) {
try {
FileInputStream s = new FileInputStream("E:\\javaIO测试\\c.txt");//读取的源文件
FileOutputStream n = new FileOutputStream("E:\\javaIO测试\\aa\\n.txt");//要复制的文件
byte[] b = new byte[100];
s.read(b);
n.write(b,0,100);//写入，参数1是缓冲数组，2是数组开始位置，3是获取数组的长度
n.flush();//把内存的数据刷到硬盘
n.close();
s.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
文件字符输入流
package file.io;
import java.io.FileReader;
/**
* @author
*
*
* */
public class MyRead {
public static void main(String[] args) {
testFileReader("E:\\javaIO测试\\c.txt");
}
public static void testFileReader(String inPant){
try {
FileReader f = new FileReader(inPant);//创建文件字符输入流对象
char[] c =new char[10];//创建临时存放数据的字符数组
int len = 0;//定义一个输入流的读取长度
while ((len = f.read(c)) !=-1){
System.out.println(new String(c,0,len));
}
f.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
文件字符输出流
package file.io;
import java.io.FileWriter;
public class MyWriter {
public static void main(String[] args) {
MyWriter.testFileWriter("E:\\javaIO测试\\a,txt", "好家伙");
}
public static void testFileWriter(String s,String n){
try {
FileWriter f = new FileWriter(s);//创建输出流对象
f.write(n);//写到内存中
f.flush();//刷到内存
f.close();//关闭
} catch (Exception e) {
e.printStackTrace();
}
}
}
注意
- 在写入一个文件时，如果目录下哟哟同名的文件，那么它将被覆盖
- 在读取文件时，必须保证该文件已存在，否则出异常
- 字符流只能操作字符
处理流
缓冲流
基于内存的，是在内存中进行io操作，比基于硬盘的快七万五千多倍
为了提高数据读写效率
对于输出缓冲流，写出的数据会先在内存中缓存，使用flush()方法将会时内存中的数据立刻写出
缓冲字节输入流
package file.io.buffered;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
/**
* @author
*/
public class MyBufferedInput {
public static void main(String[] args) throws Exception {
// 文件字节输入流对象
FileInputStream f = new FileInputStream("E:\\编程\\代码\\IdeaProjects\\javaSE\\基础语法\\src\\file\\io\\buffered\\a.txt");
// 创建缓冲字节输入流对象,把文件字节输入流放到缓冲字节输入流对象中
BufferedInputStream b = new BufferedInputStream(f);
byte[] by = new byte[10];//接收缓冲数组
int len = 0;
while ((len = b.read(by)) != -1){
System.out.println(new String(by,0,len));
}
// 关闭流的时候，要按先开晚关，晚开先关的顺序
b.close();
f.close();
}
}
缓冲字节输出流
package file.io.buffered;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
/**
* @author
*/
public class MyBufferedOutput {
public static void main(String[] args) throws Exception {
// 创建字节输出流对象
FileOutputStream f = new FileOutputStream("E:\\编程\\代码\\IdeaProjects\\javaSE\\基础语法\\src\\file\\io\\buffered\\a1.txt");
// 把字节输出流对象放到缓冲字节输出流对象中
BufferedOutputStream br = new BufferedOutputStream(f);
byte[] s = "好家伙".getBytes();
br.write(s);//写到内存
br.flush();//从内存写入硬盘
br.close();
f.close();
}
}
缓冲实现文件的复制
public static void copy() throws Exception{
FileInputStream f = new FileInputStream("E:\\编程\\代码\\IdeaProjects\\javaSE\\基础语法\\src\\file\\io\\buffered\\a1.txt");
BufferedInputStream f1 = new BufferedInputStream(f);
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("E:\\编程\\代码\\IdeaProjects\\javaSE\\基础语法\\src\\file\\io\\buffered\\a2.txt"));
byte[] bytes = new byte[10];
int len = 0;
while ((len = f1.read(bytes)) != -1){
bufferedOutputStream.write(bytes,0,len);
}
bufferedOutputStream.flush();
bufferedOutputStream.close();
f1.close();
}
flush与close的区别
flush：刷新缓冲区，流对象可以继续使用
close：先刷新缓冲区，然后通知系统释放资源，在它后面的都不能在使用流了
缓冲字符输入流
package file.io.buffered;
import java.io.BufferedReader;
import java.io.FileReader;
/**
* @author
*/
public class MyBuffederReader {
public static void main(String[] args) throws Exception {
FileReader fileReader = new FileReader("E:\\编程\\代码\\IdeaProjects\\javaSE\\基础语法\\src\\file\\io\\buffered\\a.txt");
BufferedReader bufferedReader = new BufferedReader(fileReader);
char[] b = new char[15];
int len = 0;
while ((len = bufferedReader.read(b)) != -1){
System.out.println(new String(b,0,len));
}
bufferedReader.close();
fileReader.close();
}
}
缓冲字符输出流
package file.io.buffered;
import java.io.BufferedWriter;
import java.io.FileWriter;
public class MyBufferedWriter {
public static void main(String[] args) throws Exception {
FileWriter fileWriter = new FileWriter("E:\\编程\\代码\\IdeaProjects\\javaSE\\基础语法\\src\\file\\io\\buffered\\a3.txt");
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
bufferedWriter.write("sgdjagsd");
bufferedWriter.flush();
bufferedWriter.close();
fileWriter.close();
}
}
转换流
字符流和字节流之间的转换
字节流中的内容都是字符时，转换成字符流更高
转换输入流（字节–>字符）
package file.io.streamreader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
/**
* @author
*/
public class MyInputStreamReader {
public static void main(String[] args) throws Exception {
// 创建一个文件输入流
FileInputStream f = new FileInputStream("E:\\编程\\代码\\IdeaProjects\\javaSE\\基础语法\\src\\file\\io\\streamreader\\ttt.txt");
// 把字节流转换为字符流,参数1是字节流，参数2是编码
InputStreamReader ip = new InputStreamReader(f,"UTF-8");//如果编码写错那么就会乱码
// 因为转换为字符流了，所有用char接收
char[] c = new char[1024];
int len = 0;
while ((len = ip.read(c)) != -1){
System.out.println(new String(c,0,len));
}
ip.close();
f.close();
}
public static void test(){
}
}
转换输出流（字节–>字符）
public static void test() throws Exception {
FileOutputStream f12 = new FileOutputStream("E:\\编程\\代码\\IdeaProjects\\javaSE\\基础语法\\src\\file\\io\\streamreader\\ttt1.txt");
OutputStreamWriter out = new OutputStreamWriter(f12,"UTF-8");
out.write("ZMLZMLjhfjdhgud");
out.flush();
out.close();
f12.close();
}
标准输入和输出流
类似键盘输入
package file.io.streamreader;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* @author
*/
public class MySystem {
public static void main(String[] args) throws IOException {
testSystem();
}
private static void testSystem() throws IOException {
// 创建一个接收键盘输入数据的输入流
InputStreamReader in = new InputStreamReader(System.in);
// 把输入流放到缓冲流
BufferedReader bu = new BufferedReader(in);
// 定义一个临时接收数据的字符串
String s = "";
while ( (s = bu.readLine()) != null){
System.out.println(s);
}
bu.close();
in.close();
}
}
把键盘输入的数据存入文档
private static void testSystem() throws IOException {
// 创建一个接收键盘输入数据的输入流
InputStreamReader in = new InputStreamReader(System.in);
// 把输入流放到缓冲流
BufferedReader bu = new BufferedReader(in);
// 定义一个临时接收数据的字符串
String s = "";
while ( (s = bu.readLine()) != null){
System.out.println(s);
}
bu.close();
in.close();
}
使用
package file.io.streamreader;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStreamReader;
/**
* @author
*/
public class test12 {
public static void main(String[] args) throws Exception {
FileReader f = new FileReader("E:\\编程\\代码\\IdeaProjects\\javaSE\\基础语法\\src\\file\\io\\streamreader\\ttt.txt");
BufferedReader bu = new BufferedReader(f);
InputStreamReader in = new InputStreamReader(System.in);
// 把输入流放到缓冲流
BufferedReader b = new BufferedReader(in);
String s = "";
char[] c = new char[1024];
int len = 0;
while ((len = f.read(c)) != -1){
while ((s = b.readLine()) != null){
if (s.equals(new String(c,0,len))){
System.out.println("成功");
}else if (s.equals("over")){
break;
}else {
System.out.println("失败");
}
}
}
b.close();
in.close();
bu.close();
f.close();
}
}
打印流（了解）
数据流
专门用来左基本数据类型的读写的
package file.io.streamreader;
import java.io.*;
/**
* @author
* 用数据输出流写到文件的基本数据类型的数据是乱码，不能直接辨认，需要数据输入流读取
*/
public class MyTest {
public static void main(String[] args) throws Exception {
test();
texs();
}
//数据输出流
private static void test() throws Exception {
DataOutputStream out = new DataOutputStream(new FileOutputStream("E:\\编程\\代码\\IdeaProjects\\javaSE\\基础语法\\src\\file\\io\\streamreader\\ttt2.txt"));
// out.writeBoolean(true);
out.writeDouble(1.354);
out.flush();
out.close();
}
//数据输入流
public static void texs() throws Exception {
DataInputStream out = new DataInputStream(new FileInputStream( "E:\\编程\\代码\\IdeaProjects\\javaSE\\基础语法\\src\\file\\io\\streamreader\\ttt2.txt"));
System.out.println(out.readDouble());//输入流输入用的是什么类型,这里就要用一样的,不然会输出别的东西
out.close();
}
}
对象流
用于存储和读取对象的处理流
可以把Java中的对象写入数据源中，也能把对象从数据源中还原回来
ObjectOutputStream和ObjecInutStream不能序列化static\transient修饰的成员变量
针对的是对象的各种属性，不包括类的属性
对象的序列化与反序列化使用的类要一个一致，包名、类名、类机构等等都要一致
序列化（对象写入io流）
package file.io.object;
import java.io.Serializable;
public class Person implements Serializable {
// 用来表明类的不同版本的兼容性
private static final long serializableUID = 1L;
String name;
int age;
}
package file.io.object;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
public class Test {
public static void main(String[] args) throws Exception {
test();
}
public static void test() throws Exception {
// 定义对象输出流,把对象序列化之后放到指定文件
ObjectOutputStream obj = new ObjectOutputStream(new FileOutputStream("E:\\javaIO测试\\a.txt"));
Person p = new Person();
p.age=15;
p.name="hhh";
// 序列化
obj.writeObject(p);
// 刷到硬盘
obj.flush();
obj.close();
}
}
反序列化（从io流中恢复对象）
// 反序列化
private static void test1() throws Exception {
// 创建对象输入流,从指定的文件中把序列化流读取出来
ObjectInputStream obj = new ObjectInputStream(new FileInputStream("E:\\javaIO测试\\a.txt"));
// 读取
Object o = obj.readObject();
// 强转
Person p=(Person)o;
System.out.println(p.age);
System.out.println(p.name);
}
RandomAccesssFile类
程序可以直接跳到文件的任意地方来读、写内容
package file.io.object;
import java.io.RandomAccessFile;
/**
* @author
*/
public class MyRandom {
public static void main(String[] args) throws Exception {
a();
b();
}
//随机写
// 如果从开头或中间写就会覆盖掉等长度的原内容
private static void b() throws Exception {
RandomAccessFile r = new RandomAccessFile("E:\\javaIO测试\\b.txt","rw");
//设置写的位置
r.seek(5);
// r.seek(r.length());//代表从文件结尾继续写,就是追加
r.write("你ss好".getBytes());
r.close();
}
//随机读取
private static void a() throws Exception {
// 参数1,路径 参数2 模式
/*
* r:只读
* rw:读取和写入
* rwd:读取和写入,同步文件内容更新
* rws:读取和写入,同步文件内容和源数据的更新
* */
RandomAccessFile r = new RandomAccessFile("E:\\javaIO测试\\b.txt","r");
// 设置读取文件的内容的起始点
r.seek(5);
byte[] b = new byte[1024];
int len = 0;
while ((len = r.read(b)) != -1){
System.out.println(new String(b,0,len));
}
r.close();
}
}
浙公网安备 33010602011771号