第三周预习：java IO

最新推荐文章于 2024-07-10 21:37:49 发布

#程序猴

最新推荐文章于 2024-07-10 21:37:49 发布

阅读量610

点赞数 3

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/Ma_Monkey/article/details/124127639

版权

java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一、File类

在 Java 中，File 类是 java.io 包中唯一代表磁盘文件本身的对象，也就是说，如果希望在程序中操作文件和目录，则都可以通过 File 类来完成。File 类定义了一些方法来操作文件，如新建、删除、重命名文件和目录等。
File 类不能访问文件内容本身，如果需要访问文件内容本身，则需要使用输入/输出流。
绝对路径vs相对路径
绝对路径：是一个完整的路径，以盘符开始（c： d：）
相对路径：相对指的是相对于当前项目的根目录（可以省略项目的根目录）
注意：
1、路径不区分大小写
2、路径中的文件名称分隔符windows使用反斜杠，反斜杠是转义字符，两个反斜杠代表一个普通的反斜杠

1.构造方法

①.File(String path)：如果 path 是实际存在的路径，则该 File 对象表示的是目录；如果 path 是文件名，则该 File 对象表示的是文件。
②.File(String path, String name)：path 是路径名，name 是文件名。
③.File(File dir, String name)：dir 是路径对象，name 是文件名。

2.文件的属性

经常使用的一些获取文本信息的方法

3.代码举例

import java.io.File;
public class Test {
    public static void main(String[] args) {
        File f=new File("D:\\Mjava\\src\\Demo02","Test.java");
        System.out.println(f.getName()+"是可读的吗:"+f.canRead());
        System.out.println(f.getName() + "的长度:" + f.length());
        System.out.println(f.getName() + "的绝对路径:" + f.getAbsolutePath());
        System.out.println(f.getName() + "的父路径:" + f.getParent());
    }
}

运行结果

二、文件字节输入流

1.基本步骤

设定输入流的源；
创建指向源的输入流；
让输入流读取源中的数据；
关闭输入流。

2.常用子类以及方法

构造方法：
FileInputStream(String name)
FileInputStream(File file)
InputStream 类及其子类的对象表示字节输入流，InputStream 类的常用子类如下：
ByteArrayInputStream 类：将字节数组转换为字节输入流，从中读取字节。
FileInputStream 类：从文件中读取数据。
PipedInputStream 类：连接到一个 PipedOutputStream（管道输出流）。
SequenceInputStream 类：将多个字节输入流串联成一个字节输入流。
ObjectInputStream 类：将对象反序列化。
在这里插入图片描述

import java.io.*;

