Java基础———重温关于的文件读写操作，File类，FileInputStream类等的使用

最新推荐文章于 2022-01-03 15:44:57 发布
最新推荐文章于 2022-01-03 15:44:57 发布
阅读量578 收藏 1
点赞数 1
分类专栏： java开发实战1200例 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/siying8419/article/details/78522963
版权

从文件读取文件，或者写入文件非常重要，因为这会很方便文件管理和程序编写结合为一体

  1. 文件的创建与判断

    • 分析：如果文件存在，则输出file has existed. 如果文件不存在，则创建它
package File_all;
import java.io.*;

import com.sun.org.apache.xerces.internal.util.SynchronizedSymbolTable;
/* 思路介绍：
 1. 1.首先我想建一个文件，这个文件如果存在我就直接读取数据，如果不存在，则进行创建
 2.   
 3.   
 4.   
 */
class File1{

    public static void main(String[] Args){
        File f = new File("f:\\finding_job\\Github\\File_input_out\\src\\File_all\\abc.txt");

        if(f.exists()){
            System.out.println("this file has existed!");
        }
        else {
            try{
            f.createNewFile();
            System.out.println("this file doesn't exist,but it has been created");
            }catch(IOException e){

                System.out.println("创建文件异常");
            }

        }
    }
    }

输出结果：this file has existed!

  1. 文件用FileInputStream的读取与写入
package File_all;
import java.io.*;

import com.sun.org.apache.xerces.internal.util.SynchronizedSymbolTable;
/* 思路介绍：
 * 1.首先我想建一个文件，这个文件如果存在我就直接读取数据，如果不存在，则进行创建
 * 2.如果文件不是空文件，则读取其中数据，之后，将文件清空；并将“I Love Java”写入，并输出提示“I have written appointed data”；
 *   如果文件开始就是空文件，直接将“I Love Java”写入，并读出；  
 */
class File1{

    public static void main(String[] Args){
        File f = new File("f:\\finding_job\\Github\\File_input_out\\src\\File_all\\abc.txt");

        if(f.exists()){
            System.out.println("this file has existed!");
        }
        else {
            try{
            f.createNewFile();
            System.out.println("this file doesn't exist,but it has been created");
            }catch(IOException e){

                System.out.println("创建文件异常");
            }
        }
        //这里开始将开始实现第二部分文件读写功能
                if(f.length()==0 ){
                    System.out.println("this file is empty!");
                    try{
                    //write data, use FileOutStream

                    FileOutputStream fos = new FileOutputStream(f);  //只能一个字节一个字节写入

                    fos.write('A'); //这个地方只能英文，因为只有英语字母可以用一个字节来表示，其他汉字都会出现数据丢失
                    System.out.println("the file has been writteen");
                    fos.close();
                    }catch(Exception e){

                        System.out.println("the file write not correctly");

                    }

                }
                else{System.out.println("the file's length is: "+f.length());} 
    }
    }

这段代码只能一个字母一个字母敲进去，显然不是我们想要的，接下来介绍，DataOutputStream类，这个类是可以完整敲入，int，String等数据。

以下代码：

package File_all;
import java.io.*;

/* 思路介绍：
 * 1.首先我想建一个文件，这个文件如果存在我就直接读取数据，如果不存在，则进行创建
 * 2.如果文件不是空文件，则读取其中数据，之后，将文件清空；并将“I Love Java”写入，并输出提示“I have written appointed data”；
 *   如果文件开始就是空文件，直接将“I Love Java”写入，并读出；
 *   
 *   
 */
class File1{

