精华内容
下载资源
问答
  • java输入输出节点流过滤流

    千次阅读 2016-12-09 19:58:30
    java的IO使用装饰者模式,装饰者模式分为装饰者和被装饰者,对应的就是java IO的节点流过滤流节点流就是基本流,过滤流保证节点流,添加特色功能,在构造函数中有一个InputStream参数,这是我区分节点流过滤...

    java的IO使用装饰者模式,装饰者模式分为装饰者和被装饰者,对应的就是java IO的节点流和过滤流。
    节点流就是基本流,过滤流保证节点流,添加特色功能,在构造函数中有一个InputStream参数,这是我区分节点流和过滤流的方法,我们编程一般使用过滤流的引用。以前以为FilterInputStream的子类是过滤流,现在不这样认为了。
    如何知道过滤流的特色功能呢?
    通过类名和方法推测。

    java的IO分为两种字节和字符
    字符不仅限于中文,还有字母,数字,标点符号等,但文本中包含中文推荐使用字符流,一个中文对应两个字节(unicode),由于字节流逐个字节读取,可能丢失一个字节,出现乱码的情况。而字符流是逐个字符读取的。

    字节和字符的转换

    OutputStreamWriter
    字符流转化为字节流,因为计算机底层就是字节流,使用sun.nio.cs.StreamEncoder类实现转换的功能,可以看出这是sun提供的非java标准的实现类,我想这个类用户是可以自定义实现的,这个类源码没有随jdk一起发布

    InputStreamReader
    把字节转化为字符流,字符是人类可读,使用sun.nio.cs.StreamDecoder实现解码

    展开全文
  • (1)一个人只要自己不放弃自己,整个世界也不会放弃你. (2)天生我才必有大用 (3)不能忍受学习之苦就一定要忍受生活之苦,这是多么痛苦而...节点流过滤流2.OutputStream3.输出流写数据的逻辑4.过滤流5.BufferedOu.

    (1)一个人只要自己不放弃自己,整个世界也不会放弃你.
    (2)天生我才必有大用
    (3)不能忍受学习之苦就一定要忍受生活之苦,这是多么痛苦而深刻的领悟.
    (4)做难事必有所得
    (5)精神乃真正的刀锋
    (6)战胜对手有两次,第一次在内心中.
    (7)编写实属不易,若喜欢或者对你有帮助记得点赞+关注或者收藏哦~

    Java SE 091 节点流、过滤流深入详解

    1.节点流过滤流

    在这里插入图片描述

    FilterInputStream以及它的子类是过滤流,其余的是节点流。

    2.OutputStream

    在这里插入图片描述

    package com.javareview.io.stream;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    
    /**
     * 数据由程序流向文件
     * @author x_xiongjie
     *(1)对于文件输出流,如果有文件,就可以直接往文件里面写入内容。
     *(2)如果没有文件,就新建一个文件,然后将内容写到新建的文件里面去。
     *(3)若不想每次在写入文件内容时后写入的文件内容将前面写入的文件内容覆盖掉,则可在构建文件输出流时将追加方式设置为true.即在构造方法中加入将追加设置为true。
     */
    public class OutputStreamTest1 {
    	public static void main(String[] args) throws IOException {
    		OutputStream os = new FileOutputStream(new File("d:/test.txt"),true);
    		String str = "Xiong Jie and Liu Manlin will get married!";
    		byte[] buffer = str.getBytes();
    		os.write(buffer);
    		os.close();
    	}
    }
    

    3.输出流写数据的逻辑

    在这里插入图片描述

    4.过滤流

    在这里插入图片描述
    在这里插入图片描述

    5.BufferedOutputStream(缓冲输出流)

    在这里插入图片描述

    (1)BufferedInputStream与BufferedOutputStream都是过滤流,即它们不能直接与文件打交道。它们是与一个节点流打交道的。

    import java.io.BufferedOutputStream;
    import java.io.FileOutputStream;
    import java.io.OutputStream;
    /**
     * 缓冲流不会直接的去写到文件里面,而是写到内存的缓冲区,缓冲区什么时候会将内存中的数据写入目标呢?
     * 有两种方式:
     * 1、flush()方法:清空绥中的输出流,强制的使得任何的缓冲输出字节,都会被写到底层的输出流里面,本例中它底层的输出流就是
     * FileOutputStream,写到它里边儿去之后,它就会写到文件里面去。
     * 2、close()方法,在关闭流之前,会先将缓冲区里面的东西清空,即调用一下flush()方法,然后再将数据写到目标。
     * @author x_xiongjie
     *
     */
    public class BufferedOutputStreamTest1 {
    	public static void main(String[] args) throws Exception {
    		OutputStream os = new FileOutputStream("d:/te.txt");
    		BufferedOutputStream bos = new BufferedOutputStream(os);
    		bos.write("Xiong Jie and Liu Manlin will get married!".getBytes());
    		bos.close();
    		os.close();
    	}
    }
    

    6.ByteArrayInputStream(字节数组输入流)

    在这里插入图片描述
    在这里插入图片描述

    import java.io.ByteArrayInputStream;
    /**
     * 字节数组输入流
     */
    public class ByteArrayInputStreamTest {
    	public static void main(String[] args) {
    		String str = "Xiong Jie and Liu Manlin will get married!";
    		byte[] buffer = str.getBytes();
    		ByteArrayInputStream bis = new ByteArrayInputStream(buffer);
    		ByteArrayInputStream bis2 = new ByteArrayInputStream(buffer, 0, 25);
    		for(int i = 0 ; i < str.length(); i++){
    			int c ;
    			while(-1!=(c = bis.read())){
    				if(0 == i){
    					System.out.println((char) c);
    				}else{
    					System.out.println(Character.toUpperCase((char)c));
    				}
    			}
    			System.out.println();
    			//重新定位流到这个位置上,上一次对这个流调用mark方法的那个位置。
    			bis.reset();
    		}
    	}
    }
    

    7. ByteArrayOutputStream字节数组输出流

    在这里插入图片描述

    展开全文
  • 输入输出有关的类在java.io包下,jdk1.4起加了java.nio包,jdk1.7对其做了改进,称为nio2。 按中处理的数据是以字节(8位)为单位还是以字符(16位)为单位分为字节和字符字节: InputStream和...

    输入输出流有关的类在java.io包下,jdk1.4起加了java.nio包,jdk1.7对其做了改进,称为nio2。


    按流中处理的数据是以字节(8位)为单位还是以字符(16位)为单位分为字节流和字符流

    字节流: InputStream和OutputStream


    InputStream

    InputStream是抽象类,不能直接用new InputStream()构造实例。 FileInputStream是InputStream的子类,可以生成实例。 FileInputStream有三个构造方法,最常用的构造方法如下:

    Public FileInputStream(String fileName) throws FileNotFoundException
    Public FileInputStream(File file) throws FileNotFoundException
    //fileName用来指定输入文件名及其路径,file是一个File对象

    字节流的层次结构

    InputStream类的read()方法:逐字节以二进制的原始方式读取数据

    public int read();//读入一个字节,-1表示无
    public int read(byte b[]);//返回读入的字节数
    public int read(byte[] b,int off.int len);//返回从某个位置开始制定长度的字节数


    OutputStream

    常用方法:

    //写一个字节
    void write( int ) throws IOException 
    //关闭输出流
    void close( ) throws IOException 
    //强行将缓冲区的数据写到目的地。
    void flush( ) throws IOException 
    //写一个字节数组
    void write(byte[ ] b) throws IOException 
        void write(byte[ ] b, int offset, int length ) throws IOException 

    OutputStream是抽象类,不能直接用new OutputStream()构造实例。 FileOutputStream是OutputStream的子类,可以生成实例。 FileOutputStream最常用的构造方法如下:

    Public FileOutputStream(String name) throws FileNotFoundException
    Public FileOutputStream(String name,boolean append) throws FileNotFoundException
    
    //Name用来指定输入文件名及其路径,append为true时数据将添加到文件已有内容的末尾



    利用字节流复制文件

    import java.io.*;
    class CopyAFile 
    {
        public static void main(String[] args) 
        {
            InputStream in;
            OutputStream out;
            try
            {
                in=new FileInputStream("test.txt");
                out=new FileOutputStream("copyResult.txt");
    //          out=new FileOutputStream("copyResult.txt",true);
                int aByte;
                aByte=in.read();
                while (aByte!=-1)
                {
                    out.write(aByte);
                    aByte=in.read();
                }
                in.close();
                out.close();
                System.out.println("文件复制完毕。test.txt已经复制到copyResult.txt中。");
            }
            catch(FileNotFoundException e)
            {
                System.out.println("当前目录下文件test.txt不存在!");
            }
            catch(IOException e)
            {
                System.out.println("发生输入输出错误!");
            }
        }
    }




    字符流: Reader和Writer

    字符流不一定对应两个字节,要考虑到编码问题。

    字符流层次结构

    Reader类读取的是字符,而不是字节。
    Reader类的重要方法read():

    public int read();//需要将int转为char
    public int read(char b[]);
    public int read(char[] b,int off,int len)




    节点流和过滤流

    节点流(Node Stream) :直接与原始数据存在的特定介质(如磁盘文件或其他外部设备、内存某区域或其他程序)打交道的流,在流的序列中离程序最远。
    过滤流 (Filter Stream):使用其它的流作为输入源或输出目的地,对流中的数据提供进一步处理的流。其他的流可以是节点流,也可以是另一种过滤流。过滤流不能单独使用

    一个输入流链或输出流链中一定有且只有一个节点流;可以没有,也可以有多个过滤流。

    过滤流和节点流的套接:

    InputStream in;
    in=new BufferedInputStream(new FileInputStream("test.txt"));
    
    BufferedReader in = new BufferedReader(new FileReader(file));
    
    BufferedReader in2 = new BufferedReader(new inputStreamReader(new FileInputStream(file),"utf-8"));
    s = in2.readLine();

    流的套接

    标准输入输出流和错误流

    1.System.out: -PrintStream类型
    把输出送到缺省的显示(通常是显示器)

    2.System.in - InputStream类型
    从标准输入获取输入(通常是键盘)

    3.System.err - PrintStream类型
    out的用法大家已熟知了,err的用法与out一样

    System是final类,in,out,err是System的静态成员变量,因此可以用System.in等形式直接使用。

    由于System,.in是InputStream类型,因此需要包装 :

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    br.readLine();

    注:
    1.输入/输出流的方法会抛出异常,因此必须进行异常处理
    2.标准输入/输出/错误流对象System.in, System.out、 System.err 始终存在 ,不需要实例化,也 不需要关闭

    最后附上两张图
    1、常用节点流:
    常用节点流
    2.常用过滤流:
    常用过滤流

    展开全文
  • 将中的内容写入到中2.2按单位分:字节流:以字节为单位,可以读写所有数据字符流:以字符为单位,只能读写文本数据2.3按功能分:节点流:具有实际传输数据的读写功能过滤流:在节点流的基础之上增强功能...

    一、流的定义

    定义:内存与存储设备之间传输数据的通道

    程序是在内存中运行的,文件在硬盘上,如果想要读取硬盘上的文件,需要在内存和硬盘之间建立一个通道

    二、流的分类

    2.1按方向分:

    输入流:将中的内容读入到中

    输出流:将中的内容写入到中

    2.2按单位分:

    字节流:以字节为单位,可以读写所有数据

    字符流:以字符为单位,只能读写文本数据

    2.3按功能分:

    节点流:具有实际传输数据的读写功能

    过滤流:在节点流的基础之上增强功能

    三、字节节点流

    字节流(抽象类):

    InputStream:字节输入流(从存储设备读到内存)

    pubic int read(){};//从输入流中读取数据

    public int read(byte[] b){};//从输入流中读取一定数量的字节,并将其存储在缓冲区数组b中

    public int read(byte[] b,int off,int len){};//将输入流中最多len个数据字节读入byte数组

    OutputStream:字节输出流(从内存保存到存储设备)

    public int write(int n){}//将指定的字节写入此输出流

    public int write(byte[] b){}//将b.length个字节从指定的byte数组写入此输出流

    public int write(byte[] b,int off,int len){}//将写指定byte数组中从off位置开始的len个字节写入此输出流

    文件字节流:

    FileInputStream:public int read(byte[] b)//从流中读取多个字节,将读到内容存入b数组,返回实际读到的字节数;如果达到文件的尾部,则返回-1。

    FileOutputStream: public void write(byte[] b)//一次写多个字节,将b数组中所有字节,写入输出流

    案例:文件字节输入输出流的使用

    packagecom.monv.chapter15;importjava.io.FileInputStream;/*** 演示FileInputStream的使用

    * 文件字节输入流

    *@authorMonv

    **/

    public classDemo1 {public static void main(String[] args) throwsException {//1.创建FileInputStream,并指定文件路径

    FileInputStream fis = new FileInputStream("D:\\aaa.Txt");//2.读取文件//2.1 单个字节读取 将读取的每个字节赋值给Data并输出 =-1的时候 说明读完了 跳出循环//int data =0;//while ((data = fis.read()) !=-1) {//System.out.println((char)data);//}//2.2一次读取多个字节

    byte[] buf = new byte[1024];int count = 0;while((count = fis.read(buf))!=-1) {

    System.out.println(new String(buf,0,count));

    }//3.关闭

    fis.close();

    System.out.println("读取完毕");

    }

    }--------------------------------------------------------------------

    packagecom.monv.chapter15;importjava.io.FileOutputStream;/*** 演示文件字节输出流的使用

    * FileOutputStream

    *@authorMonv

    **/

    public classDemo2 {public static void main(String[] args) throwsException{//1创建文件字节输出流对象 第二个参数 为true 表示 在原有文件上追加内容

    FileOutputStream fos = new FileOutputStream("D:\\bbb.txt",true);//2.写入文件//fos.write(97);//fos.write('b');//fos.write('c');

    String str = "HelloWorld";

    fos.write(str.getBytes());//3.关闭

    fos.close();

    System.out.println("执行完毕");

    }

    }---------------------------------------------------------

    packagecom.monv.chapter15;importjava.io.FileInputStream;importjava.io.FileOutputStream;/*** 使用文件字节流来实现文件的复制

    *@authorMonv

    **/

    public classDemo3 {public static void main(String[] args) throwsException {//1 创建流//1.1 创建文件字节输入流

    FileInputStream fis = new FileInputStream("D:\\111.jpg");//1.2 创建文件字节输出流

    FileOutputStream fos = new FileOutputStream("D:\\222.jpg");//2 一边读 一遍写

    byte[] buf = new byte[1024];int count = 0;while((count = fis.read(buf)) !=-1) {

    fos.write(buf,0,count);//不能保证每次读取1024的大小 所以把count传进来 读多少写多少

    }//3.关闭

    fis.close();

    fos.close();

    System.out.println("执行完毕");

    }

    }

    四、字节过滤流:

    缓冲流:BufferedOutputStream/BufferedInputStream

    提高IO效率,减少访问磁盘的次数;数据存储在缓冲区中,flush是将缓存区的内容写入文件中,也可以直接close。

    对象流:ObjectOutputStream/ObjectInputStream

    增强了缓冲区功能

    增强了读写8种基本数据类型和字符串功能

    增强了读写对象的功能:readObject() 从流中读取一个对象

    writeObject(Object obj) 向流中写入一个对象

    注:使用流传输对象的过程成为序列化(写入文件)、反序列化(读取文件)

    对象序列化注意事项:

    1)、序列化类必须实现Serializable接口

    2)、序列化类中对象属性要求实现Serializable接口

    3)、序列化版本号ID serialVersionUID ,保证序列化的类和反序列化的类是同一个类

    4)、使用transient(瞬间的)修饰属性,这个属性就不能序列化

    5)、静态属性也是不能序列化的(不能保存到硬盘上)

    6)、序列化多个对象的时候 可以借助集合来实现

    案例1:使用缓冲流来读写数据

    packagecom.monv.chapter15;importjava.io.BufferedInputStream;importjava.io.FileInputStream;/*** 使用字节缓冲流读取

    * BufferedInputStream

    *@authorMonv

    **/

    public classDemo4 {public static void main(String[] args) throwsException {//1.创建BufferedInputStream

    FileInputStream fis = new FileInputStream("D:\\aaa.txt");

    BufferedInputStream bis= newBufferedInputStream(fis);//2.读取//int data = 0;//while ((data = bis.read())!= -1 ) {//System.out.print((char)data);//}

    int count =0;byte[] buf = new byte[1024];while ((count = bis.read(buf)) != -1) {

    System.out.print(new String(buf,0,count));

    }//3.关闭 只关闭缓冲流就行了 内部 会把fis关掉

    bis.close();

    System.out.println("执行完毕");

    }

    }--------------------------------------------------

    packagecom.monv.chapter15;importjava.io.BufferedOutputStream;importjava.io.FileOutputStream;/*** 使用字节缓冲流写入数据

    *@authorMonv

    **/

    public classDemo5 {public static void main(String[] args) throwsException{//1.创建字节流 及 字节缓冲流

    FileOutputStream fos = new FileOutputStream("D:\\001.txt");

    BufferedOutputStream bos= newBufferedOutputStream(fos);//2.写入文件

    for(int i =0;i<10;i++) {

    bos.write("HelloWorld ".getBytes());//写入8k缓冲区

    bos.flush();//刷新到硬盘

    }//关闭(内部会调用flush)

    bos.close();

    }

    }

    案例2:使用对象流来读写数据

    --------------------学生类--------------------------

    packagecom.monv.chapter15;/*** 要想这个对象可以序列化 必须 要实现 Serializable接口*/

    importjava.io.Serializable;public class Student implementsSerializable{/*** serialVersionUID:序列化版本号ID,保证序列化的类和反序列化的类是同一个类*/

    private static final long serialVersionUID = 100L;privateString name;private transient intage;private static String country ="中国";publicStudent() {//TODO Auto-generated constructor stub

    }public Student(String name, intage) {super();this.name =name;this.age =age;

    }publicString getName() {returnname;

    }public voidsetName(String name) {this.name =name;

    }public intgetAge() {returnage;

    }public void setAge(intage) {this.age =age;

    }

    @OverridepublicString toString() {return "Student [name=" + name + ", age=" + age + "]";

    }

    }------------------------序列化操作-------------------------------

    packagecom.monv.chapter15;importjava.io.FileOutputStream;importjava.io.ObjectOutputStream;importjava.util.ArrayList;/*** 使用ObjectOutputStream实现对象的序列化

    * 注意事项:

    * (1)序列化类必须实现Serializable接口

    * (2)序列化类中对象属性要求实现Serializable接口

    * (3)序列化版本号ID serialVersionUID ,保证序列化的类和反序列化的类是同一个类

    * (4)使用transient(瞬间的)修饰属性,这个属性就不能序列化

    * (5)静态属性也是不能序列化的(不能保存到硬盘上)

    * (6)序列化多个对象的时候 可以借助集合来实现

    *@authorMonv

    **/

    public classDemo6 {public static void main(String[] args) throwsException{//1.创建对象流 需要借助文件流

    FileOutputStream fos = new FileOutputStream("D:\\Stu.bin");

    ObjectOutputStream oos= newObjectOutputStream(fos);//2.序列化 就是写入操作

    Student s1 = new Student("张三",20);

    Student s2= new Student("李四",21);

    ArrayList list = new ArrayList<>();

    list.add(s1);

    list.add(s2);

    oos.writeObject(list);//oos.writeObject(s1);//oos.writeObject(s2);//3关闭

    oos.close();

    System.out.println("序列化完毕");

    }

    }-----------------------反序列化操作------------------------------

    packagecom.monv.chapter15;importjava.io.FileInputStream;importjava.io.ObjectInputStream;importjava.util.ArrayList;/*** 使用ObjectInputStream实现反序列化(读取重构生成对象)

    *@authorMonv

    **/

    public classDemo7 {public static void main(String[] args) throwsException{//1.创建对象

    FileInputStream fis = new FileInputStream("D:\\\\Stu.bin");

    ObjectInputStream ois= newObjectInputStream(fis);//2.读取对象 只写入了一个对象 不能读多个 读完一次再读就会报错//Student s1 = (Student)ois.readObject();//Student s2 = (Student)ois.readObject();//只写入了一个对象的情况下 不能读多次 第二次读会报错(java.io.EOFException 读取到文件尾部的标志)

    ArrayList list = (ArrayList)ois.readObject();//3.关闭

    ois.close();

    System.out.println("反序列化执行完毕");//System.out.println(s1.toString());//System.out.println(s2.toString());

    System.out.println(list.toString());

    }

    }-------------------------------------------------------------

    展开全文
  • ByteArrayOutputStream是一个把字节数组当作输出的实现。package com.ahuier.io2;import java.io.ByteArrayOutputStream;import java.io.FileOutputStream;import java.io.OutputStream;public class ...
  •  过滤流:使用节点流作为输入或输出。过滤流是使用一个已经存在的输入流或者输出流链接创建的。 (2)在InputStream类和OutputStream类子类中,FilterInputStream和FilterOutputStream过滤抽象类又派生出  ...
  • JAVA IO一、相关概念1、分类:区别和联系 一、相关概念 I/O: Input/Output Stream,文件输入输出。 1、分类: 根据读写操作/数据流动的方向不同分为:输入 和 输出(站在程序的角度)。 其中输入就是指...
  • Java IO流 过滤流和包装流

    千次阅读 2011-01-05 17:50:00
    IO中的过滤流和包装流,就像是一个水管一样。我们原来的节点流水管太小了,或者说有杂质。通过他们可以过滤和增加对流的方法。更加方便我们的操作
  • java流的概念,不管是从文件还是从网络的套接字java统一当做来处理 输入,输出都是相对于程序而言的,从外部数据到程序里面的就是输入,程序是一个终点;从程序写到磁盘等都叫输出,程序是一个起点! 在...
  • 今天我学习了java课程,字符编码,字符流,字符节点过滤流,桥转换,File对象 #中国加油!武汉加油!千锋加油!也为自己加油!!!#… 笔记 课堂案例 1,TestEncoding import java.io....
  • 1. 在上一讲中我们介绍过节点流过滤流节点流是直接与目标打交道的,比如说文件,键盘等,但是什么是节点流,什么是过滤流呢?通过这个图我们来看一下。 下面这个图表示的InputStream的类层次,当然接下去同样...
  • 模块 java.base 软件包 java.io Class FilterReader java.lang.Object java.io.Reader java.io.FilterReader 实现的所有接口 ...用于读取已过滤字符的抽象类。 抽象类FilterReader本身提供了将所
  • java过滤流(包装流)

    2019-06-23 10:19:20
    各种字节节点流类,它们都只具有读写字节内容的方法,以FileInputStream与FileOutputStream为例,它们只能在文件中读取或者向文件中写入字节,在实际应用中我们往往需要在文件中读取或者写入各种类型的数据,就必须...
  • FilterInputStream 和 ...要使用过滤流,首先必须把它连接到某个输入输出节点流上,通常在构造方法的的参数中指定所要连接的节点流: FilterInputStream(InputStream in); FilterOutputStream(Outputstream out); ...
  • 节点流&包装流初体验

    2021-02-13 17:14:53
    过滤流: 是对一个已存在的流的链接和封装,通过对数据进行处理为程序提供功能强大、灵活的读写功能。 我们的节点流是真正的实现输入输出功能的流,我们的包装流是实现了对节点流的功能增强的功能,我们看一看到底有...
  • Java IO

    2018-12-22 20:27:25
    输入/输出流 - 深入理解Java中的流 (Stream) 深入理解JAVA I/O系列二:字节流详解 深入理解Java中的IO JAVA:IO流 之 节点流与处理流 ...java io 节点流和处理流 Java 各种流的分类及区别 处理流(过滤流) ...
  • 导语防止自己以后忘记,记录...按照节点流过滤流节点流直接操作文件,过滤流包装了节点流过滤流。如FileInputStream和BufferedFileInputStream就是分别是节点流过滤流。文件流比较下面重点比较我们经常用的...
  • Java.过滤流(包装流)

    万次阅读 2011-01-02 22:04:00
    各种字节节点流类,它们都只具有读写字节内容的方法,以FileInputStream与FileOutputStream为例,它们只能在文件中读取或者向文件中写入字节,在实际应用中我们往往需要在文件中读取或者写入各种类型的数据,就必须...
  • 在上一节我们说到IO流主要分为两个大类:节点流类和过滤流类(也称包装类)。程序用于直接操作目标设备所对应的类叫节点流类;为更加灵活方便地读写各种类型的数据,程序也可用通过一个间接流类去调用节点流类而这个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 411
精华内容 164
关键字:

java节点流过滤流

java 订阅