IO流基础操作

最新推荐文章于 2022-12-01 12:53:43 发布

LSCR7

最新推荐文章于 2022-12-01 12:53:43 发布

阅读量262

点赞数 1

本文链接：https://blog.csdn.net/Madridcrls7/article/details/80460469

版权

File类访问文件属性：

1.创建文件对象 File file=new File(pathname)；

2.操作文件或目录的属性

通过一段代码来说明File类的方法及File类如何操作文件：

package com.sust.stream;
import java.io.File;
import java.io.IOException;

public class CreatNewFile {
    public static void main(String[] args) {
        CreatNewFile fs=new CreatNewFile();          //创建对象
        File file1=null;                               //创建文件对象
        file1=new File("H:\\a\\test.doc");      
        fs.ddd(file1);
        fs.sss(file1);
        //fs.delete(file1);
    }
    public void ddd(File file1){                          //创建文件的方法
        if(!file1.exists()){                              //file1.exists -- 判断文件是否存在
            try{
                file1.createNewFile();
                System.out.println("finish creat new File");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    public void sss(File file1){               //显示文件信息
        if(file1.exists()){
            if(file1.isFile()){
                System.out.println("文件绝对路径为"+file1.getAbsolutePath());     
                System.out.println("文件大小为"+file1.length()+"字节");
                System.out.println("文件相对路径"+file1.getPath());
                System.out.println("文件名"+file1.getName());
            }if(file1.isDirectory()){      //判断文件是否为空目录
                System.out.println("此文件是空目录");
            }
        }else
            System.out.println("不存在此文件");
    }
    public void delete(File file1){       //删除文件
        if(file1.exists()){
            file1.delete();               
            System.out.println("文件已被删除");
        }
    }
}

Java中文件的读写操作是通过流来实现的

流是指一连串流动的字符，是以先进先出的方式发送信息的通道

流的四个实现类： Reader Writer OutputStream InputStream

按流向分类：输入流：InputStream Reader 基类

输出流：OutputStream Writer 基类

按处理数据单元划分：

字节流：字节输入流InputStream 基类字节输出流OutputStream基类

字符流：字符输入流Reader 基类字符输出流Writer 基类

文本文件的读写操作：

用FileInputStream和FileOutputStream读写文本文件

用BufferedReader和BufferedWriter读写文本文件

使用FileWriter类与BufferedWriter类可以提高字符流写文本文件的效率

使用FileReader类与BufferedReader类可以提高字符流读文本文件的效率

二进制文件的读写：

DataInputStream和DataOutputStream读写二进制文件

使用FileInputStream类与FileOutputStream实现文件的复制：

package com.sust.stream;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class InAndOutFile {
    public static void main(String[] args) {
        FileInputStream fis=null;
        FileOutputStream fos=null;
        try {
            //1、创建输入流对象,读取txt文件
            fis = new FileInputStream("H:/a/CR7.txt");
            //2、创建输出流对象
            fos = new FileOutputStream("H:/a/CR.txt",true);
            //3、创建中转站数组,存放每次读取的内容
            byte[] words=new byte[2048];
            //4、通过循环实现文件读取
            while((fis.read())!=-1){    //判断文件是否读完
                fis.read(words);
                fos.write(words, 0, words.length);
            }
            System.out.println("复制完成，请查看文件！");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            //5、关闭流
            try {
                if(fos!=null)
                    fos.close();
                if(fis!=null)
                    fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

    }
}

创建FileOutputStream实例时，如果相应的文件不存在，将会自动创建一个空的文件

FileOutputStream的三种构造方法：前俩种会覆盖文件原有的内容

FileOutputStream(File file)；

FileOutputStream(String name)；

FileOutputStream(String name,boolean append);

使用FileOutputStream类实现将字符串写出到文本文件中：

package com.sust.stream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
1.创建输出流对象
2.将要输出的字符串保存
3.创建数组接收字符串
4.写文件--将数组内容写出
5.关闭文件流对象
 */
public class FileOut {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try{
            String str="My name is Cristiano";
            byte words[]=str.getBytes();
            fos=new FileOutputStream("H:a/test2.txt");
            fos.write(words,0,words.length);
            System.out.println("文件更新完成");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("创建文件出错");
        }finally {
            try{
                if(fos!=null)
                    fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

使用FileReader类实现读文本文件的内容并打印出到控制台：

1.创建Reader对象，创建StringBuffer对象

2.创建一个字符数组

3.读数据并保存到数组 sbf.append--将读来的数据追加到数组

4.将sbf输出

package com.sust.stream;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
/*
FileReader是Reader的子类
 */
public class FileReaderTest {
    public static void main(String[] args) {
        Reader fr=null;
        StringBuffer sbf=null;    //字符串可变
        try{
            fr=new FileReader("H:/a/test2.txt");     //字符输入流
            char ch[]=new char[2048];                              //开辟空间char类型
            sbf=new StringBuffer();                                 //将记事本读来的值
            int length=fr.read(ch);                                 //将字符读入数组
            System.out.println(length);
            while((length!=-1)){
                sbf.append(ch);                                       //把ch数组的内容追加到sbf
                length=fr.read();                                     //继续读数据读不到
                //System.out.println(length);                           //读数据 读不到最高字符的下一个，Length=-1
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try{
                if(fr!=null);
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            System.out.println(sbf.toString());        //输出读到的内容
        }
    }
}

BufferedReader与BufferedWriter:

BufferedReader类是Reader的子类
BufferedReader类带有缓冲区--避免了应用程序和磁盘的频繁交互，提高效率

BufferedReader类有一个特有的readLine()方法：按行读取内容

在实际操作中，可以使用readLine方法与while循环相结合，不断读取文本内容

 String line=br.readLine();
            while(line!=null){
                System.out.println(line);
                line=br.readLine();
            }

使用BufferedReader与FileReader读文件并输出文件内容到控制台：

package com.sust.stream;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderTest {
    public static void main(String[] args) {
        FileReader fr=null;
        BufferedReader br=null;
        try{
            //创建一个FileReader对象
            fr=new FileReader("H:/A/content.TXT");
            //创建一个BufferedReader对象--定义一个带缓冲的字符输入流对象
            br=new BufferedReader(fr);
            //读取一行数据
            String line=br.readLine();
            while(line!=null){
                System.out.println(line);
                line=br.readLine();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("文件不存在");
        }finally {
            try{
                if(br!=null)
                    br.close();
                if(fr!=null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

带缓冲区的字符输入输出流实例：

package com.sust.stream;

import java.io.*;

public class BufferedWriterTest {
    public static void main(String[] args) {
        FileWriter fw=null;
        BufferedReader br=null;
        FileReader fr=null;
        BufferedWriter bw=null;
        try{
            //创建一个FileWriter对象
            fw=new FileWriter("H:/a/test00.txt");
            //创建一个BufferedWriter对象
            bw=new BufferedWriter(fw);
            bw.write("My name is Cristiano");
            bw.newLine();
            bw.write("My ");
            bw.newLine();//相当于换行
            bw.write("My name");
            bw.newLine();
            bw.write("My name is");
            bw.newLine();
            bw.write("My name is Cristiano");
            bw.flush();
            //读取文件内容
            fr=new FileReader("H:/a/test00.txt");
            br=new BufferedReader(fr);
            String line=br.readLine();
            while(line!=null){
                System.out.println(line);
                line=br.readLine();
            }
            fr.close();
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件不存在");
        }finally {
            try{
                if(fw!=null)
                    fw.close();
                if(br!=null)
                    br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

二进制文件的读与写：

使用DataInputStream与DataOutputStream读写二进制文件：如class文件

package com.sust.stream;

import java.io.*;

public class ReadAndWriteBinaryFile {
    public static void main(String[] args) {
        DataInputStream dis=null;
        DataOutputStream dos=null;
        try{
            //创建输入流对象
            FileInputStream fis=new FileInputStream("D:/Java实验3/test2.class");
            dis=new DataInputStream(fis);
            //创建输出流对象
            FileOutputStream fos=new FileOutputStream("D:/Java实验3/test00.class");
            dos=new DataOutputStream(fos);
            int test00;
            //读取文件并写入文件
            while((test00=dis.read())!=-1){
                dos.write(test00);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try{
                if(dis!=null)
                    dis.close();
                if(dos!=null)
                    dos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

练习：

使用输入输出流实现文本内容的替换

思路：

1.创建字符输入输出流对象

2.创建StringBuffer对象sbf临时存储读取到的数据

3.通过循环实现文件读取，并追加到sbf中

4.使用replace方法替换sbf中的内容

5.将替换后的内容输出到文件中

6.关闭输入输出流

package com.sust.stream;
import java.io.*;

public class ReaderAndWriterFile {
    public void replaceFile(String file1,String file2){
        BufferedReader reader=null;
        BufferedWriter writer=null;
        try{
            //创建FileReader对象和FileWriter对象
            FileReader fr=new FileReader(file1);
            FileWriter fw=new FileWriter(file2);
            //创建输入输出流对象
            reader=new BufferedReader(fr);
            writer=new BufferedWriter(fw);
            String line=null;
            StringBuffer sbf=new StringBuffer();
            //循环读取并追加字符
            while((line=reader.readLine())!=null){
                sbf.append(line);
            }
            System.out.println("替换前："+sbf);
            /*
            替换
             */
            String newString=sbf.toString().replace("{name}","C罗");
            newString=newString.replace("{club}","皇家马德里");
            newString=newString.replace("{country}","葡萄牙");
            System.out.println("替换后："+newString);
            writer.write(newString);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭writer和reader
            try{
                if(reader!=null)
                    reader.close();
                if(writer!=null)
                    reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        ReaderAndWriterFile obj=new ReaderAndWriterFile();
        obj.replaceFile("H:/a/CR.txt","H:/a/CR7.txt");
    }
}

使用输入输出流实现图片的替换

package com.sust.stream;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.Writer;
public class ImageCopy {
    public static void main(String[] args) {
        FileInputStream fis = null;
        DataInputStream dis = null;
        FileOutputStream outFile = null;
        DataOutputStream out = null;
        try {
            //创建输入流对象
            fis = new FileInputStream("H:/a/test.png");
            dis = new DataInputStream(fis);
            //创建输出流对象
            outFile = new FileOutputStream("H:/b/test.png");
            out = new DataOutputStream(outFile);
            int temp;
            //读取文件并写入文件
            while ((temp = dis.read()) != -1) {
                out.write(temp);
            }
        } catch (IOException ioe) {
            ioe.printStackTrace();
        } finally {
            try {
                if (dis != null)
                    dis.close();
                if (out != null)
                    out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

LSCR7

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
IO流基础操作

File类访问文件属性：1.创建文件对象 File file=new File(pathname)；2.操作文件或目录的属性通过一段代码来说明File类的方法及File类如何操作文件：package com.sust.stream;import java.io.File;import java.io.IOException;public class CreatNewFile { ...
复制链接

扫一扫