Java上路16-I/O

最新推荐文章于 2023-03-13 20:37:37 发布
最新推荐文章于 2023-03-13 20:37:37 发布
阅读量653 收藏
点赞数
分类专栏： Java上路 文章标签： FileReader FileWriter InputStream OutputStream 输入输出流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Vigiles/article/details/8233313
版权


        IO流用来处理设备之间的数据传输，Java对数据的操作是通过流的方式，Java用于操作的流的对象都在IO包中。流按操作数据分为字节流和字符流，流按流向分为输入流和输出流。

        字符流：FileReader、FileWriter，BufferedReader、BufferedWriter 

        字节流：InputStream、OutputStream，FileInputStream、FileOutputStream

 

一. FileWriter：

       Writer下.OutputStreamWriter的一个子类，用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的，用于写入字符流。

import java.io.FileWriter;
import java.io.IOException;
 
class IoDemo
{
       public static void main(String[] args)
       {
              FileWriter fw=null;
              try
              {
                     //在指定目录创建文件，如果已有同名文件将被覆盖
                     fw=new FileWriter("demo.txt");
 
                     //调用write方法写字符串到流
                     fw.write("HelloIO");
 
                     //刷新缓冲区，使数据进入目的地
                     fw.flush();
 
                     fw.write(" Sogood");
                     fw.flush();
              }
              catch (IOException e)
              {
                     System.out.println(e.toString());
              }
              finally
              {
                     try
                     {
                            if (fw!=null)
                            {
                                   //刷新缓冲区后关闭流
                                   fw.close();
                            }
                     }
                     catch (IOException e)
                     {
                            System.out.println(e.toString());
                     }
              }
       }
}


       如果构造函数中加入第二个参数true，将不覆盖已有的文件，而是续写操作。

 

二. FileReader：

       Reader中io.InputStreamReader的子类，用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。

import java.io.FileReader;
import java.io.IOException;
 
class IoDemo
{
       public static void main(String[] args)
       {
              FileReader fr=null;
              try
              {
                     //创建一个文件读取流对象，指定的文件必须存在
                     fr=new FileReader("demo.txt");
/*
                     //连续读取单个字符
                     int ch=0;
                     while((ch=fr.read())!=-1)
                     {
                            System.out.print((char)ch);
                     }
*/
                     //每次读取多个字符
                     char[] buf=new char[1024];
                     int num=0;
                     while((num=fr.read(buf))!=-1)
                     {
                            System.out.println("num"+": "+new String(buf, 0, num));
                     }
              }
              catch (IOException e)
              {
                     System.out.println(e.toString());
              }
              finally
              {
                     try
                     {
                            if (fr!=null)
                            {
                                   fr.close();
                                   System.out.println("fr.close();");
                            }
                     }
                     catch (IOException e)
                     {
                            System.out.println(e.toString());
                     }
              }
       }
}


三. 文件复制演示：

import java.io.*;
 
class IoDemo
{
       public static void main(String[] args)throws IOException
       {
              copy2();
       }
/*
       public static void copy1() throws IOException
       {
              //创建目标文件
              FileWriter fw=new FileWriter("NewDemo.txt");
 
              //读取源文件
              FileReader fr=new FileReader("Demo.txt");
 
              int ch=0;
              while ((ch=fr.read())!=-1)
              {
                     fw.write(ch);
                     fw.flush();
              }
              fw.close();
              fr.close();
       }
*/
       public static void copy2() throws IOException
       {
              FileWriter fw=new FileWriter("NewDemo.txt");
              FileReader fr=new FileReader("Demo.txt");
 
              char[] buf=new char[1024];
 
              int len=0;
              while ((len=fr.read(buf))!=-1)
              {
                     fw.write(buf, 0, len);
              }
              fw.close();
              fr.close();
       }
}


四. BufferedWriter & BufferedReader：

// BufferedWriter将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。创建缓冲区前，必须先有流对象。
import java.io.*;
 
