精华内容
下载资源
问答
  • 2021-03-09 01:20:04

    一、Filewriter与File——-将字符串写入文本文件

    public static void main(String[] args) {

    File f=new File("C:\\world.txt");//新建一个文件对象,如果不存在则创建一个该文件

    FileWriter fw;

    try {

    fw=new FileWriter(f);

    String str="hello world";

    fw.write(str);//将字符串写入到指定的路径下的文件中

    fw.close();

    } catch (IOException e) { e.printStackTrace(); }

    }

    二、InputStream与OutputStream 输入与输出串流

    public static void main(String args[]){

    File f= new File("C:\\world.txt") ;

    InputStream input = null ;

    // 准备好一个输入的对象

    try {

    input = new FileInputStream(f) ;

    byte b[] = new byte[1024] ;

    // 所有的内容都读到此数组之中

    input.read(b) ;

    // 读取内容 网络编程中 read 方法会阻塞

    input.close() ;

    System.out.println("内容为:" + new String(b)) ;

    }

    public static void main(String args[]){

    File f= new File("C:\\world.txt") ;

    // 声明File对象

    OutputStream out = null ;

    // 准备好一个输出的对象

    out = new FileOutputStream(f) ;

    // 通过对象多态性,进行实例化

    String str = "Hello World!!!" ;

    // 准备一个字符串

    byte b[] = str.getBytes() ;

    // 只能输出byte数组,所以将字符串变为byte数组

    out.write(b) ;

    // 将内容输出,

    out.close() ;

    }

    三、ObjectOutputStream与ObjectInputStream

    ObjectOutputStream将Java对象的基本数据类型和图形写入OutputStream。可以使用ObjectInputStream读取(重构)对象。通过在流中使用文件可以实现对象的持久存储。

    将序列化的对象写入文件

    1、将序列化的对象写入文件

    FileOutputStreamfileStream=newFileOutputStream(“Myobject.ser”);//不存在则自动创建

    2、创建ObjectOutputStream

    ObjectOutputStreamos=newObjectOutputStream(fileStream);

    3、写入对象

    os.writeObject(one);//one是一个对象实例的引用名

    4、关闭ObjectOutputStream

    os.close

    ObjectInputStream用于解序列化

    解序列化

    1、创建FileInputStream

    FileInputStreamfileStream=newFileInputStream(“MyObject.ser”);

    2、创建ObjectInputStream

    ObjectInputStreamos=newObjectInputStream(fileStream);

    3、读取对象

    Objectone=os.readObject();

    4、转换对象类型

    Modelelf=(Model)one;//Model是one对象的类名称

    5、关闭ObjectInputStream

    os.close();

    总结

    以上就是本文关于Java将字符串写入文本文件代码示例的全部内容,希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题,如有不足之处,欢迎留言指出。感谢朋友们对本站的支持

    更多相关内容
  • Java.IO 字符流读写文件

    千次阅读 2020-08-17 08:30:00
    点击上方IT牧场,选择置顶或者星标技术干货每日送达!一、序上一篇我们谈了 java.IO 文件字节读写操作(能懂系列Java.io文件字节读写)大家应该都很熟悉了。但是中文和英...

    点击上方 IT牧场 ,选择 置顶或者星标

    技术干货每日送达!

    一、序

    上一篇我们谈了 java.IO 文件字节流读写操作(能懂系列Java.io文件字节流读写)大家应该都很熟悉了。但是中文和英文在字符编码上存在一定性的差异,因为最开始使用的 ASCII编码表 的 256 个字符并没有支持中文,中文编码系统大多数采用的是 GBK 和 UTF-8 。

    在 GBK 编码表中,一个中文字符占用两个字节,UTF-8 中占用了 3 个字节,如果我们采用字节读写的方式读写中文字符就会出现中文编程乱码的情况, 我们都知道 Java 这么风靡很大部分还是因为他的跨平台性,但如果连语言都没有搞定那还怎么牛逼起来,所以 java 为了避免这种情况引进了字符的读写操作。

    所以接下来就来我们继续讲讲 Java.IO 文件字符流。

    二、Java文件读写操作的分类

    我们先来复习一下关于文件读写的主要使用类。

    这一次我们关注的是右边的字符流和他下面的分支。

    字节流读写针对的是一个字节,而在字符流读写中,他的对象并不再是一个单字节,他的读写单位将是一个字符,比如说在 GBK 编码系统中,他读写一个中文就是两字节两字节读写,对于 UTF-8 则是三个字节三个字节读写。

    三、字符流操作

    1.字符输入流Writer

    Writer 是一个用于写入字符流的 「抽象类」。子类必须实现的方法仅有 write(char[], int, int)、flush()close()

    它是所有字符输出流的父类。

    以下是Writer类中常用的几个方法:

    //写入一个字符
    void write(int c)
    
    //写入一个字符数组
    void write(char[] cbuf)
    
    //写入字符串
    void write(String str)
    
    //写入字符数组的一部分,从off索引开始,写入len个字符
    void write(char[] cbuf, int off, int len)
    

    但是由于 Writer 是一个抽象类,我们并不能直接的使用他,所以要找出 Writer 的子类。

    在 java 中有一个Writer的直接子类 FileWriter

    FileWriter 中的 write 方法都继承自 Writer 所以我们不必再去研究 FileWriter 中的方法,所以我们要把重心放到 「FileWriter的构造方法」 中。

    FileWriter 的构造方法摘要:

    /*覆盖形式写入,即从文件的开头进行写入*/
    
    //根据给定的 File 对象构造一个 FileWriter 对象。
    FileWriter(File file)   
    
    //根据给定的文件名构造一个 FileWriter 对象。
    FileWriter(String filename)   
    
    /*追加形式的写入
      若传入的append参数是true则进行追加形式的写入,
      即从文件末尾写入*/
    FileWriter(File file, boolean append)
    FileWriter(String filename, boolean append)
    

    它跟字符输入流的区别就是他会对磁盘文件进行操作,所以使用字符输出流的时候要注意有两个必须运行的方法:

    //刷新该缓冲流,即 ,将使用的Wrtier流写入到本地文件中,而不是存于内存中
    void flush()   
    
    //关闭流,并且释放资源,但必须先刷新流         
    void close()            
    

    下面我们就通过代码的演示来学习字符输出流的使用方法:

    import java.io.FileWriter;
    import java.io.IOException;
    
    public class WriterDemo {
     public static void main(String[] args) throws IOException{
      //单参数构造方法,创建一个字符输出流对象,指定数据输出存储的位置
      FileWriter fw = new FileWriter("D:\\JavaStudyCode\\WriterDemo.txt");
    
      //调用void write(int c)方法写入一个字符
      fw.write(100);
      //调用刷新方法,若未刷新文件中不会出现该字符
      fw.flush();
    
      //调用void write(char[] cbuf)方法写入一个字符数组
      char[] cbuf = {'a','b','c','d'};
      fw.write(cbuf);
      fw.flush();
    
      //调用void write(String str)
      fw.write("JavaStudy感谢您的阅读,让我们共同进步");
      fw.flush();
    
      //调用void write(char[] cbuf, int off, int len)方法写入数组的一部分
      fw.write(cbuf,1,3);
      fw.flush();
    
      //关闭流
      fw.close();
     }
    }
    
    import java.io.FileWriter;
    import java.io.IOException;
    
    public class WriterAppendTrueDemo {
     public static void main(String[] args) throws IOException {
      /*双参数构造方法,创建一个字符输出流对象,指定数据输出存储的位置
        把append参数设置为true进行追加形式的写入*/
      FileWriter fw = new FileWriter("D:\\JavaStudyCode\\WriterDemo.txt", true);
    
      /*采用刚刚的例子进行追加写入*/
      //为了演示方便,在这里插入换行符,以区分两次写入
      fw.write("\n\r");
    
      // 调用void write(int c)方法写入一个字符
      fw.write(100);
      fw.write("\n"); // 为了演示方便,在这里插入换行符
      fw.flush(); 
    
      // 调用void write(char[] cbuf)方法写入一个字符数组
      char[] cbuf = { 'a', 'b', 'c', 'd' };
      fw.write(cbuf);
      fw.write("\n"); // 为了演示方便,在这里插入换行符
      fw.flush();
    
      // 调用void write(String str)
    
      fw.write("JavaStudy感谢您的阅读,让我们共同进步");
      fw.write("\n");     // 为了演示方便,在这里插入换行符
      fw.flush();
    
      // 调用void write(char[] cbuf, int off, int len)方法写入数组的一部分
      fw.write(cbuf, 1, 3);
      fw.flush();
    
      //关闭流
      fw.close();
     }
    }
    

    2.字符输入流Reader

    「Reader」是一个用于读取字符流的「抽象类」。子类必须实现的方法只有 read(char[], int, int) 和 close()。

    它是所有字符输入流的父类。

    以下是 Reader 类中常用的几个方法:

    /*返回值用于存放读取结果,如果到达文件末尾,则返回-1*/
    
    //读取单个字符。
    int read()
    
    //将字符读入数组。 
    int read(char[] cbuf)
    
    //将字符读入数组的某一部分。 
    int read(char[] cbuf, int off, int len)
    

    同样的,由于Reader是一个抽象类,我们并不能直接的使用他,所以要找出Reader的子类。

    在java中有一个Reader的直接子类 FileReader, 它的的 read 方法都继承自 Reader ;所以我们不必再去研究 FileReader 中的方法, 只需要把重心放到 FileReader 的构造方法中。

    FileReader 的构造方法摘要:

    //在给定从中读取数据的 File 的情况下创建一个新 FileReader。
    FileReader(File file)
    
    //在给定从中读取数据的文件名的情况下创建一个新 FileReader。
    FileReader(String fileName)
    

    得到了构造方法和读取方法之后,我们就可以对这个类进行使用了,下面给出 FileReader 类的使用代码演示:

    import java.io.FileReader;
    import java.io.IOException;
    
    public class ReaderDemo {
     public static void main(String[] args) throws IOException {
      //创建一个字符输入流对象,绑定数据读取的位置
      //采用刚刚我们进行写入的文件做演示
      FileReader fw = new FileReader("D:\\JavaStudyCode\\WriterDemo.txt");
    
      //用于接收读取到的字符
      int len = 0;
    
      //循环读取到len=-1,即文件末尾
      while((len = fw.read()) != -1)
      {
       //不加强转输出结果是数字,要将他们转换为字符
       System.out.print((char)len);
      }
    
      /*
      我们也能使用字符数组来读取文件,以提高效率
      char[] cbuf = new char[1024];
      while((len = fw.read(cbuf)) != -1)
      {
       System.out.println((char)len);
      }
      */
    
      //关流
      fw.close();
     }
    }
    

    输出的结果和我们刚刚写入的文件的对比:

    干货分享

    最近将个人学习笔记整理成册,使用PDF分享。关注我,回复如下代码,即可获得百度盘地址,无套路领取!

    •001:《Java并发与高并发解决方案》学习笔记;•002:《深入JVM内核——原理、诊断与优化》学习笔记;•003:《Java面试宝典》•004:《Docker开源书》•005:《Kubernetes开源书》•006:《DDD速成(领域驱动设计速成)》•007:全部•008:加技术群讨论

    近期热文

    LinkedBlockingQueue vs ConcurrentLinkedQueue解读Java 8 中为并发而生的 ConcurrentHashMapRedis性能监控指标汇总最全的DevOps工具集合,再也不怕选型了!微服务架构下,解决数据库跨库查询的一些思路聊聊大厂面试官必问的 MySQL 锁机制

    关注我

    喜欢就点个"在看"呗^_^

    展开全文
  • Java字节流与字符流读写文件

    万次阅读 多人点赞 2018-12-11 19:04:04
    Java中文件读写有多种方式,但有一种读写方式可以处理任何场景的文件读写,就是字节的读写。 package com.main.stream; import java.io.File; import java.io.FileInputStream; import java.io....

     

    字节流读写

    Java中文件读写有多种方式,但有一种读写方式可以处理任何场景的文件读写,就是字节流的读写。

    package com.main.stream;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    
    /**
     * 字节流文件读写
     * @author PC
     *
     */
    public class FileRwByByte {
    
    	public static void main(String[] args) throws IOException {
    		// 定义源文件
    		File file = new File("D:\\springboot学习\\34116codes.zip");
    		InputStream fis = new FileInputStream(file);
    		
    		// 获取文件名
    		String fileName = file.getName();
    		
    		// 定义写文件路径
    		String aimPath = "E:\\stream\\" + fileName;
    		OutputStream fos = new FileOutputStream(aimPath);
    		
    		// 定义字节,接收读取到的源文件字节内容
    		int by;
    		while ((by = fis.read()) != -1) {
    			fos.write(by);
    		}
    		
    		fos.flush();
    		fis.close();
    		fos.close();
    	}
    }

    这里按照一个字节一个字节的读取,将读取到的字节写入到新的文件中,达到文件复制粘贴的效果。

    上面程序可以正常执行,但是执行过程中,如果遇到10MB 以上的文件,可能会感觉特别的慢,原因就在于,程序中一个字节一个字节的读取,会增大文件读写的次数。

     

    如何改进,使用字节数组,一次读取多个字节,减少文件读写次数,提交程序执行效率。

    将程序中,按照字节单字节读取的部分,修改为按照字节数组读取。这时,输入流一次读取1024个字节,然后将读取到的字节直接输出写到文件中,大大增加程序的整体效率。

    // 定义字节数组,接收读取到的源文件字节内容
    byte[] bytes = new byte[1024];
    while (fis.read(bytes) != -1) {
    	fos.write(bytes);
    }

    附整段代码

    package com.main.stream;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    
    /**
     * 字节流文件读写
     * @author PC
     *
     */
    public class FileRwByByte {
    
    	public static void main(String[] args) throws IOException {
    		// 定义源文件
    		File file = new File("D:\\springboot学习\\34116codes.zip");
    		InputStream fis = new FileInputStream(file);
    		
    		// 获取文件名
    		String fileName = file.getName();
    		
    		// 定义写文件路径
    		String aimPath = "E:\\stream\\" + fileName;
    		OutputStream fos = new FileOutputStream(aimPath);
    		
    		// 定义字节数组,接收读取到的源文件字节内容
    		byte[] bytes = new byte[1024];
    		while (fis.read(bytes) != -1) {
    			fos.write(bytes);
    		}
    		
    		fos.flush();
    		fis.close();
    		fos.close();
    	}
    }

     

    字符流读写

    上面看了字节流的读写,有单字节的读写和读取字节数组两种方式。同样,字符流的读写也有单字符读写和字符数组两种方式。

    package com.main.stream;
    
    import java.io.File;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.Reader;
    import java.io.Writer;
    
    /**
     * 字符流文件读写
     * @author PC
     *
     */
    public class FileReaderDemo {
    
    	public static void main(String[] args) throws IOException {
    		// 定义源文件
    		File file = new File("E:\\test.txt");
    		Reader reader = new FileReader(file);
    		
    		// 获取文件名
    		String fileName = file.getName();
    		
    		// 定义写文件路径
    		String aimPath = "E:\\stream\\" + fileName;
    		Writer writer = new FileWriter(aimPath);
    		
    		// 定义字符,接收读取到的源文件字符内容
    		int ch;
    		while ((ch = reader.read()) != -1) {
    			writer.write(ch);
    		}
    		
    		writer.flush();
    		writer.close();
    		reader.close();
    	}
    }
    

    同样的原因,单字符读写会稍微慢一点,那么换字符数组读取呢?

    // 定义字符数组,接收读取到的源文件字符内容
    char[] chars = new char[1024];
    while (reader.read(chars) != -1) {
    	writer.write(chars);
    }

    只需要将读写操作方式的按单字符读写修改为按照数组的方式即可。

    附完整代码:

    package com.main.stream;
    
    import java.io.File;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.Reader;
    import java.io.Writer;
    
    /**
     * 字符流文件读写
     * @author PC
     *
     */
    public class FileReaderDemo {
    
    	public static void main(String[] args) throws IOException {
    		// 定义源文件
    		File file = new File("E:\\test.txt");
    		Reader reader = new FileReader(file);
    		
    		// 获取文件名
    		String fileName = file.getName();
    		
    		// 定义写文件路径
    		String aimPath = "E:\\stream\\" + fileName;
    		Writer writer = new FileWriter(aimPath);
    		
    		// 定义字符数组,接收读取到的源文件字符内容
    		char[] chars = new char[1024];
    		while (reader.read(chars) != -1) {
    			writer.write(chars);
    		}
    		
    		writer.flush();
    		writer.close();
    		reader.close();
    	}
    }
    

     

    纯粹防止自己忘记,文章记录。

    展开全文
  • Java基础-3】吃透Java IO:字节流、字符流、缓冲流

    万次阅读 多人点赞 2020-09-23 20:12:33
    什么是Java-IO?字符流和字节流的区别与适用场景是什么?缓冲流到底实现了什么?如何高效地读写文件? 本文用大量的示例图和实例,带你吃透Java IO。

    前言

    有人曾问fastjson的作者(阿里技术专家高铁):“你开发fastjson,没得到什么好处,反而挨了骂背了锅,这种事情你为什么要做呢?”

    高铁答道:“因为热爱本身,就是奖励啊!”

    这个回答顿时触动了我。想想自己,又何尝不是如此。写作是个痛苦的过程,用心写作就更加煎熬,需字字斟酌,反复删改才有所成。然而,当一篇篇精良文章出自己手而呈现眼前时,那些痛苦煎熬就都那么值得。如果这些博文能有幸得大家阅读和认可,就更加是莫大的鼓舞了。技术人的快乐就是可以这么纯粹和简单。

    点波关注不迷路,一键三连好运连连!

    IO流是Java中的一个重要构成部分,也是我们经常打交道的。这篇关于Java IO的博文干货满满,堪称全网前三(请轻喷!)

    下面几个问题(问题还会继续补充),如果你能对答如流,那么恭喜你,IO知识掌握得很好,可以立即关闭文章。反之,你可以在后面得文章中寻找答案。

    1. Java IO流有什么特点?
    2. Java IO流分为几种类型?
    3. 字节流和字符流的关系与区别?
    4. 字符流是否使用了缓冲?
    5. 缓冲流的效率一定高吗?为什么?
    6. 缓冲流体现了Java中的哪种设计模式思想?
    7. 为什么要实现序列化?如何实现序列化?
    8. 序列化数据后,再次修改类文件,读取数据会出问题,如何解决呢?

    1 初识Java IO

    IO,即inout,也就是输入和输出,指应用程序和外部设备之间的数据传递,常见的外部设备包括文件、管道、网络连接。

    Java 中是通过流处理IO 的,那么什么是流

    流(Stream),是一个抽象的概念,是指一连串的数据(字符或字节),是以先进先出的方式发送信息的通道。

    当程序需要读取数据的时候,就会开启一个通向数据源的流,这个数据源可以是文件,内存,或是网络连接。类似的,当程序需要写入数据的时候,就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样。

    一般来说关于流的特性有下面几点:

    1. 先进先出:最先写入输出流的数据最先被输入流读取到。
    2. 顺序存取:可以一个接一个地往流中写入一串字节,读出时也将按写入顺序读取一串字节,不能随机访问中间的数据。(RandomAccessFile除外)
    3. 只读或只写:每个流只能是输入流或输出流的一种,不能同时具备两个功能,输入流只能进行读操作,对输出流只能进行写操作。在一个数据传输通道中,如果既要写入数据,又要读取数据,则要分别提供两个流。

    1.1 IO流分类

    IO流主要的分类方式有以下3种:

    1. 按数据流的方向:输入流、输出流
    2. 按处理数据单位:字节流、字符流
    3. 按功能:节点流、处理流

    在这里插入图片描述

    1、输入流与输出流

    输入与输出是相对于应用程序而言的,比如文件读写,读取文件是输入流,写文件是输出流,这点很容易搞反。

    在这里插入图片描述
    2、字节流与字符流

    字节流和字符流的用法几乎完成全一样,区别在于字节流和字符流所操作的数据单元不同,字节流操作的单元是数据单元是8位的字节,字符流操作的是数据单元为16位的字符。

    为什么要有字符流?

    Java中字符是采用Unicode标准,Unicode 编码中,一个英文字母或一个中文汉字为两个字节。
    在这里插入图片描述
    而在UTF-8编码中,一个中文字符是3个字节。例如下面图中,“云深不知处”5个中文对应的是15个字节:-28-70-111-26-73-79-28-72-115-25-97-91-27-92-124
    在这里插入图片描述

    那么问题来了,如果使用字节流处理中文,如果一次读写一个字符对应的字节数就不会有问题,一旦将一个字符对应的字节分裂开来,就会出现乱码了。为了更方便地处理中文这些字符,Java就推出了字符流。

    字节流和字符流的其他区别:

    1. 字节流一般用来处理图像、视频、音频、PPT、Word等类型的文件。字符流一般用于处理纯文本类型的文件,如TXT文件等,但不能处理图像视频等非文本文件。用一句话说就是:字节流可以处理一切文件,而字符流只能处理纯文本文件。
    2. 字节流本身没有缓冲区,缓冲字节流相对于字节流,效率提升非常高。而字符流本身就带有缓冲区,缓冲字符流相对于字符流效率提升就不是那么大了。详见文末效率对比。

    以写文件为例,我们查看字符流的源码,发现确实有利用到缓冲区:
    在这里插入图片描述
    在这里插入图片描述

    3、节点流和处理流

    节点流:直接操作数据读写的流类,比如FileInputStream

    处理流:对一个已存在的流的链接和封装,通过对数据进行处理为程序提供功能强大、灵活的读写功能,例如BufferedInputStream(缓冲字节流)

    处理流和节点流应用了Java的装饰者设计模式。

    下图就很形象地描绘了节点流和处理流,处理流是对节点流的封装,最终的数据处理还是由节点流完成的。
    在这里插入图片描述
    在诸多处理流中,有一个非常重要,那就是缓冲流

    我们知道,程序与磁盘的交互相对于内存运算是很慢的,容易成为程序的性能瓶颈。减少程序与磁盘的交互,是提升程序效率一种有效手段。缓冲流,就应用这种思路:普通流每次读写一个字节,而缓冲流在内存中设置一个缓存区,缓冲区先存储足够的待操作数据后,再与内存或磁盘进行交互。这样,在总数据量不变的情况下,通过提高每次交互的数据量,减少了交互次数。
    在这里插入图片描述

    联想一下生活中的例子,我们搬砖的时候,一块一块地往车上装肯定是很低效的。我们可以使用一个小推车,先把砖装到小推车上,再把这小推车推到车前,把砖装到车上。这个例子中,小推车可以视为缓冲区,小推车的存在,减少了我们装车次数,从而提高了效率。
    在这里插入图片描述
    需要注意的是,缓冲流效率一定高吗?不一定,某些情形下,缓冲流效率反而更低,具体请见IO流效率对比。

    完整的IO分类图如下:
    在这里插入图片描述

    1.2 案例实操

    接下来,我们看看如何使用Java IO。

    文本读写的例子,也就是文章开头所说的,将“松下问童子,言师采药去。只在此山中,云深不知处。”写入本地文本,然后再从文件读取内容并输出到控制台。

    1、FileInputStream、FileOutputStream(字节流)

    字节流的方式效率较低,不建议使用

    public class IOTest {
    	public static void main(String[] args) throws IOException {
    		File file = new File("D:/test.txt");
    
    		write(file);
    		System.out.println(read(file));
    	}
    
    	public static void write(File file) throws IOException {
    		OutputStream os = new FileOutputStream(file, true);
    
    		// 要写入的字符串
    		String string = "松下问童子,言师采药去。只在此山中,云深不知处。";
    		// 写入文件
    		os.write(string.getBytes());
    		// 关闭流
    		os.close();
    	}
    
    	public static String read(File file) throws IOException {
    		InputStream in = new FileInputStream(file);
    
    		// 一次性取多少个字节
    		byte[] bytes = new byte[1024];
    		// 用来接收读取的字节数组
    		StringBuilder sb = new StringBuilder();
    		// 读取到的字节数组长度,为-1时表示没有数据
    		int length = 0;
    		// 循环取数据
    		while ((length = in.read(bytes)) != -1) {
    			// 将读取的内容转换成字符串
    			sb.append(new String(bytes, 0, length));
    		}
    		// 关闭流
    		in.close();
    
    		return sb.toString();
    	}
    }
    

    2、BufferedInputStream、BufferedOutputStream(缓冲字节流)

    缓冲字节流是为高效率而设计的,真正的读写操作还是靠FileOutputStreamFileInputStream,所以其构造方法入参是这两个类的对象也就不奇怪了。

    public class IOTest {
    
    	public static void write(File file) throws IOException {
    		// 缓冲字节流,提高了效率
    		BufferedOutputStream bis = new BufferedOutputStream(new FileOutputStream(file, true));
    
    		// 要写入的字符串
    		String string = "松下问童子,言师采药去。只在此山中,云深不知处。";
    		// 写入文件
    		bis.write(string.getBytes());
    		// 关闭流
    		bis.close();
    	}
    
    	public static String read(File file) throws IOException {
    		BufferedInputStream fis = new BufferedInputStream(new FileInputStream(file));
    
    		// 一次性取多少个字节
    		byte[] bytes = new byte[1024];
    		// 用来接收读取的字节数组
    		StringBuilder sb = new StringBuilder();
    		// 读取到的字节数组长度,为-1时表示没有数据
    		int length = 0;
    		// 循环取数据
    		while ((length = fis.read(bytes)) != -1) {
    			// 将读取的内容转换成字符串
    			sb.append(new String(bytes, 0, length));
    		}
    		// 关闭流
    		fis.close();
    
    		return sb.toString();
    	}
    }
    

    3、InputStreamReader、OutputStreamWriter(字符流)

    字符流适用于文本文件的读写OutputStreamWriter类其实也是借助FileOutputStream类实现的,故其构造方法是FileOutputStream的对象

    public class IOTest {
    	
    	public static void write(File file) throws IOException {
    		// OutputStreamWriter可以显示指定字符集,否则使用默认字符集
    		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(file, true), "UTF-8");
    
    		// 要写入的字符串
    		String string = "松下问童子,言师采药去。只在此山中,云深不知处。";
    		osw.write(string);
    		osw.close();
    	}
    
    	public static String read(File file) throws IOException {
    		InputStreamReader isr = new InputStreamReader(new FileInputStream(file), "UTF-8");
    		// 字符数组:一次读取多少个字符
    		char[] chars = new char[1024];
    		// 每次读取的字符数组先append到StringBuilder中
    		StringBuilder sb = new StringBuilder();
    		// 读取到的字符数组长度,为-1时表示没有数据
    		int length;
    		// 循环取数据
    		while ((length = isr.read(chars)) != -1) {
    			// 将读取的内容转换成字符串
    			sb.append(chars, 0, length);
    		}
    		// 关闭流
    		isr.close();
    
    		return sb.toString()
    	}
    }
    

    4、字符流便捷类

    Java提供了FileWriterFileReader简化字符流的读写,new FileWriter等同于new OutputStreamWriter(new FileOutputStream(file, true))

    public class IOTest {
    	
    	public static void write(File file) throws IOException {
    		FileWriter fw = new FileWriter(file, true);
    
    		// 要写入的字符串
    		String string = "松下问童子,言师采药去。只在此山中,云深不知处。";
    		fw.write(string);
    		fw.close();
    	}
    
    	public static String read(File file) throws IOException {
    		FileReader fr = new FileReader(file);
    		// 一次性取多少个字节
    		char[] chars = new char[1024];
    		// 用来接收读取的字节数组
    		StringBuilder sb = new StringBuilder();
    		// 读取到的字节数组长度,为-1时表示没有数据
    		int length;
    		// 循环取数据
    		while ((length = fr.read(chars)) != -1) {
    			// 将读取的内容转换成字符串
    			sb.append(chars, 0, length);
    		}
    		// 关闭流
    		fr.close();
    
    		return sb.toString();
    	}
    }
    

    5、BufferedReader、BufferedWriter(字符缓冲流)

    public class IOTest {
    	
    	public static void write(File file) throws IOException {
    		// BufferedWriter fw = new BufferedWriter(new OutputStreamWriter(new
    		// FileOutputStream(file, true), "UTF-8"));
    		// FileWriter可以大幅度简化代码
    		BufferedWriter bw = new BufferedWriter(new FileWriter(file, true));
    
    		// 要写入的字符串
    		String string = "松下问童子,言师采药去。只在此山中,云深不知处。";
    		bw.write(string);
    		bw.close();
    	}
    
    	public static String read(File file) throws IOException {
    		BufferedReader br = new BufferedReader(new FileReader(file));
    		// 用来接收读取的字节数组
    		StringBuilder sb = new StringBuilder();
    
    		// 按行读数据
    		String line;
    		// 循环取数据
    		while ((line = br.readLine()) != null) {
    			// 将读取的内容转换成字符串
    			sb.append(line);
    		}
    		// 关闭流
    		br.close();
    
    		return sb.toString();
    	}
    }
    

    2 IO流对象

    第一节中,我们大致了解了IO,并完成了几个案例,但对IO还缺乏更详细的认知,那么接下来我们就对Java IO细细分解,梳理出完整的知识体系来。

    Java种提供了40多个类,我们只需要详细了解一下其中比较重要的就可以满足日常应用了。

    2.1 File类

    File类是用来操作文件的类,但它不能操作文件中的数据。

    public class File extends Object implements Serializable, Comparable<File>
    

    File类实现了SerializableComparable<File>,说明它是支持序列化和排序的。

    File类的构造方法

    方法名说明
    File(File parent, String child)根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
    File(String pathname)通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
    File(String parent, String child)根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
    File(URI uri)通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例。

    File类的常用方法

    方法说明
    createNewFile()当且仅当不存在具有此抽象路径名指定名称的文件时,不可分地创建一个新的空文件。
    delete()删除此抽象路径名表示的文件或目录。
    exists()测试此抽象路径名表示的文件或目录是否存在。
    getAbsoluteFile()返回此抽象路径名的绝对路径名形式。
    getAbsolutePath()返回此抽象路径名的绝对路径名字符串。
    length()返回由此抽象路径名表示的文件的长度。
    mkdir()创建此抽象路径名指定的目录。

    File类使用实例

    public class FileTest {
    	public static void main(String[] args) throws IOException {
    		File file = new File("C:/Mu/fileTest.txt");
    
    		// 判断文件是否存在
    		if (!file.exists()) {
    			// 不存在则创建
    			file.createNewFile();
    		}
    		System.out.println("文件的绝对路径:" + file.getAbsolutePath());
    		System.out.println("文件的大小:" + file.length());
    
    		// 刪除文件
    		file.delete();
    	}
    }
    

    2.2 字节流

    InputStreamOutputStream是两个抽象类,是字节流的基类,所有具体的字节流实现类都是分别继承了这两个类。

    InputStream为例,它继承了Object,实现了Closeable

    public abstract class InputStream
    extends Object
    implements Closeable
    

    InputStream类有很多的实现子类,下面列举了一些比较常用的:
    在这里插入图片描述
    详细说明一下上图中的类:

    1. InputStreamInputStream是所有字节输入流的抽象基类,前面说过抽象类不能被实例化,实际上是作为模板而存在的,为所有实现类定义了处理输入流的方法。
    2. FileInputSream:文件输入流,一个非常重要的字节输入流,用于对文件进行读取操作。
    3. PipedInputStream:管道字节输入流,能实现多线程间的管道通信。
    4. ByteArrayInputStream:字节数组输入流,从字节数组(byte[])中进行以字节为单位的读取,也就是将资源文件都以字节的形式存入到该类中的字节数组中去。
    5. FilterInputStream:装饰者类,具体的装饰者继承该类,这些类都是处理类,作用是对节点类进行封装,实现一些特殊功能。
    6. DataInputStream:数据输入流,它是用来装饰其它输入流,作用是“允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型”。
    7. BufferedInputStream:缓冲流,对节点流进行装饰,内部会有一个缓存区,用来存放字节,每次都是将缓存区存满然后发送,而不是一个字节或两个字节这样发送,效率更高。
    8. ObjectInputStream:对象输入流,用来提供对基本数据或对象的持久存储。通俗点说,也就是能直接传输对象,通常应用在反序列化中。它也是一种处理流,构造器的入参是一个InputStream的实例对象。

    OutputStream类继承关系图:
    在这里插入图片描述

    OutputStream类继承关系与InputStream类似,需要注意的是PrintStream.

    2.3 字符流

    与字节流类似,字符流也有两个抽象基类,分别是ReaderWriter。其他的字符流实现类都是继承了这两个类。

    Reader为例,它的主要实现子类如下图:
    在这里插入图片描述
    各个类的详细说明:

    1. InputStreamReader:从字节流到字符流的桥梁(InputStreamReader构造器入参是FileInputStream的实例对象),它读取字节并使用指定的字符集将其解码为字符。它使用的字符集可以通过名称指定,也可以显式给定,或者可以接受平台的默认字符集。
    2. BufferedReader:从字符输入流中读取文本,设置一个缓冲区来提高效率。BufferedReader是对InputStreamReader的封装,前者构造器的入参就是后者的一个实例对象。
    3. FileReader:用于读取字符文件的便利类,new FileReader(File file)等同于new InputStreamReader(new FileInputStream(file, true),"UTF-8"),但FileReader不能指定字符编码和默认字节缓冲区大小。
    4. PipedReader :管道字符输入流。实现多线程间的管道通信。
    5. CharArrayReader:从Char数组中读取数据的介质流。
    6. StringReader :从String中读取数据的介质流。

    WriterReader结构类似,方向相反,不再赘述。唯一有区别的是,Writer的子类PrintWriter

    2.4 序列化

    待续…

    3 IO流方法

    3.1 字节流方法

    字节输入流InputStream主要方法:

    • read() :从此输入流中读取一个数据字节。
    • read(byte[] b) :从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
    • read(byte[] b, int off, int len) :从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
    • close():关闭此输入流并释放与该流关联的所有系统资源。

    字节输出流OutputStream主要方法:

    • write(byte[] b) :将 b.length 个字节从指定 byte 数组写入此文件输出流中。
    • write(byte[] b, int off, int len) :将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
    • write(int b) :将指定字节写入此文件输出流。
    • close() :关闭此输入流并释放与该流关联的所有系统资源。

    3.2 字符流方法

    字符输入流Reader主要方法:

    • read():读取单个字符。
    • read(char[] cbuf) :将字符读入数组。
    • read(char[] cbuf, int off, int len) : 将字符读入数组的某一部分。
    • read(CharBuffer target) :试图将字符读入指定的字符缓冲区。
    • flush() :刷新该流的缓冲。
    • close() :关闭此流,但要先刷新它。

    字符输出流Writer主要方法:

    • write(char[] cbuf) :写入字符数组。
    • write(char[] cbuf, int off, int len) :写入字符数组的某一部分。
    • write(int c) :写入单个字符。
    • write(String str) :写入字符串。
    • write(String str, int off, int len) :写入字符串的某一部分。
    • flush() :刷新该流的缓冲。
    • close() :关闭此流,但要先刷新它。

    另外,字符缓冲流还有两个独特的方法:

    • BufferedWriternewLine()写入一个行分隔符。这个方法会自动适配所在系统的行分隔符。
    • BufferedReaderreadLine() :读取一个文本行。

    4 附加内容

    4.1 位、字节、字符

    字节(Byte)是计量单位,表示数据量多少,是计算机信息技术用于计量存储容量的一种计量单位,通常情况下一字节等于八位。

    字符(Character)计算机中使用的字母、数字、字和符号,比如’A’、‘B’、’$’、’&'等。

    一般在英文状态下一个字母或字符占用一个字节,一个汉字用两个字节表示。

    字节与字符:

    • ASCII 码中,一个英文字母(不分大小写)为一个字节,一个中文汉字为两个字节。
    • UTF-8 编码中,一个英文字为一个字节,一个中文为三个字节。
    • Unicode 编码中,一个英文为一个字节,一个中文为两个字节。
    • 符号:英文标点为一个字节,中文标点为两个字节。例如:英文句号 . 占1个字节的大小,中文句号 。占2个字节的大小。
    • UTF-16 编码中,一个英文字母字符或一个汉字字符存储都需要 2 个字节(Unicode 扩展区的一些汉字存储需要 4 个字节)。
    • UTF-32 编码中,世界上任何字符的存储都需要 4 个字节。

    4.2 IO流效率对比

    首先,对比下普通字节流和缓冲字节流的效率:

    public class MyTest {
    	public static void main(String[] args) throws IOException {
    		File file = new File("C:/Mu/test.txt");
    		StringBuilder sb = new StringBuilder();
    
    		for (int i = 0; i < 3000000; i++) {
    			sb.append("abcdefghigklmnopqrstuvwsyz");
    		}
    		byte[] bytes = sb.toString().getBytes();
    
    		long start = System.currentTimeMillis();
    		write(file, bytes);
    		long end = System.currentTimeMillis();
    
    		long start2 = System.currentTimeMillis();
    		bufferedWrite(file, bytes);
    		long end2 = System.currentTimeMillis();
    
    		System.out.println("普通字节流耗时:" + (end - start) + " ms");
    		System.out.println("缓冲字节流耗时:" + (end2 - start2) + " ms");
    
    	}
    
    	// 普通字节流
    	public static void write(File file, byte[] bytes) throws IOException {
    		OutputStream os = new FileOutputStream(file);
    		os.write(bytes);
    		os.close();
    	}
    
    	// 缓冲字节流
    	public static void bufferedWrite(File file, byte[] bytes) throws IOException {
    		BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream(file));
    		bo.write(bytes);
    		bo.close();
    	}
    }
    

    运行结果:

    普通字节流耗时:250 ms
    缓冲字节流耗时:268 ms
    

    这个结果让我大跌眼镜,不是说好缓冲流效率很高么?要知道为什么,只能去源码里找答案了。翻看字节缓冲流的write方法:

    public synchronized void write(byte b[], int off, int len) throws IOException {
        if (len >= buf.length) {
            /* If the request length exceeds the size of the output buffer,
               flush the output buffer and then write the data directly.
               In this way buffered streams will cascade harmlessly. */
            flushBuffer();
            out.write(b, off, len);
            return;
        }
        if (len > buf.length - count) {
            flushBuffer();
        }
        System.arraycopy(b, off, buf, count, len);
        count += len;
    }
    

    注释里说得很明白:如果请求长度超过输出缓冲区的大小,刷新输出缓冲区,然后直接写入数据。这样,缓冲流将无害地级联。

    但是,至于为什么这么设计,我没有想明白,有哪位明白的大佬可以留言指点一下。

    基于上面的情形,要想对比普通字节流和缓冲字节流的效率差距,就要避免直接读写较长的字符串,于是,设计了下面这个对比案例:用字节流和缓冲字节流分别复制文件。

    public class MyTest {
    	public static void main(String[] args) throws IOException {
    		File data = new File("C:/Mu/data.zip");
    		File a = new File("C:/Mu/a.zip");
    		File b = new File("C:/Mu/b.zip");
    
    		StringBuilder sb = new StringBuilder();
    
    		long start = System.currentTimeMillis();
    		copy(data, a);
    		long end = System.currentTimeMillis();
    
    		long start2 = System.currentTimeMillis();
    		bufferedCopy(data, b);
    		long end2 = System.currentTimeMillis();
    
    		System.out.println("普通字节流耗时:" + (end - start) + " ms");
    		System.out.println("缓冲字节流耗时:" + (end2 - start2) + " ms");
    	}
    
    	// 普通字节流
    	public static void copy(File in, File out) throws IOException {
    		// 封装数据源
    		InputStream is = new FileInputStream(in);
    		// 封装目的地
    		OutputStream os = new FileOutputStream(out);
    		
    		int by = 0;
    		while ((by = is.read()) != -1) {
    			os.write(by);
    		}
    		is.close();
    		os.close();
    	}
    
    	// 缓冲字节流
    	public static void bufferedCopy(File in, File out) throws IOException {
    		// 封装数据源
    		BufferedInputStream bi = new BufferedInputStream(new FileInputStream(in));
    		// 封装目的地
    		BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream(out));
    		
    		int by = 0;
    		while ((by = bi.read()) != -1) {
    			bo.write(by);
    		}
    		bo.close();
    		bi.close();
    	}
    }
    

    运行结果:

    普通字节流耗时:184867 ms
    缓冲字节流耗时:752 ms
    

    这次,普通字节流和缓冲字节流的效率差异就很明显了,达到了245倍。

    再看看字符流和缓冲字符流的效率对比:

    public class IOTest {
    	public static void main(String[] args) throws IOException {
    		// 数据准备
    		dataReady();
    
    		File data = new File("C:/Mu/data.txt");
    		File a = new File("C:/Mu/a.txt");
    		File b = new File("C:/Mu/b.txt");
    		File c = new File("C:/Mu/c.txt");
    
    		long start = System.currentTimeMillis();
    		copy(data, a);
    		long end = System.currentTimeMillis();
    
    		long start2 = System.currentTimeMillis();
    		copyChars(data, b);
    		long end2 = System.currentTimeMillis();
    
    		long start3 = System.currentTimeMillis();
    		bufferedCopy(data, c);
    		long end3 = System.currentTimeMillis();
    
    		System.out.println("普通字节流1耗时:" + (end - start) + " ms,文件大小:" + a.length() / 1024 + " kb");
    		System.out.println("普通字节流2耗时:" + (end2 - start2) + " ms,文件大小:" + b.length() / 1024 + " kb");
    		System.out.println("缓冲字节流耗时:" + (end3 - start3) + " ms,文件大小:" + c.length() / 1024 + " kb");
    	}
    
    	// 普通字符流不使用数组
    	public static void copy(File in, File out) throws IOException {
    		Reader reader = new FileReader(in);
    		Writer writer = new FileWriter(out);
    
    		int ch = 0;
    		while ((ch = reader.read()) != -1) {
    			writer.write((char) ch);
    		}
    		reader.close();
    		writer.close();
    	}
    
    	// 普通字符流使用字符流
    	public static void copyChars(File in, File out) throws IOException {
    		Reader reader = new FileReader(in);
    		Writer writer = new FileWriter(out);
    
    		char[] chs = new char[1024];
    		while ((reader.read(chs)) != -1) {
    			writer.write(chs);
    		}
    		reader.close();
    		writer.close();
    	}
    
    	// 缓冲字符流
    	public static void bufferedCopy(File in, File out) throws IOException {
    		BufferedReader br = new BufferedReader(new FileReader(in));
    		BufferedWriter bw = new BufferedWriter(new FileWriter(out));
    
    		String line = null;
    		while ((line = br.readLine()) != null) {
    			bw.write(line);
    			bw.newLine();
    			bw.flush();
    		}
    
    		// 释放资源
    		bw.close();
    		br.close();
    	}
    
    	// 数据准备
    	public static void dataReady() throws IOException {
    		StringBuilder sb = new StringBuilder();
    		for (int i = 0; i < 600000; i++) {
    			sb.append("abcdefghijklmnopqrstuvwxyz");
    		}
    		OutputStream os = new FileOutputStream(new File("C:/Mu/data.txt"));
    		os.write(sb.toString().getBytes());
    
    		os.close();
    		System.out.println("完毕");
    	}
    }
    

    运行结果:

    普通字符流1耗时:1337 ms,文件大小:15234 kb
    普通字符流2耗时:82 ms,文件大小:15235 kb
    缓冲字符流耗时:205 ms,文件大小:15234 kb
    

    测试多次,结果差不多,可见字符缓冲流效率上并没有明显提高,我们更多的是要使用它的readLine()newLine()方法。

    4.3 NIO

    待续…

    展开全文
  • Java实现文件写入——IO

    千次阅读 2021-02-12 14:52:34
    输入输出的重要性:输入和输出功能是Java对程序处理数据能力的提高,Java的形式处理数据。是一组有序的数据序列,根据操作的类型,分为输入和输出。程序从输入读取数据,向输出写入数据。Java是面向...
  • Java字节流与字符流文件操作

    千次阅读 2020-07-21 13:29:34
    目录Java.io知识点梳理File类字节流OutputStream字节流InputStream字符流Writer字符流Reader字节流与字符流的转换(了解)字节流与字符流的区别?两者如何使用? Java.io知识点梳理 如果要进行所有的文件以及文件...
  • 简单实现了通过字节流与字符流两种方式拷贝文件 import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.FileReader; ...
  • java 字符流实现文件读写操作(FileReader-FileWriter) 备注:字符流效率高,但是没有字节流底层 字节流地址:http://pengyan5945.iteye.com/blog/1092120 Java代码 收藏代码 package com.frank.io;   ...
  • 由于字节流操作中文不是特别的方便,所以Java就提供字符流 字符流 = 字节流 + 编码表 中文的字节存储方式 用字节流复制文本文件时,文本文件也会有中文,但是没有问题,原因是最终底层操作会自动进行字节拼接成...
  • 输入和输出功能是Java对程序处理数据能力的提高,Java的形式处理数据。是一组有序的数据序列,根据操作的类型,分为输入和输出。 程序从输入读取数据,向输出写入数据。Java是面向对象的程序语言,每...
  • 输入输出含义和意义:输入和输出功能是Java对程序处理数据能力的提高,java的形式处理数据。是一组有序的数据序列,根据操作类型,分为输入和输出。程序从输入读取数据,向输出写入数据。Java是面向...
  • Java写到.txt文件,如何实现换行

    千次阅读 2021-02-12 10:05:40
    http://blog.csdn.net/liangoo7/article/details/7882773java中写.txt文件实现换行的几种方法:1.使用java中的转义符"\r\n":Java代码 Stringstr="aaa";str+="\r\n";这样在str后面就有换行了.注意:\r,\n的顺序是...
  • 简述:观察Byte值转为字符写入文件如果在java里用byte打印出来只有33 126的输出字符比较正常此外发现Byte值为13是空格,10是换行符知识点:1. String 转为Byte输出("UTF-8"格式)2. FileOutputStream 使用输出文件...
  • 使用字符流实现文件复制

    千次阅读 2018-12-25 09:59:33
    import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.Reader; import java.io.Writer; /** * 使用...
  • Java输出文件到本地(输出

    千次阅读 2021-03-05 22:08:58
    import java.io.File;import java.io.FileOutputStream;import java.io.FileWriter;import java.io.OutputStream;import java.io.Writer;public class Hello {public static void main(String[] arg...
  • 本文将详细介绍字节流和字符流,剖析它们之间的本质区别,以及区别和对比。
  • JAVA实现HDFS文件的读写

    千次阅读 2022-04-22 23:22:52
    JAVA实现HDFS文件的读写
  • Java 字节流与字符流的区别详解

    万次阅读 多人点赞 2019-05-02 21:25:50
    1. 流的概念 在程序所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流读取数据,而当程序需要将一些数据保存起来的时候,就要使用输出...2. 字节流与字符流java.io包中操作文件内...
  • java字符流读取写入文件

    千次阅读 2015-12-09 22:14:09
    inputstreamreader的read方法返回的是一个int,代表读取的数据长度,可以将读取的数组保存...代码,先创建控制台输入对象scan,然后建立字节流与文件file连接,用字符流inputstreamreader包装字节流,同时设定字
  • java 文件读取

    千次阅读 2021-03-07 08:56:42
    Java语言的IO编程中,读取文件是分两个步骤:1、将文件中的数据转换为,2、读取内部的数据。其中第一个步骤由系统完成,只需要创建对应的对象即可,对象创建完成以后步骤1就完成了,第二个步骤使用输入...
  • 1.实现OSS文件上传,则需要准备的东西是:连接点endpoint、秘钥key、秘钥secret private static final String endpoint = "<your endpoint>"; private static final String accessKeyId = "your ...
  • Java字节流与字符流的区别详解

    千次阅读 2016-05-28 15:54:44
    字节流与字符流 先来看一下流的概念: ...在程序所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流...在Java.io包中操作文件内容的主要有两大类:字节流、字符流,两类都分为输入和输
  • java的几种IO读取文件方式

    千次阅读 2021-02-28 10:42:09
    一、超类:字节流: InputStream(读入流) OutputStream(出流)字符流: Reader(字符 读入流) Writer (字符出流)二、文件操作流字节流: FileInputStream ,FileOutputStream字符流: FileReader, FileWriter(用法...
  • package ... import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; public class ByteStream...
  • JAVA输入输出流实现文件复制

    千次阅读 2020-05-16 15:29:02
    JAVA输入输出流实现文件复制 步骤使用eclipse 1.在D盘下创建一个文件abc.txt(被复制的文件); 2.执行如下代码,代码已注释 将D盘的文件复制当前文件夹下 CopyFile.java //三步骤 1.创建对象 2.调用方法 3.关闭...
  • 字符流 Reader Writer  他们都是抽象类  具体实现  字节流 FileInputStream FileOutputStream  字符流 FileReader FileWriter   字符流处理的单元为2个字节的Unicode字符,分别操作字符、字符数组或字符
  • // 将字节传入响应里,响应浏览器 os.write(bytes); os.close(); } catch (Exception ex) { logger.error("导出失败:", ex); throw new RuntimeException("导出失败"); }finally { try { if (null != ...
  • Java 字节读写文件

    万次阅读 2019-05-07 09:49:31
    Java:字节读写文件 针对文件的读写,JDK专门提供了两个类,...FileInputStream 是操作文件的字节输入,专门用于读取文件中的数据。 例如: public class Example01 { public static void main(String[]...
  • java使用nio读写文件

    万次阅读 多人点赞 2019-11-16 15:49:45
    最近在研究 JAVA NIO 的相关知识,学习NIO,就不能提到IO的原理和事项,必经NIO是基于IO进化而来 IO涉及的底层的概念大致如下: 缓冲区操作。2) 内核空间与用户空间。3) 虚拟内存。4) 分页技术 一,虚拟存储器 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 278,339
精华内容 111,335
关键字:

java实现字符流写到文件中

java 订阅