本文主要是介绍JavaIO流，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

JavaIO流

一、流的概念

内存与存储设备之间传输数据的通道。例如在内存中的程序，想要读取硬盘中的文件，必须借助流；在水库中的水流入家庭中（存储设备到内存）

二、流的分类

按方向：

输入流：将存储设备中的内容读入到内存中
输出流：将内存中的内容写入到存储设备中
流入程序的时输入流，流出程序的是输出流

按单位：

字节流：以字节为单位，可以读写所有数据
字符流：以字符为单位，只能读写文本数据

按功能：

节点流：具有实际传输数据的读写功能
过滤流：在节点流的基础之上增强功能

三、字节流

1、字节流的父类（抽象类）

InputStream 字节输入流（读）
OutputStream 字节输出流（写）

2、文件字节流

FileInputStream

public int read(byte[] b) 从流中读取多个字节，将督导的内容存在b数组，返回实际读到的字节数；如果达到文件的1尾部，则返回-1

FileOutputStream

一次写多个字节，将b数组中所有字节，写入输出流

FileInputStream的使用

package com.an;


import java.io.FileInputStream;
import java.util.*;

public class TestHelloWorld {
public static void main(String[] args) throws Exception{
   //创建FileInputStram,并指明文件路径
    FileInputStream fis = new FileInputStream("d:\\aaa.txt");//此处有异常，就将异常抛出
    //读取文件路径，先提前创建好文件，并在文件输入内容abc
    //fis.read();第一种方法，单个字节读取
    //要将全部字节读出，先建一个循环
    int data=0;
    while((data=fis.read())!=-1){
        System.out.println((char) data);//不想读出来是哈希码，就要进行强转换
    }
    //第二种方法，一次读取多个字节，前提要先创建一个数组
    byte[] by=new byte[3];
    int count=fis.read(by);
    System.out.println(new String(by));
    System.out.println("个数为："+count);
    //第三种方法是数组有起点和长度
    System.out.println(new String(by,0,count));
    //关闭
    fis.close();
    System.out.println("执行完毕");
}


}
第二种和第三种方法换成此处代码会更有效率
byte[] by=new byte[3];
 int count=0;
    while((count=fis.read())!=-1){
            System.out.println(new String(by,o,3));
            }

FileOutputStream的使用

package com.an;


import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.*;

public class TestHelloWorld {
public static void main(String[] args) throws Exception{
   //创建FileOutputStream,并输出流对象
    FileOutputStream fis = new FileOutputStream("d:\\aaa.txt",true);//如果在此处写true，那它会写入文件末尾
    //写入文件
    fis.write(1);
    fis.write(3);
    String string="Hello";
    fis.write(string.getBytes());
    //关闭
    fis.close();
    System.out.println("执行完毕");
}


}

3、字节流复制文件

一边读，一边写就是复制的过程

4、字节缓冲流

缓冲流：BufferedInputStream和BufferedOutputStream
特点：
提供IO效率，减少访问磁盘的次数
数据存储在缓冲区中，flush是将缓冲区的内容写入文件，也可以直接close

BufferedInputStream

package com.an;


import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.*;

public class TestHelloWorld {
public static void main(String[] args) throws Exception{
   //创建FileIntputStream,并输出流对象,然后在创建BufferedInputStream
    FileInputStream fis = new FileInputStream("d:\\aaa.txt");
    BufferedInputStream dis = new BufferedInputStream(fis);//实例化
    //读取，缓冲流中的字节
    int data=0;
    while((data=dis.read())!=-1){
        System.out.println((char)data);
    }
    //也可以自己创建一个缓冲区
    byte[] gis = new byte[10];
    int count=0;
    while((count=dis.read(gis))!=0){
        System.out.println(new String(gis,0,count));
    }

    //关闭缓冲流
    dis.close();
    System.out.println("执行完毕");
}


}

BufferedOutputStream

package com.an;


import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.niocharset.             StandardCharsets;
import java.util.*;

public class TestHelloWorld {
public static void main(String[] args) throws Exception{
   //创建FileOutputStream,并输出流对象,然后在创建BufferedOutputStream
    FileOutputStream fis = new FileOutputStream("d:\\aaa.txt");
    BufferedOutputStream dis = new BufferedOutputStream(fis);
    //写入文件
    for(int i=0;i<10;i++){
        dis.write("HelloWorld".getBytes());//这行写入了缓冲区，没写入文件中
        dis.flush();//刷新到硬盘，写入文件
    }
    //关闭缓冲流，这里会调用flush方法，在上面调用的话会防止数据丢失
    dis.close();
    System.out.println("执行完毕");
}


}