class BufferedDemo
{
       public static void main(String[] args)throws IOException
       {
              //字符写入到文件类
              FileWriter fw=new FileWriter("demo.txt");
              //字符输出到流写入文本类
              BufferedWriter bufw=new BufferedWriter(fw);
              //在流中写入内容
              bufw.write("HelloBufferedWriter");
              bufw.write(" Je amievou");
              bufw.newLine();   //换行
              bufw.write("My love");
              bufw.flush();  //刷新该流的缓冲，写入文本
              bufw.close(); //关闭此流，但要先刷新它。在关闭该流之后，再调用 write() 或flush() 将导致抛出 IOException
 
              //读取文件的字符类
              FileReader fr=new FileReader("demo.txt");
              //读取文本字符输入流类
              BufferedReader bufr=new BufferedReader(fr);
              String line=null;
              //readLine读取一行，但不返还换行符
              while ((line=bufr.readLine())!=null)
              {
                     System.out.println(line);
              }
              //关闭流，释放资源
              bufr.close();
 
              //Runtime rt=Runtime.getRuntime();
              //Process p=rt.exec("notepaddemo.txt");
       }
}


五. 复制文件演示：

import java.io.*;
 
class BufferedDemo
{
       public static void main(String[] args) throws IOException
       {
              BufferedReader bufr=null;
              BufferedWriter bufw=null;
 
              try
              {
                     bufr=new BufferedReader(new FileReader("demo.txt"));
                     bufw=new BufferedWriter(new FileWriter("NewDemo.txt"));
 
                     Stringline = null;
 
                            while((line = bufr.readLine())!=null)
                            {
                                   bufw.write(line);
                                   bufw.newLine();
                                   bufw.flush();
                            }
              }
              catch(IOException e)
              {
                     throw new RuntimeException("读取失败");
              }
              finally
              {
                     try
                     {
                            if(bufr!=null)
                                   bufr.close();
                     }
                     catch(IOException e)
                     {
                            throw new RuntimeException("读取关闭失败");
                     }
 
                     try
                     {
                            if(bufw!=null)
                                   bufw.close();
                     }
                     catch(IOException e)
                     {
                            throw new RuntimeException("写入关闭失败");
                     }
              }
       }
}


六. 自定义的缓冲类

class MyBufferedReader
{
       private FileReader fr;
       MyBufferedReader(FileReader r)
       {
              fr=r;
       }
       //每次读取一行
       public String myReadLine() throws IOException
       {
              //定义一个临时容器，原BufferReader封装的是字符数组，此处使用StringBuilder
              StringBuilder sb=new StringBuilder();
              int ch=0;
              while((ch=fr.read())!=-1)
              {
                     if(ch=='\r')
                     {
                            continue;
                     }
                     if(ch=='\n')
                     {
                            return sb.toString();
                     }
                     else
                     {
                            sb.append((char)ch);
                     }
              }
              if(sb.length()!=0)
              {
                     return sb.toString();
              }
              return null;
       }
 
       public void myClose() throws IOException
       {
              fr.close();
       }
}


七. 装饰设计模式：

/*
装饰设计模式：
当想要对已有的对象进行功能增强的时候，可以定义类，将已有的对象传入，基于已有的功能，并提供加强功能。那么自定义的类成为装饰类。
装饰类通常会通过构造方法接收被装饰的对象。并基于被装饰的对象的功能进一步增强。
*/
 
import java.io.*;
 
class Person
{
       public void chifan()
       {
              System.out.println("吃饭");
       }
}
 
class SuperPerson
{
       private Person p;
       SuperPerson(Person p)
       {
              this.p=p;
       }
 
       public void superChifan()
       {
              System.out.println("甜点");
              p.chifan();
              System.out.println("咖啡");
       }
}
 
class BufferedDemo
{
       public static void main(String[] args) throws IOException
       { 
              Person p=new Person();
              p.chifan();
 
              SuperPerson sp=new SuperPerson(p);
              sp.superChifan();
       }
}


八. LineNumberReader:

跟踪行号的缓冲字符输入流。此类定义了方法 setLineNumber(int) 和 getLineNumber()，它们可分别用于设置和获取当前行号。 

import java.io.*;
 
class BufferedDemo
{
       public static void main(String[] args) throws IOException
       {
              FileReader fr=new FileReader("demo.txt");
 
              LineNumberReader lnr=new LineNumberReader(fr);
 
              String line=null;
              lnr.setLineNumber(100);
              while((line=lnr.readLine())!=null)
              {
                     System.out.println(lnr.getLineNumber()+":"+line);
              }
              lnr.close();
       }
}


       模拟LineNumberReader： 

