Java I/O输入输出处理类和方法介绍

操作文件或文件属性

在计算机中，通常使用各种各样的文件来保存数据，如何在Java程序中操作这些文件呢？java.io包提供了一些接口和类，对文件进行基本的操作，包括对文件和目录属性的操作、对文件读写的操作等。
File对象既可表示文件，也可表示目录，在程序中一个File对象可以代表一个文件或目录。利用它可用来对文件或目录进行基本操作。它可以查出与文件相关的信息。

File类

File类的常用方法如下所示：

使用File类操作文件和目录属性的步骤一般如下：
（1）引入File类。
import java.io.File;
（2）构造一个文件对象
File file=new File(“text.txt”);
（3）利用File类的方法访问文件或目录属性，具体使用如下：

方法	作用
file.exists();	判断文件或目录是否存在
file.isFile();	判断是否是文件
file.isDirectory();	判断是否是目录
file.getName();	获取文件或目录的名称
file.getPath();	获取文件或目录的相对路径
file.getAbsolutePath();	获取文件或目录的绝对路径
file.lastModified();	获取文件或目录的最后修改日期
file.length();	获取文件或目录的大小，单位为字节

示例一：

import java.io.File; import java.io.IOException; public class TestFile { public static void main(String[] args) { //        File f = new File("D:/shuju/新建文本文档.txt"); //        System.out.println(f.isFile());//是不是文件 //        System.out.println(f.isDirectory());//是不是目录 //        System.out.println(f.exists());//是不是存在 File file = new File("D:/abc/def/ggg/a.txt"); System.out.println(file.exists()); //        file.getPath();//相对路径 //        file.getAbsolutePath();//绝对路径 //        file.getName();//文件名 //        file.length();//大小 file.getParentFile().mkdirs();//mkdir()单级目录创建 try { file.createNewFile(); } catch (IOException e) { e.printStackTrace(); } System.out.println(file.exists()); file.delete();//只能够删除最后一级 // System.out.println(file.exists()); File f2 = new File("abc.txt");//直接从工程开始创建 creatFile("abc.txt"); } public static void creatFile(String path){ File f = new File(path); try { f.createNewFile(); } catch (IOException e) { e.printStackTrace(); } } } 

输出结果：

示例二：使用File类创建和删除文件。
实现步骤如下：
（1）引入File类。
（2）构造一个文件对象。
（3）调用File类的方法创建和删除文件。
代码展示：

import java.io.File; public class FileMethods { public static void main(String[] args) throws Exception { //创建和删除文件 FileMethods fm = new FileMethods(); File f = new File("D:/myDoc/test.txt"); fm.creat(f); fm.delete(f); } //创建文件的方法 public void creat(File file)throws Exception { if (!file.exists()) { file.createNewFile(); } } //删除文件的方法 public void delete(File file)throws Exception { if (file.exists()) { file.delete(); } } } 

示例三：实现查看文件属性、创建和删除文件功能。

代码展示：

import java.io.File; public class test1 { public static void main(String[] args) { File f = new File("D:/myDoc/text.txt"); System.out.println("名称："+f.getName()); System.out.println("相对路径：" + f.getPath()); System.out.println("绝对路径：" + f.getAbsolutePath()); System.out.println("文件大小："+f.length()+"字节"); //        f.getParentFile().mkdirs(); //        try { //            f.createNewFile(); //        } catch (IOException e) { //            e.printStackTrace(); //        } } } 

输出结果：

认识Java流

之前讲述了如何利用File类对文件或目录的属性进行操作，但File类不能访问文件的内容，既不能从文件中读取数据或往文件里写数据。
读文件是指把文件中的数据读取到内存中。写文件是把内存中的数据写到文件中。通过流读写文件。
流是指一连串流动的字符，是以先进先出的方式发送和接收数据的通道。
流分为输入流和输出流。输入/输出流是指相对于计算机内存来说的，如果数据输入到内存，则称为输入流，如果从内存中输出则称为输出流。Java的输出流主要由OutputStream和Write作为基类，而输入流则主要由InputStream和Reader作为基类。

在java.io包中，封装了许多输入/输出流的API。在程序中，这些输入/输出流类的对象称为流对象。可以通过这些流对象将内存中的数据以流的方式写入文件，也可以通过流对象将文件中的数据以流的方式读取带内存。
构造流对象时往往会和数据源联系起来。数据源分为源数据源和目标数据源。输入流关联的是源数据源。输出流关联的则是目标数据源。

输入/输出流又分为字节流和字符流两种。

字节流是8位通用字节流，其基本单位是字节。字节流的基类是InputStream类和OutputStream类，它们是抽象类。
字符流是16位Unicode字符流，基本单位是Unicode字符。字符流最适合用来处理字符串和文本，因为它们支持国际上大多数的字符集和语言。字符流的基类是Reader类和Writer类，它们也是抽象类。

InputStream类

InputStream类常用方法：

方法	说明
int read( )	从输入流中读取下一个字节数据
int read(byte[] b)	从输入流中读取数据，并将数据存储在缓冲区数组b中，返回实际读取的字节数。
int read(byte[] b,int off,int len)	从输入流中读取最多len长度的字节，保存到字节数组b中，保存的位置从off开始
void close( )	关闭输入流
int available()	可以从输入流中读取的字节数目

InputStream类的常用子类有FileInputStream，用于从文件中读取数据。
子类FileInputStream常用的构造方法：
FileInputStream(File file);
FileInputStream(String name);
示例四：

import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; public class TestFileInPutSteam { public static void main(String[] args) throws IOException { //        File file = new File("D:/shuju/新建文本文档.txt"); //        FileInputStream fis=new FileInputStream(file); ////        int tmp; ////        while ((tmp=fis.read()) > 0) { ////            System.out.print((char)tmp); ////        }读单个字节 //        byte[] b = new byte[1024]; //        fis.read(b); //        byte[] rst=null; //        for (int i = 0; i < b.length; i++) { //            if (b[i] == 0) { //                rst = Arrays.copyOf(b, i); //                break; //            } //        } //        String str = new String(rst); //        System.out.println(str);//读数组 String s = readByone("D:/shuju/新建文本文档.txt"); System.out.println(s); } public static String readFile(String path) { File f = new File(path); FileInputStream fis=null; String str=null; try { fis=new FileInputStream(f); byte[] b = new byte[fis.available()]; fis.read(b); //            byte[] rst=null; //            for (int i = 0; i < b.length; i++) { //                if (b[i] == 0) { //                    rst = Arrays.copyOf(b, i); //                } //            } str = new String(b); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } finally { try { fis.close(); } catch (IOException e) { e.printStackTrace(); } }return str; } public static String readByone(String path) { FileInputStream fis=null;//赋值，为了下面能看的到，资源关闭 String str=null;//为了被后面看到 try { fis=new FileInputStream(path); StringBuffer sb = new StringBuffer();//String类型不可变 int tmp;//用于接收int类型的字符 while((tmp=fis.read())>0) { char c = (char) tmp;//转成char字符 sb.append(c);//拼接 } str=sb.toString();//转成字符串的形式toString } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } finally { try { fis.close(); } catch (IOException e) { e.printStackTrace(); } }return str; } } 

输出结果：

OutputStream类

OutputStream类常用方法：

方法	说明
void write(int c)	将指定的字节数据写入此输出流中
void write(byte[] buf)	将数组buf中的所有字节写入此输出流中
void write(byte[] b,int off,int len)	将字节数组中从偏移量off开始的长度为len的字节数据输出到输出流中
void close()	关闭输出流
void flush()	强制把缓冲区的数据写到输出流中

OutputStream类的常用子类为FileOutputStream，用于向文件协数据。
子类FileOutputStream常用的构造方法：
FileOutputStream (File file);
FileOutputStream(String name);
FileOutputStream(String name,boolean append);
示例五：

import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class TestOutputStream { public static void main(String[] args) throws IOException { String str = "How do you do.\r\nFine,thank you,and you?\r\nThat's ok!"; //        FileOutputStream fos = new FileOutputStream("def.txt",true);//加一个true，追加 //        byte[] b = str.getBytes(); //        fos.write(b); //        fos.close(); writeFile(str,"text/a/txt",true); } public static void writeFile(String str, String path, boolean isAppend) { File f = new File(path); if (!f.getParentFile().exists()) { f.getParentFile().mkdirs(); } FileOutputStream fos = null; try { fos=new FileOutputStream(f,isAppend); byte[] b=str.getBytes(); fos.write(b); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } finally { try { fos.close(); } catch (IOException e) { e.printStackTrace(); } } } } 

输出结果：
示例六：

import java.io.*; public class text3 { public static void main(String[] args) throws IOException { File file = new File("D:/abce.txt"); FileInputStream fis = null; FileOutputStream fos = null; if (!file.exists()) { System.out.println("文件不存在！"); } try { fis = new FileInputStream(file); fos = new FileOutputStream("D:/shuju/abce.txt"); byte[] words = new byte[fis.available()]; fis.read(words); fos.write(words); System.out.println("复制成功！"); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }finally { fis.close(); fos.close(); } } } 

输出结果：

Reader类的

方法	说明
int read( )	从输入流中读取单个字符，返回所读取的字符数据
int read(char[] c)	从输入流中最多读取c.length个字符，保存到字符数组c中，返回实际读取的字符数
read(char[] c,int off,int len)	从输入流中读取最多len个字符，保存到字符数组c中，保存的位置从off位置开始，返回实际读取的字符数或
void close( )	关闭流

Reader类的常用子类为BufferedReader，接受Reader对象作为参数，并对其添加字符缓冲器。
子类InputStreamReader常用的构造方法：
InputStreamReader(InputStream in);
InputStreamReader(InputStream in,String charsetName);

Writer类

方法	说明
write(String str)	将str字符串里包含的字符输出到指定的输出流中
write(String str,int off,int len)	将str字符串里从off位置开始，长度为len的多个字符输出到输出流中
void close()	关闭输出流
void flush()	刷新输出流

Writer类的常用子类为BufferedWriter，用于将数据缓冲到字符输出流。
子类OutputStreamWriter常用的构造方法：
OutputStreamWriter(OutputStream out);
OutputStreamWriter(OutputStream out,String
注意：
（1）在操作上字节流和字符流有一个区别，字符流在操作时使用了缓冲区（内部存储器），而字节流在操作时直接操作文件，不会使用缓冲区。
（2）所有的这些方法在出现错误时都会抛出IOException异常。charsetName);

总结

绝对路径和相对路径：
绝对路径从根目录开始
相对路径从当前目录开始
FileInputStream读文件的流程：
1、FileInputStream对象和String结果对象声明
2、创建FileInputStream对象（文件路径或File对象）
3、读单字节或整个读到byte数组中
4、转成字符串
5、关闭FileInputStream流
6、返回结果
FileOutputStream写文件的流程：
1、File对象装载文件路径
2、判断文件父级目录是否存在，不存在则创建
3、声明FileOutputStream对象
4、创建FileOutputStream对象（File对象，是否追加）
5、把要写的字符串转成byte数组，并写入输出流
6、关闭FileOutputStream流

本文地址：https://blog.csdn.net/dsjia2970727/article/details/107885086