JavaIO流

2022/8/23 1:55:22

本文主要是介绍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:
序列化版本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类

代表物理盘符中的一个文件或者文件夹
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流的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程