精华内容
下载资源
问答
  • 我知道RandomAccessFile可以读写文件我想问的是RandomAccessFile是否可以读写对象
  • 对象流进行IO流的对象读写

    千次阅读 2018-01-03 00:19:03
    ## 对象流进行IO流的对象读写 - 对象流的作用就是对象从内存写到文件中,或者将文件读取到内存中,这个过程叫序列化(写出),写出就是反序列化(读取) - ObjectInputStream - ObjectOutputStream ```java Person p = ...


    ## 对象流进行IO流的对象读写

    - 对象流的作用就是对象从内存写到文件中,或者将文件读取到内存中,这个过程叫序列化(写出),反之就是反序列化(读取)
    -    ObjectInputStream
    -    ObjectOutputStream



    ```java
    Person p = new Person();
    p.name = "jack";
    p.age = 19;
    // p.show();
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("a.txt"));
    Object obj = ois.readObject();
    Person p2 = (Person)obj;//p2 存储的是a.txt文件中存储的对象
    p2.show();// jack...19
    ois.close();

    // // 创建一个对象输出流
    // ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("a.txt"));
    // // 写入数据
    // oos.writeObject(p);
    // // 关闭流
    // oos.close();
    System.out.println("搞定");
    ```
    展开全文
  • C++ 文件流 二进制文件流读写

    多人点赞 热门讨论 2021-05-22 21:01:15
    C++C++流文件流对文本文件流读写二进制文件流读写 C++ C++的IO 设备: 1)文件 2)控制台 3)特定的数据类型(stringstream) c++中,必须通过特定的已经定义好的类, 来处理IO(输入输出) 文件流 文件流: 对文件进行...

    C++流

    C++的IO流
    在这里插入图片描述

    设备:
    1)文件
    2)控制台
    3)特定的数据类型(stringstream)

    c++中,必须通过特定的已经定义好的类, 来处理IO(输入输出)

    在这里插入图片描述

    文件流

    文件流: 对文件进行读写操作
    头文件:
    类库:
    ifstream 对文件输入(读文件)
    ofstream 对文件输出(写文件)
    fstream 对文件输入或输出

    对文本文件流读写

    文件打开方式
    在这里插入图片描述

    二进制文件流读写

    思考:
    文本文件和二进制文件的区别?

    文本文件: 写数字1, 实际写入的是 ‘1’
    二进制文件:写数字1, 实际写入的是 整数1(4个字节,最低字节是1, 高3个字节都是0)
    写字符‘R’实际输入的还是‘R’
    在这里插入图片描述
    使用notepad++二进制方式查看:
    在这里插入图片描述
    notepad++查看二进制文件:
    1.安装notepad++ (群文件中可直接下载)
    2.配置二进制编辑插件
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    关闭notepad++, 再重新打开.

    使用二进制方式查看:
    在这里插入图片描述

    展开全文
  • 几种IO流读写文件

    万次阅读 多人点赞 2017-05-31 21:00:03
    一、超类: 字节: InputStream(读入) OutputStream(写出)...二、文件操作 字节: FileInputStream ,FileOutputStream 字符: FileReader, FileWriter(用法与字节基本相同,不写) //1.指定要读

    一、超类:
    字节流: InputStream(读入流) OutputStream(写出流)
    字符流: Reader(字符 读入流) Writer (字符写出流)

    二、文件操作流
    字节流: FileInputStream ,FileOutputStream
    字符流: FileReader, FileWriter(用法与字节流基本相同,不写)

            //1.指定要读 的文件目录及名称
            File file =new File("文件路径");
            //2.创建文件读入流对象
            FileInputStream fis =new FileInputStream(file);
            //3.定义结束标志,可用字节数组读取
            int i =0 ;
            while((i = fis.read())!=-1){ 
                //i 就是从文件中读取的字节,读完后返回-1
            }
            //4.关闭流
            fis.close();
            //5.处理异常
            //1.指定要写到的文件目录及名称
            File file =new File("文件路径");
            //2.创建文件读入流对象
        FileOutputStream fos =new FileOutputStream(file);
            //3.定义结束标志
            fos.write(要写出的字节或者字节数组);
            //4.刷新和关闭流
            fos.flush();
            fos.close();
            //5.处理异常

    三、缓冲流:
    字节缓冲流: BufferedInputStream,BufferedOutputStream
    字符缓冲流:BufferedReader ,BufferedWriter
    缓冲流是对流的操作的功能的加强,提高了数据的读写效率。既然缓冲流是对流的功能和读写效率的加强和提高,所以在创建缓冲流的对象时应该要传入要加强的流对象。

    //1.指定要读 的文件目录及名称
            File file =new File("文件路径");
            //2.创建文件读入流对象
            FileInputStream fis =new FileInputStream(file);
            //3.创建缓冲流对象加强fis功能
    BufferedInputStream bis =new BufferedInputStream(fis); 
            //4.定义结束标志,可用字节数组读取
            int i =0 ;
            while((i = bis.read())!=-1){ 
                //i 就是从文件中读取的字节,读完后返回-1
            }
            //5.关闭流
            bis.close();
            //6.处理异常
            //1.指定要写到的文件目录及名称
            File file =new File("文件路径");
            //2.创建文件读入流对象
        FileOutputStream fos =new FileOutputStream(file);
            //3.创建缓冲流对象加强fos功能
    BufferedOutputStream bos=new BufferedOutputStream(fos);
            //4.向流中写入数据
            bos.write(要写出的字节或者字节数组);
            //5.刷新和关闭流
            bos.flush();
            bos.close();
            //6.处理异常

    由以上看出流的操作基本相同,此流与文件流操作是几乎一样的只是将文件流作为参数传入缓冲流的构造方法中堆文件流读写文件的功能进行加强
    注1:在字符读入缓冲流BufferedReader 中还提供了读一行的方法 readLine() 可以读取一行文本
    在字符写出缓冲流BufferedWriter 中还提供了写人一个行行分隔符的方法writeLine(),用于写出时换行
    注2:此处用到的是GoF设计模式中的装潢(装饰)模式
    注3:创建缓冲流的对象的装逼模式:

    BufferedInputStream bis =new BufferedInputStream(
    new FileInputStream(new File("文件路径")));     

    注4:缓冲流参数只要是一中超类的子类就行

    四、对象流
    ObjectInputStream ,ObjectOutputStream
    不同于以上两种类型的流这里只能用字节对对象进行操作原因可以看上篇的编码表比照原理

    ObjectOutputStream对象的序列化:
    将java程序中的对象写到本地磁盘里用ObjectOutputStream
    eg:将Person类的对象序列化到磁盘

    1.创建Person类
        注1:此类要实现Serializable接口,此接口为标志性接口
        注2:此类要有无参的构造函数
        注3:一旦序列化此类不能再修改
        class Person implements Serializable{
            public Person(){}
        } 
    2.创建对象流对象
        注:要增强功能可以将传入文件缓冲流
        ObjectOutputStream oos =new ObjectOutputStream(
        new FileOutputStream(new File("文件路径")));
    3.写入对象 ,一般会将对象用集合存储起来然后直接将集合写入文件
        List<Person> list =new ArrayList<>();
        list.add(new Person());
        ...(可以添加多个)
        oos.writeObject(list);
    4.关闭流,处理异常
        oos.flush();
        oos.close();

    ObjectInputStream对象的反序列化:
    从本地磁盘里用ObjectInputStream将对象文件读入java程序

    1:用集合接收的时候要强转
    1.创建对象流对象
        ObjectInputStream ois =new ObjectInputStream(
        new FileInputStream(new File("文件路径")));
    2.读入对象
        List<Person> list =new ArrayList<>();
        List =(List<Person>)ois.readObject();
    3.关闭流,处理异常
        ois.close();

    五、转换流:
    这类流是用于将字符转换为字节输入输出,用于操作字符文件,属于字符流的子类,所以后缀为reader,writer;前缀inputstream,outputstream;注 :要传入字节流作为参赛
    InputStreamReader: 字符转换输出流
    OutputStreamWriter:字符转换输入流

    需求:读取键盘输入的一行文本,再将输入的写到本地磁盘上
    //1.获取键盘输入的字节流对象in
    InputStream in =Stream.in; 
    /*2.用转换流将字节流对象转换为字符流对象,方便调用字符缓冲流的readeLine()方法*/
    InputStreamReader isr =new InputStreamReader(in);
    /*5.创建字符转换输出流对象osw,方便把输入的字符流转换为字节输出到本地文件。*/
    OutputStreamWriter osw =new OutputStreamWriter(new 
        FileOutputStream(new File("文件名"))); 
    
    /*3.现在isr是字符流,可以作为参数传入字符缓冲流中*/
    BufferedReader br =new BufferedReader(isr);
    
    /*4.可以调用字符缓冲流br的readLine()方法度一行输入文本*/
    String line =null;
    while((line =br.readLine()){
        osw.write(line);//osw是字符流对象,可以直接操作字符串
    
    }
    
    
    注:InputStreamReader isr =new InputStreamReader(new "各种类型的字节输入流都行即是:后缀为InputStream就行");
    OutputStreamWriter osw =new OutputStreamWriter(new 
        "后缀为OutputStream就行"); 
    

    六、区别记忆
    1.对象流是可以读写几乎所有类型的只要是对象就行,而字节字符流,只能读写单个字节字符或者字节字符数组,以上没有读写字节字符数组的;注意对象流只有字节流!
    2.字符和字节循环读入的结束条件int i=0; (i =fis.read())!=-1
    用字符数组复制文件(fr 读入流 ,fw写出流),字节流也是相同的用法

      int i = 0;
      char[] c = new char[1024];  
         while((i = fr.reade()) !=-1)){
             fw.write(c,0,i);
         }
    

    3.对象流里面套缓冲流的情景:
    new ObjectInputStream(new BufferedInputStream(new FileInputStream(new File(“文件路径”))));

    4.记忆流及其功能的方法:
    前缀表示功能,后缀表示流的类型;
    比如说FileInputStream 前缀:File,表示操作的磁盘,后缀:intputstream,表示是字节输入流。
    同理 FileReader:表示操作文件的字符流
    ObjectInputStream :操作对象的字节输入流

    5.拓展:获取键盘输入的字符的缓冲流的写法:
    new BufferedReader(new InputStreamReader(System.in)));
    将字节以字符形式输出到控制台的字符缓冲流的写法:
    new BufferedWriter( new OutputStreamWriter(System.out))

    展开全文
  • AndroidIO流读写文件

    万次阅读 2018-06-18 12:35:54
    一、超类: 字节: InputStream(读入) OutputStream(写出) 字符: Reader(字符 读入) Writer (字符写出)二、文件操作 字节: FileInputStream ,FileOutputStream 字符: FileReader, ...

    一、概念

    文件在程序中是以的形式来操作的。

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

    二、分类

    1、按照流向划分:输入流、输出流


       以内存为参照:

       输入流:从文件流向内存

        输出流:从内存流向文件

    2、按照传输单位划分:字节流、字符流


    字节流:可以用于读写二进制文件及任何类型文件。

    字符流:可以用于读写文本文件。

    三、字节流VS字符流的区别

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

    区别:

    1、读写单位不同:字节流以字节(1 byte,1byte=8bit)为单位,字符流以字符为单位,根据码表映射字符,一次可能读多个字节。
    2、处理对象不同字节流能处理所有类型的数据(如图片、avi等),而字符流只能处理字符类型的数据
    3、缓存。字节流在操作的时候本身是不会用到缓冲区的,是文件本身的直接操作的;而字符流在操作的时候下后是会用到缓冲区的,是通过缓冲区来操作文件。

    总结优先选用字节流。因为硬盘上的所有文件都是以字节的形式进行传输或者保存的,包括图片等内容。字符只是在内存中才会形成的,所以在开发中,字节流使用广泛。

    四、具体的案例讲解

    案例0

    功能:1、创建文件夹、文件 2、遍历文件夹下面的所有文件

    [java] view plain copy
    1. public class Test1 {  
    2.     public static void main(String[] args) {  
    3.         // TODO Auto-generated method stub  
    4.         //创建新文件夹对象ff  
    5.         File f1 = new File("D:/FF");   
    6.         //如果存在  
    7.         if(f1.isDirectory()){  
    8.             System.out.println("已经存在该文件夹!");  
    9.             //将文件夹下面的所有文件 组成数组  
    10.             File lists[] = f1.listFiles();  
    11.             System.out.println("ff文件夹下面有"+lists.length+"个文件");  
    12.             //遍历,取出所有的文件名称  
    13.             for(int i=0;i<lists.length;i++){  
    14.                 System.out.println("文件名 :" +lists[i].getName());  
    15.             }  
    16.         }else {  
    17.             //如果不存在该文件夹,则输出  
    18.             System.out.println("该文件夹不存在!");  
    19.             f1.mkdir();  
    20.         }  
    21.           
    22.         //在该文件夹下面创建 新的文件  
    23.         File f2 = new File("d:\\ff\\psp.txt");  
    24.         //如果存在在文件  
    25.         if(f2.exists()){  
    26.             System.out.println("已经存在该文件");  
    27.         }else{  
    28.             try {  
    29.                 f2.createNewFile();  
    30.             } catch (IOException e) {  
    31.                 // TODO Auto-generated catch block  
    32.                 e.printStackTrace();  
    33.             }  
    34.         }  
    35.     }  
    36. }  
    案例1

    功能:从数据源中读取数据到内存(FileInputStream的使用

    [java] view plain copy
    1. /** 
    2.  * 功能:从数据源中读取数据到内存 
    3.  */  
    4. public class Test {  
    5.     public static void main(String[] args) {  
    6.         // TODO Auto-generated method stub  
    7.         File f1 = new File("d:\\ff\\test.txt");  
    8.         FileInputStream fis=null;  
    9.         try {  
    10.             fis = new FileInputStream(f1);  
    11.             byte[] bytes= new byte[1024];  
    12.             //得到实际读取的长度  
    13.             int n=0;  
    14.             //循环读取  
    15.             while((n=fis.read(bytes))!=-1){  
    16.                   
    17.                 String s = new String(bytes,0,n);  
    18.                 System.out.print(s);  
    19.             }  
    20.         } catch (Exception e) {  
    21.             // TODO Auto-generated catch block  
    22.             e.printStackTrace();  
    23.         }finally{  
    24.             //最后一定要关闭文件流  
    25.             try {  
    26.                 fis.close();  
    27.             } catch (IOException e) {  
    28.                 // TODO Auto-generated catch block  
    29.                 e.printStackTrace();  
    30.             }  
    31.         }  
    32.     }  
    33. }  
    案例2

    功能:演示FileOutputStream,从内存中读取数据到数据源

    [java] view plain copy
    1. public class Test {  
    2.     public static void main(String[] args) {  
    3.         // TODO Auto-generated method stub  
    4.         File f1 = new File("d:\\ff\\test.txt");  
    5.         FileOutputStream fos = null;  
    6.         try {  
    7.             fos = new FileOutputStream(f1);  
    8.             String s="我是曾可达,我是曾可达!\r\n";  
    9.             String s2="听到请回答!";  
    10.             byte bytes[] = new byte[1024];   
    11.               
    12.             fos.write(s.getBytes());          
    13.             fos.write(s2.getBytes());  
    14.         } catch (Exception e) {  
    15.             // TODO Auto-generated catch block  
    16.             e.printStackTrace();  
    17.         }finally{  
    18.             try {  
    19.                 fos.close();  
    20.             } catch (IOException e) {  
    21.                 // TODO Auto-generated catch block  
    22.                 e.printStackTrace();  
    23.             }  
    24.         }  
    25.     }  
    26. }  

    案例3

    功能:演示FileInputStream ,FileOutputStream ;将图片从C盘拷贝到D盘

    [java] view plain copy
    1. public class Test {  
    2.     public static void main(String[] args) {  
    3.         //定义输入流  
    4.         FileInputStream fis =null;  
    5.         //定义输出流  
    6.         FileOutputStream fos=null;  
    7.         try {  
    8.             fis = new FileInputStream("c:\\boy.jpg");  
    9.             fos = new FileOutputStream("d:\\boy.jpg");  
    10.             //读取  
    11.             byte [] bytes = new byte[1024];  
    12.             int n=0;  
    13.             while((n=fis.read(bytes))!=-1){  
    14.                 fos.write(bytes, 0, n);  
    15.             }  
    16.         } catch (Exception e) {  
    17.             // TODO Auto-generated catch block  
    18.             e.printStackTrace();  
    19.         }finally{  
    20.             try {  
    21.                 fis.close();  
    22.                 fos.close();  
    23.             } catch (IOException e) {  
    24.                 // TODO Auto-generated catch block  
    25.                 e.printStackTrace();  
    26.             }  
    27.         }  
    28.     }  
    29. }  



    一、超类: 

    字节流: InputStream(读入流) OutputStream(写出流) 
    字符流: Reader(字符 读入流) Writer (字符写出流)

    二、文件操作流 
    字节流: FileInputStream ,FileOutputStream 
    字符流: FileReader, FileWriter(用法与字节流基本相同,不写)

            //1.指定要读 的文件目录及名称
            File file =new File("文件路径");
            //2.创建文件读入流对象
            FileInputStream fis =new FileInputStream(file);
            //3.定义结束标志,可用字节数组读取
            int i =0 ;
            while((i = fis.read())!=-1){ 
                //i 就是从文件中读取的字节,读完后返回-1
            }
            //4.关闭流
            fis.close();
            //5.处理异常

            //1.指定要写到的文件目录及名称
            File file =new File("文件路径");
            //2.创建文件读入流对象
        FileOutputStream fos =new FileOutputStream(file);
            //3.定义结束标志
            fos.write(要写出的字节或者字节数组);
            //4.刷新和关闭流
            fos.flush();
            fos.close();
            //5.处理异常

    三、缓冲流: 
    字节缓冲流: BufferedInputStream,BufferedOutputStream 
    字符缓冲流:BufferedReader ,BufferedWriter 
    缓冲流是对流的操作的功能的加强,提高了数据的读写效率。既然缓冲流是对流的功能和读写效率的加强和提高,所以在创建缓冲流的对象时应该要传入要加强的流对象。

    //1.指定要读 的文件目录及名称
            File file =new File("文件路径");
            //2.创建文件读入流对象
            FileInputStream fis =new FileInputStream(file);
            //3.创建缓冲流对象加强fis功能
    BufferedInputStream bis =new BufferedInputStream(fis); 
            //4.定义结束标志,可用字节数组读取
            int i =0 ;
            while((i = bis.read())!=-1){ 
                //i 就是从文件中读取的字节,读完后返回-1
            }
            //5.关闭流
            bis.close();
            //6.处理异常

            //1.指定要写到的文件目录及名称
            File file =new File("文件路径");
            //2.创建文件读入流对象
        FileOutputStream fos =new FileOutputStream(file);
            //3.创建缓冲流对象加强fos功能
    BufferedOutputStream bos=new BufferedOutputStream(fos);
            //4.向流中写入数据
            bos.write(要写出的字节或者字节数组);
            //5.刷新和关闭流
            bos.flush();
            bos.close();
            //6.处理异常

    由以上看出流的操作基本相同,此流与文件流操作是几乎一样的只是将文件流作为参数传入缓冲流的构造方法中堆文件流读写文件的功能进行加强 
    注1:在字符读入缓冲流BufferedReader 中还提供了读一行的方法 readLine() 可以读取一行文本 
    在字符写出缓冲流BufferedWriter 中还提供了写人一个行行分隔符的方法writeLine(),用于写出时换行 
    注2:此处用到的是GoF设计模式中的装潢(装饰)模式 
    注3:创建缓冲流的对象的装逼模式:

    BufferedInputStream bis =new BufferedInputStream(
    new FileInputStream(new File("文件路径")));     

    注4:缓冲流参数只要是一中超类的子类就行

    四、对象流 
    ObjectInputStream ,ObjectOutputStream 
    不同于以上两种类型的流这里只能用字节对对象进行操作原因可以看上篇的编码表比照原理

    ObjectOutputStream对象的序列化: 
    将java程序中的对象写到本地磁盘里用ObjectOutputStream 
    eg:将Person类的对象序列化到磁盘

    1.创建Person类
        注1:此类要实现Serializable接口,此接口为标志性接口
        注2:此类要有无参的构造函数
        注3:一旦序列化此类不能再修改
        class Person implements Serializable{
            public Person(){}
        } 
    2.创建对象流对象
        注:要增强功能可以将传入文件缓冲流
        ObjectOutputStream oos =new ObjectOutputStream(
        new FileOutputStream(new File("文件路径")));
    3.写入对象 ,一般会将对象用集合存储起来然后直接将集合写入文件
        List<Person> list =new ArrayList<>();
        list.add(new Person());
        ...(可以添加多个)
        oos.writeObject(list);
    4.关闭流,处理异常
        oos.flush();
        oos.close();

    ObjectInputStream对象的反序列化: 
    从本地磁盘里用ObjectInputStream将对象文件读入java程序

    1:用集合接收的时候要强转
    1.创建对象流对象
        ObjectInputStream ois =new ObjectInputStream(
        new FileInputStream(new File("文件路径")));
    2.读入对象
        List<Person> list =new ArrayList<>();
        List =(List<Person>)ois.readObject();
    3.关闭流,处理异常
        ois.close();

    五、转换流: 
    这类流是用于将字符转换为字节输入输出,用于操作字符文件,属于字符流的子类,所以后缀为reader,writer;前缀inputstream,outputstream;注 :要传入字节流作为参赛 
    InputStreamReader: 字符转换输出流 
    OutputStreamWriter:字符转换输入流

    需求:读取键盘输入的一行文本,再将输入的写到本地磁盘上
    //1.获取键盘输入的字节流对象in
    InputStream in =Stream.in; 
    /*2.用转换流将字节流对象转换为字符流对象,方便调用字符缓冲流的readeLine()方法*/
    InputStreamReader isr =new InputStreamReader(in);
    /*5.创建字符转换输出流对象osw,方便把输入的字符流转换为字节输出到本地文件。*/
    OutputStreamWriter osw =new OutputStreamWriter(new 
        FileOutputStream(new File("文件名"))); 
    
    /*3.现在isr是字符流,可以作为参数传入字符缓冲流中*/
    BufferedReader br =new BufferedReader(isr);
    
    /*4.可以调用字符缓冲流br的readLine()方法度一行输入文本*/
    String line =null;
    while((line =br.readLine()){
        osw.write(line);//osw是字符流对象,可以直接操作字符串
    
    }
    
    
    注:InputStreamReader isr =new InputStreamReader(new "各种类型的字节输入流都行即是:后缀为InputStream就行");
    OutputStreamWriter osw =new OutputStreamWriter(new 
        "后缀为OutputStream就行"); 
    

    六、区别记忆 
    1.对象流是可以读写几乎所有类型的只要是对象就行,而字节字符流,只能读写单个字节字符或者字节字符数组,以上没有读写字节字符数组的;注意对象流只有字节流! 
    2.字符和字节循环读入的结束条件int i=0; (i =fis.read())!=-1 
    用字符数组复制文件(fr 读入流 ,fw写出流),字节流也是相同的用法

      int i = 0;
      char[] c = new char[1024];  
         while((i = fr.reade()) !=-1)){
             fw.write(c,0,i);
         }
    

    3.对象流里面套缓冲流的情景: 
    new ObjectInputStream(new BufferedInputStream(new FileInputStream(new File(“文件路径”))));

    4.记忆流及其功能的方法: 
    前缀表示功能,后缀表示流的类型; 
    比如说FileInputStream 前缀:File,表示操作的磁盘,后缀:intputstream,表示是字节输入流。 
    同理 FileReader:表示操作文件的字符流 
    ObjectInputStream :操作对象的字节输入流

    5.拓展:获取键盘输入的字符的缓冲流的写法: 
    new BufferedReader(new InputStreamReader(System.in))); 
    将字节以字符形式输出到控制台的字符缓冲流的写法: 
    new BufferedWriter( new OutputStreamWriter(System.out))

    展开全文
  • java文件流读写操作

    万次阅读 多人点赞 2018-01-08 23:13:19
    当我们读写文本文件的时候,采用Reader是非常方便的,比如FileReader,InputStreamReader和BufferedReader。其中最重要的类是InputStreamReader, 它是字节转换为字符的桥梁。你可以在构造器重指定编码的方式,如果...
  • 通过实现文件读写的方法(上)

    千次阅读 2017-05-09 21:56:40
    可以通过如下三种方式对文件中的数据进行读取和写入:字节方式、字符方式以及缓冲区方式。
  • nodejs中如何使用数据读写文件

    千次阅读 2019-03-04 17:10:07
    在nodejs中,可以使用fs模块的readFile方法、readFileSync方法、read方法和readSync方法读取一个文件的内容,还可以使用fs模块的writeFile方法、writeFileSync方法、write方法和writeSync方法向一个文件中写入内容。...
  • C++:利用fstream流读写文件和string

    千次阅读 2019-06-11 00:38:23
    ofstream 是从输出文件流,ifstream 是从输入文件流 ofstream 是从内存到硬盘,ifstream 是从硬盘到内存 不多啰嗦,明白了这两点之后,直接简单的代码带入理解。   ifstream类的使用:将指定路径文件输入到...
  • /* 两种基本的是:输入(Input Stream)和输出(Output Stream) ...可从中读出一系列字节的对象称为输入。 而能向其中写入一系列字节的对象称为输出。 System.out.println 中的 out 是 PrintStream 类对象
  • C++ /文件流 /BMP文件读写

    千次阅读 2014-05-23 22:59:44
    C++文件流 ...ofstream: 写操作(输出)的文件类 (由ostream引申而来)ifstream: 读操作(输入)的文件类(由istream引申而来)fstream: 可同时读写操作的文件类 (由iostream引申而来) 文件输出
  • 安卓中文件读写-操作

    千次阅读 2019-06-27 16:12:35
    字节在操作的时候本身是不会用到缓冲区(内存)的,是与文件本身直接操作的,所以InputStream需要提前设置缓存区大小,而字符在操作的时候是使用到缓冲区的。 字节在操作文件时,即使不关闭资源(close方法)...
  • 1:创建文件流 2:创建阅读器或者写入器 3:执行读写操作 4:关闭阅读器或者写入器 5:关闭文件流 (注意事项: 使用文件流需要导入System.Io命名空间) //创建文件流 FileStream myfs = new FileStream("路径",...
  • C# FileStream流文件读写

    万次阅读 2015-10-14 09:30:40
    //C#文件流文件,默认追加FileMode.Append   string msg = "okffffffffffffffff";  byte[] myByte = System.Text.Encoding.UTF8.GetBytes(msg);  using (FileStream fsWrite = new FileS
  • Java_文件读写 File File: 作为java中的文件类,当我们需要操作文件的时候,通常会new一个file对象,并让其得到所需要操作得文件路径,让其”读取成为“这个文件,然后在其之上调用方法进行操作。 构造方法: File...
  • Java——IO流读写对象操作规律

    千次阅读 2015-07-28 17:07:35
    IO 概述:IO就是用来进行数据的输入输出操作的一个缓冲区。 按操作的对象不同可分为:  1、对字符操作 ...字符: ...FileWriter:是Writer的一个子类,用于进行文件的数据写入,以字符为操
  • 文件读写

    千次阅读 2009-02-20 23:44:00
    是字节序列的抽象概念,或者说是计算机在处理文件或数据时产生的二进制序列。例如文件、输入/输出设备、内部进程通信管道或者 TCP/IP 套接字。Stream 类及其派生类提供这些不同类型的输入和输出的一般视图,使...
  • Delphi的TFileStream文件流读写

    千次阅读 2012-10-25 15:50:02
    TStream 是一个抽象的基类, 不能直接生成对象. 在具体的应用中, 主要使用它的子孙类:TFileStream: 文件流TStringStream: 字符串流TMemoryStream: 内存TResourceStream: 资源文件流THandleStream: 是 TFileStream ...
  • Java笔记(7)-输入、输出流 字节流 字符流 文件字节流 文件字符流 缓冲流 随机流 数组流 数据流 对象流 序列化和对象克隆 文件锁 Scanner解析文件 Console就读取密码 InputStream、Reader、FileInputStream、...
  • Delphi TFileStream(文件流) 读写

    千次阅读 2020-01-08 09:43:07
    TStream 是一个抽象的基类, 不能直接生成对象. 在具体的应用中, 主要使用它的子孙类
  • Java 读写docx文件直接转成PDF文件方法

    千次阅读 热门讨论 2018-07-09 09:51:37
    需要读写docx文件需要用到poi包,等下会提供下载地址,在读写docx文件之前,需要对docx文件进行操作,打开docx文件后,再需要编辑的地方加上“:${key}”,再在java文件中通过map来对这个值进行编辑,比如map.put(key...
  • Node读写Excel文件(txt文件

    千次阅读 2020-01-14 22:46:30
    文章目录读取txt文件的内容写入txt文件读取Excel文件 前端有时要处理一些数据(比如多语言文件内容的替换),我们不要傻乎乎地干这种重复枯燥又浪费时间的ctrl C+ ctrl V的工作,这种事情交给计算机做再合适不过了。...
  • import java.io.DataInputStream;//引入相关类 import java.io.DataOutputStream; import java.io.FileInputStream; import java.io.FileOutputStream;... * 读写二进制文件(所有文件) * 使用字节DataIn...
  • Android中文件读写操作 1. Android中文件读写的原理: (1).所有文件的储存都是字节的储存。 (2).在磁盘上保留的并不是文件的字符而是先把字符编码成字节,再储存这些字节到磁盘。 (3).在读取文件(特别是文本...
  • 1. 文本文件的操作 直接文件流对象 的 > 来操作,和 cout>x,一样:  ofile 就是把 字符串 写入到 ofile对象关联的文件名中  ifile>>s ------> 就是从ifile关联的文件中读取一个单词(不一定是一个单词,就是遇到...
  • java--io和nio读写文件

    千次阅读 2019-03-17 16:30:30
    java–io和nio读写文件 ...文件拷贝2.1文件复制:io流读写文件、大文件2.2文件复制:nio缓冲区读写文件2.3文件复制:MappedByteBuffer内存映射读写文件2.4文件复制:FileChannel 传输:Channel-to-Channel传输2.5简单...
  • Qt文件读写问题

    千次阅读 2018-12-10 15:19:47
    Qt文件读写操作 一、Qt文件读写基本描述 1.1 QFile实现文件读写 QFile(const QString &...1. 从QFile的构造函数我们知道,可以直接在调用构造函数的时候就传递文件名给QFile类 2. 对于先...
  • 文件操作——读写文件

    千次阅读 2013-04-02 17:48:14
    文件读写操作应该是最重要的文件操作,System.IO命名空间提供了诸多文件读写操作类,对文件内容进行操作常见有3种方式:文本模式、二进制模式以及异步模式。 1、文本模式  StreamReader和StreamWriter类提供...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 118,388
精华内容 47,355
关键字:

对象流可以直接读写文件吗