    public static void main(String[] Args) throws Exception{

        File f = new File("f:\\finding_job\\Github\\File_input_out\\src\\File_all\\abc1.txt");

        if(f.exists()){
            System.out.println("this file has existed!");
        }
        else {
            try{
            f.createNewFile();
            System.out.println("this file doesn't exist,but it has been created");
            }catch(IOException e){

                System.out.println("创建文件异常");
            }
        }
        //这里开始将开始实现第二部分文件读写功能
                if(f.length()==0 ){
                    System.out.println("this file is empty!");
                    try{
                    //write data, use FileOutStream

                    FileOutputStream fos = new FileOutputStream(f,false);  //只能一个字节一个字节写入,替换掉原来的东西
                    //定义DataOutputStream类
                    DataOutputStream dos = new DataOutputStream(fos); //这样是为了将数据传入流中，相当于数据流的入口

                    dos.writeUTF("I don't Love Java"); 
                    System.out.println("the file has been writteen");
                    fos.close();
                    dos.close();
                    }catch(Exception e){

                        System.out.println("the file write not correctly");

                    }

                } 
                else{
                    System.out.println("the file's length is: "+f.length()+"byte");
                    try{
                        //clear data

                        FileOutputStream fos = new FileOutputStream(f,false);  //只能一个字节一个字节写入,替换掉原来的东西
                        //定义DataOutputStream类
                        DataOutputStream dos = new DataOutputStream(fos); //这样是为了将数据传入流中，相当于数据流的入口

                        dos.write(new String("").getBytes()); //z这里就是为了清空文档
                        System.out.println("the file has been cleared，it is an empty file now");
                        fos.close();
                        dos.close();
                        }catch(Exception e){

                            System.out.println("the file clear not correctly");

                        }

                    try{
                        //write data, use FileOutputStream

                        FileOutputStream fos = new FileOutputStream(f,false);  //只能一个字节一个字节写入,替换掉原来的东西
                        //定义DataOutputStream类
                        DataOutputStream dos = new DataOutputStream(fos); //这样是为了将数据传入流中，相当于数据流的入口

                        dos.writeUTF("I Love Java"); //这个地方读入字符串
                        System.out.println("the file has been writteen");

                        dos.close();
                        }catch(Exception e){

                            System.out.println("the file write not correctly");

                        }
                    try{  
                    //read data, use FileInputStream


                    FileInputStream fis = new FileInputStream(f);  //只能一个字节一个字节读
                    //定义DataOutputStream类
                    DataInputStream dis = new DataInputStream(fis); //这样是为了将数据传入流中，相当于数据流的入口

                    System.out.println("the file's content is: "+dis.readUTF());

                    fis.close();
                    dis.close();

                        }catch(IOException e){
                            System.out.println("the file can't read correctly");
                        }

                }           
    }
    }

输出结果：
第一次运行结果：
this file has existed!
the file’s length is: 13byte
the file has been cleared，it is an empty file now
the file has been writteen
the file’s content is: I Love Java

以上都是以字节为单位进行处理数据，包括DataInputStream类这种可以输入字符串的方式，那么引入以字符为单位的输入和输出流非常有必要。

package File_all;
import java.io.*;

/* 思路介绍：
 * 1.首先我想建一个文件，这个文件如果存在我就直接读取数据，如果不存在，则进行创建
 * 2.如果文件不是空文件，则读取其中数据，之后，将文件清空；并将“I Love Java”写入，并输出提示“I have written appointed data”；
 *   如果文件开始就是空文件，直接将“I Love Java”写入，并读出；
 *   
 *   
 */
class File1{