3、对象流

ObjectOutputStream/ObjectInputStream
使用流传输对象的过程称为序列化和反序列化
特点：
增强了缓冲区功能
增强了读写8终基本数据类型和字符串功能
增强了读写对象的可能：readObject()从流中读取一个对象；writeObject(Object obj) 向流中写入一个对象

序列化

把对象转换为字节序列的过程称为对象的序列化。
要想序列化学生类要先继承接口Serializable

package com.an;


import java.io.*;
import java.nio.charset.            StandardCharsets;
import java.util.*;

public class TestHelloWorld  Throws Exception{
public static void main(String[] args) throws Exception{
   //创建FileOutputStream,并输出流对象,然后在创建对象流
    FileOutputStream fis = new FileOutputStream("d:\\aaa.txt");
    ObjectOutputStream dis = new ObjectOutputStream(fis);
    //序列化，写入操作
    Student s=new Student("张三",22);
    dis.writeObject(dis);
    /**Student s1=(Student).dis.ReadObject("李四",23);
    ArrayList<student> list = new ArrayList<>();
    list.add(zhangsan);//如果有多个对象，可以用集合的方式写入文件
    list.add(lisi);
    dis.WritwObject(list);*/
    //关闭
    dis.close();
    System.out.println("执行完毕");
}


}

反序列化

把字节序列恢复为对象的过程称为对象的反序列化
package com.an;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.*;

