精华内容
下载资源
问答
  • //随机存取文件流的使用 //该类的实例支持读取和写入随机访问文件。 随机访问文件的行为类似于存储在文件系统中的大量字节。 // 有一种游标,或索引到隐含的数组,称为文件指针 ; 输入操作读取从文件指针开始的字节...
    //随机存取文件流的使用
    //该类的实例支持读取和写入随机访问文件。 随机访问文件的行为类似于存储在文件系统中的大量字节。
    // 有一种游标,或索引到隐含的数组,称为文件指针 ; 输入操作读取从文件指针开始的字节,并使文件指针超过读取的字节。
    // 如果在读/写模式下创建随机访问文件,则输出操作也可用; 输出操作从文件指针开始写入字节,并将文件指针提前到写入的字节。
    // 写入隐式数组的当前端的输出操作会导致扩展数组。 文件指针可以通过读取getFilePointer方法和由设置seek方法。
    //构造器
    //RandomAccessFile(File file, String mode)
    //创建一个随机访问文件流从File参数指定的文件中读取,并可选地写入文件。
    //RandomAccessFile(String name, String mode)
    //创建随机访问文件流,以从中指定名称的文件读取,并可选择写入文件。
    
    /*1.RandomAccessFile直接继承于Object类,实现了DataInput和DataOutput接口
    * 2.RandomAccessFile既可以作为一个输入流有可以作为一个输出流
    * 3.如果RandomAccessFile作为输出流时,写出到的文件如果不存在,则在执行过程中自动创建,如果存在,则会对原有文件内容进行覆盖
    * 4.通过相关操作,可以实现RandomAccessFile的插入操作,但是效率不高
    *
    * **/

     

    class RandomAccessFile_use {
        public static void insert(int site,File file,String s)  {
    
            File filetemp= null;
            BufferedOutputStream outputStream= null;
            BufferedInputStream inputStream= null;
            RandomAccessFile rw = null;
    
            try {
                rw = new RandomAccessFile(file, "rw");
                filetemp = new File("src/temp.txt");
                outputStream = new BufferedOutputStream(new FileOutputStream(filetemp));
                inputStream = new BufferedInputStream(new FileInputStream(filetemp));
                //将文件指针调到特定索引位置
                rw.seek(site);
                byte[] bytes=new byte[5];
                int len;
                //将余下内容写出到一个介质文件中
                while ((len= rw.read(bytes))!=-1){
                    outputStream.write(bytes);
                }
                //重新指定指针
                rw.seek(site);
                //插入内容到文件
                rw.write(s.getBytes());
                //将余下内容重新写入文件中
                while ((len=inputStream.read(bytes))!=-1){
                    rw.write(bytes, 0, len);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (outputStream!=null){
                    try {
                        outputStream.flush();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    try {
                        outputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (inputStream!=null){
                    try {
                        inputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (rw!=null){
                    try {
                        rw.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            //关闭流
    
            //删除文件
            filetemp.delete();
    
    
        }
        public static void main(String[] args) throws IOException {
    //        RandomAccessFile rw = null;//读和写
    //        try {
    //            rw = new RandomAccessFile(new File("src/IO_use/hello.txt"), "rw");
    //            byte[] bytes=new byte[100];
    //            int len;
    //            rw.seek(3);
    //            //会对文件写入的地方进行覆盖
    //            rw.write("a".getBytes());
    //        } catch (IOException e) {
    //            e.printStackTrace();
    //        } finally {
    //            if (rw!=null) {
    //                try {
    //                    rw.close();
    //                } catch (IOException e) {
    //                    e.printStackTrace();
    //                }
    //            }
    //        }
        insert(1, new File("src/IO_use/hello1mystery1.txt"), "a");
    
        }
    }

    展开全文
  • 1.随机存取文件流: RandomAccessFile 2.使用说明: 1.RandomAccessFile直接继承于java.lang.Object类,实现了DataInput和DataOutput接口 2.RandomAccessFile既可以作为一个输入流,又可以作为一个输出流 3....

    1.随机存取文件流:

    RandomAccessFile

    2.使用说明:

    • 1.RandomAccessFile直接继承于java.lang.Object类,实现了DataInput和DataOutput接口

    • 2.RandomAccessFile既可以作为一个输入流,又可以作为一个输出流

    • 3.如果RandomAccessFile作为输出流时,写出到的文件如果不存在,则在执行过程中自动创建。 如果写出到的文件存在,则会对原文件内容进行覆盖。(默认情况下,从头覆盖

    • 4.可以通过相关的操作,实现RandomAccessFile“插入”数据的效果

    3.代码举例

    典型代码1:

    /*
    图片的复制:
     */
    @Test
    public void test1() {
        RandomAccessFile raf1 = null;
        RandomAccessFile raf2 = null;
        try {
            raf1 = new RandomAccessFile(new File("灿烈.jpg"), "r");
            raf2 = new RandomAccessFile(new File("灿烈1.jpg"), "rw");
    
            byte[] buffer = new byte[20];
            int len;
            while ((len = raf1.read(buffer)) != -1) {
                raf2.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (raf2 != null) {
                try {
                    raf2.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (raf1 != null) {
                try {
                    raf1.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    

    典型代码2:

        /*
       使用RandomAccessFile实现数据的插入效果
        */
        @Test
        public void test3() {
            RandomAccessFile raf = null;
            ByteArrayOutputStream baos = null;
            try {
    //        abcdefg
    //        hijk
    //        lmn
                raf = new RandomAccessFile("hello.txt", "rw");
    
                raf.seek(3);//将指针调到角标为3的位置
                //保存指针3后面的所数据到StringBuilder中
               // StringBuilder sb = new StringBuilder((int)new File("hello.txt").length());
                baos = new ByteArrayOutputStream();
                byte[] buffer = new byte[5];
                int len;
                while((len = raf.read(buffer)) != -1){
                 //   sb.append(new String(buffer,0,len));
                    //将字节5个5个写入,不会出现乱码,最后再一起转成字符串
                    baos.write(buffer,0,len);
                }
    
                //调回指针,写入“xyz”
                raf.seek(3);
                raf.write("xyz".getBytes());
    
                //将StringBuilder中的数据写入到文件中
             //   raf.write(sb.toString().getBytes());
                raf.write(baos.toString().getBytes());
    //         abcxyzdefg
    //          hijk
    //          lmn
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (raf != null) {
                    try {
                        raf.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(baos != null){
                    try {
                        baos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            //思考:将StringBuilder替换为ByteArrayOutputStream
        }
    
    

    ByteArrayOutputStream
    字节数组输出流在内存中创建一个字节数组缓冲区,所有发送到输出流的数据保存在该字节数组缓冲区中。
    详细知识:
    https://www.runoob.com/java/java-bytearrayoutputstream.html

    展开全文
  • 随机存取文件流 随机存取文件流介绍 RandomAccessFile声明在java.io包下,但直接继承于java.lang.Object类。并且它实现了DataInput、DataOutput两个接口,也就意味着这个类即可以读也可以写。 RandomAccessFile类...

    随机存取文件流

    随机存取文件流介绍

    • RandomAccessFile声明在java.io包下,但直接继承于java.lang.Object类。并且它实现了DataInput、DataOutput两个接口,也就意味着这个类即可以读也可以写。
    • RandomAccessFile类支持“随机访问”的方式,程序可以直接跳到文件的任意地方来读、写文件。
      • 支持只访问文件的部分内容
      • 可以向已存在的文件后追加内容
    • RandomAccessFile对象包含一个记录指针,泳衣标示当前读写处的位置。
    • RandomAccessFile类对象可以自由移动记录指针:
      • long getFilePointer():获取文件记录指针的当前位置
      • void seek(long pos):将文件记录指针定位到pos位置

    RandomAccessFile类

    • 构造器

      • public RandomAccessFile(File file,String mode)

      • public RandomAccessFile(String name,String mode)

      • public RandomAccessFile(String name, String mode)
        throws FileNotFoundException
           {
               this(name != null ? new File(name) : null, mode);
           }
        
           public RandomAccessFile(File file, String mode)
        throws FileNotFoundException
           {
        String name = (file != null ? file.getPath() : null);
        int imode = -1;
        if (mode.equals("r"))
            imode = O_RDONLY;
        else if (mode.startsWith("rw")) {
            imode = O_RDWR;
            rw = true;
            if (mode.length() > 2) {
           if (mode.equals("rws"))
               imode |= O_SYNC;
           else if (mode.equals("rwd"))
               imode |= O_DSYNC;
           else
               imode = -1;
            }
        }
        if (imode < 0)
            throw new IllegalArgumentException("Illegal mode \"" + mode
                           + "\" must be one of "
                           + "\"r\", \"rw\", \"rws\","
                           + " or \"rwd\"");
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkRead(name);
            if (rw) {
           security.checkWrite(name);
            }
        }
               if (name == null) {
                   throw new NullPointerException();
               }
        fd = new FileDescriptor();
               fd.incrementAndGetUseCount();
        open(name, imode);
           }
        
    • 创建RandomAccessFile类实例需要指定一个mode参数,改参数指定RandomAccessFile的访问模式:

      • r:以只读方式打开
      • rw:打开以便读取和写入
      • rwd:打开以便读取和写入;同步文件内容的更新
      • rws:打开以便读取和写入;同步文件内容和元数据的更新
    • 如果模式为只读r。则不会创建文件,而是会去读取一个已存在的文件,如果读取的文件不存在则会出现异常。如果模式为rw读写,如果文件不存在则会去创建文件,如果存在则不会创建

    • 注意:JDK1.6上面写的每次write数据时,“rw”模式,数据不会立即写到硬盘中;而“rwd”,数据会被立即写入硬盘。如果写数据过程中发生异常,“rwd"模式中已被writer的数据被保存到硬盘,而”rw“则全部丢失。

    RandomAccessFile使用例子

    public class RandomAccessFileTest {
    
        @Test
        public void test(){
            RandomAccessFile raf1 = null;
            RandomAccessFile raf2 = null;
            try {
                raf1 = new RandomAccessFile(new File("hello1.txt"),"r");
                raf2 = new RandomAccessFile(new File("hello1.txt"),"rw");
                String s = raf1.readLine();
                System.out.println(s);
                raf2.writeUTF("写入数据库");
                if(true){
                    throw new Exception("dafasdf");
                }
                raf2.writeUTF("写入数据库");
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
            }
        }
    
        @Test
        public void copy(){
            RandomAccessFile raf1 = null;
            RandomAccessFile raf2 = null;
            try {
                raf1 = new RandomAccessFile(new File("Semaphore.png"),"r");
                raf2 = new RandomAccessFile(new File("Semaphore1.png"),"rw");
                byte[] buffer = new byte[1024];
                int length;
                while((length = raf1.read(buffer))!=-1){
                    raf2.write(buffer,0,length);
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
            }
        }
    }
    

    展开全文
  • 随机存取文件流 RandomAccessFile 声明在java.io包下,但直接继承于java.lang.Object类。并 且它实现了DataInput、DataOutput这两个接口,也就意味着这个类既可以读也 可以写。 RandomAccessFile 类支持 “随机访问...

    1:随机存取文件流(既可以读也可以写)

    • RandomAccessFile 声明在java.io包下,但直接继承于java.lang.Object类。并
      且它实现了DataInput、DataOutput这两个接口,也就意味着这个类既可以读也
      可以写
    • RandomAccessFile 类支持 “随机访问” 的方式,程序可以直接跳到文件的任意
      地方来读、写文件
      • 支持只访问文件的部分内容
      • 可以向已存在的文件后追加内容

    在这里插入图片描述


    2:既可以读也可以写

    在这里插入图片描述


    3:使用RandomAccessFile实现数据的插入效果

    在这里插入图片描述
    未插入前:
    在这里插入图片描述

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

    问题:只能实现对原文件的覆盖,不想覆盖,想实现插入


    完善:真正实现插入
    在这里插入图片描述

    展开全文
  • 随机存取文件流 RandomAccessFile 声明在java.io包下,但直接继承于java.lang.Object类。并 且它实现了DataInput、DataOutput这两个接口,也就意味着这个类可以作为输入流,也可以作为输出流。 构造器:public ...
  • 随机存取文件流的使用 package com.hpeu.random; import java.io.File; import java.io.IOException; import java.io.RandomAccessFile; import org.junit.Test; // 随机存取文件流的使用 public class ...
  • 随机存取文件流

    2020-08-14 15:07:49
    随机存取文件流 package com.atguigu.java; import org.junit.Test; import java.io.File; import java.io.IOException; import java.io.RandomAccessFile; /** * RandomAccessFile的使用 * 1....
  • RandomAccessFile类 ●RandomAccessFile声明在java.io包下,但直接继承...●RandomAccessFile类支持“随机访问"的方式,程序可以直接跳到文件的任意地方来读、写文件 ➢支持只访问文件的部分内容 ➢可以向已存在的文...
  • 打开一个随机存取文件后,要么对它进行只读操作,要么就同时对它进行读写操作。 具体的选择是把构造方法的第二个参数指定成一个“r”或“rw”、“rws”、“rwd”来实现的。 随机存取文件的行为类似于储存在文件...
  • 随机存取文件流 RandomAccessFile声明在java.io包下,但是直接继承与java.lang.Object,并且实现了DataInput和DataOut这两个接口,意味着这个类可以进行读写操作。既可以作为输入流,也可以作为输出流,但是一个...
  • 随机存取文件流 RandomAccessFile类 import org.junit.Test; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; import java.io.RandomAccessFile; import java.nio....
  • 随机存取文件流 简介 RandomAccessFile声明在java.io包下, 但直接继承于java.lang.Object类。 并且它实现了Datalnput. DataOutput这两 个接口,也就意味着这个类既可以读也可以写。 RandomAccessFile类支持...
  • RandomAccessFile 类 RandomAccessFile 声明在java.io包下,但直接继承于... RandomAccessFile 类支持 “随机访问” 的方式,程序可以直接跳到文件的任意 地方来读、写文件 支持只访问文件的部分内容 可以向...
  • } } } } 输出 我爱北京天安门 Person{name='刘能', age=23, id=0, acct=null} Person{name='张学良', age=23, id=1001, acct=Account{balance=5000.0}} 23.Test:随机存取文件流 public void test1() { ...
  • 比上一个博客的文章更加通用的代码如下: 补充:hello.txt文档内容: abcdefg12345 adafe 123wwe   public class TestRandomAccessFile { //相较于test3,更通用 @Test ...raf = new Rando...
  • 1.java对象 对象 ObjectInputStream ObjectOutputStream 用于存储和读取对象的处理; 它的强大之处就是可以吧java中的对象写入到数据源中,也能把对象从数据源中还原回来。 用ObjectOutputStream类将一个java...
  • @Test public void test1(){ //构造器1 File file1 = new File("hello.txt");//相对于当前的module File file2 = new File("D:\\ideaworkspace\\SeniorJava\\day08\\he.txt"); System.out.println(file1);...
  • public class TestRandomAccessFile { 其实,方法都是 一个思想,但是实现一个复杂一点,一个简单一些。补充:hello.txt中内容为:abcdefg12345  //方法一:实现插入的效果:在d字符后面插入“xy” ...
  • 需要注意的是,RondomAccesFile的readLine()方法在读取含有非ASCLL字符的文件时(如含有汉字)会出现乱码问题,因此需要把readLine()读取的字符串用“iso-8859-1"重新编码放到数组byte中,然后用当前机器的编码将...
  • 随机文件读取 该类不算是IO体系中子类 而是直接继承object 但是它是io包中成员,因为它具备读和写的功能 内部封装了一个数组,而且通过指针对数组的元素进行操作。 可以通过getFilePointer获取指针位置, 同时可以...
  • package _9RandomAccessFile类; import java.io.File; import java.io.FileNotFoundException; import java.io....// 的方式 // 写入数据,按照写入数据的顺序存储 // 读出的时候,顺序读出,比如你要读第...
  • java I/O:文件随机存取

    千次阅读 2008-11-10 22:39:00
    import java.io.*; public class randomAccess { /** * @param args */ String Filename; public randomAccess(String Filename) {this.Filename=Filename;} public void writeEmployee(Employee e,int n)t
  • Java基础-3】吃透Java IO:字节、字符、缓冲

    万次阅读 多人点赞 2020-09-23 20:12:33
    什么是Java-IO?字符和字节的区别与适用场景是什么?缓冲到底实现了什么?如何高效地读写文件? 本文用大量的示例图和实例,带你吃透Java IO。
  • Java-随机流

    2018-06-03 13:52:55
    /** 把10个整数写入一个tom.bat文件当中,并且按相反顺序读出*/package Practice;import java.io.*;public class Main { public static void main(String[] args) { // TODO Auto-generated method stub ...
  • Java基础-IO对象之随机访问文件(RandomAccessFile)  作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任。       一.RandomAccessFile简介  此类的实例支持对随机访问文件的读取和写入。随机...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,264
精华内容 6,105
关键字:

java随机存取文件流

java 订阅