    public static void main(String[] Args) throws Exception{

        File f = new File("f:\\finding_job\\Github\\File_input_out\\src\\File_all\\abc.txt");

        if(f.exists()){
            System.out.println("this file has existed!");
        }
        else {
            try{
            f.createNewFile();
            System.out.println("this file doesn't exist,but it has been created");
            }catch(IOException e){

                System.out.println("创建文件异常");
            }
        }
        //这里开始将开始实现第二部分文件读写功能
                if(f.length()==0 ){
                    System.out.println("this file is empty!");
                    try{
                    //write data, use FileOutStream

                    FileOutputStream fos = new FileOutputStream(f,false);  //只能一个字节一个字节写入,替换掉原来的东西
                    //定义DataOutputStream类
                    DataOutputStream dos = new DataOutputStream(fos); //这样是为了将数据传入流中，相当于数据流的入口

                    dos.writeUTF("I don't Love Java"); 
                    System.out.println("the file has been writteen");
                    fos.close();
                    dos.close();
                    }catch(Exception e){

                        System.out.println("the file write not correctly");

                    }

                } 
                else{
                    System.out.println("the file's length is: "+f.length()+"byte");
                    try{
                        //clear data

                        FileOutputStream fos = new FileOutputStream(f,false);  //只能一个字节一个字节写入,替换掉原来的东西
                        //定义DataOutputStream类
                        DataOutputStream dos = new DataOutputStream(fos); //这样是为了将数据传入流中，相当于数据流的入口

                        dos.write(new String("").getBytes()); //z这里就是为了清空文档
                        System.out.println("the file has been cleared，it is an empty file now");
                        fos.close();
                        dos.close();
                        }catch(Exception e){

                            System.out.println("the file clear not correctly");

                        }

                    try{
                        //write data, use FileOutputStream

                        FileOutputStream fos = new FileOutputStream(f,false);  //只能一个字节一个字节写入,替换掉原来的东西
                        //定义DataOutputStream类
                        DataOutputStream dos = new DataOutputStream(fos); //这样是为了将数据传入流中，相当于数据流的入口

                        dos.writeUTF("I Love Java"); //这个地方读入字符串
                        System.out.println("the file has been writteen");

                        dos.close();
                        }catch(Exception e){

                            System.out.println("the file write not correctly");

                        }
                    try{  
                    //read data, use FileInputStream


                    FileInputStream fis = new FileInputStream(f);  //只能一个字节一个字节读
                    //定义DataOutputStream类
                    DataInputStream dis = new DataInputStream(fis); //这样是为了将数据传入流中，相当于数据流的入口

                    System.out.println("the file's content is: "+dis.readUTF());

                    fis.close();
                    dis.close();

                        }catch(IOException e){
                            System.out.println("the file can't read correctly");
                        }

                }
        System.out.println("****************the DataInputStream has ended,the BufferedWriter and BufferedReader start now***********");
        try{  
            //read data, use FileInputStream


            FileOutputStream fos = new FileOutputStream(f);  //只能一个字节一个字节读
            //定义DataOutputStream类
            OutputStreamWriter osw = new OutputStreamWriter(fos); //这个是针对字符流，可以一个个输入字符
            BufferedWriter bw = new BufferedWriter(osw); //这样是为了将数据传入流中，相当于数据流的入口，但是可以输入字符串，并用行来读出
            System.out.println("please input the content that you want to show");

            InputStreamReader isr = new InputStreamReader(System.in); //这样是为了将数据传入流中，相当于数据流的入口
            BufferedReader br = new BufferedReader(isr);
            String temp = new String(br.readLine());

            bw.write(temp);
            bw.newLine();
            System.out.println("the content from your keyboard has been written correctly");
            bw.close();

                }catch(IOException e){
                    System.out.println("the file has not written correctly");
                }
        try{  
            //read data, use FileInputStream


            FileInputStream fis = new FileInputStream(f);  //只能一个字节一个字节读
            //定义IutputStreamReader类
            InputStreamReader isr = new InputStreamReader(fis); //这样是为了将数据传入流中，相当于数据流的入口
            BufferedReader br = new BufferedReader(isr);
            System.out.println("the file's content is: ");
            //输出结果
            String s;
            while((s= br.readLine())!=null){
                System.out.println("I AM IN loop");
            System.out.println(s);
            }

            br.close();

                }catch(IOException e){
                    System.out.println("the file can't read correctly");
                }   

    }
    }

输出结果：
this file has existed!
this file is empty!
the file has been writteen
***********the DataInputStream has ended,the BufferedWriter and BufferedReader start now******
please input the content that you want to show
it’s your last chance
the content from your keyboard has been written correctly
the file’s content is:
I AM IN loop
it’s your last chance

最后介绍一下完整的从键盘输入数据到文件中，并且读出

功能描述：从键盘不限行的输入数据，并且保存到文件中，同时读出

package File_all;
import java.io.*;

/* 思路介绍：
 * 1.首先我想建一个文件，这个文件如果存在我就直接读取数据，如果不存在，则进行创建
 * 2.如果文件不是空文件，则读取其中数据，之后，将文件清空；并将“I Love Java”写入，并输出提示“I have written appointed data”；
 *   如果文件开始就是空文件，直接将“I Love Java”写入，并读出；
 *  3.从键盘上不限行读入，如果遇到一个新的行“ok”，则读入完毕；并将这个内容写入到文件中，读出；
 *   
 */
class File1{

