精华内容
下载资源
问答
  • 输出流

    千次阅读 2018-04-22 12:04:57
    标准输出流(流向显示器的数据):  cout:cout流是流向显示器的数据  cerr:err的作用是向标准错误设备输出相关的错误信息;  clog:clog的对象是标准错误流,作用和cerr一样,在显示器上显示错误信息。   cout:...

    标准输出流(流向显示器的数据):
     cout:cout流是流向显示器的数据
     cerr:err的作用是向标准错误设备输出相关的错误信息;
     clog:clog的对象是标准错误流,作用和cerr一样,在显示器上显示错误信息。
     
    cout:cout流中的数据是用插入运算符"<<"顺序加入的。
     功能和c中的printf是一样的,不同的是cout在输出数据时,不需要自己考虑数
    据的类型,而printf需要自己判断输出类型。
     cout后面加上endl的时候,意味着换行,相当于c中的'\n'。

    cerr:对象时标准错误流,与显示器关联。      
     与标准输出流cout的作用和用法差不多,不同点在于:cout不仅可以在显示器中
    显示,还可以输出到磁盘文件;而cerr中的信息只能显示在显示器中。
     cerr流中的信息是用户根据要求指定的。

    clog:和cerr的区别在于:cerr是不经过缓冲区,直接向显示器上输出有关信息,而clog中的信息存放在缓冲区中,缓冲区满后或遇endl时向显示器输出。

        除了用控制符来控制输出格式之外,还可以调用流对象cout中用于控
    制输出格式的成员函数来控制输出格式。

    流成员函数     与之作用相同的控制符 作用
    precision(n) setprecision(n)   设置实数的精度为n位
    width(n)  setw(n)     设置字段宽度为n位
    fill(c)   setfill(c)    设置填充宇符c
    setf()   setiosflags()   设置输出格式状态,括号中应给出格式状态,内容与控制符setiosflags括号中的内容相同
    unsetf()  resetioflags()   终止已设置的输出格式状态,在括号中应指定内容

    使用setf设置一种格式状态时,想要换成另一种格式状态的话,需要先使用unsetf结束原来的状态,再重新设置。


    流成员函数setf和控制符setiosflags括号中的参数表示格式状态,它是通过格式标志来指定的。
    格式标志在类ios中被定义为枚举值,所以在引用格式标志时在前面加上类名和"::"。

    格式标志  作用
    ios::left  输出数据在本域宽范围内向左对齐
    ios::right  输出数据在本域宽范围内向右对齐
    ios::internal 数值的符号位在域宽内左对齐,数值右对齐,中间由填充字符填充
    ios::dec  设置整数的基数为10
    ios::oct  设置整数的基数为8
    ios::hex  设置整数的基数为16
    ios::showbase 强制输出整数的基数(八进制数以0打头,十六进制数以0x打头)
    ios::showpoint 强制输出浮点数的小点和尾数0
    ios::uppercase 在以科学记数法格式E和以十六进制输出字母时以大写表示
    ios::showpos 对正数显示“+”号
    ios::scientific 浮点数以科学记数法格式输出
    ios::fixed  浮点数以定点格式(小数形式)输出
    ios::unitbuf 每次输出之后刷新所有的流
    ios::stdio  每次输出之后清除stdout, stderr

    可以用'|'组合多个格式标志,如:cout.setf(ios::internal I ios::showpos);

     

     

     

     

     

     

     

     

     

     

     

     

     

     


     

    展开全文
  • Java(2)-Java IO输入输出流

    万次阅读 多人点赞 2012-04-01 11:28:55
    Java中I/O操作主要是指使用Java进行输入,输出操作.Java所有的I/O机制都是基于数据进行输入输出,这些数据表示了字符或者字节数据的流动序列。Java的I/O提供了读写数据的标准方法。任何Java中表示数据源的...

     

     

    一.什么是IO


          Java中I/O操作主要是指使用Java进行输入,输出操作. Java所有的I/O机制都是基于数据流进行输入输出,这些数据流表示了字符或者字节数据的流动序列Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。  

          Java.io是大多数面向数据流的输入/输出类的主要软件包。此外,Java也对块传输提供支持,在核心库 java.nio中采用的便是块IO。

      流IO的好处是简单易用,缺点是效率较低。块IO效率很高,但编程比较复杂。 
          Java IO模型  :
          Java的IO模型设计非常优秀,它使用Decorator模式,按功能划分Stream,您可以动态装配这些Stream,以便获得您需要的功能。例如,您需要一个具有缓冲的文件输入流,则应当组合使用FileInputStream和BufferedInputStream。

     

    二.数据流的基本概念


            数据流是一串连续不断的数据的集合,就象水管里的水流,在水管的一端一点一点地供水,而在水管的另一端看到的是一股连续不断的水流。数据写入程序可以是一段、一段地向数据流管道中写入数据,这些数据段会按先后顺序形成一个长的数据流。对数据读取程序来说,看不到数据流在写入时的分段情况,每次可以读取其中的任意长度的数据,但只能先读取前面的数据后,再读取后面的数据。不管写入时是将数据分多次写入,还是作为一个整体一次写入,读取时的效果都是完全一样的。 

          “流是磁盘或其它外围设备中存储的数据的源点或终点。”

        在电脑上的数据有三种存储方式,一种是外存,一种是内存,一种是缓存。比如电脑上的硬盘,磁盘,U盘等都是外存,在电脑上有内存条,缓存是在CPU里面的。外存的存储量最大,其次是内存,最后是缓存,但是外存的数据的读取最慢,其次是内存,缓存最快。这里总结从外存读取数据到内存以及将数据从内存写到外存中。对于内存和外存的理解,我们可以简单的理解为容器,即外存是一个容器,内存又是另外一个容器。那又怎样把放在外存这个容器内的数据读取到内存这个容器以及怎么把内存这个容器里的数据存到外存中呢?

         在Java类库中,IO部分的内容是很庞大的,因为它涉及的领域很广泛:

             标准输入输出,文件的操作,网络上的数据流,字符串流,对象流,zip文件流等等,java中将输入输出抽象称为流,就好像水管,将两个容器连接起来。将数据冲外存中读取到内存中的称为输入流,将数据从内存写入外存中的称为输出流。

        流是一个很形象的概念,当程序需要读取数据的时候,就会开启一个通向数据源的流,这个数据源可以是文件,内存,或是网络连接。类似的,当程序需要写入数据的时候,就会开启一个通向目的地的流。

    总结的基本概念如下:

    1) 数据流

        一组有序,有起点和终点的字节的数据序列。包括输入流和输出流。

      

    2) 输入流(Input  Stream):

          程序从输入流读取数据源。数据源包括外界(键盘、文件、网络…),即是将数据源读入到程序的通信通道

         

     3) 输出流

        程序向输出流写入数据。将程序中的数据输出到外界(显示器、打印机、文件、网络…)的通信通道。

             

    采用数据流的目的就是使得输出输入独立于设备。

    Input  Stream不关心数据源来自何种设备(键盘,文件,网络)
    Output  Stream不关心数据的目的是何种设备(键盘,文件,网络)

    4) 数据流分类:

    流序列中的数据既可以是未经加工的原始二进制数据,也可以是经一定编码处理后符合某种格式规定的特定数据。因此Java中的流分为两种:
     1)  字节流:数据流中最小的数据单元是字节
     2)  字符流:数据流中最小的数据单元是字符, Java中的字符是Unicode编码,一个字符占用两个字节。

     

     

    三. 标准I/O


          Java程序可通过命令行参数与外界进行简短的信息交换,同时,也规定了与标准输入、输出设备,如键盘、显示器进行信息交换的方式。而通过文件可以与外界进行任意数据形式的信息交换。

    1. 命令行参数

    public class TestArgs {
    	public static void main(String[] args) {
    		for (int i = 0; i < args.length; i++) {
    			System.out.println("args[" + i + "] is <" + args[i] + ">");
    		}
    	}
    }

    运行命令:java Java C VB
    运行结果:
    args[0] is <Java>
    args[1] is <C>
    args[2] is <VB>

     

    2. 标准输入,输出数据流

    java系统自带的标准数据流:java.lang.System:

    java.lang.System 
    public final class System  extends Object{ 
       static  PrintStream  err;//标准错误流(输出)
       static  InputStream  in;//标准输入(键盘输入流)
       static  PrintStream  out;//标准输出流(显示器输出流)
    }

    注意:
    (1)System类不能创建对象,只能直接使用它的三个静态成员。
    (2)每当main方法被执行时,就自动生成上述三个对象。

    1) 标准输出流 System.out

       System.out向标准输出设备输出数据,其数据类型为PrintStream。方法:

          Void print(参数)
          Void println(参数)

    2)标准输入流 System.in

        System.in读取标准输入设备数据(从标准输入获取数据,一般是键盘),其数 据类型为InputStream。方法:

            int read()  //返回ASCII码。若,返回值=-1,说明没有读取到任何字节读取工作结束。
             int read(byte[] b)//读入多个字节到缓冲区b中返回值是读入的字节数
    例如:
    import java.io.*;
    public class StandardInputOutput {
    	public static void main(String args[]) {
    		int b;
    		try {
    			System.out.println("please Input:");
    			while ((b = System.in.read()) != -1) {
    				System.out.print((char) b);
    			}
    		} catch (IOException e) {
    			System.out.println(e.toString());
    		}
    	}
    }
    等待键盘输入,键盘输入什么,就打印出什么:

     

    3)标准错误流

       System.err输出标准错误,其数据类型为PrintStream。可查阅API获得详细说明。

        标准输出通过System.out调用println方法输出参数并换行,而print方法输出参数但不换行。println或print方法都通 过重载实现了输出基本数据类型的多个方法,包括输出参数类型为boolean、char、int、long、float和double。同时,也重载实现 了输出参数类型为char[]、String和Object的方法。其中,print(Object)和println(Object)方法在运行时将调 用参数Object的toString方法。

    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    public class StandardInputOutput {
    	public static void main(String args[]) {
    		String s;
    		// 创建缓冲区阅读器从键盘逐行读入数据
    		InputStreamReader ir = new InputStreamReader(System.in);
    		BufferedReader in = new BufferedReader(ir);
    		System.out.println("Unix系统: ctrl-d 或 ctrl-c 退出"
    				+ "\nWindows系统: ctrl-z 退出");
    		try {
    			// 读一行数据,并标准输出至显示器
    			s = in.readLine();
    			// readLine()方法运行时若发生I/O错误,将抛出IOException异常
    			while (s != null) {
    				System.out.println("Read: " + s);
    				s = in.readLine();
    			}
    			// 关闭缓冲阅读器
    			in.close();
    		} catch (IOException e) { // Catch any IO exceptions.
    			e.printStackTrace();
    		}
    	}
    }

     

    四.java.IO层次体系结构


         在整个Java.io包中最重要的就是5个类和一个接口。5个类指的是File、OutputStream、InputStream、Writer、Reader;一个接口指的是Serializable.掌握了这些IO的核心操作那么对于Java中的IO体系也就有了一个初步的认识了

          Java I/O主要包括如下几个层次,包含三个部分:

       1.流式部分――IO的主体部分;

       2.非流式部分――主要包含一些辅助流式部分的类,如:File类、RandomAccessFile类和FileDescriptor等类;

       3.其他类--文件读取部分的与安全相关的类,如:SerializablePermission类,以及与本地操作系统相关的文件系统的类,如:FileSystem类和Win32FileSystem类和WinNTFileSystem类。

       主要的类如下:

         1. File(文件特征与管理):用于文件或者目录的描述信息,例如生成新目录,修改文件名,删除文件,判断文件所在路径等。

         2. InputStream(二进制格式操作):抽象类,基于字节的输入操作,是所有输入流的父类。定义了所有输入流都具有的共同特征。

         3. OutputStream(二进制格式操作):抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。

         Java中字符是采用Unicode标准,一个字符是16位,即一个字符使用两个字节来表示。为此,JAVA中引入了处理字符的流。

         4. Reader(文件格式操作):抽象类,基于字符的输入操作。

         5. Writer(文件格式操作):抽象类,基于字符的输出操作。

         6. RandomAccessFile(随机文件操作):它的功能丰富,可以从文件的任意位置进行存取(输入输出)操作

     

         Java中IO流的体系结构如图:

         

     

     

    五. 非流式文件类--File类


    在Java语言的java.io包中,由File类提供了描述文件和目录的操作与管理方法。但File类不是InputStream、OutputStream或Reader、Writer的子类,因为它不负责数据的输入输出,而专门用来管理磁盘文件与目录。
     
    作用:File类主要用于命名文件、查询文件属性和处理文件目录。
    public    class   File   extends Object 
        implements Serializable,Comparable
    {}

     

    File类共提供了三个不同的构造函数,以不同的参数形式灵活地接收文件和目录名信息。构造函数:
    1)File (String   pathname)   
         例:File  f1=new File("FileTest1.txt"); //创建文件对象f1,f1所指的文件是在当前目录下创建的FileTest1.txt
    2)File (String  parent  ,  String child)
         例:File f2=new  File(“D:\\dir1","FileTest2.txt") ;//  注意:D:\\dir1目录事先必须存在,否则异常
    3)File (File    parent  , String child)
         例:File  f4=new File("\\dir3");
              File  f5=new File(f4,"FileTest5.txt");  //在如果 \\dir3目录不存在使用f4.mkdir()先创建
            一个对应于某磁盘文件或目录的File对象一经创建, 就可以通过调用它的方法来获得文件或目录的属性。    
           1)public boolean exists( ) 判断文件或目录是否存在
           2)public boolean isFile( ) 判断是文件还是目录 
           3)public boolean isDirectory( ) 判断是文件还是目录
           4)public String getName( ) 返回文件名或目录名
           5)public String getPath( ) 返回文件或目录的路径。
           6)public long length( ) 获取文件的长度 
           7)public String[ ] list ( ) 将目录中所有文件名保存在字符串数组中返回。 
           File类中还定义了一些对文件或目录进行管理、操作的方法,常用的方法有:
           1) public boolean renameTo( File newFile );    重命名文件
           2) public void delete( );   删除文件
           3)  public boolean mkdir( ); 创建目录
     
    例子:

     

    import java.io.File;
    import java.io.IOException;
    public class TestFile {
    	public static void main(String args[]) throws IOException {
    		File dir = new File("\\root");
    		File f1 = new File(dir, "fileOne.txt");
    		File f2 = new File(dir, "fileTwo.java");
    		// 文件对象创建后,指定的文件或目录不一定物理上存在
    		if (!dir.exists())
    			dir.mkdir();
    		if (!f1.exists())
    			f1.createNewFile();
    		if (!f2.exists())
    			f2.createNewFile();
    		System.out.println("f1's AbsolutePath=  " + f1.getAbsolutePath());
    		System.out.println("f1 Canread=" + f1.canRead());
    		System.out.println("f1's len= " + f1.length());
    		String[] FL;
    		int count = 0;
    		FL = dir.list();
    		for (int i = 0; i < FL.length; i++) {
    			count++;
    			System.out.println(FL[i] + "is in \\root");
    		}
    		System.out.println("there are" + count + "file in //root");
    	}
    
    }

     

    说明:File类的方法:
    (1) exists()测试磁盘中指定的文件或目录是否存在
    (2) mkdir()创建文件对象指定的目录(单层目录)
    (3) createNewFile()创建文件对象指定的文件

    (4) list()返回目录中所有文件名字符串

     

    六. Java.IO流类库


    1. io流的四个基本类

          java.io包中包含了流式I/O所需要的所有类。在java.io包中有四个基本类:InputStream、OutputStream及Reader、Writer类,它们分别处理字节流和字符流:

    基本数据流的I/O

    输入/输出

    字节流

    字符流

    输入流

    Inputstream

    Reader

    输出流

    OutputStream

    Writer

     
    IO框架:

     

        

     

     Java中其他多种多样变化的流均是由它们派生出来的:

          JDK1.4版本开始引入了新I/O类库,它位于java.nio包中,新I/O类库利用通道和缓冲区等来提高I/O操作的效率。

          在java.io包中, java.io.InputStream 表示字节输入流, java.io.OutputStream表示字节输出流,处于java.io包最顶层。这两个类均为抽象类,也就是说它们不能被实例化,必须生成子类之后才能实现一定的功能。

     

    2. io流的具体分类

    一、按I/O类型来总体分类:

         1. Memory 1)从/向内存数组读写数据: CharArrayReader、 CharArrayWriter、ByteArrayInputStream、ByteArrayOutputStream
                       2)从/向内存字符串读写数据 StringReader、StringWriter、StringBufferInputStream
         2.Pipe管道  实现管道的输入和输出(进程间通信): PipedReader、PipedWriter、PipedInputStream、PipedOutputStream
         3.File 文件流。对文件进行读、写操作 :FileReader、FileWriter、FileInputStream、FileOutputStream
         4. ObjectSerialization 对象输入、输出 :ObjectInputStream、ObjectOutputStream
         5.DataConversion数据流 按基本数据类型读、写(处理的数据是Java的基本类型(如布尔型,字节,整数和浮点数)):DataInputStream、DataOutputStream
         6.Printing 包含方便的打印方法 :PrintWriter、PrintStream
         7.Buffering缓冲  在读入或写出时,对数据进行缓存,以减少I/O的次数:BufferedReader、BufferedWriter、BufferedInputStream、BufferedOutputStream
         8.Filtering 滤流,在数据进行读或写时进行过滤:FilterReader、FilterWriter、FilterInputStream、FilterOutputStream过
         9.Concatenation合并输入 把多个输入流连接成一个输入流 :SequenceInputStream
        10.Counting计数  在读入数据时对行记数 :LineNumberReader、LineNumberInputStream
        11.Peeking Ahead 通过缓存机制,进行预读 :PushbackReader、PushbackInputStream
        12.Converting between Bytes and Characters 按照一定的编码/解码标准将字节流转换为字符流,或进行反向转换(Stream到Reader,Writer的转换类):InputStreamReader、OutputStreamWriter

    、按数据来源(去向)分类: 
    1、File(文件): FileInputStream, FileOutputStream, FileReader, FileWriter 
    2、byte[]:ByteArrayInputStream, ByteArrayOutputStream 
    3、Char[]: CharArrayReader, CharArrayWriter 
    4、String: StringBufferInputStream, StringReader, StringWriter 
    5、网络数据流:InputStream, OutputStream, Reader, Writer 

     

     

    七. 字节流InputStream/OutputStream


     1. InputStream抽象类 

          InputStream 为字节输入流,它本身为一个抽象类,必须依靠其子类实现各种功能,此抽象类是表示字节输入流的所有类的超类。 继承自InputStream  的流都是向程序中输入数据的,且数据单位为字节(8bit);

    InputStream是输入字节数据用的类,所以InputStream类提供了3种重载的read方法.Inputstream类中的常用方法: 
      (1) public abstract int read( ):读取一个byte的数据,返回值是高位补0的int类型值。若返回值=-1说明没有读取到任何字节读取工作结束。
      (2) public int read(byte b[ ]):读取b.length个字节的数据放到b数组中。返回值是读取的字节数。该方法实际上是调用下一个方法实现的 
      (3) public int read(byte b[ ], int off, int len):从输入流中最多读取len个字节的数据,存放到偏移量为off的b数组中。 
      (4) public int available( ):返回输入流中可以读取的字节数。注意:若输入阻塞,当前线程将被挂起,如果InputStream对象调用这个方法的话,它只会返回0,这个方法必须由继承InputStream类的子类对象调用才有用, 
      (5) public long skip(long n):忽略输入流中的n个字节,返回值是实际忽略的字节数, 跳过一些字节来读取 
      (6) public int close( ) :我们在使用完后,必须对我们打开的流进行关闭. 

             主要的子类:

            

             1) FileInputStream把一个文件作为InputStream,实现对文件的读取操作     
        2) ByteArrayInputStream:把内存中的一个缓冲区作为InputStream使用 
        3) StringBufferInputStream:把一个String对象作为InputStream 
        4) PipedInputStream:实现了pipe的概念,主要在线程中使用 
        5) SequenceInputStream:把多个InputStream合并为一个InputStream 

     

     2.OutputStream抽象类

      OutputStream提供了3个write方法来做数据的输出,这个是和InputStream是相对应的。 
      1. public void write(byte b[ ]):将参数b中的字节写到输出流。 
      2. public void write(byte b[ ], int off, int len) :将参数b的从偏移量off开始的len个字节写到输出流。 
      3. public abstract void write(int b) :先将int转换为byte类型,把低字节写入到输出流中。 
      4. public void flush( ) : 将数据缓冲区中数据全部输出,并清空缓冲区。 
      5. public void close( ) : 关闭输出流并释放与流相关的系统资源。 

     

           主要的子类:

            

          1) ByteArrayOutputStream:把信息存入内存中的一个缓冲区中 
          2) FileOutputStream:把信息存入文件中 
          3) PipedOutputStream:实现了pipe的概念,主要在线程中使用 
          4) SequenceOutputStream:把多个OutStream合并为一个OutStream 

    流结束的判断:方法read()的返回值为-1时;readLine()的返回值为null时。

    3. 文件输入流: FileInputStream类

          FileInputStream可以使用read()方法一次读入一个字节,并以int类型返回,或者是使用read()方法时读入至一个byte数组,byte数组的元素有多少个,就读入多少个字节。在将整个文件读取完成或写入完毕的过程中,这么一个byte数组通常被当作缓冲区,因为这么一个byte数组通常扮演承接数据的中间角色。

     

     

    作用:以文件作为数据输入源的数据流。或者说是打开文件,从文件读数据到内存的类。
    使用方法(1)    
       File  fin=new File("d:/abc.txt"); 
      FileInputStream in=new FileInputStream( fin);

     

    使用方法(2)
       FileInputStream  in=new  FileInputStream(“d: /abc.txt”);

    程序举例:
    将InputFromFile.java的程序的内容显示在显示器上

     

    import java.io.IOException;
    import java.io.FileInputStream;
    ;
    public class TestFile {
    	public static void main(String args[]) throws IOException {
    		try{	
    		       FileInputStream rf=new   FileInputStream("InputFromFile.java");
    		       int n=512;   byte  buffer[]=new  byte[n];   
    		       while((rf.read(buffer,0,n)!=-1)&&(n>0)){
    		           System.out.println(new String(buffer) );
    		        }
    		        System.out.println();
    		        rf.close();
    		} catch(IOException  IOe){	    
    		      System.out.println(IOe.toString());
    		}
    
    	}
    
    }

     

    4.文件输出流:FileOutputStream类

       作用:用来处理以文件作为数据输出目的数据流;或者说是从内存区读数据入文件

          FileOutputStream类用来处理以文件作为数据输出目的数据流;一个表示文件名的字符串,也可以是File或FileDescriptor对象。 
      创建一个文件流对象有两种方法: 
      方式1: 
       File   f=new  File (“d:/myjava/write.txt ");
            FileOutputStream  out= new FileOutputStream (f);
      方式2: 
      FileOutputStream out=new FileOutputStream(“d:/myjava/write.txt "); 
      方式3:构造函数将 FileDescriptor()对象作为其参数。 
      FileDescriptor() fd=new FileDescriptor(); 
      FileOutputStream f2=new FileOutputStream(fd); 
      方式4:构造函数将文件名作为其第一参数,将布尔值作为第二参数。 
      FileOutputStream f=new FileOutputStream("d:/abc.txt",true); 
      注意: (1)文件中写数据时,若文件已经存在,则覆盖存在的文件;(2)的读/写操作结束时,应调用close方法关闭流。 

     

    程序举例:使用键盘输入一段文章,将文章保存在文件write.txt中
    import java.io.IOException;
    import java.io.FileOutputStream;
    public class TestFile {
    	public static void main(String args[]) throws IOException {
    		try {
    			System.out.println("please Input from      Keyboard");
    			int count, n = 512;
    			byte buffer[] = new byte[n];
    			count = System.in.read(buffer);
    			FileOutputStream wf = new FileOutputStream("d:/myjava/write.txt");
    			wf.write(buffer, 0, count);
    			wf.close(); // 当流写操作结束时,调用close方法关闭流。
    			System.out.println("Save to the write.txt");
    		} catch (IOException IOe) {
    			System.out.println("File Write Error!");
    		}
    	}
    
    }

    5. FileInputStream流和FileOutputStream的应用

    利用程序将文件file1.txt 拷贝到file2.txt中。
    import java.io.File;
    import java.io.IOException;
    import java.io.FileOutputStream;
    import java.io.FileInputStream;
    
    public class TestFile {
    	public static void main(String args[]) throws IOException {
    		try {
    			File inFile = new File("copy.java");
    			File outFile = new File("copy2.java");
    			FileInputStream finS = new FileInputStream(inFile);
    			FileOutputStream foutS = new FileOutputStream(outFile);
    			int c;
    			while ((c = finS.read()) != -1) {
    				foutS.write(c);
    			}
    			finS.close();
    			foutS.close();
    		} catch (IOException e) {
    			System.err.println("FileStreamsTest: " + e);
    		}
    	}
    
    }
    

     

    6. 缓冲输入输出流 BufferedInputStream/ BufferedOutputStream

            

     

          

           计算机访问外部设备非常耗时。访问外存的频率越高,造成CPU闲置的概率就越大。为了减少访问外存的次数,应该在一次对外设的访问中,读写更多的数据。为此,除了程序和流节点间交换数据必需的读写机制外,还应该增加缓冲机制。缓冲流就是每一个数据流分配一个缓冲区,一个缓冲区就是一个临时存储数据的内存。这样可以减少访问硬盘的次数,提高传输效率。

    BufferedInputStream: BufferedInputStream比FileInputStream多了一个缓冲区。它提供了一个缓冲数组,每次调用read方法的时候,它首先尝试从缓冲区里读取数据,若读取失败(缓冲区无可读数据),则选择从物理数据源(譬如文件)读取新数据(这里会尝试尽可能读取多的字节)放入到缓冲区中,最后再将缓冲区中的内容部分或全部返回给用户.由于从缓冲区里读取数据远比直接从物理数据源(譬如文件)读取速度快。BufferedInputStream的默认缓冲区大小是8192字节。当每次读取的数据量很小时,FileInputStream每次都是从硬盘读入,而BufferedInputStream大部分是从缓冲区读入。读取内存速度比读取硬盘速度快得多,因此BufferedInputStream效率高。

    例如:BUFFER_SIZE < 8192时候,BufferedInputStream性能是很高。

    BufferedInputStream  bufferedInput = new BufferedInputStream(new FileInputStream(fileA));
    byte[] buffer = new byte[BUFFER_SIZE];
    int len;
    while ((len = bufferedInput.read(buffer)) > 0){
        System.out.println(new String(buffer, 0, len));
    }

    BUFFER_SIZE > 8192时候, FileInputStream和BufferedInputStream两者效率就没有明显差别了。

    BufferedOutputStream :执行wirte时先写入缓冲区,待缓冲区写满后,系统再写入输出设备。

     

    1)将文件读入内存:

    BufferedInputStreamFileInputStream相接

      FileInputStream in = new  FileInputStream( “file1.txt ” );

      BufferedInputStream bin = new  BufferedInputStreamin); 

    2)将内存写入文件:

    BufferedOutputStream FileOutputStream相接:

    String fileB = "/Users/huangguisu/b.txt";
    FileOutputStream out = new FileOutputStream(fileB);
    BufferedOutputStream bOut = new BufferedOutputStream(out);
    byte[] buffer = {0x1,0x2,0x3};
    bOut.write(buffer);
    bOut.flush();
    bOut.close();


    3)键盘输入流读到内存
    BufferedReader标准的数据流相接 
     InputStreamReader sin = new InputStreamReader (System.in) ;
    BufferedReader bin = new       BufferedReader(sin);
    import java.io.*;
    
    public class ReadWriteToFile {
    	public static void main(String args[]) throws IOException {
    		InputStreamReader sin = new InputStreamReader(System.in);
    		BufferedReader bin = new BufferedReader(sin);
    		FileWriter out = new FileWriter("myfile.txt");
    		BufferedWriter bout = new BufferedWriter(out);
    		String s;
    		while ((s = bin.readLine()).length() > 0) {
    			bout.write(s, 0, s.length());
    		}
    
    	}
    }

    程序说明:
    从键盘读入字符,并写入到文件中BufferedReader类的方法:String readLine()
    作用:读一行字符串,以回车符为结束。
    BufferedWriter类的方法:bout.write(String s,offset,len)
    作用:从缓冲区将字符串s从offset开始,len长度的字符串写到某处。

     

     

    八. 字符流Writer/Reader


            Java中字符是采用Unicode标准,一个字符是16位,即一个字符使用两个字节来表示。为此,JAVA中引入了处理字符的流。

    1. Reader抽象类

        用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是,多数子类将重写此处定义的一些方法,以提供更高的效率和/或其他功能。

           

            1) FileReader :与FileInputStream对应  
               主要用来读取字符文件,使用缺省的字符编码,有三种构造函数: 
          (1)将文件名作为字符串 :FileReader f = new FileReader(“c:/temp.txt”); 
          (2)构造函数将File对象作为其参数。 
                  File f=new file(“c:/temp.txt”); 
                  FileReader f1=new FileReader(f); 
         (3)  构造函数将FileDescriptor对象作为参数 
                FileDescriptor() fd = new FileDescriptor() 
                FileReader f2=new FileReader(fd); 
                   (1) 用指定字符数组作为参数:CharArrayReader(char[]) 
                   (2) 将字符数组作为输入流:CharArrayReader(char[], int, int) 
              读取字符串,构造函数如下: public StringReader(String s); 
            2) CharArrayReader:与ByteArrayInputStream对应  
      3) StringReader : 与StringBufferInputStream对应 
      4) InputStreamReader 
            从输入流读取字节,在将它们转换成字符:Public inputstreamReader(inputstream is); 
      5) FilterReader: 允许过滤字符流 
            protected filterReader(Reader r); 
      6) BufferReader :接受Reader对象作为参数,并对其添加字符缓冲器,使用readline()方法可以读取一行。 
         Public BufferReader(Reader r); 

          主要方法:

          (1)  public int read() throws IOException; //读取一个字符,返回值为读取的字符 

      (2)  public int read(char cbuf[]) throws IOException; /*读取一系列字符到数组cbuf[]中,返回值为实际读取的字符的数量*/ 
      (3)  public abstract int read(char cbuf[],int off,int len) throws IOException; 
      /*读取len个字符,从数组cbuf[]的下标off处开始存放,返回值为实际读取的字符数量,该方法必须由子类实现*/ 

    2. Writer抽象类

         写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是,多数子类将重写此处定义的一些方法,以提供更高的效率和/或其他功能。 其子类如下:

        

          1) FileWrite: 与FileOutputStream对应  
      将字符类型数据写入文件,使用缺省字符编码和缓冲器大小。 
      Public FileWrite(file f); 
      
    2)  chararrayWrite:与ByteArrayOutputStream对应 ,将字符缓冲器用作输出。 
          Public CharArrayWrite(); 
      3) PrintWrite:生成格式化输出 
          public PrintWriter(outputstream os); 
      4) filterWriter:用于写入过滤字符流 
          protected FilterWriter(Writer w); 
      5) PipedWriter:与PipedOutputStream对应   

          6) StringWriter:无与之对应的以字节为导向的stream  

          主要方法:

      (1)  public void write(int c) throws IOException; //将整型值c的低16位写入输出流 
      (2)  public void write(char cbuf[]) throws IOException; //将字符数组cbuf[]写入输出流 
      (3)  public abstract void write(char cbuf[],int off,int len) throws IOException; //将字符数组cbuf[]中的从索引为off的位置处开始的len个字符写入输出流 
      (4)  public void write(String str) throws IOException; //将字符串str中的字符写入输出流 
      (5)  public void write(String str,int off,int len) throws IOException; //将字符串str 中从索引off开始处的len个字符写入输出流 
      (6)  flush( ) //刷空输出流,并输出所有被缓存的字节。 
      (7)close()    关闭流 public abstract void close() throws IOException

     

     

    3 .InputStream与Reader差别 OutputStream与Writer差别

     

    InputStream和OutputStream类处理的是字节流,数据流中的最小单位是字节(8个bit)
    Reader与Writer处理的是字符流,在处理字符流时涉及了字符编码的转换问题

    import java.io.*;
    public class EncodeTest {
        private static void readBuff(byte [] buff) throws IOException {
           ByteArrayInputStream in =new ByteArrayInputStream(buff);
            int data;
            while((data=in.read())!=-1)   System.out.print(data+"  ");
            System.out.println();     in.close();     }
    
       public static void main(String args[]) throws IOException {
           System.out.println("内存中采用unicode字符编码:" );
           char   c='好';
           int lowBit=c&0xFF;     int highBit=(c&0xFF00)>>8;
           System.out.println(""+lowBit+"   "+highBit);
           String s="好";
           System.out.println("本地操作系统默认字符编码:");
           readBuff(s.getBytes());
           System.out.println("采用GBK字符编码:");
           readBuff(s.getBytes("GBK"));
           System.out.println("采用UTF-8字符编码:");      
           readBuff(s.getBytes("UTF-8"));      }
    }
    


    Reader类能够将输入流中采用其他编码类型的字符转换为Unicode字符,然后在内存中为其分配内存

    Writer类能够将内存中的Unicode字符转换为其他编码类型的字符,再写到输出流中。

     

    4、BufferedInputStream 和BufferedReader区别

    首先虽然都作为一个包装类,但是BufferedReader针对字符流,BufferedInputStream针对字节流

    BufferedInputStream在实现的时候是在自身read方法中提供缓存,是一次取1024或更多字节然后再慢慢读,一个个的返回,它并没有实现读一行的方法

    BufferedReader在实现时通过提供一个readLine方法,使用数组或者stringBuilder存储一行数据,并一次性返回

     

    九. FileWriter类(字符输出流类)


    构造方法:FileWriter fw = new FileWriter(String fileName);//创建字符输出流类对象和已存在的文件相关联。文件不存在的话,并创建。

                   如: FileWriter fw = new FileWriter("C:\\1.txt");

                     FileWriter fw = new FileWriter(String fileName,boolean append);//创建字符输出流类对象和已存在的文件相关联,并设置该该流对文件的操作是否为续写。

                   如:FileWriter fw = new FileWriter("C:\\1.txt",ture); //表示在fw对文件再次写入时,会在该文件的结尾续写,并不会覆盖掉。

    主要方法: 

            void write(String str)   //写入字符串。当执行完此方法后,字符数据还并没有写入到目的文件中去。此时字符数据会保存在缓冲区中。此时在使用刷新方法就可以使数据保存到目的文件中去。

            viod flush()                //刷新该流中的缓冲。将缓冲区中的字符数据保存到目的文件中去。

            viod close()               //关闭此流。在关闭前会先刷新此流的缓冲区。在关闭后,再写入或者刷新的话,会抛IOException异常。

    十. 如何选择IO流


     

    1、确定是数据源和数据目的(输入还是输出

                  源:输入流 InputStream Reader
                  目的:输出流 OutputStream Writer

    2、明确操作的数据对象是否是纯文本

                 是:字符流Reader,Writer
                 否:字节流InputStream,OutputStream

    3、明确具体的设备。

           是硬盘文件:File++:
                  读取:FileInputStream,, FileReader,
                   写入:FileOutputStream,FileWriter
          是内存用数组
                  是byte[]:ByteArrayInputStream, ByteArrayOutputStream
                  是char[]:CharArrayReader, CharArrayWriter
                  是String:StringBufferInputStream(已过时,因为其只能用于String的每个字符都是8位的字符串), StringReader, StringWriter
                  是网络用Socket流: 输入socket.getOutputStream()      输出socket.getInputStream()
                 是键盘:用System.in(是一个InputStream对象)读取,用System.out(是一个OutoutStream对象)打印

    4、是否需要转换流

                是,就使用转换流,从Stream转化为Reader,Writer:InputStreamReader,OutputStreamWriter 

    5、是否需要缓冲提高效率

            是就加上Buffered:BufferedInputStream, BufferedOuputStream, BuffereaReader, BufferedWriter
       

    6、是否需要格式化输出

     

    例如:将一个文件中数据存储到另一个文件中。JAVA的文件读取主要有字节流读取和字符流读取两种方式,字节流可以既可以操作文本文件,也可以操作非文本文件,如一些二进制数据(图片,视频,对象),而字符流只能操作文本。
         

    将一个文件中数据存储到另一个文件中:

    1) 数据源和数据目的:读取流,InputStream/Reader  输出:OutputStream/Writer
    2)是否纯文本:是!可以选择Reader Writer和InputStream/OutputStream。
    3)设备:是硬盘文件。Reader体系中可以操作文件的对象是 FileReader FileWriter。
                  FileReader fr = new FileReader("a.txt");  
                  FileWriter fw = new FileWriter("b.txt"); 
    4)是否需要提高效率:是,加Buffer
                 BufferedReader bfr = new BufferedReader(new FileReader("a.txt");  );  
                 BufferedWriter bfw = new BufferedWriter(new FileWriter("b.txt");  );

    package com.javademo.demo.io;
    import java.io.*;
    
    public class IoFileDemo {
        private static int BUFFER_SIZE = 1024;
        public static void main(String[] args) throws Exception {
            IoFileDemo  ioFileDemo = new IoFileDemo();
            String  fileA = "/Users/huangguisu/a.txt";
            String  fileB = "/Users/huangguisu/b.txt";
            ioFileDemo.copyFileWithBufferStream(fileA, fileB);
    
        }
    
        /**
         * 字符流读取:只能操作文本文件
         * @param srcFile
         * @throws IOException
         */
        public String readFile(String srcFile)  throws IOException {
            FileReader fr = new FileReader(srcFile);//读取流
            //不要直接用String直接拼接文本。。效率太低,每次要new新对象,用StringBuilder,StringBuffer都可以
            StringBuffer sb = new StringBuffer();
            char[] buf = new char[10];
            int len;
            //读取文件并把它存入buf中,用len返回读到字符的个数,一直读到结尾
            while ((len = fr.read(buf)) != -1) {
                //buf字符数组里仍有空白没有读入的位置,所以不要直接new String(buf);
                String str = new String(buf,0,len);
                sb.append(str);
            }
            fr.close();
            return  sb.toString();
    
        }
    
        /**
         * 字符流读取和写入:只能操作文本
         * @param srcFile
         * @param dstFile
         * @throws IOException
         */
        public void copyFileWithString(String srcFile, String dstFile)  throws IOException {
            FileReader fr = new FileReader(srcFile);//读取流
            FileWriter fw = new FileWriter(dstFile);//输出流
            char[] buf = new char[10];
            int len;
            //读取文件并把它存入buf中,用len返回读到字符的个数,一直读到结尾
            while ((len = fr.read(buf)) != -1) {
                //buf字符数组里仍有空白没有读入的位置,所以不要直接fw.write(buf);可以直接使用fw.write(buf, 0, len);
                String str = new String(buf,0,len);
                fw.write(str);
            }
            fr.close();
            fw.close();
    
        }
    
        /**
         * 使用buffer读取和写入字符流::只能操作文本
         * @param srcFile
         * @param dstFile
         * @throws IOException
         */
        public void copyFileWithBufferedString(String srcFile, String dstFile)  throws IOException {
            FileReader fr = new FileReader(srcFile);//读取流
            FileWriter fw = new FileWriter(dstFile);//输出流
            //使用Buffer提高效率
            BufferedReader bfr = new BufferedReader(fr);
            BufferedWriter bfw = new BufferedWriter(fw);
    
            String str = null;
            int j = 1;
            while ((str = bfr.readLine()) != null) {
                System.out.println("第" + j + "行内容:" + str);
                bfw.write(str);
                bfw.newLine();//跨平台的换行符
                j++;
            }
            bfr.close();
            bfw.close();
            fr.close();
            fw.close();
    
    
        }
    
        /**
         * 例:将一个二进制数据(图片,视频,对象)文件中数据存储到另一个文件中,只能用xxxStream.
         * 当然也可以读取文本文件。
         * 字节输入流和输出流
         * @param srcFile
         * @param dstFile
         * @throws IOException
         */
        public void copyFileWithStream(String srcFile, String dstFile)  throws IOException {
            FileInputStream finS = new FileInputStream(srcFile);
            FileOutputStream foutS = new FileOutputStream(dstFile);
            int c;
            while ((c = finS.read()) != -1) {
                foutS.write(c);
            }
            //或者
            /*
            byte[] buffer = new byte[1024];
            int len;
            while ((len = finS.read(buffer)) > 0){
                foutS.write(buffer, 0, len);
                len.flush();
            }
            */
            finS.close();
            foutS.close();
        }
    
        /**
         * 使用Buffer
         * @param srcFile
         * @param dstFile
         * @throws IOException
         */
        public void copyFileWithBufferStream(String srcFile, String dstFile) throws IOException{
            FileInputStream finS = new FileInputStream(srcFile);
            FileOutputStream foutS = new FileOutputStream(dstFile);
            BufferedInputStream  bufferedInput = new BufferedInputStream(finS);
            BufferedOutputStream bufferedOutput = new BufferedOutputStream(foutS);
            byte[] buffer = new byte[BUFFER_SIZE];
            int len;
            while ((len = bufferedInput.read(buffer)) > 0){
                bufferedOutput.write(buffer, 0, len);
                bufferedOutput.flush();
            }
    
            bufferedInput.close();
            bufferedOutput.close();
            finS.close();
            foutS.close();
        }
    
        /**
         * BufferedReader则是比InputStreamReader更高级,它封裝了StreamReader类,一次读取取一行的字符
         * @param srcFile
         * @param dstFile
         * @throws IOException
         */
        public void copyFileWithBufferStream2(String srcFile, String dstFile)  throws IOException {
            FileInputStream finS = new FileInputStream(srcFile);
            FileOutputStream foutS = new FileOutputStream(dstFile);
    
            InputStreamReader inputStreamReader = new InputStreamReader(finS,"utf8");
            OutputStreamWriter outputStreamWriter = new  OutputStreamWriter(foutS, "utf8");
            BufferedReader brRead = new BufferedReader(inputStreamReader);
            BufferedWriter brWriter = new BufferedWriter(outputStreamWriter);
            String line = null;
            while((line= brRead.readLine()) != null){
                System.out.println(line);
                brWriter.write(line);
                brWriter.newLine();//跨平台的换行符
                brWriter.flush();//刷新流
            }
            brRead.close();
            brWriter.close();
            finS.close();
            foutS.close();
    
        }
    
    
    }
    

     

    7、网络(socket)数据交互:

    package com.javademo.demo.socket;
    
    import java.io.*;
    import java.net.Socket;
    
    public class SocketClient {
        public static void main(String args[]) throws Exception{
            //1、创建客户端Socket,指定服务器地址和端口
            Socket socket = new Socket("127.0.0.1",10000);
            //2、获取输出流,向服务器端发送信息:由Socket对象得到输出流
            OutputStream output = socket.getOutputStream();//字节输出流
            //构造PrintWriter对象:将输出流包装成打印流
            PrintWriter printWriter = new PrintWriter(output);
            printWriter.write("{'user':'hgs'}");
            printWriter.flush();
    
    
            //3、获取输入流,并读取服务器端的响应信息:由Socket对象得到输入流
            InputStream inputStream = socket.getInputStream();
            //构造相应的BufferedReader对象
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            String info = null;
            while((info = bufferedReader.readLine()) != null){
                System.out.println("Hello,我是客户端,服务器说:"+info);
            }
    
            //4、由系统标准输入设备构造BufferedReader对象
            BufferedReader stdIn = new BufferedReader( new InputStreamReader(System.in));
            String readline;
            readline= stdIn.readLine(); //从系统标准输入读入一字符串
            //若从标准输入读入的字符串为 "ok"则停止循环
            while(!readline.equals("ok")){
                //将从系统标准输入读入的字符串输出到Server
                printWriter.println(readline);
                //刷新输出流,使Server马上收到该字符串
                printWriter.flush();
                //在系统标准输出上打印读入的字符串
                System.out.println("Client:"+readline);
                //从Server读入一字符串,并打印到标准输出上
                System.out.println("Server:"+bufferedReader.readLine());
                readline = stdIn.readLine(); //从系统标准输入读入一字符串
            }
    
        }
    }

     

    11. IOException异常类的子类


    1.public class  EOFException :
       非正常到达文件尾或输入流尾时,抛出这种类型的异常。
    2.public class FileNotFoundException:
       当文件找不到时,抛出的异常。
    3.public class InterruptedIOException:
       当I/O操作被中断时,抛出这种类型的异常。




     

    感谢您的支持,我会继续努力的! 扫码打赏,你说多少就多少

             

     

     

     

    展开全文
  • Java IO流学习总结一:输入输出流

    万次阅读 多人点赞 2017-01-09 19:49:50
    Java IO流学习总结一:输入输出流 转载请标明出处:http://blog.csdn.net/zhaoyanjun6/article/details/53761199 本文出自【赵彦军的博客】 Java流类图结构:流的概念和作用流是一组有顺序的,有起点和终点的字节...

    Java IO流学习总结一:输入输出流

    转载请标明出处:http://blog.csdn.net/zhaoyanjun6/article/details/54292148
    本文出自【赵彦军的博客】

    Java IO流学习总结一:输入输出流
    Java IO流学习总结二:File
    Java IO流学习总结三:缓冲流-BufferedInputStream、BufferedOutputStream
    Java IO流学习总结四:缓冲流-BufferedReader、BufferedWriter
    Java IO流学习总结五:转换流-InputStreamReader、OutputStreamWriter
    Java IO流学习总结六:ByteArrayInputStream、ByteArrayOutputStream
    Java IO流学习总结七:Commons IO 2.5-FileUtils

    Java流类图结构:

    这里写图片描述

    流的概念和作用

    流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象。即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输特性将流抽象为各种类,方便更直观的进行数据操作。

    IO流的分类

    • 根据处理数据类型的不同分为:字符流和字节流
    • 根据数据流向不同分为:输入流和输出流

    字符流和字节流

    字符流的由来: 因为数据编码的不同,而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时,去查了指定的码表。 字节流和字符流的区别:

    • 读写单位不同:字节流以字节(8bit)为单位,字符流以字符为单位,根据码表映射字符,一次可能读多个字节。

    • 处理对象不同:字节流能处理所有类型的数据(如图片、avi等),而字符流只能处理字符类型的数据。

    • 字节流:一次读入或读出是8位二进制。

    • 字符流:一次读入或读出是16位二进制。

    设备上的数据无论是图片或者视频,文字,它们都以二进制存储的。二进制的最终都是以一个8位为数据单元进行体现,所以计算机中的最小数据单元就是字节。意味着,字节流可以处理设备上的所有数据,所以字节流一样可以处理字符数据。

    结论:只要是处理纯文本数据,就优先考虑使用字符流。 除此之外都使用字节流。

    输入流和输出流

    输入流只能进行读操作,输出流只能进行写操作,程序中需要根据待传输数据的不同特性而使用不同的流。

    输入字节流 InputStream

    • InputStream 是所有的输入字节流的父类,它是一个抽象类。
    • ByteArrayInputStreamStringBufferInputStreamFileInputStream 是三种基本的介质流,它们分别从Byte 数组StringBuffer、和本地文件中读取数据。
    • PipedInputStream 是从与其它线程共用的管道中读取数据,与Piped 相关的知识后续单独介绍。
    • ObjectInputStream 和所有FilterInputStream 的子类都是装饰流(装饰器模式的主角)。

    输出字节流 OutputStream

    • OutputStream 是所有的输出字节流的父类,它是一个抽象类。
    • ByteArrayOutputStreamFileOutputStream 是两种基本的介质流,它们分别向Byte 数组、和本地文件中写入数据。
    • PipedOutputStream 是向与其它线程共用的管道中写入数据。
    • ObjectOutputStream 和所有FilterOutputStream 的子类都是装饰流。

    总结:

    • 输入流:InputStream或者Reader:从文件中读到程序中;
    • 输出流:OutputStream或者Writer:从程序中输出到文件中;

    节点流

    节点流:直接与数据源相连,读入或读出。
    直接使用节点流,读写不方便,为了更快的读写文件,才有了处理流。
    这里写图片描述

    常用的节点流

    • 父 类 :InputStreamOutputStreamReaderWriter
    • 文 件 :FileInputStreamFileOutputStreanFileReaderFileWriter 文件进行处理的节点流
    • 数 组 :ByteArrayInputStreamByteArrayOutputStreamCharArrayReaderCharArrayWriter 对数组进行处理的节点流(对应的不再是文件,而是内存中的一个数组)
    • 字符串 :StringReaderStringWriter 对字符串进行处理的节点流
    • 管 道 :PipedInputStreamPipedOutputStreamPipedReaderPipedWriter 对管道进行处理的节点流

    处理流

    处理流和节点流一块使用,在节点流的基础上,再套接一层,套接在节点流上的就是处理流。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装,称为流的链接。
    这里写图片描述

    常用的处理流

    • 缓冲流:BufferedInputStreanBufferedOutputStreamBufferedReaderBufferedWriter 增加缓冲功能,避免频繁读写硬盘。
    • 转换流:InputStreamReaderOutputStreamReader实现字节流和字符流之间的转换。
    • 数据流: DataInputStreamDataOutputStream 等-提供将基础数据类型写入到文件中,或者读取出来。

    转换流

    InputStreamReaderOutputStreamWriterInputStreamOutputStream作为参数,实现从字节流到字符流的转换。

    构造函数

    InputStreamReader(InputStream);        //通过构造函数初始化,使用的是本系统默认的编码表GBK。
    InputStreamReader(InputStream,String charSet);   //通过该构造函数初始化,可以指定编码表。
    OutputStreamWriter(OutputStream);      //通过该构造函数初始化,使用的是本系统默认的编码表GBK。
    OutputStreamwriter(OutputStream,String charSet);   //通过该构造函数初始化,可以指定编码表。
    

    实战演练

    • FileInputStream类的使用:读取文件内容
    package com.app;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    
    public class A1 {
    
    	public static void main(String[] args) {
    		A1 a1 = new A1();
    	
    		//电脑d盘中的abc.txt 文档
    		String filePath = "D:/abc.txt" ;
    		String reslut = a1.readFile( filePath ) ;
            System.out.println( reslut ); 
    	}
    
    
    	/**
    	 * 读取指定文件的内容
    	 * @param filePath : 文件的路径
    	 * @return  返回的结果
    	 */
    	public String readFile( String filePath ){
    		FileInputStream fis=null;
    		String result = "" ;
    		try {
    			// 根据path路径实例化一个输入流的对象
    			fis  = new FileInputStream( filePath );
    
    			//2. 返回这个输入流中可以被读的剩下的bytes字节的估计值;
    			int size =  fis.available() ;
    			//3. 根据输入流中的字节数创建byte数组;
    			byte[] array = new byte[size];
    			//4.把数据读取到数组中;
    			fis.read( array ) ; 
    
    			//5.根据获取到的Byte数组新建一个字符串,然后输出;
    			result = new String(array);	
    
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		}catch (IOException e) {
    			e.printStackTrace();
    		}finally{
    			if ( fis != null) {
    				try {
    					fis.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    
    		return result ;
    	}
    
    
    }
    
    
    
    • FileOutputStream 类的使用:将内容写入文件
    package com.app;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class A2 {
    
    	public static void main(String[] args) {
    		A2 a2 = new A2();
    
    		//电脑d盘中的abc.txt 文档
    		String filePath = "D:/abc.txt" ;
    
    		//要写入的内容
    		String content = "今天是2017/1/9,天气很好" ;
    		a2.writeFile( filePath , content  ) ;
    
    	}
    
    	/**
    	 * 根据文件路径创建输出流
    	 * @param filePath : 文件的路径
    	 * @param content : 需要写入的内容
    	 */
    	public void writeFile( String filePath , String content ){
    		FileOutputStream fos = null ;
    		try {
    			//1、根据文件路径创建输出流
    			fos  = new FileOutputStream( filePath );
    
    			//2、把string转换为byte数组;
    			byte[] array = content.getBytes() ;
    			//3、把byte数组输出;
    			fos.write( array );
    
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		}catch (IOException e) {
    			e.printStackTrace();
    		}finally{
    			if ( fos != null) {
    				try {
    					fos.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    
    
    }
    
    

    注意:

    1. 在实际的项目中,所有的IO操作都应该放到子线程中操作,避免堵住主线程。
    2. FileInputStream在读取文件内容的时候,我们传入文件的路径("D:/abc.txt"), 如果这个路径下的文件不存在,那么在执行readFile()方法时会报FileNotFoundException异常。
    3. FileOutputStream在写入文件的时候,我们传入文件的路径("D:/abc.txt"), 如果这个路径下的文件不存在,那么在执行writeFile()方法时, 会默认给我们创建一个新的文件。还有重要的一点,不会报异常。

    效果图:

    这里写图片描述

    • 综合练习,实现复制文件,从D盘复制到E盘
    package com.app;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public class A3 {
    
    	public static void main(String[] args) {
    		A3 a2 = new A3();
    
    		//电脑d盘中的cat.png 图片的路径
    		String filePath1 = "D:/cat.png" ;
    
    		//电脑e盘中的cat.png 图片的路径
    		String filePath2 = "E:/cat.png" ;
    
    		//复制文件
    		a2.copyFile( filePath1 , filePath2 );
    
    	}
    
    	/**
    	 * 文件复制 
    	 * @param filePath_old : 需要复制文件的路径
    	 * @param filePath_new : 复制文件存放的路径
    	 */
    	public void copyFile( String filePath_old  , String filePath_new){
    		FileInputStream fis=null ;
    		FileOutputStream fout = null ;
    		try {
    			// 根据path路径实例化一个输入流的对象
    			fis  = new FileInputStream( filePath_old );
    
    			//2. 返回这个输入流中可以被读的剩下的bytes字节的估计值;
    			int size =  fis.available() ;
    			//3. 根据输入流中的字节数创建byte数组;
    			byte[] array = new byte[size];
    			//4.把数据读取到数组中;
    			fis.read( array ) ; 
    
    			//5、根据文件路径创建输出流
    			fout = new FileOutputStream( filePath_new ) ;
    			
    			//5、把byte数组输出;
    			fout.write( array );
    
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		}catch (IOException e) {
    			e.printStackTrace();
    		}finally{
    			if ( fis != null) {
    				try {
    					fis.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    			if ( fout != null ) {
    				try {
    					fout.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}	
    			}
    		}
    	}
    }
    
    
    展开全文
  • Java实现文件写入——IO流(输入输出流详解)

    万次阅读 多人点赞 2017-09-09 20:43:12
    流是一组有序的数据序列,根据操作的类型,分为输入流和输出流。 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;程序从输入流读取数据,向输出流写入数据。Java是面向对象的程序语言,每一个数据流都是一个...

    输入输出的重要性:

         输入和输出功能是Java对程序处理数据能力的提高,Java以流的形式处理数据。流是一组有序的数据序列,根据操作的类型,分为输入流和输出流。

         程序从输入流读取数据,向输出流写入数据。Java是面向对象的程序语言,每一个数据流都是一个对象,它们提供了各种支持“读入”与“写入”操作的流类。

    Java的输入输出功能来自java.io 包中的InputStream类、OutputStream类、Reader类和Writer类以及继承它们的各种子类。


    (一)解析文件处理的奥秘



    1、学习使用文件类 : File类


         File类用于封装系统的文件和目录的相关信息。在该类中定义了一些与平台无关的方法来操作文件。例如文件的大小、修改时间、文件路径等。

    创建 File 对象可以通过下面3种方式:

    方法1: 方法2: 方法3:
    new File(String pathName) File file = new File(“E://1.txt”) new File(String parent , String child)
    parent :父抽象路径名;child:子路径名字符串

    2、如何获取文件信息

    File 类是对文件和文件夹的抽象,包含了对文件和文件夹的多种属性和操作方法。File类的常用方法如下表:

    返回 方法 说明
    String getName 获取文件名称
    String getParent 获取文件的父路径字符串
    String getPath 获取文件的相对路径字符串
    String getAbsolutePath 获取文件的绝对路径字符串
    boolean exists 判断文件或者文件夹是否存在
    boolean isFile 判断是不是文件类型
    boolean isDirectory 判断是不是文件夹类型
    boolean delete 删除文件或文件夹,如果删除成功返回结果为true
    boolean mkdir 创建文件夹,创建成功返回true
    boolean setReadOnly 设置文件或文件夹的只读属性
    long length 获取文件的长度
    long lastModified 获取文件的最后修改时间
    String[ ] list 获取文件夹中的文件和子文件夹的名称,并存放到字符串数组中

    下面通过实例介绍File类获取文件信息

    package com.zch.io;
    
    import java.io.File;
    import java.util.Date;
    
    /**
     * 在src根目录下创建FileInfo类,在该类的主方法中创建文件对象,通过File类的相关方法,获取文件的相关信息
     * 
     * @author zch
     * 
     */
    public class FileInfo {
    	public static void main(String[] args) {
    
    		String filePath = "src/com/zch/io/FileInfo.java";
    		// 根据指定路径创建文件对象
    		File file = new File(filePath);
    		System.out.println("文件名称:" + file.getName());
    		System.out.println("文件是否存在:" + file.exists());
    		System.out.println("文件的相对路径:" + file.getPath());
    		System.out.println("文件的绝对路径:" + file.getAbsolutePath());
    		System.out.println("是否为可执行文件:" + file.canExecute());
    		System.out.println("文件可以读取:" + file.canRead());
    		System.out.println("文件可以写入:" + file.canWrite());
    		System.out.println("文件上级路径:" + file.getParent());
    		System.out.println("文件大小:" + file.length() + "B");
    		System.out.println("文件最后修改时间:" + new Date(file.lastModified()));
    		System.out.println("是否文件类型:" + file.isFile());
    		System.out.println("是否为文件夹:" + file.isDirectory());
    
    	}
    
    }
    
    

    运行结果如下:

    文件名称:FileInfo.java
    文件是否存在:true
    文件的相对路径:src\com\zch\io\FileInfo.java
    文件的绝对路径:D:\Java\IO\src\com\zch\io\FileInfo.java
    是否为可执行文件:true
    文件可以读取:true
    文件可以写入:true
    文件上级路径:src\com\zch\io
    文件大小:1195B
    文件最后修改时间:Sat Sep 09 21:30:10 CST 2017
    是否文件类型:true
    是否为文件夹:false
    

    在使用delete()方法删除File对象时,如果删除的对象是目录,该目录中的内容必须为空。


    (二)使用字节输入输出流

         字节流用于处理二进制数据的读取和写入,它以字节为单位,InputStream类和OutputStream类是字节流的抽象类,它们定义了数据流读取和写入的基本方法。各个子类会依其特点实现或覆盖这些方法。


    1、字节数入流抽象类InputStream

          InputStream 类是字节输入流的抽象类,定义了操作输入流的各种方法,这些方法如表:

    返回 方法 说明
    int available() 返回当前输入流的数据读取方法可以读取的有效字节数量
    Abstract int read() 从当前数据流中读取一个字节。若已达到流结尾,则返回-1
    int read(byte[ ] bytes) 从当前输入流读取一定的byte数据,并存取在数组中,然后返回读取的byte数据的数量,若已到达流结尾,则返回-1。
    void reset() 将当前的输入流重新定位到最后一次调用mark()方法时的位置
    void mark(int readlimit) 在当前输入流中做标记位置,当调用reset()方法时将返回到该位置,从标记位置开始,到再读入readlimit个字符为止,这个标记都维持有效。
    Boolean markSupported() 测试当前输入流是否支持mark()和reset()方法,只要其中一个不支持,则返回false
    long skip(long n) 跳过和丢弃当前输入的n个字节数据
    void close() 关闭当前输入流,并释放任何与之相关联的系统资源

         InputStream 类是抽象类,不能通过new关键字来创建该实例对象,需要其子类创建该实例对象。下面通过实例如何使用InputStream从控制台获取用户输入的数据信息。

    package com.zch.io;
    
    import java.io.IOException;
    import java.io.InputStream;
    
    /**
     * 创建InputStream实例inp,并将其赋值为System类的in属性,定义为控制台输入流,从inp输入流中获取字节信息,
     * 用这些字节信息创建字符串,并将其在控制台上输出。
     * @author zch
     *
     */
    public class InputMessage {
    	public static void main(String[] args) {
    		InputStream inp = System.in;
    		
    		byte[] bytes = new byte[1024];
    		
    		try {
    			while(inp.read() != -1){
    				//根据用户输入的信息创建字符串
    				
    				String str = new String(bytes).trim();
    				
    			}
    			inp.close();		//关闭流
    			
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    	}
    }
    
    


    2、字节输出流抽象类OutputStream类


    OutputStream定义了输出流的各种方法,如下表:
    返回 方法 说明
    void write(byte[ ] b) 将byte[ ] 数组中的数据写入当前输出流
    void write(byte[] b ,int off, int len) 将byte[ ]数组下标off开始的len长度的数据写入当前输出流
    Abstract void write(int b) 写入一个byte数据到当前输出流
    void flush() 刷新当前输出流,并强制写入所有缓冲的字节数据
    void close() 关闭当前输出流

         和InputStream类一样,OutputStream 类是抽象类,不能通过new关键字来创建该实例对象,需要其子类创建该实例对象。

    package com.zch.io;
    
    import java.io.IOException;
    import java.io.OutputStream;
    
    /**
     * 创建OutputStream实例out,并将其赋值为System.out标准输出流。通过write()方法向流写入数据。
     * @author zch
     *
     */
    public class OutputData {
    	public static void main(String[] args) {
    	OutputStream output = System.out;			//实例化OutputStream对象
    	
    	byte[] bytes = "使用OutputStream输出流在控制台输出字符串\n".getBytes();		//创建bytes数组
    	
    	try {
    		output.write(bytes);
    		
    		bytes = "输出内容:\n".getBytes();
    		output.write(bytes);        //向流中写入数据
    		
    		bytes = "Java数据交互管道——IO流 \n".getBytes();
    		output.write(bytes);
    		
    		output.close();
    		
    	} catch (IOException e) {
    		// TODO Auto-generated catch block
    		e.printStackTrace();
    	}
    	}
    }
    
    

    输出结果如下:

    使用OutputStream输出流在控制台输出字符串
    输出内容:
       Java数据交互管道——IO流 
    
    



    3、文件字节输入流类 : FileInputStream类


         文件字节输入流可以从指定路径的文件中读取字节数据。文件字节输入流类继承InputStream类,并实现了读取输入流的各种方法。

           创建文件字节输入流创建的构造方法语法如下:

    • 语法1:以File对象为参数创建FileInputStream实例
    new FileInputStream(File file)
    
    • 语法2:以文件对象的绝对路径为参数创建FIleInputStream实例
    new FileInputStream(String filepath)
    

    4、文件字节输出流类:FileOutputStream

          文件字节输出流关联指定文件路径的文件,数据通过文件字节输出流以字节为单位输出并保存到文件中。文件字节输出流继承自OutputStream类,并实现OutputStream类的各种方法。

           文件字节输出流的构造方法语法如下:

    • 语法1:以File对象为参数创建FileOutputStream实例
    new FileOutputStream(File file)
    
    • 语法2:以文件对象的绝对路径为参数创建FIleOutputStream实例
    new FileOutputStream(String filepath)
    
    

    下面通过实例介绍文件的写入和读取:

    package com.zch.io;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /**
     * 创建OutputStream实例out,并将其赋值为System.out标准输出流,通过write方法向流中写入数据
     * 
     * @author zch
     * 
     */
    public class FileCreate {
    	public static void main(String[] args) {
    		File file = new File("D:/", "word.txt");  //创建文件对象
    
    		try {
    			if (!file.exists()) {				//如果文件不存在则新建文件
    				file.createNewFile();			
    
    			}
    			FileOutputStream output = new FileOutputStream(file);
    
    			byte[] bytes = "Java数据交流管道——IO流".getBytes();
    
    			output.write(bytes);				//将数组的信息写入文件中
    
    			output.close();
    
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    
    		try {
    			FileInputStream input = new FileInputStream(file);
    
    			byte[] bytes2 = new byte[1024];
    
    			int len = input.read(bytes2);
    
    			System.out.println("文件中的信息是:" + new String(bytes2, 0, len));
    
    			input.close();
    
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    
    	}
    }
    
    
    

    (三) 使用字符输入输出流

          字符输入输出流 与 字节输入输出流有相同的功能,但传送数据的方式不一样,字节流以字节为单位传送数据,可以使任何类型的数据,例如文本、音频、视频、图片等。字符流以字符为单位传送数据,只能传送文本类型的数据。使用字符输入输出流的好处是,当读取中文时不会出现乱码问题,而使用字节输入输出流时,却不能保证这一点。

    1、字符输入流抽象类:Reader类

    该类定义了操作字符输入流的方法,如下表:

    返回 方法 说明
    boolean ready() 判断此数据流是否准备好
    int read() 读入一个字符,若已读到流结尾,则返回值为-1
    int read(char[ ]) 读取一些字符到char[ ]数组内,并返回所读入的字符的数量,若已到达流结尾,则返回-1
    Abscract int read(char[ ] chars,int off,int len) 读取一些字符到char[ ]数组下标从off开始到off+len的位置,并返回所读入的字符的数量,若已到达流结尾,则返回-1;
    void reset() 将当前输入流重新定位到最后一次mark()方法时的位置
    void mark(int readLimit) 将当前输入流中做标记,当调用reset方法时将返回到该位置,从标记位置开始,到再读入readLimit个字符为止,这个标记都维持有效
    boolean markSupported 测试当前输入流是否支持mark()方法和reset()方法。只要有一个方法不支持,则返回-1
    long skip(long n) 跳过参数n指定的字符数量,并返回所跳过字符的数量
    Abstract void close() 关闭字符输入流,并释放与之关联的所有资源



    2、字符输出流类Writer类

           Writer 类主要是用于解决字符输入流的类,其地位与Reader类在输入流的地位和作用是相同的,也是所有字符输出流的流类。


    Writer类的主要方法如下:

    返回 方法 说明
    void write(char[ ] cbuf) 将字符数组的数据写入字符输出流
    Abstract void write(char[ ] cbuf int off ,int len) 将字符数组从下标off 开始向输入流写入长度为len的数据
    void write(int c ) 向字符输入流中写入一个字符数据
    void write(String str ) 向输入流中写入一个字符串数据
    void write(String str , int off ,int len) 向输入流中写入一个字符串从off 开始长度为len的数据
    Abstract void flush() 刷新当前输出流,并强制写入所有缓冲区的字节数据
    void close() 向输出流中写入缓冲区的数据,然后关闭当前输出流,释放所有与当前输出流相关联的系统资源


    3、文件字符输入流FileReader

           文件字符输入流与文件字节输入流的功能相似,但是传送数据的方式不一样,字节流以字节为单位传送数据,可以使文本、视频、音频、图片等。字符流以字符为单位传送数据,只能传送文本类型的数据。

    创建字符输入流常用的构造方法:

    • 语法1:
    new FileReader(File file);
    
    
    • 语法2:
    new FileReader(String path);
    
    

    下面通过实例介绍FileReader类读取指定磁盘文件的内容。

    package com.zch.io;
    
    import java.io.File;
    import java.io.FileReader;
    
    public class FileInAndOut {
    	public static void main(String[] args) {
    		//定义指定磁盘的文件的File对象
    		File file = new File("D://word.txt");
    		
    		if(! file.exists()){
    			System.out.println("对不起,不包含指定路径的文件");
    		}else{
    			//根据指定路径的File对象创建FileReader对象
    			try {
    				FileReader fr = new FileReader(file);
    				
    				char[] data = new char[23];			//定义char数组
    				
    				int length = 0;
    				
    				while((length = fr.read(data))>0){			//循环读取文件中的数据
    					String str = new String(data,0,length);			//根据读取文件的内容创建String 对象
    					System.out.println(str);				//输出读取内容
    				}
    				fr.close();								//关闭流
    				
    				
    				
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			
    		}
    	}
    }
    
    
    

    运行结果如下图:

    这里写图片描述
    这里写图片描述


    4、文件字符输出流FileWriter

           文件字符输出流继承自Writer类,提供了向文件输出的各种方法,数据通过文件字符输出流以字符为单位输出并保存到文件中。

    package com.zch.io;
    /**
     * 通过给定的String类型参数的指定文件名称与路径,创建FileWriter类。
     * 
     * @author zch
     */
    import java.io.File;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    
    public class FileWriterDemo {
    	public static void main(String[] args) {
    		File file = new File("D://word2.txt");		//创建指定文件
    		
    		try {
    		if(! file.exists()){
    				file.createNewFile();				//如果指定文件不存在,新建文件
    			
    		}
    		
    		FileReader fr = new FileReader("D://word.txt");
    		
    		FileWriter fw = new FileWriter(file);				//创建FileWriter对象
    		
    		int length = 0;
    		while((length = fr.read()) != -1){			//如果没有读到文件末尾
    			fw.write(length);			//向文件写入数据
    			
    		}
    		fr.close();							//关闭流
    		fw.close();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    }
    
    
    

    运行后创建了Word2.txt 文件,并向其中写入数据
    这里写图片描述


    (四)IO流实战:

    1、Java IO流实现复制文件夹

           通过IO不仅可以复制文件,还可以复制文件夹,但是文件夹内,可能包含其他文件夹,因此需要对他们进行分别复制。

    package com.zch.io;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    
    public class CopyFile {
    	public static void main(String[] args) {
    		File sourceFile = null;
    		File desFile = null;
    
    		String sourceFolder = "D://简历2";
    		String copyFolder = "D://copy";
    
    		sourceFile = new File(sourceFolder);
    
    		if (!sourceFile.isDirectory() || !sourceFile.exists()) {
    			System.out.println("源文件夹不存在!");
    		} else {
    			desFile = new File(copyFolder);
    			desFile.mkdir();
    
    			copy(sourceFile.listFiles(), desFile);
    			System.out.println("文件夹复制成功!");
    		}
    	}
    /**
     * 创建copy方法,该方法接收文件数组和目标文件夹两个参数,如果目标文件夹不存在,则调用mkdir()方法创建文件夹,然后再循环中将文件数组
     * 中的每个文件对象写到目标文件夹内。
     * @param fl
     * @param file
     */
    	public static void copy(File[] fl, File file) {
    		if (!file.exists()) { // 如果文件夹不存在
    			file.mkdir(); // 建立新的文件夹
    		}
    
    		for (int i = 0; i < fl.length; i++) {
    			if (fl[i].isFile()) { // 如果是文件类型,则复制文件
    				try {
    					FileInputStream fis = new FileInputStream(fl[i]);
    					FileOutputStream out = new FileOutputStream(new File(
    							file.getPath() + File.separator + fl[i].getName()));
    
    					int count = fis.available();
    					byte[] data = new byte[count];
    
    					if ((fis.read(data)) != -1) {
    						out.write(data);
    					}
    				} catch (Exception e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    			}
    
    			if (fl[i].isDirectory()) { // 如果是文件夹类型
    				File des = new File(file.getPath() + File.separator
    						+ fl[i].getName());
    				des.mkdir(); // 在目标文件夹中创建相同的文件夹
    				copy(fl[i].listFiles(), des); // 递归调用方法本身
    			}
    
    		}
    
    	}
    }
    
    
    

    运行本实例,会将D盘中的简历文件中的内容复制到D盘的copy文件夹中,而且包含文件夹的子文件夹


    2、Java IO流实现分行向文件中写入数据

          FileWriter类可以向文件写入字符数据,如果将FileWriter类封装到BufferWriter类的缓冲字符流中,能够实现缓冲字符输出流,并且可以通过读输出流的newLine()方法,来实现数据的分行写入。

    package com.zch.io;
    
    import java.io.BufferedWriter;
    import java.io.File;
    import java.io.FileWriter;
    import java.io.IOException;
    
    /**
     * 创建BranchWriter类,在主方法中定义文件对象,将该对象作为参数创建BufferedWriter类实例,
     * 调用该实例的writer方法将数据写入文件中,然后 调用newLine()方法写入换行符,实现分行向文件写入数据。
     * 
     * @author zch
     * 
     */
    public class BranchWriter {
    	public static void main(String[] args) {
    		String filePath = "D://BranchWriter.txt";
    
    		File file = new File(filePath);
    
    		try {
    			if (!file.exists()) {
    				file.createNewFile();
    			}
    			FileWriter fw = new FileWriter(file); // 创建文件输出流
    
    			BufferedWriter bw = new BufferedWriter(fw); // 使用缓冲区数据流封装输出流
    			for (int i = 0; i < 100; i++) {				//循环写入100行数据
    				
    				bw.write("Java交互管道——IO流".toCharArray());// 写入数据到输出流
    				
    				bw.newLine(); // 写入换行符
    				
    				bw.flush(); // 刷新缓冲区
    			}
    
    			System.out.println("成功写入数据!");
    
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    }
    
    
    

    3、删除指定文件

           File类的delete()方法可以实现删除指定的文件,首先使用目标文件路径创建File类的实例对象,然后再调用File类的delete()方法。

    package com.zch.io;
    
    import java.io.File;
    
    public class FileDelete {
    
    	public static void main(String[] args) {
    		String filePath = "D://word.txt";
    
    		File file = new File(filePath);
    		delFile(file);
    	}
    
    	public static void delFile(File file) {
    		if (!file.exists()) {
    			System.out.println("文件不存在!");
    			return;
    		}
    		boolean rs = file.delete();
    		if (rs) {
    			System.out.println("文件删除成功!");
    		} else {
    			System.out.println("文件删除失败!");
    		}
    	}
    }
    
    
    
    展开全文
  • C++ 输入输出流

    千次阅读 2021-04-06 20:08:31
    C++ 输入输出流 输入输出流基本概念 与输入输出流操作相关的类:类的继承关系从上往下如下图所示 istream:用于输入的流类,cin 是该类的对象 ostream:用于输出的流类,cout cerr clog 是该类的对象 ifstream:...
  • 流 输入流的指向称为源,程序从指向源的输入流中读取源中的数据。当程序需要读取数据时,就会开启一个通向数据源的流,这个数据源可以...输出流的指向称为目的地,程序通过向输出流中写入数据把信息传递到目的地。 ...
  • Java输入/输出流

    千次阅读 2021-01-01 19:21:49
    Java输入/输出流 一、流的概念 输入流只能读不能写,输出流只能写不能读。按照流中数据的处理单位不同,可将流分为字节流和字符流。在字节流中,数据的组织和操作的基本单位是字节;在字符流中,数据的组织和操作的...
  • //保存原输出流 PrintStream out=System.out; //保存原错误输出流 PrintStream err=System.err; //建立新的输出流 PrintStream ps=new PrintStream("./log.txt"); System.out....
  • 标准输出流

    2018-11-03 21:00:10
    标准输出流是流向标准输出设备(显示器)的数据。ostream类定义了三个输出流对象:cout,cerr,clog。 (1)cout流对象: cout不是C++的关键字,是ostream流类的对象,在iostream中定义。用cout&lt;&lt;...
  • 输入流和输出流理解

    千次阅读 2018-08-09 15:34:00
    输入流就是把数据(键盘输入、鼠标、扫描仪等等外设设备)读入到内存(程序)中,输出流就是把内存(程序)中的数据输出到外设或其他地方,从文件角度简单总结就是,输入流就是读数据,输出流就是写数据。...
  • 文件输入输出流->带缓冲的输入输出流(过滤流)->基本数据的输入输出流 链接 这样的好处是增强了文件输入输出流的功能  例如 我们只用文件流不能直接对文件写入 int char float 等类型的数据 但是我们吧这三个...
  • 输入流和输出流的区别

    千次阅读 2020-03-20 22:37:44
    输入流与输出流 输入输出的方向是针对程序而言,向程序中读入数据,就是输入流;从程序中向外写出数据,就是输出流。 简单来讲: 你编写了一个java程序, 你用这个java程序从你的电脑上读取文件,就是输入流; 你把...
  • 字节输出流和字节输入流

    千次阅读 2019-06-23 16:10:38
    字节输出流和输入流1. 字节输出流 之前介绍的File文件操作类可以关联本地文件系统,实现文件的创建,删除和查询一些文件信息。但是File类不支持对文件内容进行操作,如果要处理文件内容,必须通过流的方式。 流分为...
  • 【Java 输入、输出流

    千次阅读 多人点赞 2021-04-15 17:02:47
    Java 输入、输出流(I/O流)1 File类1.1 文件的属性1.2 目录2 文件字节输入、输出流二级目录三级目录3 文件字符输入、输出流二级目录三级目录4 缓冲流二级目录三级目录 概述:输入、输出流提供一条通道程序,可以...
  • 字符输出流和字符输入流

    千次阅读 2019-06-23 17:11:25
    字符输出流和输入流字符输出流字符输入流 字节流和字符流操作的本质区别只有一个:字节流是原生的操作,而字符流是经过处理后的操作。 在进行网络数据传输、磁盘数据保存所支持的数据类型只有字节。 字符输出流 字符...
  • 输出流(SideOutput) 大部分的DataStream API的算子的输出是单一输出,也就是某种数据类型的流。除了split算子,可以将一条流分成多条流,这些流的数据类型也都相同。process function的side outputs功能可以产生...
  • c++输入输出流

    千次阅读 2019-08-12 18:03:13
    输入输出流 cout 标准输出流 全局流对象 有缓冲区 输出到显示器 cin 标准输入流 全局流对象 有缓冲区 输出到显示器 cerr 标准错误流 没有缓冲区 输出到显示器 clog 标准日志流 有缓冲区 输出到显示器 cin.get() ...
  • IO流(输入流和输出流)

    千次阅读 2017-08-03 21:51:57
    1. 输入流和输出流的联系和区别,字符流和字节流的联系和区别 输入流是得到数据,输出流是输出数据。 字符流和字节流是流的一种划分,按处理照流的数据单位进行的划分。 两类都分为输入和输出操作。 在字节流中...
  • JAVA 输入流 与 输出流 概念剖析

    千次阅读 2020-07-06 12:15:42
    字节流 InputStrean字节输入流从文件到程序 ...字节输出流:数据以字节形式从程序流出,输出流只能向流中写入数据,使用OutputStream 1. InputStrean的主要方法 类方法 描述 Public void close() 关闭...
  • 1.1 标准输入输出流 public static final InputStream in:标准输入流 public static final PrintStream out:标准输出流 OutputStreamWriter:将字节输出流转换为字符输出流 public class ...
  • 重定向标准输入输出流以及标准错误输出流的重定向:(ex:System.out 把数据输出到控制台,通过重定向可以改变输出的目的地) System中提供对应的重定向的方法:static void setOut(PrintStream out):重新分配...
  • 标准输入输出流以及标准错误输出流的基本使用: System.out是一个特殊的 PrintStream "标准"输出流==》 输出结果到控制台System.err是一个特殊的 PrintStream "标准"错误输出流==》输出到控制台System.in是一个...
  • 文件输入流和输出流详解

    千次阅读 2018-06-24 14:30:38
    按照流向划分为输入流和输出流 输入流:就是以程序为中心点,硬盘上的文件内容流入到程序中可以存储数据的东西中比如说数组,用read方法 输出流:就是以程序为中心点,程序中的数组或者其他的可以存储数据的东西中...
  • 三、字节输出流 四、字节输入流 五、字节流文件复制 六、字符输出流 七、字符输入流 八、字符流复制文本文件 一、File 类 1. 概述 文件 和 目录路径名 的抽象表达形式 Java中把文件或者目录(文件夹)都封装成 File...
  • 【C++】输入流和输出流

    千次阅读 2019-07-15 00:15:21
    【C++】输入流和输出流一. 流的概念和流类库的结构二. 标准I/O流三. 标准输入流四. 标准输出流1. 字符输出2. 格式化输出五. 文件读写1. 文件流类和文件流对象2. C++打开文件3. C++关闭文件4. C++对ASCII文件的读写...
  • Java输入输出流

    千次阅读 多人点赞 2017-02-18 17:07:20
    Java输入输出流
  • 字节流:可以处理一切。(包括音频、图片、视频之类) InputStream ---文件的复制--->  OutputStream  输入流:InputStream ...输出流:OutputStream FileOutputStream BufferedOutputStream  
  • “标准”输出流。此流已打开并准备接受输出数据。通常,此流对应于显示器输出或者由主机环境或用户指定的另一个输出目标。对于简单独立的 Java 应用程序,编写一行输出数据的典型方式是:System.out.println(data);...
  • springmvc 输出流导出

    千次阅读 2017-02-15 14:28:34
    springmvc 输出流导出
  • 按流动方向可以分为输入流及输出流两种,输入流,输出流是以程序为参考点来说的 输入流:就是程序从中获取数据的流,输入流的一边是程序,而另一边就是流的数据源 输出流:就是程序要其写数据的流,输出流的一边则...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 82,640
精华内容 33,056
关键字:

输出流