public class TestHelloWorld {
public static void main(String[] args) throws Exception{
   //创建FileInputStream,并输出流对象,然后在创建对象流
    FileInputStream fis = new FileInputStream("d:\\aaa.txt");
    ObjectInputStream dis = new ObjectInputStream(fis);
    //反序列化，读操作
    Student s=(Student).dis.ReadObject();
    /**ArrayList<Student> list=(ArrayList<Student>)dis.readObject();
    System.out.println(list.toString());//遇见读多个对象时，可以用集合的方式*、
    //关闭
    dis.close();
    System.out.println("执行完毕");
    System.out.println(s.toString());
}


}

序列化与反序列化注意事项

序列化版本ID：

• 序列化类必须要实现Serializable接口
• 序列化类中对象属性要求实现Serializable
• 序列化版本ID，保证序列化的类和反序列化的类是同一个类
• 使用transient(瞬间的，不持久)修饰属性，这个属性不能序列化
• 静态属性不能序列化
• 序列化多个对象时，可以借助集合实现

四、编码方式

编码方式和解码方式不一致时，会产生乱码
UTF—8读取文件时，一个汉字三个字节

五、字符流

1、字符流的父类(抽象类)

Reader:字符输入流
Writer:字符输出流

2、文件字符流（子类）

FileReader:
public int read(char[] c) 从流中读取多个字符，将读到内容存入C数组，返回实际读到的字符数；如果达到文件尾部，则返回-1
FileWriter:
public void write(String str) 一次写入多个字符，将b数组中所有字符，写入输出流

FileReader

package com.an;


import com.sun.org.apache.xpath.    internal.operations.String;

import java.io.*;
import java.nio.charset.    StandardCharsets;
import java.util.*;

public class TestHelloWorld {
public static void main(String[] args) throws Exception{
   //创建FileReader,文件字符输入流
    FileReader fis = new FileReader("d:\\aaa.txt");
    //读取
    //第一种方法单个字符读取
    int data=0;
    while((data= fis.read())!=-1){//读取一个字符=三个字节
        System.out.println((char)data);
    }
    //第二种方法创建一个字符缓冲区
    char[] dis = new char[1024];
    int count=0;
    while((count=fis.read(dis))!=-1){
        System.out.println(new String(dis,0,count));
    }
    //关闭
    fis.close();
    dis.close();//有数组时只需关闭数组的即可
    System.out.println("执行完毕");
    System.out.println(s.toString());
}


}

FileWriter

package com.an;


import com.sun.org.apache.xpath.    internal.operations.String;

import java.io.*;
import java.nio.charset.    StandardCharsets;
import java.util.*;

public class TestHelloWorld {
public static void main(String[] args) throws Exception{
   //创建FileWriter,文件字符输入流
    FileWriter fis = new FileWriter("d:\\aaa.txt");
    //写入
    for(int i=0;i<10;i++){
        fis.write("java是最好的语言\r\n");//\r\n表示换行
        fis.flush();
    }
    //关闭
    fis.close();
    System.out.println("执行完毕");
    
}


}

3、字符流的文件复制

使用FileReader和FileWriter复制文本文件，不能复制图片或者二进制图片

package com.an;


import com.sun.org.apache.xpath.    internal.operations.String;

import java.io.*;
import java.nio.charset.    StandardCharsets;
import java.util.*;

public class TestHelloWorld {
public static void main(String[] args) throws Exception{
   //创建文件字符输入流或者输出流
    FileWriter fis = new FileWriter("d:\\aaa.txt");
    FileReader dis = new FileReader("d:\\bbb.txt");
    //一边读，一边写
    int data=0;
    while((data=dis.read())!=-1){
        fis.write(data);
        fis.flush();
    }

    //关闭
    fis.close();
    dis.close();
    System.out.println("复制完毕");

}


}

4、字符缓冲流

BufferedReader/BufferWriter
特点：
高效读写
支持输入换行符
可一次写一行、读一行

BufferReader

package com.an;


import com.sun.org.apache.xpath.    internal.operations.String;

import java.io.*;
import java.nio.charset.    StandardCharsets;
import java.util.*;

public class TestHelloWorld {
public static void main(String[] args) throws Exception{
   //创建缓冲流
    FileReader dis = new FileReader("d:\\bbb.txt");
    BufferedReader fis = new BufferedReader(dis);
    //读取
    //第一种方式
    char[] s = new char[1024];
    int data=0;
    while((data=fis.read(s))!=-1){
        System.out.println(new String(s,0,data));
    }
    //第二种方式，一行一行读
    String Line=null;
    while((Line=fis.readLine()!=null)){
        System.out.println(Line);
    }
    //关闭
    fis.close();
    System.out.println("复制完毕");

}


}

BufferedWriter

package com.an;


import com.sun.org.apache.xpath.internal.operations.String;

import java.io.*;
import java.nio.charset.    StandardCharsets;
import java.util.*;

public class TestHelloWorld {
public static void main(String[] args) throws Exception{
   //创建缓冲流
    FileWriter dis = new FileWriter("d:\\bbb.txt");
    BufferedWriter fis = new BufferedWriter(dis);
    //写入
    //第一种方式
    for(int i=0;i<10;i++){
        fis.write("你好");
        fis.newLine();//换行符 windows用\r\n   linux用\n
        fis.flush();
    }
    //关闭
    fis.close();
    System.out.println("执行完毕");

}


}

5、打印流

PrintWriter:
封装了Print()/Println()方法
支持数据原样打印

package com.an;


import com.sun.org.apache.xpath.    internal.operations.String;

import java.io.*;
import java.nio.charset.        StandardCharsets;
import java.util.*;

public class TestHelloWorld {
public static void main(String[] args) throws Exception{
   //创建打印流
    PrintWriter pr = new PrintWriter("d:\\aaa.txt");
    //打印
    pr.print(3);
    //关闭
    pr.close();
    System.out.println("执行完毕");

}


}

6、转换流

桥转换流：InputStreamReader/OutputStreamWriter
特点：
可将字节流转换成字符流
可设置字符的编码方式

InputStreamReader(可以指定使用的编码)

package com.an;

import com.sun.org.apache.xpath.internal.operations.String;

import java.io.;
import java.nio.charset.StandardCharsets;
import java.util.;

public class TestHelloWorld {
public static void main(String[] args) throws Exception{
//创建InputStreamReader对象
FileInputStream fis = new FileInputStream("d:\aaa.txt");
InputStreamReader dis = new InputStreamReader(fis,"UTF-8");//这里要和文件的编码一样
//读取文件
int data=0;
while((data=dis.read())!=0){
System.out.println((char)data);
}
//关闭
dis.close();
System.out.println("执行完毕");

}


}

OutputStreamWriter

写入文件，使用指定的编码
package com.an;

import com.sun.org.apache.xpath.    internal.operations.String;

import java.io.*;
import java.nio.charset.    StandardCharsets;
import java.util.*;

public class TestHelloWorld {
public static void main(String[] args) throws Exception{
   //创建OutputStreamReader对象
    FileOutputStream fis = new FileOutputStream("d:\\aaa.txt");
    OutputStreamWriter dis = new OutputStreamWriter(fis,"UTF-8");//这里要和文件的编码一样
    //写入文件
    for(int i=0;i<10;i++){
        dis.write("你好");
        dis.flush();
    }
    //关闭
    dis.close();
    System.out.println("执行完毕");

}


}

六、File类

代表物理盘符中的一个文件或者文件夹

1、文件的操作

File类的使用：
分隔符
文件操作
文件夹操作
package com.an;

import com.sun.org.apache.xpath.    internal.operations.String;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.*;

public class TestHelloWorld  {
public static void main(String[] args) throws Exception{
    separator();
    fileOpe();
    directoryOpe();
}
//分隔符
public static void separator(){
    System.out.println("路径分隔符：" +File.pathSeparator);//路径分隔符为;，参考环境变量
    System.out.println("名称分隔符："+File.separator);//名称分隔符为\，参考文件路径
}
//文件操作
public static void fileOpe() throws Exception {
    //创建文件：首先要创建一个对象，并填入路径
    File fi = new File("d:\\aaa.txt");
    System.out.println(fi.toString());//然后在主方法调用fileOpe()，运行结果为d:\\aaa.txt
    //此时已经创建好对象，但在文件夹中实际没有这个文件，所以要有判断这个文件是否存在的操作
    if(!fi.exists()) {
        boolean b = fi.createNewFile();
        System.out.println("创建结果：" + b);
    }//存在文件为true，返回值false，则创建文件
    //删除文件，方法一
    System.out.println("删除结果："+fi.delete());//返回值为true或者false
    //删除文件，方法二：使用jvm删除
    fi.deleteOnExit();
    Thread.sleep(5000);//休眠5000后自动删除
    //获取文件信息
    System.out.println("获取绝对路径:"+fi.getAbsolutePath());
    System.out.println("获取路径："+fi.getPath());//代码中写什么路径，就是什么
    System.out.println("获取名称："+fi.getName());
    System.out.println("获取父目录："+fi.getParent());
    System.out.println("获取文件长度："+fi.length());
    System.out.println("文件创建时间"+new Date(fi.lastModified()));
    //判断
    System.out.println("文件是否可读"+fi.canRead());
    System.out.println("文件是否是隐藏"+fi.isHidden());
    System.out.println("是否是文件"+fi.isFile());
}

public static void directoryOpe() throws Exception{
    //创建文件夹
    File di = new File("d:\\aaa\\bbb");
    System.out.println(di.toString());//此处在main（）里调用directoryOpe()
    if(!di.exists()){
        System.out.println("创建结果为"+ di.mkdir());//只能创建单级目录
        System.out.println("创建结果为"+di.mkdirs());//可以创建多级目录
    }
    //删除文件，方法一:直接删除，只能删除最低级的目录，且只能删除空目录
    System.out.println("删除结果："+di.delete());//返回值为true或者false
    //删除文件，方法二：使用jvm删除与直接删除一样
    di.deleteOnExit();
    Thread.sleep(5000);//休眠5000后自动删除
    //获取文件信息
    System.out.println("获取绝对路径:"+di.getAbsolutePath());
    System.out.println("获取路径："+di.getPath());//代码中写什么路径，就是什么
    System.out.println("获取名称："+di.getName());//只能获取最低级目录的名称
    System.out.println("获取父目录："+di.getParent());//结果为d:\aaa
    System.out.println("获取文件长度："+di.length());
    System.out.println("文件创建时间"+new Date(di.lastModified()));
    //判断
    System.out.println("文件夹是否是隐藏"+di.isHidden());
    System.out.println("是否是文件夹"+di.isDirectory());
    //遍历文件夹，遍历一个文件夹bbb中的图片
    File pi = new File("d:\\aaa\\bbb");
    String[] files=pi.list();//获取当前的文件，返回值是一串数组
    for(String string:files){//遍历一下
        System.out.println(string);
    }

}


}

2、FileFilter接口（文件过滤器）

public interface FileFilter
boolean accept(File pathname)

当调用File类中的listFiles()方法时，支持传入FileFilter接口接口实现类，对获取文件进行过滤，只有满足条件的文件才可以出现在listFiles()的返回值中

//获得bbb文件里jpg格式的图片
    File pi = new File("d:\\aaa\\bbb");
    Files[] files2=pi.listFiles(new FileFilter() {
        @Override
        public boolean accept(File pathname) {
            if (pathname.getname().endsWith(".jpg"))
                return true;//符合jpg格式的返回true，否则为false
        }
        return false;
    }
    });
    for(File file:files2){
    System.out.println(file.getName());//遍历写出jpg图片名称

}

3、案例

递归遍历文件夹

package com.an;


import com.sun.org.apache.xpath.internal.operations.String;

import java.io.*;
import java.nio.charset.    StandardCharsets;
import java.nio.file.Files;
import java.util.*;

public class TestHelloWorld  {
public static void main(String[] args) {
   //一个文件夹myfiles里有两个文件和两个文件夹，文件夹里又有文件，要将myfiles里的文件全部显示出来
    listDir(new File("d:\\myfiles"));//调用该方法将myfiles传给listDir()方法

}

public static void listDir(File dir) {
    File[] files = dir.listFiles();//调用dir里的listFiles()方法，返回值是一个File数组
    System.out.println(dir.getAbsoluteFile());
    if(files!=null$$files.length>0){
        for (File file : files) {//file是myfiles文件夹里的所有文件
            if(file.isDirectory()){//如果file是文件夹的话再次调用该方法，实现递归
                listDir(file);
            }else{
                System.out.println(file.getAbsoluteFile());//不是文件夹获取路径
            }
        }
    }

}


}

递归删除文件夹

package com.an;


import com.sun.org.apache.xpath.internal.operations.String;

import java.io.*;
import java.nio.charset.    StandardCharsets;
import java.nio.file.Files;
import java.util.*;

public class TestHelloWorld  {
public static void main(String[] args) {
   //一个文件夹myfiles里有两个文件和两个文件夹，文件夹里又有文件，要将myfiles里的文件全部显示出来
    //想要删除myfiles文件夹，必须从最低级的那一级文件开始删除
    deleteDir(new File("d:\\myfiles"));//调用该方法将myfiles传给listDir()方法

}

public static void deleteDir(File dir) {
    File[] files = dir.listFiles();//调用dir里的listFiles()方法，返回值是一个File数组
    System.out.println(dir.getAbsoluteFile());
    if(files!=null$$files.length>0){
        for (File file : files) {//file是myfiles文件夹里的所有文件
            if(file.isDirectory()){//如果file是文件夹的话再次调用该方法，实现递归
                deleteDir(file);
            }else{
                System.out.println(file.getAbsoluteFile()+"删除"+delete());//删除文件
            }
        }
    }
    System.out.println(dir.getAbsoluteFile()+"删除"+dir.delete());//把所有子文件删除后，最后要将myfiles文件删除

}


}

4、properties

是一个属性集合
特点：

• 存储属性名和属性值

• 属性名和属性值都是字符串类型

• 没有泛型（是一种参数化类型，数据类型被指定为一个参数，也就是不确定的数据类型）

• 和流有关

  package com.an;

  import com.sun.org.apache.xpath.internal.operations.String;

  import java.io.;
  import java.nio.charset. StandardCharsets;
  import java.nio.file.Files;
  import java.util.;

  public class TestHelloWorld {
  public static void main(String[] args) {
  //创建一个集合
  Properties properties = new Properties();
  //添加数据
  properties.setProperty("username","张三");
  properties.setProperty("age","22");
  System.out.println(properties.toString());
  //遍历：keyset、entrySet、StringPropertiesNames()
  Set<java.lang.String> pronames = properties.stringPropertyNames();
  for (java.lang.String pro : pronames) {
  System.out.println(pro+"----"+properties.getProperty());
  }
  //和流有关的方法
  PrintWriter pw=new PrintWriter("d:\:print.txt");
  properties.list(pw);//将集合里的内容存入txt文件
  pw.close();
  //store()方法 保存
  FileOutputStream fos = new FileOutputStream("d:\print.properties");
  properties.store(fos,"注释");
  fos.close();
  //load() 加载
  Properties properties2 = new Properties();
  FileInputStream hi = new FileInputStream("d:\aaa.txt");
  properties2.load(hi);
  hi.close();
  System.out.println(properties2.toString());

  }
  }

七、总结

这篇关于JavaIO流的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！