精华内容
下载资源
问答
  • java的io操作
    千次阅读
    2021-01-20 11:53:39

    java.io.OutputStream抽象类是表示字节输出流的所有类的超类,将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

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

    注意: close方法,当完成流的操作时,必须调用此方法,释放系统资源。

    OutputStream有很多子类,我们从最简单的一个子类开始。

    FileOutputStream

    java.io.FileOutputStream 类是文件输出流,用于将数据写出到文件。

    构造方法

    • public FileOutputStream(File file):创建文件输出流以写入由指定的 File对象表示的文件。
    • public FileOutputStream(String name): 创建文件输出流以指定的名称写入文件。

    当你创建一个流对象时,必须传入一个文件路径。该路径下,如果没有这个文件,会创建该文件。

    写出字节数据

    public class Main {
        public static void main(String[] args) throws IOException {
        	//true 代表写入内容是追加的
            FileOutputStream fos = new FileOutputStream("hello.txt", true);
            String str = "Hello World";
            fos.write(str.getBytes());
            fos.close();
        }
    }
    
    更多相关内容
  • java IO操作知识点

    千次阅读 2022-05-02 15:40:48
    IO流的概念: IO流,将不同的输入输出,以相同的方式操作read(),write();创建不同类型的流,有不同的实现方式,不同类型的流,又有各自... java.io.InputStream抽象类:基本子类,ByteArrayInputStream,FileInputStr.

     IO流的概念:

    • IO流,将不同的输入输出,以相同的方式操作read(),write();创建不同类型的流,有不同的实现方式,不同类型的流,又有各自特有的操作方式。
    • 无论内部如何工作,所有IO流呈现的都是相同的,简单的模式,程序中流入或流出的一系列数据。

    Inputstream、Outputstream:

    • 输入流,输出流的操作超类,支持子类以基本字节的方式操作二进制数据
    • java.io.InputStream抽象类:基本子类,ByteArrayInputStream,FileInputStream等; 
    • int read() throws IOException,抽象方法由具体子类实现,返回流中下一字节(必然是0-255之间的整数表示),如果到达流末没有可读字节,返回-1.
    • java.io.OutputStream抽象类:基本子类,ByteArrayOutputStream,FileOutputStream等;
    • void write(int b) throws IOException 抽象方法。将十进制按字节写入输出流。
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.nio.file.Paths;
    
    public class TestIO {
        public static void main(String[] args) {
            try {
                getByteStreams();
            } catch (IOException e) {
                e.printStackTrace();
            }
    
        }
        public static void getByteStreams()throws IOException {
            FileInputStream in=new FileInputStream("C:/Users/yu/Desktop/a.txt");
            FileOutputStream out=new FileOutputStream("C:/Users/yu/Desktop/b.txt");
            int c;
            while((c=in.read())!=-1){
                System.out.println("读取字节的10进制整数:"+c);
                out.write(c);
            }
            in.close();//有个问题就在于一旦异常了资源就无法关闭;
            out.close();
        }
    
    }
    

    资源对象的关闭:

    • 资源文件的关闭:资源文件,比如IO流不会像其他对象,因失去引用而自动释放占用的资源,因此,必须被正确的关闭,否则会导致内存的溢出,以IO流为例,为确保无论是否出现异常,资源均被关闭,应在finally块中手动关闭资源,但这样会让程序中有大量的冗余 ;

    • 解决办法:引入java.lang.AutoCloseable接口,任何实现AutoCloseable接口的类型,均是支持自动关闭的资源类型。然后采用try-with-resources,在try语句中,声明需要关闭的资源,从而保证,无论try块是否引发异常,资源在try块结束后自动关闭(Java7) ;

    • java.io.Closeable接口继承AutoCloseable接口。原全部需要手动调用close()方法关闭的资源,全部支持try-with-resources自动关闭。

      try-with-resources语句,极大的简化了资源处理代码,使开发者无需关心资源状态,无需关心资源对象的创建顺序,无需关心资源对象的正确关闭方式

    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.nio.file.Paths;
    
    public class TestIO {
        public static void main(String[] args) {
                getByteStreams();
        }
        public static void getByteStreams() {
            try (FileInputStream in = new FileInputStream("C:/Users/yu/Desktop/a.txt");
                 FileOutputStream out = new FileOutputStream("C:/Users/yu/Desktop/b.txt");) {
                int c;
                while ((c = in.read()) != -1) {
                    System.out.println("读取字节的10进制整数:" + c);
                    out.write(c);
                }
                in.close();//有个问题就在于一旦异常了资源就无法关闭;
                out.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
    }
    
    • 注意:

      (1)资源的自动关闭,与异常无关。异常改怎么处理依然怎么处理。

      (2)在try语句中声明使用资源后,执行顺序:

      • ​​​​无异常,在try块执行后,自动关闭资源,finally块

      • 有异常,自动关闭资源,catch块,finally块

    基于字符数组缓冲区的IO操作处理:

    • 前面说的基于单字节的基本read()/write()方法,仅用于理解IO流执行过程,实际开发不会使用。用的是基于字节数组缓冲区的IO操作方法:
    • int read(byte[] b),InputStream中声明的方法,将流中字节读取到字节数组b中,第1个字节置入数组0位置…,直到读取到数组b长度的字节位置为止;返回读取的字节长度;如果没有可读字节,返回-1。

    • write(byte[] b, int off, int len),OutputStream中声明的方法,从字节数组b,off位置开始读取,至长度len结束;
    • import java.io.FileInputStream;
      import java.io.FileNotFoundException;
      import java.io.FileOutputStream;
      import java.io.IOException;
      import java.nio.file.Paths;
      
      public class TestIO {
          public static void main(String[] args) {
                  getByteStreams();
          }
          public static void getByteStreams() {
              try (FileInputStream in = new FileInputStream("C:/Users/yu/Desktop/a.txt");
                   FileOutputStream out = new FileOutputStream("C:/Users/yu/Desktop/b.txt");) {
                  byte []buffer=new byte[2];
                  int len=0;
                  while((len=in.read(buffer))!=-1){
                      out.write(buffer,0,len);
                  }
                  in.close();//有个问题就在于一旦异常了资源就无法关闭;
                  out.close();
              } catch (FileNotFoundException e) {
                  e.printStackTrace();
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      
      }
      

    路径:

    • 绝对路径,始终包含根元素和查找文件所需的完整目录列表。 例如,D:/test/a.txt。找到文件所需的所有信息都包含在路径声明中

      相对路径,例如,a.txt。没有更多信息,程序将无法访问。即,相对路径,最终也必须基于绝对路径描述。

    • 为什么用NIO:

      Java.io.File类,包含耦合了文件路径声明,以及文件操作方法的类;且是同步阻塞的

      NIO2 (java8),将文件路径与文件操作,分离;且支持异步非阻塞

      java.nio.file.Path接口,表示系统文件/目录的绝对的/相对的路径

      java.nio.file.Files工具类,包含处理文件操作的方法,包括文件的,创建,删除,复制,移动等

    • Path接口:Path代表一个不依赖于系统的文件路径。即运行在不同操作系统下,Path的具体实现不同(windows/linux),但开发者仅需面向Path描述路径,不同系统,而无需关心操作系统差异。

    • Path get(String path):最常用的方法,把转换路径字符串转为Path对象。

    • Path定义了许多获取文件数据信息的方法及路径的拼接方法:

      Path getFileName(),返回文件名或名称元素序列的最后一个元素。即,最后一个路径描述,可能是文件名也可能是目录名

      Path getParent(),返回父目录的路径

      Path getRoot(),返回路径的根

      Path resolve(Path other)方法,将路径拼接为一个新路径

      boolean equals(Object obj):重写了equals判断路径是否相同

    •  
      import java.io.FileInputStream;
      import java.io.FileNotFoundException;
      import java.io.FileOutputStream;
      import java.io.IOException;
      import java.nio.file.Path;
      import java.nio.file.Paths;
      
      public class TestIO {
          public static void main(String[] args) {
                  Path p= Paths.get("C:/Users/yu/Desktop");
                  Path p1=Paths.get("a.txt");
              System.out.println(p.getClass().getName());//Path是一个接口输出实现类的名字
              System.out.println(p);
              System.out.println(p.getFileName());//返回文件名或名称元素序列的最后一个元素。即,最后一个路径描述,可能是文件名也可能是目录名
              System.out.println(p.getParent());//返回父目录的路径
              System.out.println(p.getRoot());//返回路径的根
              p.resolve(p1);//将路径拼接为一个新路径
              p.equals(p1);//重写了equals判断路径是否相同
      
          }
      
      }
      

    Files工具类:

    • java.nio.file.Files工具类,提供了丰富的基于Path操作的静态方法,读取/写入/操作,文件与目录。方法分类:

    •  文件或目录的判断:

      boolean exists(Path path)/notExists(Path path),Path路径是否存在

      Boolean isDirectory(Path path),path是否为目录

    • 文件或目录的创建:

      Path createDirectory(Path dir) throws IOException。目录路径已存在则异常;目录路径为多级目录,异常

      Path createDirectories(Path dir) throws IOException。自动创建多级不存在目录;目录已存在,无异常

      Path createFile(path) throws IOException。基于指定路径,创建文件。文件存在,异常

    • 文件或目录的复制:

      Path copy(Path source, Path target, CopyOption... options) throws IOException,将文件复制到目标文件。默认,如果文件已经存在,异常

      如果source为目录,不会复制里面的文件,仅相当于创建一个空目录

      java.nio.file.StandardCopyOption枚举,实现了CopyOption接口,复制选项

    • 文件或目录的移动:

      Path move(Path source, Path target, CopyOption... options) throws IOException,将文件移动或重命名为目标文件。

      默认,如果目标文件存在,则异常,可通过options参数声明移动选项

      如果在本目录下移动,相当于文件改名

    • 文件或目录的删除:

      void delete(Path path) throws IOException。删除指定路径;路径不存在,异常

      boolean deleteIfExists(Path path) throws IOException。路径不存在,不删除。返回是否删除成功

      如果路径为目录,目录中包含文件(即不为空),2种删除均异常

    •  指定路径的遍历(Files的方法):

      Stream<Path> walk(Path start, int maxDepth) throws IOException:遍历,基于指定深度遍历path路径中的目录和文件

      Stream<Path> walk(Path start) throws IOException:遍历path路径中的所有目录和文件,包括子目录的,观察遍历时的输出顺序,按层次输出的。注意返回值是流,后面可以用流的操作,比如过滤,排序等功能。可以借助于此方法删除非空目录

    • import java.io.FileInputStream;
      import java.io.FileNotFoundException;
      import java.io.FileOutputStream;
      import java.io.IOException;
      import java.nio.file.Files;
      import java.nio.file.Path;
      import java.nio.file.Paths;
      import java.nio.file.StandardCopyOption;
      import java.util.function.Consumer;
      
      public class TestIO {
          public static void main(String[] args) {
              try {
                  path();
              } catch (IOException e) {
                  e.printStackTrace();
              }
      
          }
          public static void path() throws IOException {
              Path p= Paths.get("C:/Users/yu/Desktop");
              Path p1=Paths.get("a.txt");
              Path p2=Paths.get("C:/Users/yu/Desktop/b.txt");
              Path p3=Paths.get("C:/Users/yu/Desktop/a.txt");
      //        System.out.println(Files.exists(p));//Path路径是否存在
      //        System.out.println(Files.isDirectory(p));//path是否为目录
      //        System.out.println(Files.createDirectory(p));//目录的创建,目录路径已存在则异常;目录路径为多级目录,异常
      //        System.out.println(Files.createDirectories(p));//目录的创建,自动创建多级不存在目录;目录已存在,无异常
      //        System.out.println(Files.createFile(p2));//文件的创建,基于指定路径,创建文件。文件存在,异常;
      //        Files.copy(p2,p3, StandardCopyOption.REPLACE_EXISTING);/*将文件复制到目标文件。默认,如果文件已经存在,异常
      //        如果source为目录,不会复制里面的文件,仅相当于创建一个空目录
      //        java.nio.file.StandardCopyOption枚举,实现了CopyOption接口,复制选项*/
      //        Files.move(p2,p3,StandardCopyOption.REPLACE_EXISTING)/*将文件移动或重命名为目标文件。
      //           默认,如果目标文件存在,则异常,可通过options参数声明移动选项
      //           如果在本目录下移动,相当于文件改名*/
      //        Files.delete(p2);/*路径不存在,不删除。返回是否删除成功
      //如果路径为目录,目录中包含文件(即不为空),2种删除均异常*/
      
              Files.walk(p3).forEach(System.out::println);
          }
      }
      

    展开全文
  • 原理:从已有文件中读取字节,将该字节写出到另一个文件中 代码如下: public class Main { public static void main(String[] args) throws IOException { FileInputStream fis = new FileInputStream("a.flac");...

    原理:从已有文件中读取字节,将该字节写出到另一个文件中

    代码如下:

    public class Main {
        public static void main(String[] args) throws IOException {
            FileInputStream fis = new FileInputStream("a.flac");
            FileOutputStream fos = new FileOutputStream("b.flac");
            byte[] bytes = new byte[1024];
            int b;
            while ((b = fis.read(bytes)) != -1) {
                fos.write(bytes, 0, b);
            }
            fos.close();
            fis.close();
        }
    }
    
    展开全文
  • Java IO操作-按行读取txt文本文件

    千次阅读 2019-10-17 17:45:29
    Java IO操作-按行读取txt文本文件 文章目录Java IO操作-按行读取txt文本文件0.前言1.将txt文本文件按照UTF-8格式存储2.按行读取代码实现3.运行效果4.字符串提取单词txt百度网盘下载(无提取码) 0.前言 同学安卓课设想...

    Java IO操作-按行读取txt文本文件

    0.前言

    同学安卓课设想做一个仿百词斩的低配版记单词APP,但是没有找到开放的单词数据接口,于是有了本文:

    当然本文只是使用Java的I/O操作读取网上一个单词txt文件,后续将其存入数据库并提供接口等本文不提及。

    要是想做高仿的记单词软件,那就得写爬虫获取更详细的图片,音频,例句等信息了。

    百度搜到了某网站有2000常用单词的txt文件,而且还是按照一定的规律排列好的!!

    2000常用单词的txt下载网站

    但是里面有极个别的数据有瑕疵,文章末尾有稍微处理过的txt百度网盘下载链接

    文本文件中按照一定方式存储了2000个常用单词,文件内容如下所示:

    1 the [ðə, ði:] art.这,那 ad.[用于比较级;最高级前]
    2 be [bi:,bi] aux. v.(am,is,are之原型) vi.是;在
    3 of  [əv, ə, ɔv] prep.…的;由…制成的;关于;由于
    4 and  [ənd, ænd] conj.和;那么;然后;而且
    ...
    1998 soup [su:p] n.汤
    1999 whistle [ˈwisəl] vi.吹口哨,鸣笛
    2000 scenery  [ˈsi:nəri] n.风景,景色
    

    1.将txt文本文件按照UTF-8格式存储

    使用记事本打开txt文件,选择 文件->另存为->选择编码方式UTF-8

    在这里插入图片描述

    把改为UTF-8格式的txt文件放到编译器的目录下来,当然使用绝对路径操作文件也可以。

    2.按行读取代码实现

    罗里吧嗦半天,其实代码就下面一点点…

        private static String[] words = new String[2000];
    
        public static void main(String[] args) {
            int m = 0;//words数组下标
            //读取文件至 words 字符串数组中
            try {
                BufferedReader br = new BufferedReader(
                        new InputStreamReader(
                                new FileInputStream("src/Demo/oldtxt.txt")));
                String linestr;//按行读取 将每次读取一行的结果赋值给linestr
                while ((linestr = br.readLine()) != null) {
                    System.out.println(linestr);//输出每行的信息
                    words[m++] = line1;//赋值给数组后,下标后移
                }
                br.close();//关闭IO
            } catch (Exception e) {
                System.out.println("文件操作失败");
                e.printStackTrace();
            }
    

    3.运行效果

    每行输出:

    1 the [ðə, ði:] art.这,那 ad.[用于比较级;最高级前]
    2 be [bi:,bi] aux. v.(am,is,are之原型) vi.是;在
    3 of  [əv, ə, ɔv] prep.…的;由…制成的;关于;由于
    ...
    1998 soup [su:p] n.汤
    1999 whistle [ˈwisəl] vi.吹口哨,鸣笛
    2000 scenery  [ˈsi:nəri] n.风景,景色
    

    4.字符串提取

    为了区别序列号 ,单词 ,英标,词性与释义,又对每一行的字符串进行了处理:

    //字符串分割
            for (int i = 0; i < words.length; i++) {
                //分割 序列号+单词+英标 词性+中文释义
                String[] result1 = words[i].split("]");
                result1[0] += "]";//result1[0]为序列号+单词+英标  result1[1]为词性+中文释义
                
                if (result1.length == 3) result1[1] = result1[1] + "]" + result1[2];
                //处理后result1[1]词性+中文释义 含[]
                
                //转义符 \\ 分割result1[0]中的 序列号+单词  英标
                String[] result2 = result1[0].split("\\[");
                StringBuilder sb = new StringBuilder(result2[1]);//构造一个StringBuilder对象
                sb.insert(0, "[");
                result2[1] = sb.toString();//处理后 result2[0]序列号+单词, result2[1] 英标
               String[] result3 = result2[0].split(" ");//处理后result3[0]为序号result3[1]为单词
    
                //打印最终分割结果
                System.out.println("序号: " + result3[0]);//序列号
                System.out.println("单词: " + result3[1]);//单词
                System.out.println("英标: " + result2[1]);//英标
                System.out.println("词性和中文释义:" + result1[1]);//词性和中文释义
                //插入数据库 省略
            }
    

    效果如下:

    序号: 1
    单词: the
    英标: [ðə, ði:]
    词性和中文释义: art.这,那 ad.[用于比较级;最高级前
    序号: 2
    单词: be
    英标: [bi:,bi]
    词性和中文释义: aux. v.(am,is,are之原型) vi.是;在
    序号: 3
    单词: of
    英标: [əv, ə, ɔv]
    词性和中文释义: prep.…的;由…制成的;关于;由于
    ...
    序号: 1999
    单词: whistle
    英标: [ˈwisəl]
    词性和中文释义: vi.吹口哨,鸣笛
    序号: 2000
    单词: scenery
    英标: [ˈsi:nəri]
    词性和中文释义: n.风景,景色
    

    插入MySQL数据库后使用navicat工具查看:表中数据1000条一页,有2页数据,共计2000个单词数据都插入数据库了。

    在这里插入图片描述

    单词txt百度网盘下载(无提取码)

    https://pan.baidu.com/s/1G6mEDsoR13gPFMkto3a2yg

    展开全文
  • java.io.InputStream抽象类是表示字节输入流的所有类的超类,可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。 public void close() :关闭此输入流并释放与此流相关联的任何系统资源。 public ...
  • JAVA IO操作类讲解

    2012-06-10 20:31:59
    JAVA IO
  • java IO操作详解.pdf

    2009-11-18 09:43:35
    java IO操作详细解释 清华大学java io专用教材
  • Java IO操作详解

    千次阅读 多人点赞 2016-10-26 13:03:01
    Java编程中,IO(输入输出)是重要的组成部分,Java应用常常...所有的IO操作都在java.io包之中进行定义,而且整个java.io包实际上就是五个类和一个接口: (1)五个类:File、InputStream、OutputStream、Reader、
  • Java IO commons-io-2.5.jar

    2019-04-02 16:11:58
    Java IO commons-io-2.5.jar。 commons-io-2.5.jar 是Java IO的增强版,功能很强大。里面封装了很多实用方便的函数,文件操作、目录操作的。 Java IO
  • A文件: A B C D B文件: 1 2 3 4 利用java io操作A B 文件,得出 C文件: A 1234 B 1234 C 1234 D 1234 或者 A 1 A 2 A 3 A 4 B 1 B 1 B 2 B 3 B 4 ………… 大神求解
  • Java IO操作——回退流PushbackInputStream

    万次阅读 多人点赞 2016-08-10 15:49:35
    JAVA IO中所有的数据都是采用顺序的读取方式,即对于一个输入流来讲都是采用从头到尾的顺序读取的,如果在输入流中某个不需要的内容被读取进来,则只能通过程序将这些不需要的内容处理掉,为了解决这样的处理问题...
  • 字节流提供了处理任何类型的IO操作的功能,但它不能直接处理Unicode字符,而字符流就可以。 字节流和字符流的转换 字节流是最基本的,所有的InputStream和OutputStream的子类都是,主要用在处理二进制数据,它是按...
  • Java IO操作——文件操作类File的使用

    千次阅读 2016-07-14 15:46:20
    学习目标 掌握File类的使用 可以使用File类中的方法对文件进行操作。 在整个Java的学习中,个人感觉学习较为困难的... 所有的IO操作都保存在java.io包中。 File类 在整个io包中,唯一表示与文件本身有关的类就是Fi
  • 该文件用于解决通过java控制串口发送数据给时在Linux...报错内容如下: [librxtxSerial.so+0x75da] Java_gnu_io_RXTXPort_nativeDrain+0xea。经过一番研究得出结论为为rxtx包版本问题,使用本文档中的版本即可正常运行
  • Java IO流详解

    千次阅读 2022-02-09 22:09:58
    javaio是实现输入和输出的基础,可以方便的实现数据的输入和输出操作。在java中把不同的输入/输出源(键盘,文件,网络连接等)抽象表述为“流”(stream)。通过流的形式允许java程序使用相同的方式来访问不同的...
  • Java IO操作之缓冲输入流 BufferdReader

    千次阅读 2019-02-13 11:34:34
    如果要进行中文数据的处理首先想到的一定是字符流,并且要想完整的处理数据,那么一定需要到缓冲区,对于缓冲区的操作,有两种流: 字符缓冲区流:BufferedReader、BufferedWriter 字节缓冲区流:...
  • 学习目标  掌握DataOutputStream和...在io包中,提供了两个与平台无关的数据操作流: 数据输出流(DataOutputStream) 数据输入流 (DataInputStream) 通常数据输出流会按照一定的格式将数据输出,再通过数据输
  • Java IO 详解

    千次阅读 2021-03-03 11:28:10
    Java IO 详解初学java,一直搞不懂java里面的io关系,在网上找了很多大多都是给个结构图草草描述也看的不是很懂。而且没有结合到java7 的最新技术,所以自己来整理一下,有错的话请指正,也希望大家提出宝贵意见。...
  • java io操作,poi导出到excel表格,sl4j日志打印,集合自带排序Comparator 要求: 取出txt文件中其中第50000行到60000行的数据,进行数据的解析,然后对数据的某一项进行排序,从小到大输出到excel表格中.每一步的...
  • Java基础|I/O六个常见类和使用示例。
  • java IO写入读取操作,防止乱码,JavaIO分页读取

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 780,903
精华内容 312,361
关键字:

java的io操作

友情链接: DrawBlank.rar