import java.io.*;
 
class MyLineNumberReader
{
       private Reader r;
       private int lineNumber;
 
       MyLineNumberReader(Reader r)
       {
              this.r=r;
       }
 
       public String myReadLine() throws IOException
       {
              lineNumber++;
              StringBuilder sb=new StringBuilder();
              intch=0;
              while((ch=r.read())!=-1)
              {
                     if(ch=='\r')
                     {
                            continue;
                     }
                     if(ch=='\n')
                     {
                            return sb.toString();
                     }
                     else
                     {
                            sb.append((char)ch);
                     }
              }
              if(sb.length()!=0)
              {
                     return sb.toString();
              }
              return null;
       }
 
       public void setLineNumber(int lineNumber)
       {
              this.lineNumber=lineNumber;
       }
 
       public int getLineNumber()
       {
              return lineNumber;
       }
 
       public void myClose() throws IOException
       {
              r.close();
       }
}
 
class BufferedDemo
{
       public static void main(String[] args) throws IOException
       {
              FileReader fr=new FileReader("demo.txt");
 
              MyLineNumberReader mlnr=new MyLineNumberReader(fr);
 
              String line=null;
              mlnr.setLineNumber(100);
              while((line=mlnr.myReadLine())!=null)
              {
                     System.out.println(mlnr.getLineNumber()+":"+line);
              }
              mlnr.myClose();
       }
}


九. FileInputStream & FileOutputStream：

       字节读取流和字节写入流，可以对图片及视频等文件复制拷贝。

import java.io.*;
 
class BufferedDemo
{
       public static void main(String[] args) throws IOException
       {
              writeFile();
              readFile_1();
              readFile_2();
              readFile_3();
       }
 
       public static void readFile_3() throws IOException
       {
              //通过打开一个到实际文件的连接来创建一个输入字节流
              FileInputStream fis=new FileInputStream("demo.txt");
              byte[] buf=new byte[fis.available()]; //定义一个刚刚好的缓冲区
              fis.read(buf);
              System.out.println(new String(buf));
              fis.close();
       }
 
       public static void readFile_2() throws IOException
       {
              FileInputStream fis=new FileInputStream("demo.txt");
              byte[] buf=new byte[1024];      //     定义指定大小的缓冲区
              intlen=0;
              while((len=fis.read(buf))!=-1)
              {
                     System.out.println(new String(buf, 0, len));
              }
              fis.close();
       }
 
       public static void readFile_1() throws IOException
       {
              FileInputStream fis=new FileInputStream("demo.txt");
              int ch=0;
              //单个字符循环读取
              while ((ch=fis.read())!=-1)
              {
                     System.out.println((char)ch);
              }
              fis.close();
       }
 
       public static void writeFile() throws IOException
       {
              //创建一个向指定 File 对象表示的文件中写入数据的文件输出流
              FileOutputStream fos=new FileOutputStream("demo.txt");
              fos.write("这是新的文字内容2012-11-27".getBytes());
              fos.close();
       }
}



拷贝图片示例： 

import java.io.*;
 
class BufferedDemo
{
       public static void main(String[] args)
       {
              FileOutputStream fos=null;
              FileInputStream fis=null;
 
              try
              {
                     fis=new FileInputStream("E:\\test.jpg"); //源文件
                     fos=new FileOutputStream("E:\\newtest.jpg");     //新文件
 
                     byte[] buf=new byte[1024];
                     int len=0;
                     while((len=fis.read(buf))!=-1)
                     {
                            fos.write(buf, 0, len);
                     }
              }
              catch(IOException e)
              {
                     throw new RuntimeException("复制文件失败");
              }
              finally
              {
                     try
                     {
                            if(fis!=null)
                            {
                                   fis.close();
                            }
                     }
                     catch(IOException e)
                     {
                            throw new RuntimeException("读取关闭失败");
                     }
 
                     try
                     {
                            if(fos!=null)
                            {
                                   fos.close();
                            }
                     }
                     catch(IOException e)
                     {
                            throw new RuntimeException("写入关闭失败");
                     }
              }
       }
}

拷贝MP3文件示例：

import java.io.*;
 
