精华内容
下载资源
问答
  • 2022-05-03 18:46:45

    简要:

    • 实现类为:FileInputStream和FileOutputStream,都是用来操作磁盘文件的。
    • 输入输出流是相对于内存而言的。当写文件时实际是从内存输出磁盘中,故用的是输出流;当度文件时实际是从磁盘输入到内存,故用的是输入流(入内存即输入,出内存即输出)。
    • 这两个流,主要用于文件的写入和读取
    • 注意流的使用后是需要关闭的,否则占用过多的系统资源
    • 这两个流对象的创建,可能涉及到文件类异常,故要用到try...catch语句
    • 最后这两个实现类需要从java.io包中导入

    代码了解:

    //在Test.java文件中
    
    
    import java.io.*;
    
    public class Test{
      public static void main(String[] args){
          //创建一个文件对象file
          File file = new File("test.txt");
    
          try{
              //创建文件输出流对象fo
              FileOutputStream fo = new FileOutputStream(file);
              //向文件中写入内容
              byte [] bytecontent = "我是写入的文件内容".getBytes();	//将字符串转换文字节数组类型
              fo.write(bytecontent);	//以字节数组类型写入内容
              //关闭文件输出流
              fo.close();
              System.out.println("已创建test.txt文件,已写入内容");
              
              
              //创建文件输入流对象
              FileInputStream fi = new FileInputStream(file);
              //读取文件内容
              byte bytearr[] = new byte[1000];	//创建个字节数组,给定长度为1000
              int len = fi.read(bytearr); 	//将读取到的文本元素放入bytearr数组中,返回数组长度
              System.out.println("读取的文件内容为:"+new String(bytearr,0,len));	//将字节型数组转换为字符串
              //关闭文件输入流
              fi.close();
              
          }catch(Exception e){
              System.out.println(e);
          }
      } 
    }

    ok,通过以上代码使用输出流和输入流,就实现了文件的写入和文件的读取。

    更多相关内容
  • FileOutputStream(File File):---创建一个file对象表示的文件中写出数据的文件输出流 FileOutputStream(String filename)---创建一个具有指定名称的文件中写出数据的文件输出流 注意:若指定的文件已经包含内容...
    一、创建FOS对象(重写模式)
    FileOutputStream是文件的字节输出流,以字节为单位将数据写入文件
    FileOutputStream(File File):---创建一个file对象表示的文件中写出数据的文件输出流
    FileOutputStream(String filename)---创建一个具有指定名称的文件中写出数据的文件输出流
    注意:若指定的文件已经包含内容,那么当使用FOS写入数据,数据会全部清空
    文件若不存在,则新建该文件;文件存在,则清空数据重新写入
    
    
    
    package cn.edu.sqxy.day13;
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    //输入和输出流
    public class Inout {
        public static void main(String[] args) throws IOException {
            Inout io = new Inout();
            io.testFosByAppend();
        }
    //    1、FOS对象重写文件(新建文件,写入内容,清空原数据)
        public void testFosByAppend() throws IOException {
    //        创建文件字节输出流
            FileOutputStream fos=new FileOutputStream("fos.txt");
    //        写出一组字节,将字符转化为byte[]字节数组
            fos.write("sqxy".getBytes());
            fos.close();
        }
    }
    
    
    二、建FOS对象(追加模式)FileOutputStream(File file,boolean append)创建一个向指定文件feil对象写出数据的文件输出流
    FileOutputStream(String filename,boolean append)
    注意:第二参数为true则通过末尾追加
    
    2、FOS对象重写文件(新建文件,写入内容,清空原数据)
        
    public void testFosByAppend() throws IOException {
    //        创建文件字节输出流
            FileOutputStream fos=new FileOutputStream("fos.txt");
    //        写出一组字节,将字符转化为byte[]字节数组
            fos.write("sqxy".getBytes());
            fos.close();
        }
    //    1、FOS对象追加文件(写入内容)
        public void testFosByAppendTrue() throws IOException {
    //        创建文件字节输出流
            FileOutputStream fos=new FileOutputStream("fos.txt",true);
    //        写出一组字节,将字符转化为byte[]字节数组
            fos.write("ydd".getBytes());
            fos.close();
        }

    展开全文
  • Java 文件输出流

    2021-03-05 22:05:42
    Java IO教程 - Java文件输出流创建输出要写入文件,我们需要创建一个FileOutputStream类的对象,它将表示输出。// Create a file output streamString destFile = "test.txt";FileOutputStream fos = new ...

    Java IO教程 - Java文件输出流

    创建输出流

    要写入文件,我们需要创建一个FileOutputStream类的对象,它将表示输出流。// Create a file output stream

    String destFile = "test.txt";

    FileOutputStream fos = new FileOutputStream(destFile);

    当写入文件时,如果文件不存在,Java会尝试创建文件。我们必须准备好处理这个异常,将代码放在try-catch块中,如下所示:try {

    FileOutputStream fos = new FileOutputStream(srcFile);

    }catch (FileNotFoundException e){

    // Error handling code goes here

    }

    如果文件包含数据,数据将被擦除。为了保留现有数据并将新数据附加到文件,我们需要使用FileOutputStream类的另一个构造函数,它接受一个布尔标志,用于将新数据附加到文件。

    要将数据附加到文件,请在第二个参数中传递true,使用以下代码。FileOutputStream fos = new FileOutputStream(destFile, true);

    写数据

    FileOutputStream类有一个重载的write()方法将数据写入文件。我们可以使用不同版本的方法一次写入一个字节或多个字节。

    通常,我们使用FileOutputStream写入二进制数据。

    要向输出流中写入诸如“Hello"的字符串,请将字符串转换为字节。

    String类有一个getBytes()方法,该方法返回表示字符串的字节数组。我们给FileOutputStream写一个字符串如下:String text = "Hello";

    byte[] textBytes = text.getBytes();

    fos.write(textBytes);

    要插入一个新行,使用line.separator系统变量如下。String lineSeparator = System.getProperty("line.separator");

    fos.write(lineSeparator.getBytes());

    我们需要使用flush()方法刷新输出流。fos.flush();

    刷新输出流指示如果任何写入的字节被缓冲,则它们可以被写入数据宿。

    关闭输出流类似于关闭输入流。我们需要使用close()方法关闭输出流。// Close the output stream

    fos.close();

    close()方法可能抛出一个IOException异常。如果我们希望自动关闭tit,请使用try-with-resources创建输出流。

    以下代码显示如何将字节写入文件输出流。import java.io.File;

    import java.io.FileOutputStream;

    public class Main {

    public static void main(String[] args) {

    String destFile = "luci2.txt";

    // Get the line separator for the current platform String lineSeparator = System.getProperty("line.separator");

    String line1 = "test";

    String line2 = "test1";

    String line3 = "test2";

    String line4 = "test3";

    try (FileOutputStream fos = new FileOutputStream(destFile)) {

    fos.write(line1.getBytes());

    fos.write(lineSeparator.getBytes());

    fos.write(line2.getBytes());

    fos.write(lineSeparator.getBytes());

    fos.write(line3.getBytes());

    fos.write(lineSeparator.getBytes());

    fos.write(line4.getBytes());

    // Flush the written bytes to the file fos.flush();

    System.out.println("Text has been written to "

    + (new File(destFile)).getAbsolutePath());

    } catch (Exception e2) {

    e2.printStackTrace();

    }

    }

    }

    上面的代码生成以下结果。

    5ba9d2eb2e140580eb13a02959eea5ee.png

    展开全文
  • IO

    File对象

    File的介绍

    File 类 就是当前系统中 文件或者文件夹的抽象表示
        
    通俗的讲  就是 使用File对象 来操作我们电脑系统中的文件或者文件夹

    学习File类 其实就是学习 如何通过file对象 对系统中的文件/文件夹进行增删改查

    1.创建file对象

    File 名字 =new File(路径);

    路径path即:"什么盘/什么文件/什么文件/什么文件";

     路径分割符
             *  D:\haha\hehe\123.mp4    称之为路径  其中 \ 就是路径分割符 代表的是 下级目录
             *  在windows系统中 路径分割符为  \   在 Linux 和 Mac 中 路径分割符是 /
             *  我们写的java代码  需要跨平台 多环境运行   开发环境:windows   生成环境:Linux
             *  此时就会出现一个问题  如果我们的路径分隔符 写成 \  在 windows中好使 到了 Linux就不识别
             *  所以我们可以使用以下两种方式解决:

    方式一:windows不仅支持\还支持/

    File 名字 =new File("D:/abc/a/123.txt");

    方式二:使用动态识别的常量,File.separator根据当前代码所在的系统获取相应的分隔符

    File 名字=new File("D:"+File.separator+"abc"+File.separator+"a"+File.separator+"123.txt");

    2.file的增加操作

    我们创建了一个新的file对象并不是在电脑中已经添加了文件,在电脑中创建文件需要file的添加

    一定记得要抛出错误

    (1)创建相应的文件:

    file对象.createNewFile();

    (2)创建单层目录:

    file对象.mkdir();

    mkdir:make directory

    (3)创建多层目录:

    file对象.mkdirs()

    根据你调用的方法不同会创建不同类型的文件

     File file01=new File("D:/Lianxi/hello.text");
     file01.createNewFile();//创建文件
     File file02=new File("D:/Lianxi/aaa");
     file02.mkdir();//创建单层目录
     File file03=new File("D:/Lianxi/A1/A2");
     file03.mkdirs();//创建多层目录

    3.file的删除操作

    (1)删除文件:

    file对象名字.delete();

    (2)延迟删除(休眠删除)

    file对象名字.deleteOnExit();//当程序退出后 删除

    Thread.sleep(毫秒);

    记得要抛出异常不然sleep会报错

    (3)删除空目录

    file对象.delete();

    删除目录的前提一定是目录下没有文件即该目录为空目录;

            File file04=new File("D:/Lianxi/eee");
            //删除指定的文件
            file04.delete();
            File file05=new File("D:/Lianxi/hello.text");
            //延迟删除文件也可以叫做休眠删除文件
            file04.deleteOnExit();//程序退出后删除
            //多少毫秒后删除
            Thread.sleep(5000);
            File file06=new File("D:/Lianxi/A1/A2");
            //删除目录文件前提是空目录
            file06.delete();

    4.file的修改操作

    (1)设置该文件的权限为不能读:

    file对象.setRedadable(false);

    (2)设置该文件的全选为不能写:

    file对象.setWritable(false);

    (3)设置文件为只读权限:

    file对象.setReadOnly()

    (4)重命名

    file对象.renameTo(new File(你要修改的路径));

            //创建一个file对象
            File file01=new File("D:/Lianxi/123.txt");
            //对原始文件进行重命名
            file01.renameTo(new File("D:/Lianxi/456.txt"));
            File file02=new File("D:/Lianxi/456.txt");
            //修改路径
            file01.renameTo(new File("D:/Lianxi/A1/A2/789.txt"));

    5.file的查询操作

    (1)得到当前文件的名称

    file对象.getName();

    (2)得到父级路径的名称

    file对象.getParent();

    (3)得到文件的路径名称:

    file对象.Path();

    (4)判断该对象文件是否为文件类型:

    file对象.isFile();

    如果是返回true否则返回false;

    (5)判断该文件对象是否为目录类型

    file对象.isDirectory();

    如果是文件目录类型返回true否则返回false;

            File file=new File("D:/Lianxi/A1/A2/789.txt");
            //获取当前文件的文件名
            String str1=file.getName();
           // System.out.println("文件名为:"+str1);
            //获取当前文件的父级路径
            String str2=file.getParent();
            //System.out.println("文件的父级路径为:"+str2);
            //获取文件的路径
            String str3=file.getPath();
            System.out.println("文件的路径为:"+str3);
            //判断是否为文件类型
            boolean b1=file.isFile();
            System.out.println(b1);
            //判断该文件是否为文件目录类型
            boolean b2=file.isDirectory();
            System.out.println(b2);

    面试题:显示指定目录下的所有文件

    用方法的递归调用

     public static void main(String[] args) {
            showFile("D:/Lianxi");
        }
        public static void showFile(String path){
            //1.创建一个文件对象把路径参数传入
            File file01=new File(path);
            //2.判断文件类型,是否是文件是否是文件目录
            if(!file01.exists() || !file01.isDirectory()){
                return;
            }
            //3.创建一个文件数组来进行循环遍历;
            File[] files=file01.listFiles();
            //4.用for each循环来遍历输出
            for(File f:files){
                //5.判断文件类型是否为文件目录
                //如果是文件目录
                if(f.isDirectory()){
                    //输出文件目录所在的路径
                    System.out.println(f.getPath()+"<Dir>");
                    //继续调用本方法
                    showFile(f.getPath());
                }
                else {
                    //如果不是则输出文件所在的路径
                    System.out.println(f.getPath());
                }
            }
        }

    IO流

    IO流的介绍

    IO都是全大写 说明肯定是两个单词的首字母
    I   inputstream 输入流     O  outputstream  输出流

    IO 称之为 java的输入输出

            其实学习IO  就是学习  如何通过java代码 对文件内容 进行   读(输入流)  写(输出流)
    所以有一话:   读进来 写出去

    IO的作用:就是对文件中的内容进行操作。

    输入: 读操作(读取文件的内容)   输出: 写操作(往文件中写内容)

     IO流的分类:

     (1)根据流的方向:
        ---输入流: 程序可以从中读取数据的流。
        ---输出流: 程序能向其中写入数据的流。
        
     (2)根据流的单位:
        ---字节流: 以字节为单位传输数据的流
        ---字符流: 以字符为单位传输数据的流
     
     (3)根据功能
        ---节点流: 直接和文件进行交互,用于直接操作目标设备的流。
        ---处理流(过滤流): 不是直接作用在文件上。 是对一个已存在流的链接和封装,通过对数据进行处理为程序提供功能强大、灵活的读写功能。
        
    四个基本的流: 其他的流都是在这四个流的基础上进行扩展的
            字节输入流
            字节输出流
        
            字符输入流
            字符输出流

     

    字符流

     1.Writer字符输出流

    它是所有字符输出流的根类。---FileWriter类

    字符输出流 ---指定对哪个文件(路径)进行写操作

    1.创建:

    Writer write对象=new FileWriter(路径)

    2.添加

    writer对象.write(内容);

    3.刷新流

    write对象.flush();

    4.关闭流资源

    write.close();

    5.追加内容

    上面每次往文件中写内容时 就会把原来的内容覆盖了。

    我们只需要在创建write对象时在路径后加上true即:

    Writer write对象=new FileWriter(路径,true)

            //创建writer对象指定路径
            Writer writer=new FileWriter("D:/Lianxi/A1/A2/789.txt");
            String s1="今天是个好日子,好呀么好日子!";
            //调用write方法添加指定的字符串
            writer.write(s1);
            //刷新流
            writer.flush();
            //关闭流
            writer.close();
            //追加内容
            Writer writer1=new FileWriter("D:/Lianxi/A1/A2/789.txt",true);
            String s2="非常适合写代码";
            writer1.write(s2);
            writer1.flush();
            writer1.close();

    2.Reader字符输入流

    它是所有字符输入流的根类  它的实现类有很多,我们使用FileReader实现类

    1.创建字符输入流对象

    Reader reader对象=new FileReader(路径);

    2.读取元素

    Reader对象.read(存储的容器);

    使用读取方法后它会返回每次读取的个数

    如果已经读取完所有元素或文件里没有元素就会返回-1;

            //定义String类型,此时集合中只能存储String类型的数据而且定义使用的类型必须是对象类型
            List<String> list=new ArrayList<String>();
            list.add("张三");
            list.add("李四");
            list.add("王五");
            String s1=list.get(2);
           // System.out.println(s1);
            //循环遍历输出集合里的内容
            for(String s2:list){
                System.out.println(s2);
            }

    字节流

    1.字节输出流-OutputStream

    它可以对任意文件进行操作,对文件进行输出操作。以字节为单位。 它是所有字节输出流的父类,
    FileOutputStream

    1.字节输出流的创建

    OutputStream 名字=new FileOutputStream(路径);

    2.字节输出流的添加操作

    字符操作流一般使使用字节数组byte[]来存储写入

    (1)定义一个字符串来存储将你要写入文件的内容

    (2)定义一个byte字节数组把字符串转换为字节数组.用到了字符串的get方法

    3.字节流的写入操作

    outputstream对象.write(数组名);

            //定义一个字节输出流
            OutputStream outputStream=new FileOutputStream("D:/Lianxi/dd/456.txt");
            String str1="叫偶靓仔";
            //将字符串转换为字节数组
            byte[] bytes=str1.getBytes();
            //调用write方法将数组写入文件
            outputStream.write(bytes);
            //刷新输出流
            outputStream.flush();
            //关闭输出流
            outputStream.close();

    2.字节输入流-InputStream

    它可以对任意文件进行读操作 ,以字节为单位,它是所有字节输入流的父类,子类有FileInputStream

    1.字节输入流的创建

     InputStream 名字=new FileInputStream(路径);

    2.字节输入流的读取

    (1)首先要先定义一个字节数组byte[]来接收读取的内容

    (2)定义一个整型来记录每次读取的返回值即每次读取的数量

    (3)调用读取的方法

    inputstream对象.read(字节数组);

    通常我使用循环来获取文件读取文件里的数据

            //创建一个字节输入流
            InputStream inputStream=new FileInputStream("D:/Lianxi/dd/123.txt");
            //定义一个整型用于记录每次读取的个数
            int num1=0;
            //定义一个字节数组存储读取的的内容长度为10
            byte[] bytes=new byte[12];
            //定义循环来读取内容
            while ((num1= inputStream.read(bytes))!=-1){
                String str1=new String(bytes,0,num1);
                System.out.println(str1);
            }
            //关闭流
             inputStream.close();

    3.使用字节输入和输出流完成文件的复制功能

            //1.定义一个读取对象把文件内容读取出来,字符输入流
            Reader reader=new FileReader("D:/Lianxi/A1/A2/789.txt");
            //2.定义一个输出对象把要复制的内容写入,字符输出流
            Writer writer=new FileWriter("D:/Lianxi/dd/123.txt");
            //3.定义一个整型接收读取时的返回值
            int num1=0;
            //4.定义一个char数组用于存储读取的数据
            char[] chars=new char[10];
            //定义循环进进行复制
            while ((num1=reader.read(chars))!=-1){
                writer.write(chars,0,num1);
                writer.flush();
            }
            reader.close();
            writer.close();

    缓冲流

    缓存流是在基础流[InputStream OutputStream Reader Writer]之上 添加了一个缓存池功能.
    BufferInutStream  BufferOutputStream BufferReader  BufferWriter 提高IO的效率,降低IO的次数。

    缓存流建立在基础流的基础上

    1.缓存流的创建

    (1)输出缓冲流:
    BufferedOutputStream 名字=new BufferedOutputStream(输出流名字);

    (2)输入缓冲流:

    BufferedInputStream 名字=new BufferedInputStream(输入流名字);

    2.缓冲流的方法

    (1)输出缓冲流的用法:

    bufferedoutputstream对象.write(字节数组);

    (2)输入缓冲流的用法

    bufferedInputstream对象.read(字节数组)

            //定义一个输出流
            OutputStream outputStream=new FileOutputStream("D:/Lianxi/A1/A2/789.txt");
            //定义一个输出缓冲流
            BufferedOutputStream bufferedOutputStream=new BufferedOutputStream(outputStream);
            //定义一个字符串来存你要写进去的东西
            String str1="你是我的小呀小苹果";
            //定义一个字节数组
            byte[] bytes=str1.getBytes();
            //调用缓存流方法存暂时把要写入的数据存入到缓存流中,因为你写的内容暂时放入缓存池中并没有直接放入文件中,所以文件中没有你的内容。
            bufferedOutputStream.write(bytes);
            //关闭缓存流,关闭缓存流时会先先刷新缓存池刷新缓存池时会把池子内的数据写入文件
             bufferedOutputStream.close();

    对象流-对java对象进行IO操作

    为什么需要对象流
              我们现在操作IO流的时候 都是将字符串读写操作 可不可以将java对象在文件中进行读写呢? 可以的 Student st=new Student();对象
              将java对象进行读写操作 意义在于持久化信息  例如: 游戏存档。

            因为运行的时候 所有的数据都是在运行内存中的   持久化 将运行内存的数据 保存到硬盘上    存档(写)  读档(读)

    1.对象输出流(序列化)

    (1)首先你要先定义一个类给定属性和方法并且此类一定要实现Serializable 序列化接口

    (2)对象输出流的创建

    要先创建一个字节输出流然后创建对象输出流

    ObjectOutputStream 名字=new ObjectOutputStream(字节输出流名字);

    (3)对象输出流的方法

    名字.writeObject(对象);

    使用对象输出流调用输出方法 输出的类对象 该类必须实现Serializable 序列化接口

       //使用
            //定义一个字节输出流
            OutputStream outputStream=new FileOutputStream("D:/Lianxi/dd/456.txt");
            //定义一个对象输出流
            ObjectOutputStream objectOutputStream=new ObjectOutputStream(outputStream);
            //调用自己定义的对象进行传参
            Hero h1=new Hero("张三",20,"男","人族");
            //调用对象流的写入方法将自己定义的对象写入文件中
            objectOutputStream.writeObject(h1);
            //关闭对象流
            objectOutputStream.close();

    2.对象输入流(反序列化)

    (1)对象输入流的创建

    首先你要先定义一个字节输入流对象然后创建对象输入流

    ObjectInputStream 名字=new ObjectInputStream(字节输入流名字);

    (3)对象输入流的方法

    名字.readObject();

    一定记得要用Object类型来接收数据即:

    Object o=名字.readObject();

            //定义一个字节输入对象
            InputStream inp=new FileInputStream("D:/Lianxi/dd/456.txt");
            //定义一个对象流输入对象
            ObjectInputStream objectInputStream=new ObjectInputStream(inp);
            //定义一个对象类型来接收读取的内容
            Object o1=objectInputStream.readObject();
            System.out.println(o1);
            objectInputStream.close();

    1. 序列化: 把内存中的java对象存储到磁盘[网盘]的过程。
             ---java对象所属的类必须实现序列化接口.implements Serializable
    2. 反序列化: 把磁盘中的内容读取到java对象内存中的过程。

    总结

    1.  通过字符流完成文件的复制---->它只能复制文本文件
    2.  字节流:---字节输入流和字节输出流。
    3.  字节流 我们也可以完成文件的复制功能---它可以复制任意类型的文件.
    4.  缓存流--->它基本流的基础上 添加了一个缓存池
    5.  对象流: ObjectInputStream  ObjectOutputStream
         序列化,反序列化:

    展开全文
  • Java输入输出流

    2021-03-15 15:58:31
    在写入文件时,首先创建了一个文件输出流对象fos: fos = new FileOutputStream("e: \\out.txt"); 该对象创建以后,就实现了从到外部数据源e:\out.txt的连接。说明:当外部文件不存在时,系统会自动创建该文件...
  • Java输出文件到本地(输出流

    千次阅读 2021-03-05 22:08:58
    } } Java修炼——文件字节输入输出流复制和缓冲复制 一:文件字节输入输出流复制 首先明确数据源和目的文件,然后就是"中转站",最后就是关闭 package com.bjsxt.ioproject; import java.io.Fi ... Java 输出文件...
  • 输入输出含义和意义:输入和输出...Java是面向对象的程序语言,每一个数据都是一个对象,它们提供了各种支持“读入”与“写入”操作的类。Java的输入输出功能来自java.io 包中的InputStream类、OutputStream类...
  • C++文件输入/输出流

    千次阅读 2022-03-24 19:16:48
    文章目录文件输入/输出流类表5: 文件读写模式表6:ios_base 标识的组合意义ofstream:写入文件类例8:输出文本文件例9:输出二进制文件ifstream:从文件中读取的类例10:输入文本文件例11:输入二进制文件表7:...
  • Java 文件输出流.pdf

    千次阅读 2021-03-17 19:37:09
    Java 文件输出流Java ⽂件输出Java IO教程 - Java⽂件输出流创建输出要写⼊⽂件,我们需要创建⼀个FileOutputStream类的对象,它将表⽰输出。// Create a file output streamString destFile = "test.txt";...
  • 输出流创建txt文件

    千次阅读 2019-11-07 20:12:01
    问题:利用输入在指定路径下创建file.txt,并且写入字符“文件创建成功!”。然后用记事本打开,查看写入是否正确。 效果: 代码: package _Stream; import java.io.File; import java.io.FileWriter; ...
  • C++ 文件操作(输入输出流

    万次阅读 多人点赞 2018-09-26 20:37:15
    到目前为止,我们已经使用了 iostream 标准库,它提供了 cin 和 cout 方法分别用于从标准输入读取和向标准输出写入。...该数据类型表示输出文件流,用于创建文件并向文件写入信息。 ifstream 该数据类型...
  • 文件输出流:FileOutputStream

    千次阅读 2020-03-29 11:11:18
    OutputStream有很多子类,我们从最简单的一个子类...public FileOutputStream(File file):创建文件输出流以写入由指定的 File对象表示的文件。 public FileOutputStream(String name): 创建文件输出流以指定的名称...
  • Java 输入输出流

    2021-03-01 09:59:51
    读取数据的对象叫做输入,写入数据的对象叫做输出流。2. 在Java中,字符是如何在内存中表示的,是如何在文本文件中表示的?在内存中用Unicode编码来表示字符,在文本文件中用一种指定的编码方案来表示字符,如果...
  • HttpResponse输出文件:Response.Clear();Response.ContentType = "application/octet-stream";//通知浏览器下载文件而不是打开Response.AddHeader("Content-Disposition", "attachment; filename=aaa.csv");var sw =...
  • C++中文件的写与读(输入输出流

    千次阅读 2022-04-25 23:56:39
    C++中对文件操作需要包含头文件<fstream>...2.创建流对象 3.指定打开方式 4.写内容 5.关闭文件 代码如下: #include<iostream> #include<fstream>//1.包含头文件 using namespac
  • 字节输入输出流: (1)定义的方法有: int read() Int read(byte[] buffer):len=fis.read(byt) fis输入read读放入byt数组,把读到的字节个数返回给len Int read(byte[] buffer,int offest,int length) 索引从...
  • java中对象输入输出流

    万次阅读 多人点赞 2017-05-17 15:48:46
    对象输出流和对象输入流可以为应用提供对象持久化的功能,分别调用文件输出流和文件输入流来实现。另一种使用对象流的场景是,在不同主机用socket流在远程通信系统中传递传递数据。1.ObjectInputStream对象输入流是...
  • C++输入输出流(超级详细)

    千次阅读 2022-02-13 09:31:32
    C++输入输出流(超级详细) C++ 又可以称为“带类的 C”,即可以理解为 C++ 是 C 语言的基础上增加了面向对象(类和对象)。在此基础上,学过 C 语言的读者应该知道,它有一整套完成数据读写(I/O)的解决方案:...
  • Java——特殊操作之标准输入输出流、打印对象序列化对象反序列化及应用一、标准输入二、标准输出流三、打印四、字节打印五、字符打印六、复制java文件(打印改进版)七、对象序列化对象反...
  • 下面用**setOut重定向System.out.print输出地址:**的例子来演示如何不覆盖写入 import java.io.*; public class SysteminReader { public static void main(String[] args) throws Exception { //System.out....
  • Java是面向对象的程序语言,每一个数据都是一个对象,它们提供了各种支持“读入”与“写入”操作的类。 Java的输入输出功能来自java.io 包中的InputStream类、OutputStream类、Reader类和Writer类以及继承它们...
  • //创建输出流 try (Writer out = new FileWriter("d:\\Student.txt", true)) { //遍历数组拿到数组中元素的属性按要求写入到文件中 for (Student stu : stuList) { String name = stu.getName(); out.write...
  • 文件字节流输出(文件写操作)

    千次阅读 2020-03-24 00:42:17
    文件字节流输出操作用到的包: import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; 1、文件字节流输出(FileOutputStream)简介: 1.1、outputStream:...
  • 1.对象字节(ObjectInputStream\ObjectOutputStream)在学习对象字节之前,先来了解一个接口java.io.SerializableJAVA允许我们在内存中创建可重复使用的对象,但是,他们的生命仅仅只和虚拟机运行时间一样长。...
  • 【Java 输入、输出流

    千次阅读 多人点赞 2021-04-15 17:02:47
    Java 输入、输出流(I/O)1 File类1.1 文件的属性1.2 目录2 文件字节输入、输出流二级目录三级目录3 文件字符输入、输出流二级目录三级目录4 缓冲二级目录三级目录 概述:输入、输出流提供一条通道程序,可以...
  • FileWriter:用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲...特别是某些平台一次只允许一个 FileWriter(或其他文件写入对象)打开文件进行写入。在这种情况下,如果所涉及的文件已经打...
  • 8种方法在java8中创建流对象(Stream)

    千次阅读 2021-03-01 09:18:11
    8种方法在java8中创建流对象(Stream)创建空的Streamempty()方法用来创建一个空的Stream stream = Stream.empty();stream.forEach(System.out::println);这个方法经常被用在创建一个不含元素的空的进行返回,避免...
  • 1.首先,我们要分别建立一个文件输入文件输出流对象,用来读取和写入数据 2.然后,我们将读取的数据用一个字节数组接受,当read方法返回值不是-1时,说明文件就没有读完。 3.文件输出流调用write方法,将...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 956,801
精华内容 382,720
关键字:

创建文件输出流对象