首页 > 编程语言> 文章详细

JavaIO流

2022-08-22 03:30:08 阅读：128 来源： 互联网

标签：java System JavaIO new println import out

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类

代表物理盘符中的一个文件或者文件夹
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());

}
}

七、总结

标签：java,System,JavaIO,new,println,import,out
来源： https://www.cnblogs.com/ChenAiNan/p/16611598.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

JavaIO流

JavaIO流

一、流的概念

二、流的分类

按方向：

按单位：

按功能：

三、字节流

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

2、文件字节流

FileInputStream

FileOutputStream

FileInputStream的使用

FileOutputStream的使用

3、字节流复制文件

4、字节缓冲流

BufferedInputStream

BufferedOutputStream

3、对象流

序列化

反序列化

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

四、编码方式

五、字符流

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

2、文件字符流（子类）

FileReader

FileWriter

3、字符流的文件复制

4、字符缓冲流

BufferReader

BufferedWriter

5、打印流

6、转换流

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

OutputStreamWriter

六、File类

1、文件的操作

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

3、案例

递归遍历文件夹

递归删除文件夹

4、properties

七、总结