class MyBufferedInputStream
{
       private InputStream in;
 
       private byte[] buf=new byte[1024*4];
       private int pos=0, count=0;
 
       MyBufferedInputStream(InputStream in)
       {
              this.in=in;
       }
 
       //每次读取一个字节
       public int myRead() throws IOException
       {
              if(count==0)
              {
                     //通过in对象读取硬盘上的数据存储在buf
                     count = in.read(buf);
 
                     if(count<0)
                            return -1;
 
                     pos=0;
                     byte b=buf[pos];
 
                     count--;
                     pos++;
                     return b&255;      //类型提升，避免-1出现
              }
              else if(count>0)
              {
                     byte b=buf[pos];
 
                     count--;
                     pos++;
                     return b&255;
              }
              return -1;
       }
 
       public void myClose() throws IOException
       {
              in.close();
       }
}
 
class IoDemo
{
       public static void main (String [] args)throws IOException
       {
              MyBufferedInputStream bufis=new MyBufferedInputStream(new FileInputStream("E:/demo.mp3"));
              BufferedOutputStream bufos=new BufferedOutputStream(new FileOutputStream("E:/newdemo.mp3"));
 
              int by=0;
              while ((by=bufis.myRead())!=-1)
              {
                     bufos.write(by);
              }
              bufos.close();
              bufis.myClose();
       }
}

---------------------**---------------------------

附加：

        Editplus编译运行java程序设置：





