精华内容
下载资源
问答
  • 节点流处理流简单总结

    千次阅读 2017-06-09 20:00:01
    节点流处理流     “按照流是否直接与特定的地方(如磁盘、内存、设备等)相连,分为节点流处理流两类。”      节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader ,节点流由两部分...

    节点流和处理流 

     
                 “按照流是否直接与特定的地方(如磁盘、内存、设备等)相连,分为节点流和处理流两类。” 
     

      节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader ,节点流由两部分组成:

                    《1》字符流: InputStream OutputStream(抽象的

                    《2》字节流:Reader Writer (抽象的

     
      处理流:是对一个已存在的流的连接和封装,通过所封装的流的功能调用实现数据读写。
    如BufferedReader。处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过
    其他流的多次包装,称为流的链接。 
     
      常用的节点流 
    父  类 :                           InputStream OutputStream Reader Writer 
    文  件 :                           FileInputStream FileOutputStrean FileReader FileWriter (处理文件)
    数  组 :                           ByteArrayInputStream  ByteArrayOutputStream  CharArrayReader  CharArrayWriter (处理数组)             
    字符串(只有字符流): StringReader StringWriter (处理字符串)
    管  道:                           PipedInputStream  PipedOutputStream  PipedReader  PipedWriter (处理管道)
     
      常用处理流(关闭处理流使用关闭里面的节点流) 
    父  类   :          InputStream OutputStream Reader Writer 
    缓冲流  :          BufferedImputStrean BufferedOutputStream BufferedReader BufferedWriter ----需
          (要父类作为参数构造,增加缓冲功能,避免频繁读写硬盘,可以初始化缓冲数据的大小,由
    于带了缓冲功能,所以就写数据的时候需要使用    “flush”  方法咯 )

    转换流 :           InputStreamReader  OutputStreamWriter- ( 要inputStream 或OutputStream作为
                                                                                                       参数,实现从字节流到字符流的转换 )------------作为中介存在
     

     



    其他特殊记住的类

    PrintStream--继承自-->FilterOutputStream--继承自-->OutputStream,(它的构造函数需要
    OutputStream对象) 
     
    *  PrintWriter---继承自-->Writer(它的构造函数需要Writer对象) 
     
      System.In====InputStream 
     
      System.Out===PrintStream 
     

      这种流的print方法不会抛出异常

    展开全文
  • Java:节点流处理流

    千次阅读 2014-09-23 20:59:25
    JAVA IO 操作总结——节点流处理流    按照流是否直接与特定的地方(如磁盘、内存、设备等)相连,分为节点流处理流两类。     节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader    ...
    JAVA IO 操作总结——节点流和处理流 
     
    按照流是否直接与特定的地方(如磁盘、内存、设备等)相连,分为节点流和处理流两类。 
     
      节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader 
     
      处理流:是对一个已存在的流的连接和封装,通过所封装的流的功能调用实现数据读写。
    如BufferedReader。处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过
    其他流的多次包装,称为流的链接。 
     
      常用的节点流 
    父  类  InputStream OutputStream Reader Writer 
    文  件  *FileInputStream FileOutputStrean FileReader FileWriter 文件进行处理的节点流 
    数  组  *ByteArrayInputStream  ByteArrayOutputStream  CharArrayReader  CharArrayWriter 
    对数组进行处理的节点流(对应的不再是文件,而是内存中的一个数组) 
    字符串  *无    无  StringReader StringWriter 对字符串进行处理的节点流 
    管  道  *PipedInputStream  PipedOutputStream  PipedReader  PipedWriter 对管道进行处
    理的节点流 
     
      常用处理流(关闭处理流使用关闭里面的节点流) 
    父  类  InputStream OutputStream Reader Writer 
    缓冲流  *BufferedImputStrean BufferedOutputStream BufferedReader BufferedWriter ----需
    要父类作为参数构造,增加缓冲功能,避免频繁读写硬盘,可以初始化缓冲数据的大小,由
    于带了缓冲功能,所以就写数据的时候需要使用flush方法咯 
    转换流  *InputStreamReader  OutputStreamWriter-  要inputStream 或OutputStream作为
    参数,实现从字节流到字符流的转换 
    数据流  *DataInputStream DataOutputStream -提供将基础数据类型写入到文件中,或者
    读取出来,为什么要有这个流呢?看这样的分析,如果没有这种流的话,有一个long,本身
    只占8个字节,如果我要写入到文件,需要转成字符串,然后在转成字符数组,那空间会占
    用很多,但是有了这种流之后就很方便了,直接将这8个字节写到文件就完了。。是不是既
    节约了内存空间有让程序写起来更加方便简单了呐。写倒是很简单,但是读取的时候就注意
    了,根据读取的数据类型,指针会往下移,所以你写的顺序必须要和读的顺序一致才能完成
    你正确的需求。 
     
      *ObjectInputStream ObjectOutputStream 
     
      *顺便研究序列化---将对象所在的类型全部转换成二进制,然后写入到介质中去 
     
      *transient关键字--修饰成员变量,不写入该成员变量 
     
      *Serializable接口--表示接口,怎样实现的呢,在序列化之前,首先判断 (对象  instanceof 
    Serializable)如果返回true则执行序列化,否者抛出异常,并且里面有一个ID,是用来快速
    查找某个对象的时候使用的 
     
      *Externalizable接口--外部化接口;他是Serializable接口的子接口,能手动控制序列化
    的方式 
     
      为什么要用writeUTF()--因为这种方式是按照utf-8来写入的,而默认方式是utf-16只是
    节省空间而已 
     
      --字节流读取中文的问题 
     
      *由于java 使用的是unicode编码,每一个中文字符是占用两个字节的,所以没有只读
    出其中一个字节并使用的话当然是乱码咯,虽然普通的英文字符也是两个字节的,但是读取
    的时候将高8位去掉也能回去正确的英文字符,所以没有问题,所以最好还是使用字符流的
    方式读取好点 
     
      --java.io 中专门提供用于打印的流(这类流在写入的时候有自动flush 的功能,所以你不
    需要每打印一个东西都flush 一次)--------注意他们也是属于处理流,只不过这里单独列出来
    分析而已 
     
    *PrintStream--继承自-->FilterOutputStream--继承自-->OutputStream,(它的构造函数需要
    OutputStream对象) 
     
    *  PrintWriter---继承自-->Writer(它的构造函数需要Writer对象) 
     
      System.In====InputStream 
     
      System.Out===PrintStream 
     
      这种流的print方法不会抛出异常,这是JSP技术中常用的流,如果在JSP页面的打印会
    抛出异常的话,那JSP也太难写了点!注意理解这样的设计思路 
     
      --看这样的代码 
     
      PrintStream ps=new PrintStream(new OutputStream("c://...")); 
     
      System.setOut(ps); 
     
      System.Out.println("jfdajsflkajdf");//这样将不会在打印到命令行窗口,而是指定的
    PrintStream目标文件里面去 
    展开全文
  • 节点流处理流区别

    2019-11-26 09:16:50
    处理流:对已存在的流的连接和封装,实现更为丰富的流数据处理,处理流的构造方法必需其他的流对象参数。如 BufferedReader 【Java面试题与答案】整理推荐 基础与语法 集合 网络编程 并发编程 Web 安全 ...

    按流的处理位置分类

    • 节点流:可以从某节点读数据或向某节点写数据的流。如 FileInputStream
    • 处理流:对已存在的流的连接和封装,实现更为丰富的流数据处理,处理流的构造方法必需其他的流对象参数。如 BufferedReader

     


    【Java面试题与答案】整理推荐

     

    展开全文
  • JAVA:IO流 之 节点流处理流(2)

    万次阅读 多人点赞 2017-05-15 15:37:24
    1. 流的分类 按数据流的方向不同:输入流,输出流。...按功能不同:节点流处理流。 (1)程序用于直接操作目标设备所对应的类叫节点流。 (2)程序通过一个间接流类去调用节点流类,以达到更加灵活方...

    1. 流的分类

    • 按数据流的方向不同:输入流,输出流。
    • 按处理数据单位不同:字节流,字符流。
      (1) 字节流:数据流中最小的数据单元是字节。
      (2)字符流:数据流中最小的数据单元是字符, Java中的字符是Unicode编码,一个字符占用两个字节。
    • 按功能不同:节点流,处理流。
      (1)程序用于直接操作目标设备所对应的类叫节点流。
      (2)程序通过一个间接流类去调用节点流类,以达到更加灵活方便地读写各种类型的数据,这个间接流类就是处理流。

    2. 节点流

    2.1 节点流的类型

    这里写图片描述

    • (1)File 文件流。对文件进行读、写操作 :FileReader、FileWriter、FileInputStream、FileOutputStream。、
    • (2)Memory
      1)从/向内存数组读写数据: CharArrayReader与 CharArrayWriter、ByteArrayInputStream与ByteArrayOutputStream。
      2)从/向内存字符串读写数据 StringReader、StringWriter、StringBufferInputStream。
    • (3)Pipe管道流。 实现管道的输入和输出(进程间通信): PipedReader与PipedWriter、PipedInputStream与PipedOutputStream。

    2.2 节点流执行的图示

    这里写图片描述

    3. 处理流

    3.1 处理流的类型

    这里写图片描述
    - (1)Buffering缓冲流:在读入或写出时,对数据进行缓存,以减少I/O的次数:BufferedReader与BufferedWriter、BufferedInputStream与BufferedOutputStream。
    - (2)Filtering 滤流:在数据进行读或写时进行过滤:FilterReader与FilterWriter、FilterInputStream与FilterOutputStream。
    - (3)Converting between Bytes and Characters 转换流:按照一定的编码/解码标准将字节流转换为字符流,或进行反向转换(Stream到Reader):InputStreamReader、OutputStreamWriter。
    - (4)Object Serialization 对象流 :ObjectInputStream、ObjectOutputStream。
    - (5)DataConversion数据流: 按基本数据类型读、写(处理的数据是Java的基本类型(如布尔型,字节,整数和浮点数)):DataInputStream、DataOutputStream 。
    - (6)Counting计数流: 在读入数据时对行记数 :LineNumberReader、LineNumberInputStream。
    - (7)Peeking Ahead预读流: 通过缓存机制,进行预读 :PushbackReader、PushbackInputStream。
    - (8)Printing打印流: 包含方便的打印方法 :PrintWriter、PrintStream。

    3.2 处理流执行的图示

    这里写图片描述

    3.3 缓冲流

    • 【1】对I/O进行缓冲是一种常见的性能优化,缓冲流为I/O流增加了内存缓冲区,增加缓冲区的两个目的:
      (1)允许Java的I/O一次不只操作一个字符,这样提高䇖整个系统的性能;
      (2)由于有缓冲区,使得在流上执行skip、mark和reset方法都成为可能。

    • 【2】缓冲流:它是要“套接”在相应的节点流之上,对读写的数据提供了缓冲的功能,
      提高了读写的效率,同时增加了一些新的方法。例如:BufferedReader中的readLine方法,
      BufferedWriter中的newLine方法。

    • 【3】J2SDK提供了4种缓存流,常用的构造方法为:

    //字符输入流
    BufferedReader(Reader in)//创建一个32字节的缓冲区
    BufferedReader(Reader in, int size)//size为自定义缓存区的大小
    
    //字符输出流
    BufferedWriter(Writer out)
    BufferedWriter(Writer out, int size)
    
    //字节输入流
    BufferedInputStream(InputStream in)
    BufferedInputStream(InputStream in, int size)
    
    //字节输出流
    BufferedOutputStream(OutputStream in)
    BufferedOutputStream(OutputStream in, int size)
    • 【4】其他
      (1)缓冲输入流BufferedInputSTream除了支持read和skip方法意外,还支持其父类的mark和reset方法;
      (2)BufferedReader提供了一种新的ReadLine方法用于读取一行字符串(以\r或\n分隔);
      (3)BufferedWriter提供了一种新的newLine方法用于写入一个行分隔符;
      (4)对于输出的缓冲流,BufferedWriter和BufferedOutputStream,写出的数据会先在内存中缓存,
      使用flush方法将会使内存的数据立刻写出。

    • 示例1:

    import java.io.*;
    public class TestBufferStream1 {
      public static void main(String[] args) {
        try {
          FileInputStream fis = new FileInputStream(
              "d:\\JavaProject\\demo13\\ProcessingStream\\TestBufferStream1.java");
          BufferedInputStream bis = new BufferedInputStream(fis);
          int c = 0;
          System.out.println((char)bis.read());
          System.out.println((char)bis.read());
          bis.mark(100);/*在当前输入流的当前位置上做一个标志,允许最多再读入100个字节*/
          for(int i=0;i<=10 && (c=bis.read())!=-1;i++){
            System.out.print((char)c+" ");
          }
          System.out.println(); 
          bis.reset();/*把输入指针返回到以前所做的标志处*/
          for(int i=0;i<=10 && (c=bis.read())!=-1;i++){
            System.out.print((char)c+" ");
          }
          bis.close();
        } catch (IOException e) {e.printStackTrace();}
      }
    }
    • 示例2:
    import java.io.*;
    public class TestBufferStream2
    {
        public static void main(String[] args)
        {
        try{
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\JavaProject\\demo13\\BufferStream\\dat2.txt"));
        BufferedReader br = new BufferedReader(new FileReader("D:\\JavaProject\\demo13\\BufferStream\\dat2.txt"));
        String s = null;
        for(int i=0;i<10;i++)
        {
            s = String.valueOf(Math.random());//产生一个小于1的正的随机数,并转换成字符串形式
            bw.write(s);//把字符串s写入到dat2.txt文件中
            bw.newLine();//写入一个行分隔符
        }
        bw.flush();//使用flush方法将会使内存的数据立刻写出
    
        while((s=br.readLine()) != null)
        {
            System.out.println(s);
        }
        bw.close();
        br.close();
        }
        catch(IOException e)
        {
            e.printStackTrace();
        }
    
        }
    }

    3.4 转换流

    • 转换流有两种:
      (1)InputStreamReader:将字节流转换为字符流;
      (2)OutputStreamWriter:将字符流转换为字节流。
    • 什么时候使用转换流?由以下分析: 流对象很多,就要明确使用哪个流对象。
    通过三点来完成: 
        1、明确数据的来源和数据到达的目的地。
                     来源:输入流 [InputStream,Reader]。 
                     目的:输出流 [OutputStream,Writer]。 
        2、操作的数据是否是纯文本。  
                     是:字符流,使用Reader与Writer; 
                     否:字节流,使用InputStreamOutputStream3、明确要使用哪个具体的对象。 通过设备来进行区分: 
                     源设备:内存用数组,硬盘就加file,键盘用System.in; 
                     目的设备:内存用数组,硬盘就加file,键盘用System.out。 
        4、明确是否还需要其他额外功能:例如 
                    (1)是否需要较高的效率,即是否需要使用缓冲区,是就加上Buffered;
                    (2)是否需要转换,是,就使用转换流,InputStreamReader 和 OutputStreamWriter。
    • 用一个例子简单的说明: 将键盘录入的数据保存到一个文件中,输入“over”时表示录入结束。 详细分析:
    源:从InputStream,Reader中选择; 因为是键盘录入的是纯文本,所以使用Reader。 
    设备:键盘,所以用System.in; 发现System.in是字节流的操作,与Reader(字符流)矛盾,
    这时就要用到转换流 InputStreamReader 。为了提高操作效率,使用缓冲技术,选择BufferedReader。 
    
    目的:从 OutputStream,Writer中选择。 因为是文本文件,所以选择Writer。 
    设备:硬盘上,一个文件,选择FileWriter。 为了提高操作效率,使用缓冲技术,选择BufferedWriter。 
    • 示例1:
    import java.io.*; 
        class ReadinFile 
            { 
                public static void main(String[] args)throws IOException //这里为了方便阅读,先不做异常处理。 
                { 
                    BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in)); 
                    BufferedWriter bufw=new BufferedWriter(new FileWriter("readin.txt")); 
                    String line=null; 
                    while((line=bufr.readLine())!=null) 
                    { 
                        if("over".equals(line)) break; 
                        bufw.write(line); 
                        bufw.newLine(); 
                    } 
                    bufw.close(); 
                    bufr.close(); 
                } 
            }
    • 示例2:
    import java.io.*;
    public class TestTransForm 
    {
        public static void main(String[] args) throws IOException //这里为了方便阅读,先不做异常处理。 
        {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
            OutputStreamWriter osw = new OutputStreamWriter(
                                     new FileOutputStream("D:\\JavaProject\\demo13\\TransStream\\TransForm.txt",true));
            BufferedWriter bw = new BufferedWriter(osw);
            String str = null;
            str = br.readLine();
            while(str != null)
            {
                if(str.equalsIgnoreCase("exit")) break;
                bw.write(str);
                bw.newLine();
                str = br.readLine();
            }
            br.close();
            bw.close();
        }
    }
    • 注意:
      (1)构造方法:public FileOutputStream(String name,boolean append) throws FileNotFoundException
      如果append为True,输出字节流就写入文件的末尾,而不是开头(覆盖原来的内容);
      如果append为False,输出字节流就写入文件的开头,即覆盖原来的内容从文件开始处写内容。
      (2)构造方法:public FileOutputStream(String name) throws FileNotFoundException
      每次覆盖原文件的内容,从文件开始处写内容。

    3.5 数据流——数据的存储和数据恢复

    • 数据流:DataInputStream和DataOutputStream
      (0)DataInputStream和DataOutputStream是面向字节的,因此要使用InputStream和OutputStream。
      (1)DataInputStream和DataOutputStream分别继承InputStream和OutputStream,
      它们属于处理流,需要分别“套接”在InputStream和OutputStream类型的节点流上。
      (2)DataInputStream和DataOutputStream提供了可以存取与机器无关的Java原始类数据(如:int,double等)的方法。
      (3)DataInputStream和DataOutputStream的构造方法:
         DataInputStream(InputStream in)
         DataOutputStream(OutputStream out
    • 示例1:
    import java.io.*;
    public class TestDataStream
    {
        public static void main(String[] args) throws IOException
        {
            FileOutputStream fout = new FileOutputStream("D:/JavaProject/demo13_IO/DataStream/demo.txt",true);
            BufferedOutputStream bout = new BufferedOutputStream(fout);
            DataOutputStream dout = new DataOutputStream(bout);
            /*DataOutputStream,BufferedOutputStream,FileOutputStream这里使用了流栈。*/
    
            dout.writeInt(110);
            dout.writeUTF("hello,中国");
            dout.writeFloat(3.14f);
            dout.writeChar(97);/*97对应的是'a'*/
            dout.close();/*如果正在使用一个流栈,程序关闭最上面的一个流也就自动的关闭了栈中的所有底层流。*/
    
            FileInputStream fin = new FileInputStream("D:/JavaProject/demo13_IO/DataStream/demo.txt");
            BufferedInputStream bin = new BufferedInputStream(fin);
            DataInputStream din = new DataInputStream(bin);
    
            int i = din.readInt();
            String str = din.readUTF();
            float f = din.readFloat();
            char c = din.readChar();
            fin.close();/*如果正在使用一个流栈,程序关闭最上面的一个流也就自动的关闭了栈中的所有底层流。*/
            System.out.println("int:"+i+"\nString:"+str+"\nfloat:"+f+"\nchar:"+c);
        }
    
    }
    • 编译,运行:
    D:\JavaProject\demo13_IO\DataStream>javac TestDataStream.java
    
    D:\JavaProject\demo13_IO\DataStream>java TestDataStream
    int:110
    String:hello,中国
    float:3.14
    char:a
    • 注意:
            int i = din.readInt();
            String str = din.readUTF();
            float f = din.readFloat();
            char c = din.readChar();
            /*此段代码的顺序不能乱,要保证先写入的先读出来的原则,否则会出现错误。
            *    因此,我们在写代码的时候,我们必须:
            *         要么为文件中的数据采用固定的格式;
            *         要么将额外的信息保存到文件中,以便能够对其进行解析以确定数据的寻访位置。
            */
    展开全文
  • 节点流处理流

    万次阅读 多人点赞 2012-02-29 20:24:34
    JAVA IO 操作总结——节点流处理流    按照流是否直接与特定的地方(如磁盘、内存、设备等)相连,分为节点流处理流两类。     节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader    ...
  • 3 节点流处理流的区别 节点流 可以从或向一个特定的地方(节点)读写数据。 如:FileReader、FileWriter、FileInputStream、FileOutputStream等文件进行处理的节点流处理流 是对一个已存在的流的连接和封装...
  • 节点流处理流的使用

    千次阅读 2018-09-10 23:20:25
    节点流处理流的使用 •什么是节点流 ü节点流:从一个特定的数据源(节点)读写数据(如:文件、内存)的类叫做节点流类 ü ü这些节点类跟数据源或数据目的地做直接连接用的 ü在java.io包中,字节继承体系...
  • 处理流节点流

    2016-09-09 10:47:14
    按照流是否直接与特定的地方(如磁盘、内存、设备等)相连,分为节点流处理流两类。  节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader.  处理流:是对一个已存在的流的连接和封装,通过所封装的流...
  • java节点流处理流

    千次阅读 2012-12-12 10:40:58
    JAVA IO操作总结:节点流处理流 JAVA IO操作总结——节点流处理流 按照流是否直接与特定的地方(如磁盘、内存、设备等)相连,分为节点流处理流两类。  节点流:可以从或向一个特定的地方(节点)读写...
  • 什么是节点流处理流

    千次阅读 2018-11-18 18:01:53
    按照流是否直接与特定的地方(如磁盘、内存、设备等)相连,分为节点流处理流两类。节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader.处理流:是对一个已存在的流的连接和封装,通过所封装的流的功能...
  • java里面的节点流处理流

    千次阅读 2017-05-26 18:27:02
    按照流是否直接与特定的地方(如磁盘、内存、设备等)相连,分为节点流处理流两类。  节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader.  处理流:是对一个已存在的流的连接和封装,通过所封装的流...
  • 转载于:...今天在编写hadoop程序的时候,用到了处理。关闭的时候出现了问题: 代码: 1 FSDataInputStream fsin = fs.open(new Path(filein)); 2 FSDataOutputStream fsout = fs.append
  • JAVA IO操作总结——节点流处理流

    千次阅读 2011-11-19 18:43:11
    JAVA IO操作总结——节点流处理流 按照流是否直接与特定的地方(如磁盘、内存、设备等)相连,分为节点流处理流两类。 节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader 处理流:是对一个已...
  • 在java中的流 按流动方向可以分为输入流及输出流两种,输入流,输出流是以...按流的处理位置可分为节点流处理流  节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader. 处理流:是对一个已存在的流的
  • 节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader.处理流:是对一个已存在的流的连接和封装,通过所封装的流的功能调用实现数据读写。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做...
  • 前面我们所用到的都是节点流,比较麻烦,所以我们今天的处理流处理流可以隐藏底层设备上节点流的差异,对外提供更方便的输入输出方式,让节点流去处理与底层的IO设备 文件交互。我们只要做到处理流的构造器参数...
  • 例如,处理流a依赖节点流b,应该先关闭处理流a,再关闭节点流b。 可以只关闭处理流,不用关闭节点流处理流关闭的时候,会调用其处理的节点流的关闭方法。 注意 : -如果将节点流关闭以后再关闭处理流,会抛...
  • JAVA IO一、相关概念1、分类:区别和联系 一、相关概念 I/O: Input/Output Stream,文件输入输出。 1、分类: 根据读写操作/数据流动的方向不同分为:输入 和 输出(站在程序的角度)。 其中输入就是指...
  • 首先,是什么? 是个抽象的概念,是对输入输出设备的抽象,Java程序中,对于数据的输入/输出操作都是以“”的方式进行。设备可以是文件,网络,内存等。 具有方向性,至于是输入还是输出则是...
  • 在程序中所有的数据都是以的方式进行传输或保存的,所以在Java中IO也是必不可少的。Java中的IO在java.io包中。 在java.io包中不管是操作文件和目录都是使用File类来操作,File能新建、删除、重命名文件和目录...
  • 1)按照流是否直接与特定的地方 (如磁盘、内存、设备等) 相连,分为节点流处理流两类。节点流可以从或向一个特定的地方(节点)读写数据;处理流是对一个已存在的流的连接和封装,通过所封装的流的功能调用实现...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 301,985
精华内容 120,794
关键字:

节点流处理流