    public static void main(String[] Args) throws Exception{

        File f = new File("f:\\finding_job\\Github\\File_input_out\\src\\File_all\\abc.txt");

        if(f.exists()){
            System.out.println("this file has existed!");
        }
        else {
            try{
            f.createNewFile();
            System.out.println("this file doesn't exist,but it has been created");
            }catch(IOException e){

                System.out.println("创建文件异常");
            }
        }
        //这里开始将开始实现第二部分文件读写功能
                if(f.length()==0 ){
                    System.out.println("this file is empty!");
                    try{
                    //write data, use FileOutStream

                    FileOutputStream fos = new FileOutputStream(f,false);  //只能一个字节一个字节写入,替换掉原来的东西
                    //定义DataOutputStream类
                    DataOutputStream dos = new DataOutputStream(fos); //这样是为了将数据传入流中，相当于数据流的入口

                    dos.writeUTF("I don't Love Java"); 
                    System.out.println("the file has been writteen");
                    fos.close();
                    dos.close();
                    }catch(Exception e){

                        System.out.println("the file write not correctly");

                    }

                } 
                else{
                    System.out.println("the file's length is: "+f.length()+"byte");
                    try{
                        //clear data

                        FileOutputStream fos = new FileOutputStream(f,false);  //只能一个字节一个字节写入,替换掉原来的东西
                        //定义DataOutputStream类
                        DataOutputStream dos = new DataOutputStream(fos); //这样是为了将数据传入流中，相当于数据流的入口

                        dos.write(new String("").getBytes()); //z这里就是为了清空文档
                        System.out.println("the file has been cleared，it is an empty file now");
                        fos.close();
                        dos.close();
                        }catch(Exception e){

                            System.out.println("the file clear not correctly");

                        }

                    try{
                        //write data, use FileOutputStream

                        FileOutputStream fos = new FileOutputStream(f,false);  //只能一个字节一个字节写入,替换掉原来的东西
                        //定义DataOutputStream类
                        DataOutputStream dos = new DataOutputStream(fos); //这样是为了将数据传入流中，相当于数据流的入口

                        dos.writeUTF("I Love Java"); //这个地方读入字符串
                        System.out.println("the file has been writteen");

                        dos.close();
                        }catch(Exception e){

                            System.out.println("the file write not correctly");

                        }
                    try{  
                    //read data, use FileInputStream


                    FileInputStream fis = new FileInputStream(f);  //只能一个字节一个字节读
                    //定义DataOutputStream类
                    DataInputStream dis = new DataInputStream(fis); //这样是为了将数据传入流中，相当于数据流的入口

                    System.out.println("the file's content is: "+dis.readUTF());

                    fis.close();
                    dis.close();

                        }catch(IOException e){
                            System.out.println("the file can't read correctly");
                        }

                }
        System.out.println("****************the DataInputStream has ended,the BufferedWriter and BufferedReader start now***********");
        try{  
            //read data, use FileInputStream


            FileOutputStream fos = new FileOutputStream(f);  //只能一个字节一个字节读
            //定义DataOutputStream类
            OutputStreamWriter osw = new OutputStreamWriter(fos); //这个是针对字符流，可以一个个输入字符
            BufferedWriter bw = new BufferedWriter(osw); //这样是为了将数据传入流中，相当于数据流的入口，但是可以输入字符串，并用行来读出
            System.out.println("please input the content that you want to show,end with new line <ok>");

            InputStreamReader isr = new InputStreamReader(System.in); //这样是为了将数据传入流中，相当于数据流的入口
            BufferedReader br = new BufferedReader(isr);
            while(true){
            String temp = new String(br.readLine());

            if(temp.equals("ok")) break; //注意这个地方不能用等号，用equals
            bw.write(temp);
            bw.newLine();
            }
            bw.newLine();
            System.out.println("the content from your keyboard has been written correctly");
            bw.close();

                }catch(IOException e){
                    System.out.println("the file has not written correctly");
                }
        try{  
            //read data, use FileInputStream


            FileInputStream fis = new FileInputStream(f);  //只能一个字节一个字节读
            //定义IutputStreamReader类
            InputStreamReader isr = new InputStreamReader(fis); //这样是为了将数据传入流中，相当于数据流的入口
            BufferedReader br = new BufferedReader(isr);
            System.out.println("the file's content is: ");
            //输出结果
            String s;
            while((s= br.readLine())!=null){

            System.out.println(s);
            }

            br.close();

                }catch(IOException e){
                    System.out.println("the file can't read correctly");
                }   

    }
    }

运行结果：
this file has existed!
this file is empty!
the file has been writteen
***********the DataInputStream has ended,the BufferedWriter and BufferedReader start now******
please input the content that you want to show,end with new line ok
hello,welcome to my blog!
test this file
progress a lot
ok
the content from your keyboard has been written correctly
the file’s content is:
hello,welcome to my blog!
test this file
progress a lot

这里写图片描述