vigiles
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
探索Java I/O 模型的演进
08-25
Java I/O 模型的演进是随着技术发展和并发需求的提升而逐步完善的。在理解Java I/O模型之前，我们需要先了解一些基础概念，包括同步与异步、阻塞与非阻塞。 同步和异步是描述用户线程与内核交互方式的概念。同步I/O...
Java I/O中I/O流的典型使用方式详解
08-25
"Java I/O中I/O流的典型使用方式详解" Java I/O中I/O流的典型使用方式详解是Java编程中的一种重要技术，它提供了多种方式来处理输入和输出操作。下面将详细介绍四种典型的I/O流使用方式：缓冲输入文件、从内存输入...
Java上路18-I/O-File
Vigiles的编程基础
12-03 629
一. File： File对象可以表示文件或者目录，利用它可对文件或目录的属性进行基本操作。也可以查询文件的基本信息，并进行修改。   构造函数     File file = new File (“ Demo.txt ”) ;    在默认目录创建文件    File file = new File (“ C : \\”，“ Demo
Java上路19-I/O-常用类
Vigiles的编程基础
12-03 588
一. 对象序列化： Java对象序列化将那些实现了Serializable接口的对象转换成一个字节序列，并能够以后将这个字节序列完全恢复为原来的对象。利用对象的序列化，可以实现轻量级持久性，这意味着一个对象的生存周期并不取决于程序是否正在执行，它可以生存于程序的调用之间。通过将一个序列化对象写入磁盘，然后在重新调用程序时恢复该对象，就能够实现持久性的效果。ObjectOutputStream /
Java上路17-I/O-字符与字节
Vigiles的编程基础
11-30 767
一. System.in ： 1. 键盘录入对象： import java.io.*; class InAndOut { public static void main(String[] args) throws IOException { //获取键盘录入对象 InputStream in=Syste
JAVA I/O流（10）
王小六4ever’s poke
03-07 249
这一讲就是JAVA中的I/O流的一部分内容，当然，跟前面一样，咱们浅尝辄止，需要深入了解的推荐大家看一本JAVA 核心技术 这本书讲的比较深入也很全面。 第一节  I/O流简介 流的本质是数据传输。 流分为两类主要：字符流和字节流 第二节 文件操作File类 先讲两个比较经典的用法就是创建文件和监测文件是否创建成功： public class
Java上路13-泛型
Vigiles的编程基础
11-23 617
泛型是JDK1.5为类型安全做的更新，将运行时期出现的ClassCaseException转移到了编译时期。通过尖括号定义要引用的数据类型。 import java.util.*; class GenericDemo { public static void main(String[] args) { //使用尖括号声明String
java开发手册-阿里巴巴2020最新版
zw764987243的博客
03-10 2363
前言 《Java 开发手册》是阿里巴巴集团技术团队的集体智慧结晶和经验总结，经历了多次大规模一 线实战的检验及不断完善，公开到业界后，众多社区开发者踊跃参与，共同打磨完善，系统化地整理 成册，当前的版本是嵩山版。现代软件行业的高速发展对开发者的综合素质要求越来越高，因为不仅 是编程知识点，其它维度的知识点也会影响到软件的最终交付质量。比如：五花八门的错误码人为地 增加排查问题的难度；数据库的表结构和索引设计缺陷带来的系统架构缺陷或性能风险；工程结构混 乱导致后续项目维护艰难；没有鉴权的漏洞代码易被黑客攻击等
趣学 Node.js：最初的卖点：事件循环与异步 I/O（上）
最新发布
sybh的博客
03-13 228
趣学 Node.js - 死月 - 掘金小册带你重新体悟 Node.js 之美。「趣学 Node.js」由死月撰写，2109人购买在 MDN 里面，有这么一段话：JavaScript 有一个基于事件循环的并发模型，事件循环负责执行代码、收集和处理事件以及执行队列中的子任务。这个模型与其它语言中的模型截然不同，比如 C 和 Java。大家是不是想问本章讲的就是这个？是也不是。上面那段话讲的是 JavaScript，不是 Node.js。别急着问这有差吗？
新手上路 -- 02
free_puppet的博客
07-20 132
java编程基础大杂烩第二期
java中的常见异常1 -- 新手上路，减速慢行
m0_48837241的博客
12-29 348
ArrayIndexOutOfBoundsException、ArithmeticException、InputMismatchException StackOverflowError、NullPointExcept、FileNotFoundException、InvalidClassException NotSerializableException、InterruptedException、NoSuchMethodException、ClassCastException、IllegalArgumentE
java7 新I/O知识点详解
08-25
Java 7引入的新I/O API，也称为NIO.2，是Java语言中的一大改进，为开发者提供了更高效、更灵活的I/O操作方式。这一API主要集中在`java.nio`包及其子包中，旨在提高文件操作的性能，增强并发处理，并引入了异步I/O...
java基础之I/O流
10-12
Java中的I/O流是程序与外部数据交互的重要机制，它允许数据在程序、文件、网络等之间流动。I/O流分为两大类：字符流（Character Stream）和字节流（Byte Stream），每类又分为输入流（Input Stream）和输出流...
基于Java回顾之I/O的使用详解
09-05
在Java编程中，I/O（Input/Output）操作是至关重要的，它允许程序与外部世界交换数据，如读取文件、接收网络数据或输出结果。Java的I/O系统设计得相当全面，支持多种类型的流来处理不同数据源和目的地。在本文中，...
Java上路04-流程控制语句
Vigiles的编程基础
11-14 1494
一．条件判断语句： 1. if-else，如果，否则。当if的条件成立时，执行if语句块，忽略else语句块， if (条件) {       执行语句1; } else {       执行语句2; } 例子：   2. if-elseif-else，如果，或者如果，否则当第一个if不成立时，会判断紧跟着的else if语句，如果还不成立，执行else if(
Java上路09-多线程
Vigiles的编程基础
11-19 1340
记得九几年小学课本里有一篇华罗庚的文章写的是统筹学，里面的例子大概是这么说的：我们想喝茶，第一种办法，洗刷茶壶，放上茶叶，烧水，等水开了泡茶；第二种办法，烧水，等待水开的时间里洗刷茶壶，放上茶叶，然后水开了泡茶。        生活中的统筹学也就是编程思想中的算法。在此之前我们写的所有程序都可以说是单线程的。因为都是按部就班的干了一样再干另一样。而多线程达到了事半功倍的效果，一个时刻可以进行多个
Java上路06-面向对象
Vigiles的编程基础
11-15 1145
面向对象（Object Oriented Programming，OOP）是一种思想，Java可以通过这种思想设计程序。最笨的理解就是让别人去干活，自己做管理。 一. 类： class Human { public static void main(String[] args) { System.out.println("HelloWorld!我是
Java上路07-异常处理
Vigiles的编程基础
11-16 1124
当运行时发生的错误就是异常，而不是编译时发生的语法错误。比如下面： class Computer { void count(int i, int j) { System.out.println("两个数的商是：" + i / j); } } class Exceptions { public static
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值