public class Test {
    public static void main(String[] args) {
        int n=-1;
        byte [] a=new byte[100];
        try{
            File f=new File("D:\\Mjava\\src\\Demo02\\Test.java");
            InputStream in = new FileInputStream(f);
            while((n=in.read(a,0,100))!=-1){
                String s=new String(a,0,n);
                System.out.println(s);
            }
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用文件字节读取文件
！！！：当把读入的字节转化为字符串时，要把实际读入的字节转化为字符串。

三、文件字节输出流

1.基本步骤

给出输出流的目的地；
创建指向目的地的输出流；
让输出流把数据写入到目的地；
关闭输出流；

2.常用子类以及方法

构造方法：
Fileoutput(String name);
Fileoutput(File file);
OutputStream 类及其子类的对象表示一个字节输出流。OutputStream 类的常用子类如下：
ByteArrayOutputStream 类：向内存缓冲区的字节数组中写数据。
FileOutputStream 类：向文件中写数据。
PipedOutputStream 类：连接到一个 PipedlntputStream（管道输入流）。
ObjectOutputStream 类：将对象序列化。
在这里插入图片描述

import java.io.*;
public class Test {
    public static void main(String[] args) {
        byte [] a="新年快乐".getBytes();
        byte [] b="Happy New Year".getBytes();
        File file =new File("a.txt");
        try{
            OutputStream out=new FileOutputStream(file);
            System.out.println(file.getName() + "的大小:" + file.length() + "字节");
            out.write(a);
            out.close();
            out=new FileOutputStream(file,true);
            System.out.println(file.getName() + "的大小:" + file.length() + "字节");
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

四、文件字符输入、输出流

1.Reader类

Reader 类的常用子类如下:
CharArrayReader 类：将字符数组转换为字符输入流，从中读取字符。
StringReader 类：将字符串转换为字符输入流，从中读取字符。
BufferedReader 类：为其他字符输入流提供读缓冲区。
PipedReader 类：连接到一个 PipedWriter。
InputStreamReader 类：将字节输入流转换为字符输入流，可以指定字符编码。
在这里插入图片描述

2.Writer类

Writer 类的常用子类如下:
CharArrayWriter 类：向内存缓冲区的字符数组写数据。
StringWriter 类：向内存缓冲区的字符串（StringBuffer）写数据。
BufferedWriter 类：为其他字符输出流提供写缓冲区。
PipedWriter 类：连接到一个 PipedReader。
OutputStreamReader 类：将字节输出流转换为字符输出流，可以指定字符编码。
在这里插入图片描述

import java.io.*;
public class Test {
    public static void main(String[] args) {
    File sourceFile = new File("a.txt");
    File targetFile = new File("b.txt");
    char c[]=new char [19];
    try{
        Writer out = new FileWriter(targetFile,true);
                Reader in = new FileReader(sourceFile);
                int n=-1;
                while((n=in.read(c))!=-1){
                    out.write(c,0,n);
                }
                out.flush();
                out.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
    }
}

五、缓冲流

1.概述

java缓冲流本身不具IO功能，只是在别的流上加上缓冲提高效率，像是为别的流装上一种包装。当对文件或其他目标频繁读写或操作效率低，效能差。这时使用缓冲流能够更高效的读写信息。因为缓冲流先将数据缓存起来，然后一起写入或读取出来。所以说，缓冲流还是很重要的，在IO操作时记得加上缓冲流提升性能。缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO读取次数，从而提高读写的效率。
它是四个基本File流的增强，所以也是4个流，按照数据类型分类：
字节缓冲流：BufferedInputStream，BufferedOutputStream
字符缓冲流：BufferedReader，BufferedWriter
原理图：
在这里插入图片描述

2.BufferedInputStream

在这里插入图片描述

3.BufferedOutputStream

在这里插入图片描述

4.BufferedReader

在这里插入图片描述

5.BufferedWriter

在这里插入图片描述

六.随机流

RandomAccessFile 是 Java 输入/输出流体系中功能最丰富的文件内容访问类，它提供了众多的方法来访问文件内容，它既可以读取文件内容，也可以向文件输出数据。
在这里插入图片描述
RandomAccessFile 类的构造方法有如下两种重载形式:
RandomAccessFile(File file, String mode)：访问参数 file 指定的文件，访问形式由参数 mode 指定，mode 参数有两个常用的可选值 r 和 rw，其中 r 表示只读，rw 表示读写。
RandomAccessFile(String name, String mode)：访问参数 name 指定的文件，mode 参数的含义同上。
例：

import java.io.*;
public class Test {
    public static void main(String[] args) throws IOException {
        File file = null;
        try {
            file = new File("D:\\Mjava\\src\\Demo02\\hello.txt");
            if (file.exists()) { // 判断文件是否存在
                file.delete();
                file.createNewFile();
            }
        } catch (IOException e) {
            System.out.print(e);
        }
        RandomAccessFile raf = new RandomAccessFile(file, "rw");
        String str1 = "晴天，阴天，多云，小雨，大风，中雨，小雪，雷阵雨";    // 要写入的字符串
        String str2 = new String(str1.getBytes("GBK"),"ISO-8859-1");   // 编码转换
        raf.writeBytes(str2);    //写入文件
        System.out.println("当前文件指针的位置：" + raf.getFilePointer());
        raf.seek(6); // 移动文件指针
        System.out.println("从文件头跳过6个字节，现在文件内容如下：");
        byte[] buffer = new byte[2];
        int len = 0;
        while ((len = raf.read(buffer, 0, 2)) != -1) {
            System.out.print(new String(buffer, 0, len)); // 输出文件内容
        }
    }
    }

在这里插入图片描述

七.数组流

ByteArrayInputStream ：在构造的时候，需要接收数据源，它是一个字节数组。
ByteArrayOutputStream：在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。
因为这两个流对象都在内存中操作数组，并没有使用系统资源。所以，不用进行close关闭。
size() ，返回缓冲区的当前大小。
toByteArray() ，创建一个新分配的数组。

import java.io.*;
public class Test {
    public static void main(String[] args) throws IOException {
        ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEFD".getBytes());
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        int by = 0;
        while((by=bis.read())!=-1)
        {
            bos.write(by);
        }
        System.out.println(bos.toString());
        bos.writeTo(new FileOutputStream("a.txt"));
        }
    }

在这里插入图片描述

八.数据流

数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。
构造：
DataInputStream dis = new DataInputStream(InputStream in);
在这里插入图片描述
数据输出流允许应用程序以与机器无关方式将Java基本数据类型写到底层输出流。
下面的构造方法用来创建数据输出流对象:
DataOutputStream out = new DataOutputStream(OutputStream out);

例：

import java.io.*;
public class Test{
    public static void main(String args[])throws IOException{

        DataInputStream in = new DataInputStream(new FileInputStream("D:\\Mjava\\src\\Demo02\\hello.txt"));
        DataOutputStream out = new DataOutputStream(new  FileOutputStream("D:\\Mjava\\src\\Demo02\\hello.txt"));
        BufferedReader d  = new BufferedReader(new InputStreamReader(in));
        String count;
        while((count = d.readLine()) != null){
            String u = count.toUpperCase();
            System.out.println(u);
            out.writeBytes(u + "  ,");
        }
        d.close();
        out.close();
    }
}

九.对象流

ObjectInputStream和ObjectOutputStream类分别是InputStream和OutputStream类的子类。ObjectInputStream和ObjectOutputStream类创建的对象称为输入流和对象输出流，对象输出流使用writeObject(Object obj)方法将一个对象obj写入到一个文件，对象输入流使readObject()读取一个对象到程序中。
ObjectInputStream和ObjectOutputStream类的构造方法如下：
ObjectInputStream(InputStream in);
ObjectOutputStream(OutputStream out);
例：

import java.io.*;
public class Test{
    public static void main(String args[])throws IOException {
        TV changhong = new TV();
        changhong.setName("长虹电视");
        changhong.setPrice(5678);
        File file = new File("D:\\Mjava\\src\\Demo02\\television.txt");
        try {
            FileOutputStream fileOutput = new FileOutputStream(file);
            ObjectOutputStream objectOut = new ObjectOutputStream(fileOutput);
            objectOut.writeObject(changhong);
            objectOut.close();
            FileInputStream fileIn=new FileInputStream(file);
            System.out.println("changhong的名字" + changhong.getName());
            System.out.println("changhong的价格" + changhong.getPrice());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

#程序猴

关注

3
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
第三周预习：java IO

一、File类在 Java 中，File 类是 java.io 包中唯一代表磁盘文件本身的对象，也就是说，如果希望在程序中操作文件和目录，则都可以通过 File 类来完成。File 类定义了一些方法来操作文件，如新建、删除、重命名文件和目录等。File 类不能访问文件内容本身，如果需要访问文件内容本身，则需要使用输入/输出流。绝对路径vs相对路径绝对路径：是一个完整的路径，以盘符开始（c： d：）相对路径：相对指的是相对于当前项目的根目录（可以省略项目的根目录）注意：1、路径不区分大小写2、
复制链接

扫一扫