Jeremy__Zhu
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java文件操作类FileManager
01-20
读写文件是常用的操作之一，每次将相应的代码片段复制过来不仅麻烦，还会影响整体的美观。为此我单独写了一个文件操作的类，需要时先把这个类的代码粘过去，再调用方便多了。 import java.io.BufferedReader; ...
java 文件inputstream_Java使用FileInputStream流读取文件示例详解
weixin_35574537的博客
02-12 6866
一、File流概念JAVA中针对文件的读写操作设置了一系列的流，其中主要有FileInputStream,FileOutputStream,FileReader,FileWriter四种最为常用的流二、FileInputStream1)FileInputStream概念FileInputStream流被称为文件字节输入流，意思指对文件数据以字节的形式进行读取操作如读取图片视频等2)构造方法2.1)...
Java中用FileInputStream读取文本文件
u014804332的博客
04-01 1万+
FileInputStream类，俗称文件输入流，他的作用是将文本文件中的数据输入到内存中。他是一个字节输入流，是InputStream抽象类的一个子类。使用FileInputStream类读写文本文件分为以下几个步骤：1.引入相关的类import java.io.FileInputStream; import java.io.FileNotFoundException; import java....
File 类 读写文件操作
weixin_46681279的博客
11-04 2124
File 类 命名空间: System.IO 程序集: System.IO.FileSystem.dll 提供用于创建、复制、删除、移动和打开单一文件的静态方法，并协助创建FileStream对象。 示例 下面的示例演示如何使用File类检查文件是否存在，根据结果创建新文件并对其进行写入，或者打开现有文件并从中读取。在运行代码之前，请创建一个c:\temp文件夹 using System; using System.IO; class Test { public s...
Java使用FileInputStream流读取文件示例详解
08-18
主要介绍了Java使用FileInputStream流读取文件示例详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Android 数据存储之 FileInputStream 工具类及FileInputStream类的使用
09-03
主要介绍了Android 数据存储之 FileInputStream 工具类及FileInputStream类的使用的相关资料,需要的朋友可以参考下
使用java读写properties文件属性
01-20
　我们要做的第一步是要将文件读取到Properties类对象中，由于load有一个参数是InputStream，所以我们可以用 InputStream的子类FileInputStream将属性文件读取到Properties对象中，知道prop.properties的路径，我们...
java 二进制文件的读写操作
12-12
java 二进制文件的读写操作使用FileInputStream FileOutputStream
使用RandomAccessFile类对文件进行读写
weixin_30483013的博客
04-17 955
1. RandomAccessFile类简介   RandomAccessFile是Java提供用来访问一些保存数据记录的文件的类，可以进行读取操作，也可以进行写入操作，写入的数据则以byte的形式存储；支持随机访问，也就是可以访问文件的任意位置（通过文件指针实现）。 2. 构造函数 RandomAccessFile(String name, String mode) RandomAccessFi...
使用字节流FileInputStream读取、FileOutputStream写入、拷贝(先读取后写入)
ThinkPet
07-27 3092
package com.io.test; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; /** * 使用字节流FileInputStream读取、FileOutputStrea...
java基础知识之FileInputStream流
热门推荐
咕噜是个胖子
07-18 20万+
一、File流概念        JAVA中针对文件的读写操作设置了一系列的流，其中主要有FileInputStream,FileOutputStream,FileReader,FileWriter四种最为常用的流 二、FileInputStream 1）FileInputStream概念                FileInputStream流被称为文件字节输入流，意思指对文件数据...
简述Java File类
m0_64803670的博客
01-03 146
File类：能够使用File的对象操作文件，如：删除、获取文件信息、创建文件夹等。 但File类不可用于读写文件内容。 读写及修改文件内容可用IO流。 File类构建对象的方式： --File 创建对象=new File("//路径")； File中的路径可分为两种： --相对路径：相对路径是不带盘符的，默认相对到工程下开始寻找文件。 推荐 --绝对路径：绝对路径是带盘符的，依赖当前系统。 --File类常用Api： publicbooleanisDi..
使用FileInputStream和FileOutputStream实现本地文件读写操作
Angelica
08-26 1万+
FileInputStream和FileOutputStream 是一对继承与InputStream和OutputStream的类，分别用来创建磁盘文件的输入流和输出流对象，开发中我们会经常需要使用FileInputStream和FileOutputStream来实现本地文件读写操作，下面分享一个本地文件读写类package com.pumasoft.vr.utils;import android.
File（文件）类
Lin724915的博客
08-16 999
File（文件）类 对文件和目录的属性进行操作，对文件进行读写操作的类。 如果要是用到该包中的类，要声明import java.io.*; java.io.File类的对象可以表示文件和目录，在程序中一个File类对象可以代表一个文件或目录。 当创建一个File对象后，就可以利用它来对文件或目录的属性进行操作 File对象不能直接对文件内容进行读写操作，只能查看文件的属性 在java中""符号表示转意，如果使用"\"作为路线分隔符，则需要编写"\\"，也可以用/来替代 如果以"\\"或者"/"
怎么使用Java中的File类或者IO流来访问磁盘文件。
最新发布
05-31
使用Java中的File类或者IO流来访问磁盘文件可以分为两个步骤：1. 创建File对象；2. 通过IO流读取或写入文件内容。下面是一个简单的示例代码： ```java import java.io.*; public class FileExample { public ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值