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

    2019-12-19 08:06:05
    java.io.OutputStream (字节输出流) 此抽象类是表示输出字节流的所有类的超类。定义了一些子类共性的方法 void close() :关闭此输出流并释放与此流有关的所有系统资源。 void flush(): 刷新此输出流并强制写出...

    java.io.OutputStream (字节输出流) 此抽象类是表示输出字节流的所有类的超类。
    定义了一些子类共性的方法

    • void close() :关闭此输出流并释放与此流有关的所有系统资源。
    • void flush(): 刷新此输出流并强制写出所有缓冲的输出字节。
    • void write(byte[] b) :将 b.length 个字节从指定的 byte 数组写入此输出流。
    • void write(byte[] b, int off, int len) :将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
    • abstract void write(int b) :将指定的字节写入此输出流。

    FileOutputStream

    java.io.FileOutputStream extends OutputStream
    FileOutputStream(文件字节输出流)
    作用:把内存中的数据写入到硬盘的文件中

    构造方法
    • FileOutputStream(File file) :创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
    • FileOutputStream(File file, boolean append) :创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
    • FileOutputStream(FileDescriptor fdObj) :创建一个向指定文件描述符处写入数据的输出文件流,该文件描述符表示一个到文件系统中的某个实际文件的现有连接。
    • FileOutputStream(String name) :创建一个向具有指定名称的文件中写入数据的输出文件流。
    • FileOutputStream(String name, boolean append) :创建一个向具有指定 name 的文件中写入数据的输出文件流。

    参数:
    File file:目的地是一个文件
    String name:目的地是一个路径
    boolean append: 追加写开关
    true:创建对象不会覆盖原文件,继续在文件末尾追加写数据
    false:创建一个新文件,覆盖原文件

    作用:

    1. 创建一个FileOutputStream对象
    2. 会根据构造方法中传递的文件/文件路径,创建一个空的文件
    3. 会把FileOutputStream对象指向创建好的文件

    写入数据的原理(内存–>硬盘)
    java程序–>jvm–>os操作系统–>os调用写数据的方法–>把数据写入到文件中

    字节输出流的使用步骤

    1. 创建FileOutputStream对象,构造方法中传递写入数据的目的地址
    2. 调用FileOutputStream对象中的方法write,把数据写入到文件中
    3. 释放资源
      1
      2
      3
      
      FileOutputStream fos = new FileOutputStream("E:\\Down\\a.txt");
             fos.write(42);
             fos.close();
      

      FileOutputStream对象写多个字节

      void write(byte[] b) :将 b.length 个字节从指定的 byte 数组写入此输出流。

    注意:
    如果写的第一个字节是正数(0-127),那么显示的时候查询ASII表
    如果写的第一个字节是负数,那第一个字节会和第二个字节组成一个中文显示,查询系统默认码表(GBK)

    1
    2
    3
    4
    5
    
    FileOutputStream fos = new FileOutputStream(new File("E:\\Down\\a.txt"));
          byte[] a = {-65,-66,-68,69,66};
          fos.write(a);
          fos.close();
    文件内容:烤糆B
    

    void write(byte[] b, int off, int len) :将指定 byte 数组中从偏移量
    int off:数组的开始索引
    int len:写几个字节

    1
    2
    3
    4
    5
    
    FileOutputStream fos = new FileOutputStream(new File("E:\\Down\\a.txt"));
          byte[] a = {-65,-66,-68,69,66};
          fos.write(a,0,2);
          fos.close();
    文件内容:烤
    

    字节输出流的续写和换行

    构造方法:
    FileOutputStream(File file, boolean append) :创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
    FileOutputStream(String name, boolean append) :创建一个向具有指定 name 的文件中写入数据的输出文件流。

    写换行:写换行符号

    windows:\r\n
    linux:/n
    mac:/r

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    
    FileOutputStream fos = new FileOutputStream(new File("E:\\Down\\a.txt"),true);
          for(int i=0;i<5;i++){
              fos.write("你好".getBytes());
              fos.write("\r\n".getBytes());
          }
    文件内容:
    你好
    你好
    你好
    你好
    你好
    

    谢谢你请我吃糖果

    支付宝
    微信
    展开全文
  • 字节输出流和字节输入流

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

    字节输出流和输入流


    之前介绍的File文件操作类可以关联本地文件系统,实现文件的创建,删除和查询一些文件信息。但是File类不支持对文件内容进行操作,如果要处理文件内容,必须通过流的方式。

    流分为输入流和输出流。输入流:数据流入程序;输出流:数据从程序流出。

    java.io包中,流分为两种:字节流和字符流。

    1. 字节流:InputStream, OutputStream
    2. 字符流:Reader, Writer

    不管使用的字节流还是字符流,其基本的操作流程几乎是一样的,以文件操作为例。

    1. 根据文件路径创建File对象;
    2. 根据字节流或字符流的子类实例化父类对象;
    3. 进行数据的读取或者写入操作;
    4. 关闭流(close()).

    对于I/O操作属于资源处理,所有的资源处理操作(I/O操作、数据库操作、网络)最后必须要进行关闭。

    这篇博客主要介绍字节的输入流和输出流

    1. 字节输出流

    如果想要通过程序将数据流出,则通过java.io.OutputStream
    OutputStream类的结构:

    public abstract class OutputStream implements Closeable, Flushable
    

    由以上可知OutputStream是一个抽象类,所以无法直接实例化,必须通过子类实例化。
    OutputStream子类如下:
    在这里插入图片描述
    文件输出流是用于将数据写入到输出流File中。

    FileOutputStream中的构造方法如下:

    1. 创建输出流写入指定的File对象(覆盖):public FileOutputStream(String name) throws FileNotFoundException
    2. 创建输出流写入指定的File对象(追加):public FileOutputStream(String name, boolean append) throws FileNotFoundException

    举例:实现文件内容的输出

    public class TestStream {
        public static void main(String[] args) {
            String directory = "D:"+File.separator+"test1"+File.separator
                    +"java"+File.separator+"hh.txt";
            //File和本地文件系统相关联
            File file = new File(directory);
    
            OutputStream out = null;
            try {
               
                out = new FileOutputStream(file);
                //写入一个字节
                out.write('b');
                out.write('\n');
                //写入字节数组
                out.write("hello world!!!\n".getBytes());
                //写入指定字节长度
                String str = "I love programming!!!";
                byte[] bytes = str.getBytes();
                out.write(bytes, 0 , 8);
                //刷新此字节流并强制缓冲区的输出字节被写出
                out.flush();
                out.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally{
                if(out!=null){
                    try {
                        out.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    
    

    在上面中,需要注意两点

    1. 输出流文件如果存在,那么会自动创建;
    2. 在FileOutputStream中的构造方法中,append默认是false

    另外,以上用到了OutputStream的三个方法

    1. 将给定的字节数组内容全部输出:public void write(byte b[]) throws IOException
    2. 将部分字节内容输出:public void write(byte b[], int off, int len) throws IOException
    3. 输出单个字节:public abstract void write(int b) throws IOException;

    通过上述代码发现,手动关闭流对象过于繁琐,所以JDK1.7后提供了自动关闭功能。这是因为OutputStream实现了AutoCloseable接口,Java虚拟机会帮我们自动关闭

    举例:实现自动关闭

    public class TestStream {
        public static void main(String[] args) {
            String directory = "D:"+File.separator+"test1"+File.separator
                    +"java"+File.separator+"hh.txt";
            //File和本地文件系统相关联
            File file = new File(directory);
    
            //在括号内实例化对象,最后会实现自动关闭
            try ( OutputStream out = new FileOutputStream(file);){
                out.write(49);   //字符1
                out.write("\n".getBytes());
    
                String str = "helloworld";
                byte[] buff = str.getBytes();
                out.write(buff, 0,5);
    
                out.flush();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
    
        }
    }
    
    

    2. 字节输入流

    OutputStream是将数据输出到文件中,那么使用InputStream就是读取文件的内容
    InputStream的定义如下:

    public abstract class InputStream implements Closeable 
    

    因为也是抽象类,所以必须使用子类FileInputStream,从文件系统中的文件获取输入字节流。

    InputStream中提供了如下方法

    1. public int read(byte b[])throws IOException:读取数据到字节数组中,返回数据的读取个数。
    2. public int read(byte b[], int off, int len)throws IOException:读取传递数组部分内容。
    3. public abstract int read()throws IOException:读取单个字节。

    这三种,当读取没有数据时返回-1.

    举例:读取文件内容

    public class TestStream {
        public static void main(String[] args) {
            String directory = "D:"+File.separator+"test1"+File.separator
                    +"java"+File.separator+"hh.txt";
            //File和本地文件系统相关联
            File file = new File(directory);
            if(file.exists()&&file.isFile()){
                try (InputStream in = new FileInputStream(file);){
    
                    byte[] data = new byte[7];
                    int len = in.read(data);
                    System.out.println("读取数据的长度:"+len);
                    System.out.println("读取的数据:"+new String(data));
                    //读取单个字节
                    System.out.println(in.read());
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }else{
                throw new RuntimeException("文件不存在或者文件是个目录");
            }
        }
    }
    
    

    但以上中产生了一个问题:不能确定是否读完,只能一直读。

    举例:采用循环的方式

    public class TestStream {
        public static void main(String[] args) {
            String directory = "D:"+File.separator+"test1"+File.separator
                    +"java"+File.separator+"hh.txt";
            //File和本地文件系统相关联
            File file = new File(directory);
            if(file.exists()&&file.isFile()){
                try (InputStream in = new FileInputStream(file);){
    
                    int d = -1;
                    while((d = in.read())!= -1){
                        System.out.print((char)d);  //读出来的为字节,强制转换
                    }
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }else{
                throw new RuntimeException("文件不存在或者文件是个目录");
            }
        }
    }
    

    一个一个字节读取,效率太慢,所以采用缓冲区的读取方式。

    举例:缓冲区方式读取

    public class TestStream {
        public static void main(String[] args) {
            String directory = "D:"+File.separator+"test1"+File.separator
                    +"java"+File.separator+"hh.txt";
            //File和本地文件系统相关联
            File file = new File(directory);
            if(file.exists()&&file.isFile()){
                try (InputStream in = new FileInputStream(file);){
                    byte[] buff = new byte[1024];
                    int len = -1;
                    while((len = in.read(buff))!=-1){
                        //有了偏移量,从0开始读取
                        System.out.print(new String(buff,0,len));
                    }
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }else{
                throw new RuntimeException("文件不存在或者文件是个目录");
            }
        }
    }
    
    

    简单总结,以文件操作为例

    1. 对于OutputStream:就是将数据流出,将数据写到文件里;常用的使用的方法就是write(byte b[])
    2. 对于InputStream:就是读取文件中的数据,流入程序;常用的使用方法就是read(byte b[], int offset, int len)
    3. 对于OutputStream来说,写入到文件中时,若文件没有,可以自动创建;而对于InputStream来说,文件必须存在

    展开全文
  • 一、字节输出流开发步骤  (1)创建一个字节输出流对象(这里假设一个文件out.txt):OutputStream out = new FileOutputStream("out.txt");  (2)使用流对象给当前文件中写数据  两种方式:a.写一个...

    一、字节输出流开发步骤

           (1)创建一个字节输出流对象(这里假设一个文件out.txt):OutputStream out = new FileOutputStream("out.txt");

           (2)使用流对象给当前文件中写数据

                     两种方式:a.写一个字节:write(int i);

                                     b.写一个字节数组:write(byte[] bys);

           (3)释放资源

                     关闭流对象

    二、字节输入流开发步骤

          (1)创建字节输入流对象:FileInputStream in = new FileInputStream("in.txt");

          (2)读数据

                    两种方式:a.一次读一个字节

                                       int by = 0;

                                       while((by = in.read())!=-1){

                                       System.out.println((char)by);//强制类型转换

                                       }

                                    b.一次读一个字节数组(比第一种方式速度快) public int read(byte[] bys);

                                       byte[] bys = new byte[1024];

                                       int len = 0;

                                       while((len = in.read(bys))!=-1){

                                       System.out.println(new String(bys.0.len));

                                       }

          (3)释放资源

    三、读写操作(复制文本文件、音频文件、图片文件等)

          复制:

                (1)分析源文件:所存储的路径→使用字节输入流读文件

                (2)分析目的地文件:将要复制到盘符下的路径→使用字节输出流写对象

                (3)方法:一次读一个字节(边读边写这个字节)/一次读一个字节数组(输出流对象.write(bys.0.len));

    四、递归:方法调用方法本身的一种现象     注意:构造方法没有方法递归

                       举例:例如有一个a方法,当它递归时,a方法会一直调用自己,可以看成a(a(a(a(a(...........,方法一直没有结束,直到将内存耗尽报错(方法只开不关)。

           所以使用递归时一定要定义递归头和递归体,让方法知道什么时候应该开始递归,什么时候结束递归。

           在实际需要中,我们更依赖于循环,凡是递归能做的循环都可以做,并且循环的速度快,内存占用小,效率较高,一般不会造成内存耗尽的情况。

           前提条件:1)必须写一个方法

                           2)出口条件(最终要能结束掉)

                           3)符合需求的一些规律

           解决思路:分成若干个小问题

    展开全文
  • IO流 IO流分为: 输出流——写出数据 输入流——读取数据 数据类型不同,有:字节流和字符...如,写出数据到文件,是文件字节输出流FileOutputStream(输出流对象指向文件)。 字节输出流OutputStream操作步骤 1.创...

    IO流

    IO流分为:
    输出流——写出数据
    输入流——读取数据

    数据类型不同,有:字节流字符流

    字节流的抽象基类:InputStream、OutputStream
    字符流的抽象基类:Reader、Writer

    字节输出流OutputStream

    如,写出数据到文件,是文件字节输出流FileOutputStream(输出流对象指向文件)。

    字节输出流OutputStream操作步骤

        1.创建字节流对象
        2.写数据
        3.释放资源
    

    文件字节输出流FileOutputStream

    把一个字符串写到F:\testIOStream\1.txt文件里

    是字节输出流,先要把String字符串——>byte[]字节数组
    如:将“hello”转换为字节数组:“hello”.getbytes()

    code V1:

    import java.io.FileOutputStream;
    import java.io.IOException;
    
    public static void main(String[] args) throws IOException {
          
            /*
            方式一:
            String path="F:\\testIOStream\\1.txt";
            //File(String pathname) File的一个构造方法:构造File实例
            //封装成一个File
            File file= new File(path);
    
            //创建文件输出流
            //构造方法FileOutputStream(File file)
            FileOutputStream fos= new FileOutputStream(file);
            */
    
            //文件输出流指向了要操作的文件
            //构造方法:FileOutputStream(String name)
            FileOutputStream fos= new FileOutputStream("F:\\testIOStream\\2.txt");
            /**
            这一句代码创建字节输出流做了哪些事:
            调用系统功能创建文件;
            创建流对象;
            把流对象指向这个文件。
             */
    
            //要写出的数据
            String content="public static void main(String[] args{}); 文件.";
            //将字符串转换为字节数组
            byte[] b= content.getBytes();
    
            //写出到文件
            fos.write(b);
    
            //释放资源
            //关闭此文件输出流并释放与此流有关的所有系统资源
            fos.close();
            /**
             * 为什么一定要close()呢:
             * 让流对象变成垃圾,可以被垃圾回收器回收;
             * 通知系统去释放跟文件相关的资源
             */
    
        }
    }
    

    public void write(byte[] b, int off, int len) 只写一部分数据

    实现数据的换行

    写入换行符号。如,fos.write("\n".getbytes());

    注意,不同系统的换行标识符不一样
    windows: \r\n
    linux: \n
    Mac: \r
    一些常见的高级记事本是可以识别任意换行符号的。

    实现数据的追加

    构造方法FileOutputStream(String name,boolean append)+ append是true。
    构造方法FileOutputStream(File file, boolean append)
    append - 如果是 true ,那么字节将被写入文件的末尾,而不是开头 。

    把一个字符串写到F:\testIOStream\1.txt文件里,一起做异常处理

    public class FileOutputStreamDemo2 {
        public static void main(String[] args){
    
            //准备数据
            String s= "我要写入数据到这个文件hhh\r\nhello, IO.";
            byte[] b= s.getBytes();
    
            FileOutputStream fos= null;
            try{
                //创建流对象
                fos= new FileOutputStream("F:\\javalearnCode\\IOstream\\testIOStream\\1.txt");
                //写入到1.txt文件
                fos.write(b);
            } catch( IOException e){
                e.printStackTrace();
            } finally{
                
                try {
                    fos.close();//放到finally里,保证一定执行
                } catch (IOException e) {
                    e.printStackTrace();
                }
                
            }
        }
    }
    

    文件字节输入流FileInputStream

    从文件读数据

    1.一次读一个字节
    public int read()一次读一个字节。返回值是int类型的ASCii码值哦。 读到文件末尾,返回值为-1,所以可以拿-1做判断读完没。
    public int read()一次读一个字节数据 返回值为intASCii码值,,读到文件末尾,返回值为-1,所以可以拿-1做判断

    import java.io.FileInputStream;
    import java.io.IOException;
    
    public class FileInputStreamDemo {
        public static void main(String[] args) {
            FileInputStream fis= null;
            try{
                fis= new FileInputStream("F:\\javalearnCode\\IOstream\\testIOStream\\1.txt");
                int data=0;
                //(data=fis.read())!=-1)读取 赋值 判断 都做了
                while((data=fis.read())!=-1){ //public int read()一次读一个字节数据 返回值为int,读到文件末尾,返回值为-1,所以可以拿-1做判断
                                                //注意:读不出中文
                    System.out.print((char)data);
                };
    
            }catch(IOException e){
                e.printStackTrace();
            }finally {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
    
        }
    }
    

    2.一次读一个字节数组
    public int read(byte[] b)
    **字节数组b就是一个临时的空间,用来放每次读取的数据的。**第1次读取完数据,第2次读取的会把第一次的覆盖掉…到读完。
    要定义一个字节数组,开辟一个空间。

    import java.io.FileInputStream;
    import java.io.IOException;
    
    public class FileInputStreamDemo2 {
        public static void main(String[] args) throws IOException {
            FileInputStream fis= new FileInputStream("F:\\javalearnCode\\IOstream\\FileDemo.java");
    
            //字节数组就是一个临时的空间,用来放每次读取的数据的
            //字节数组的长度一般是1024或者1024的整数倍(给的每次可读取的空间的大小)
            byte[] bys= new byte[1024];
            int len= 0;
            while((len=fis.read(bys))!=-1){//fis.read(bys) 读取到的存在了bys字节数组里。返回的是读取到的实际长度
                System.out.print(new String(bys, 0, len)); //String的构造方法之用字符数组构造新的String:String(byte[] bytes)和String(byte[] bytes, int offset, int length)
            }
            
    		fis.close();
        }
    }
    
    展开全文
  • 字节输出流 response.getOutputStream() 通过io字节读取路径下的文件,形成输出流到response返回给页面: // 设置响应的格式 response.setContentType("image/jpg"); //字节输入流 InputStream in = new ...
  • 字节输出流和字符输出流的编码问题     字节输出流 OutputStream out = new FileOutputStream("d:\\demo.txt"); out.write("123".getBytes("UTF-8")); 上面的文件格式并不是utf-8,还是ANSI ...
  • FileOutputStream :文件输入流用于将数据写入File FileOutputStream​(String name) 创建文件输出流以指定的名称写入文件。 ```java ... //创建字节输出流对象 //FileOutputStream​(String name)
  • java.io.OutputStream:字节输出流 此抽象类是表示输出字节流的所有类的超类 定义了一些子类共性的成员方法: -public void close() :关闭此输出流并释放与此流相关联的任何系统资源。 -public void flush() :...
  • io流的分类: 按流向分: 输入流 输出流 按数据类型划分: 字节流 字符流 字节流: 输入流:InputStream ...字节输出流OutputStream OutputStream定义了一些子类共性的成员方法:* public void close() ...
  • Fileoutputstream文件字节输出流 作用: 以内存为基准,把内存中的数据,按照字节的形式写出到磁盘文件中去。 简单来说,把内存数据按照字节写出到磁盘文件中去。 构造器: public Fileoutputstream(File file): 创建...
  • Java 文件字节输出流

    2018-06-19 11:57:49
    关闭输出流如果对文件的写入需求比较简单,那么可以使用FileOutputStream类(文件字节输出流),它是OutputStream类的子类(亿字节为单位向文件类写入内容)。该类的实例方法是从OutputStream类继承来的。可以使用...
  • ------------------------------------java字节输出流OutputStream概述----------------------------- 字节输入流:InputStream 常用子类 FileInputStream 字节输出流:OutputStream 常用子类 FileOutputStream ...
  • public BufferedOutputStream(OutputStream in) ​ public BufferedOutputStream(OutputStream in,int size)
  • IO流---字节输出流

    2017-04-26 19:02:07
    IO的作用是为了处理设备之间数据的传输问题,... 具体分为:字节输入流 InputStream,字节输出流 OutputStream,字符输入流 Reader,字符输出流 Writer 字节流可以处理所有类型数据格式的传输,例如图片和视频。字符
  • 字节操作流:OutputStream(字节输出流)InputStream(字节输入流) 字符操作流:Writer(字符输出流)Reader(字符输入流) 通用操作步骤 通过File类设定要操作的文件路径(针对文件流而言) 通过字节流或字符流的子类...
  • 关于FileOutputStream文件字节输出流: 负责Write(写),从内存 到 硬盘 输出文件。 什么文件都能输出到硬盘上,使用和FileInputStream一样,最终写入完的时候需要调用flush()方法。 测试代码: import java.io.*; ...
  • 1. 字节输入: 1.1 InputStream类的常用方法 1. available() 方法,获取与之关联的文件剩余可读的字节数。 2. int read() 方法,读取输入。读取输入的下一个字节,返回一个0-255之间的int类型整数。如果到达...
  • Java的io流学习记录(2)--字节输出流OutputStream及其字节输出流的子类. 一、outputstream是一个抽象类: 包含的method有: 1. // 将字节b写入到“输出流”中。  // 它在子类中实现! 2. // 写入字节...
  • 字节输出流OutputStream

    2020-02-19 11:24:26
    输出流中定义都是写write方法,如下图: 一、FileOutputStream类 OutputStream有很多子类,其中子类FileOutputStream可用来写入数据到文件。 FileOutputStream类,即文件输出流,是用于将数据写入 Fil...
  • * java.io.OutputStream:字节输出流 * 此抽象类是表示输出字节流的所有类的超类 *定义了一些子类共性的成员方法: * public void close():关闭输出流并释放与此相关联的任何系统资源 * public void flush():刷新此...
  • /*字节输出流 OutputStream ->abstract(抽象)类型 该类中有两个接口 1. Closeable -> 关闭 2. Flushable -> 清空 三个输出的方法: 1. 输出单个字节:public abstract void write(int b) throw IOException ...
  • FileOutputStream,FileInputStream介绍@Test /** * 字节输入流与字节输出流 * FileOutputStream,FileInputStream介绍 * */ public void test2(){
  • package cnitcast_01;... * 字节输出流操作步骤 * A; 创建字节输出流对象 * B;调用write()方法 * C:释放资源 * * public void write(int b):写一个字节 * public void write(byte[] b);写一个字节数
  • 一,概述 1,IO流概念: I:input,输入,即把硬盘中的数据读取到内存中使用,也叫读取; O:output,输出,把内存中的数据写入到硬盘当中保存,也就写入; 流:即数据(字符、字节),1字符...二,字节输出流OutputStream
  • - - - - | OutputStream 是所有 字节输出流的基类,抽象类 - - - - - - - - | FileOutputStream 向文件输出数据的输出字节流 1.输出字节流使用步骤FileOutputStream 1.找到目标文件 File file = new File("E:\\...
  • 一、类Java的流式输入/输出是建立在四个抽象类的基础上的:InputStream、...InputStream和OutputStream为字节流设计,Reader和Writer为字符设计,字节流和字符形成分离的层次结构。一般来说,处理字符...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,667
精华内容 8,666
关键字:

字节输出流