java文件与流

Hello 帅帅 2021-02-05

532

File类

java.io.File
类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。

构造方法

无论构造方法路径下是否存在文件或者目录，都不影响File对象的创建。

public File(String pathname)

 File f1 = new File("C:\\src\\com\\company\\Main.java");

public File(String parent, String child)

 File f2=new File("C:\\src\\com\\company","Main.java");

public File(File parent, String child)

 File f3=new File(new File("C:\\src\\com\\company"),"Main.java");

public File(URI uri)

 File f4=new File("https://www.runoob.com/");

常用方法

文件获取

public String getAbsolutePath()
：返回此File的绝对路径名字符串。
public String getPath()
：将此File转换为路径名字符串。
public String getName()
：返回由此File表示的文件或目录的名称。
public long length()
：返回由此File表示的文件的长度。

 private static void demo2() {
     File f = new File("C:\\Users\\zs\\IdeaProjects\\filestream\\src\\com\\company\\Main.java");
     System.out.println("文件绝对路径:"+f.getAbsolutePath());
     System.out.println("文件构造路径:"+f.getPath());
     System.out.println("文件名称:"+f.getName());
     System.out.println("文件长度:"+f.length()+"字节" + "\n");
 
     //不存在此路径
     File f2 = new File("c:/xxx");
     System.out.println("目录绝对路径:"+f2.getAbsolutePath());
     System.out.println("目录构造路径:"+f2.getPath());
     System.out.println("目录名称:"+f2.getName());
     System.out.println("目录长度:"+f2.length() + "\n");
 
     File f3 = new File("file1.txt");
     System.out.println("目录绝对路径:"+f3.getAbsolutePath());
     System.out.println("目录构造路径:"+f3.getPath());
     System.out.println("文件（目录）名称:"+f3.getName());
     System.out.println("目录长度:"+f3.length() + "\n");
 }

输出：

 文件绝对路径:C:\Users\zs\IdeaProjects\filestream\src\com\company\Main.java
 文件构造路径:C:\Users\zs\IdeaProjects\filestream\src\com\company\Main.java
 文件名称:Main.java
 文件长度:1574字节
 
 目录绝对路径:c:\xxx
 目录构造路径:c:\xxx
 目录名称:xxx
 目录长度:0
 
 目录绝对路径:C:\Users\zs\IdeaProjects\filestream\file1.txt
 目录构造路径:file1.txt
 文件（目录）名称:file1.txt
 目录长度:13

文件判断

public boolean exists()
：此File表示的文件或目录是否实际存在。
public boolean isDirectory()
：此File表示的是否为目录。
public boolean isFile()
：此File表示的是否为文件。

 private static void demo3() {
     File f1 = new File("C:\\Users\\zs\\IdeaProjects");
     File f2 = new File("C:\\Users\\zs\\IdeaProjects2");
     File f3 = new File("file1.txt");
 
     System.out.print(f1.exists()+ "  ");
     System.out.print(f1.isDirectory()+ "  ");
     System.out.println(f1.isFile());
 
     System.out.print(f2.exists()+ "  ");
     System.out.print(f2.isDirectory()+ "  ");
     System.out.println(f2.isFile());
 
     System.out.print(f3.exists()+ "  ");
     System.out.print(f3.isDirectory()+ "  ");
     System.out.println(f3.isFile());
 }

输出：

 true  true  false
 false  false  false
 true  false  true

文件创建与删除

public boolean createNewFile()
：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
public boolean delete()
：删除由此File表示的文件或目录。
public boolean mkdir()
：创建由此File表示的目录。
public boolean mkdirs()
：创建由此File表示的目录，包括任何必需但不存在的父目录。

代码：

 private static void demo4() {
         File f1=new File("myfile1.txt");
         File f2=new File("myfile2.txt");
         File d1=new File("dir1");
         File d2=new File("dir2\\dir2");
 
         try {
             boolean newFile1 = f1.createNewFile();
             if(newFile1){
                 System.out.println("创建文件成功");
             }
             boolean newFile2 = f2.delete();
             if(newFile2){
                 System.out.println("删除文件成功");
             }
             d1.mkdir();
             d2.mkdirs();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }

初始：

执行后：

目录的遍历

普通遍历

public String[] list()
：返回一个String数组，表示该File目录中的所有子文件或目录。

public File[] listFiles()
：返回一个File数组，表示该File目录中的所有的子文件或目录。

 public class FileFor {
     public static void main(String[] args) {
         File dir = new File("C:\Users\zs\IdeaProjects\filestream");
       
         //获取当前目录下的文件以及文件夹的名称。
         String[] names = dir.list();
         for(String name : names){
             System.out.println(name);
         }
         File[] files = dir.listFiles();
         for (File file : files) {
             System.out.println(file);
         }
     }
 }

小贴士：
调用listFiles方法的File对象，表示的必须是实际存在的目录，否则返回null，无法进行遍历。

递归遍历

 public class Main2 {
     public static void main(String[] args) {
         printDirect(new File("C:\\Users\\zs\\IdeaProjects\\filestream"));
     }
     public static void  printDirect(File dir) {
         File[] files = dir.listFiles();
         for (File file : files) {
             if (file.isFile()) {
                 System.out.println("文件:"+ file.getAbsolutePath());
             } else {
                 System.out.println("目录:"+file.getAbsolutePath());
                 printDirect(file);
             }
         }
     }
 }

文件搜索

java.io.FileFilter
是一个接口，是File的过滤器。该接口的对象可以传递给File类的listFiles(FileFilter)
作为参数，接口中只有一个方法。

boolean accept(File pathname)
：测试pathname是否应该包含在当前File目录中，符合则返回true。

 public static void printDirect2(File dir) {
     File[] files = dir.listFiles(f ->{
         return f.getName().endsWith(".java") || f.isDirectory();
     });
     for (File file : files) {
         if (file.isFile()) {
             System.out.println("文件名:" + file.getAbsolutePath());
         } else {
             printDirect2(file);
         }
     }
 }

字节流

概念

根据数据的流向分为：输入流和输出流。

输入流 ：把数据从其他设备上读取到内存中的流。
输出流 ：把数据从内存中写出到其他设备上的流。

格局数据的类型分为：字节流和字符流。

字节流 ：以字节为单位，读写数据的流。
字符流 ：以字符为单位，读写数据的流。

	输入流	输出流
字节流	字节输入流InputStream	字节输出流OutputStream
字符流	字符输入流Reader	字符输出流Writer

OutputStream与FileOutputStream

构造函数与常用方法

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)
：将指定的字节输出流。

FileOutputStream构造方法:

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。

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

文件写入

写出字节数据：

 public class Main3 {
     public static void main(String[] args) {
         try (OutputStream fos = new FileOutputStream("file1.txt")) {
             byte[] bs = {97, 98, 99, 100};
             String s="\r\n12345676543212";
 //            写入单个byte
             fos.write(97);
             fos.write(98);
             fos.write(99);
             fos.write(100);
 //            写入byte数组
             fos.write(bs);
 //            写入byte数组，并设置好偏移位与长度
             fos.write(bs,1,2);
 //            将字符串转换为字符数组
             fos.write(s.getBytes());
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 }

追加续写：

 private static void demo2() {
     try (OutputStream fos = new FileOutputStream("file1.txt",true)) {
         String s="\r\n12345676543212";
         fos.write(s.getBytes());
     } catch (IOException e) {
         e.printStackTrace();
     }
 }

InputStream与FileInputStream

构造函数与常用方法

java.io.InputStream
抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

public void close()
：关闭此输入流并释放与此流相关联的任何系统资源。
public abstract int read()
：从输入流读取数据的下一个字节。
public int read(byte[] b)
：从输入流中读取一些字节数，并将它们存储到字节数组 b中

读取字节数据

     private static void demo2() {
         try (FileInputStream fis = new FileInputStream("file1.txt");) {
             // 定义变量，保存数据
             byte[] b = new byte[2];
             int len;
             while ((len = fis.read(b)) != -1) {
                 System.out.print(new String(b, 0, len));
             }
         } catch (IOException e) {
             e.printStackTrace();
         }
     }

图片文件传输

 private static void demo3() {
     try (FileInputStream fis = new FileInputStream("英国.gif"); FileOutputStream fos=new FileOutputStream("English.gif")) {
         // 定义变量，保存数据
         byte[] b = new byte[100];
         int len;
         while ((len = fis.read(b)) != -1) {
             fos.write(b,0,len);
         }
     } catch (IOException e) {
         e.printStackTrace();
     }
 }

字符流

java.io.Reader
抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。

java.io.FileReader
类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。

Reader与FileReader

读取字符数据

     private static void demo1() {
         try (Reader r = new FileReader("read1.txt")) {
             int len;
             char[] buf = new char[5];
             while ((len = r.read(buf)) != -1) {
                 System.out.print(new String(buf, 0, len));
             }
         } catch (IOException e) {
             e.printStackTrace();
         }
     }

Writer与FileWriter

写出字符数组 ：write(char[] cbuf)
和 write(char[] cbuf, int off, int len)
，每次可以写出字符数组中的数据，用法类似FileOutputStream。
写出字符串：write(String str)
和 write(String str, int off, int len)
，每次可以写出字符串中的数据，更为方便。

基本写出数据

 private static void demo2() {
     try (FileWriter r = new FileWriter("read2.txt",true)) {
         String s="长风破浪会有时";
         r.write(s);
     } catch (IOException e) {
         e.printStackTrace();
     }
 }

因为内置缓冲区的原因，如果不关闭输出流，无法写出字符到文件中。但是关闭的流对象，是无法继续写出数据的。如果我们既想写出数据，又想继续使用流，就需要flush
方法了。

flush
：刷新缓冲区，流对象可以继续使用。
close
:先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

属性集

概述

java.util.Properties
继承于Hashtable
，来表示一个持久的属性集。它使用键值结构存储数据，每个键及其对应值都是一个字符串。该类也被许多Java类使用，比如获取系统属性时，System.getProperties
方法就是返回一个Properties
对象。

构造方法：

public Properties()
:创建一个空的属性列表。

基本方法：

public Object setProperty(String key, String value)
：保存一对属性。
public String getProperty(String key)
：使用此属性列表中指定的键搜索属性值。
public Set<String> stringPropertyNames()
：所有键的名称的集合。

例：

新建read.properties文件

 name=wenwen
 age=18
 date=2020-10-10

读取：

 private static void demo2() throws IOException {
     Properties pro = new Properties();
     // 加载文本中信息到属性集
     pro.load(new FileInputStream("read.properties"));
     // 遍历集合并打印
     Set<String> strings = pro.stringPropertyNames();
     for (String key : strings ) {
         System.out.println(key+" -- "+pro.getProperty(key));
     }
 }

缓冲流

缓冲流,也叫高效流，是对4个基本的FileXxx
流的增强，所以也是4个流，按照数据类型分类：

字节缓冲流：BufferedInputStream
，BufferedOutputStream
字符缓冲流：BufferedReader
，BufferedWriter

缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

字节缓冲流复制视频：

 private static void demo1() {
     try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("movie.mp4"));
          BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("movie2.mp4"))
     ) {
         int len;
         byte[] b = new byte[1024];
         while ((len = bis.read(b)) != -1) {
             bos.write(b, 0, len);
         }
     } catch (IOException e) {
         e.printStackTrace();
     }
 }

字符缓冲流的基本方法与普通字符流调用方式一致，不过有特有。

BufferedReader：public String readLine()
: 读一行文字。
BufferedWriter：public void newLine()
: 写一行分隔符,由系统属性定义符号。

转换流

转换流java.io.InputStreamReader
，是Reader的子类，是从字节流到字符流的桥梁。它读取字节，并使用指定的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。

InputStreamReader构造方法

InputStreamReader(InputStream in)
: 创建一个使用默认字符集的字符流。
InputStreamReader(InputStream in, String charsetName)
: 创建一个指定字符集的字符流。

构造举例，代码如下：

 InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
 InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");

转换流java.io.OutputStreamWriter
，是Writer的子类，是从字符流到字节流的桥梁。使用指定的字符集将字符编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。

OutputStreamWriter构造方法

OutputStreamWriter(OutputStream in)
: 创建一个使用默认字符集的字符流。
OutputStreamWriter(OutputStream in, String charsetName)
: 创建一个指定字符集的字符流。

构造举例，代码如下：

 OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
 OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");

序列化流

概述

Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。对象的数据、对象的类型和对象中存储的数据信息，都可以用来在内存中创建对象。

注：可序列化的类必须在类定义的时候实现Serializable接口

Baby：

创建一个Baby对象

WriteObject（序列化）：

创建一个baby对象
创建文件输出流
打开一个对象输出流
将baby对象写入

ReadObject（反序列化）：

创建文件输入流
打开一个对象输入流
读取出baby对象

Baby

 package com.company;
 import java.io.Serializable;
 
 public class Baby implements Serializable {
     private String name;
     private int age;
     public Baby(String name, int age) {
         this.name = name;
         this.age = age;
     }
 
     public String getName() {
         return name;
     }
 
     public void setName(String name) {
         this.name = name;
     }
 
     public int getAge() {
         return age;
     }
 
     public void setAge(int age) {
         this.age = age;
     }
 
     @Override
     public String toString() {
         return "Baby{" +
                 "name='" + name + '\'' +
                 ", age=" + age +
                 '}';
     }
 }

WriteObject

 package com.company;
 
 import java.io.FileOutputStream;
 import java.io.ObjectOutputStream;
 
 class WriteObject {
     public static void main(String[] args) throws Exception {
         Baby baby = new Baby("Xiaowenwen", 23);
         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Baby.txt"));
         oos.writeObject(baby);
         oos.close();
     }
 }

ReadObject

 package com.company;
 
 import java.io.FileInputStream;
 import java.io.ObjectInputStream;
 
 public class ReadObject {
     public static void main(String[] args) throws Exception {
         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("Baby.txt"));
         Baby brady = (Baby) ois.readObject();
         System.out.println(brady);
         ois.close();
     }
 }

打印流

构造方法

public PrintStream(String fileName)
：使用指定的文件名创建一个新的打印流。

构造举例，代码如下：

 PrintStream ps = new PrintStream("ps.txt")；

改变打印流向

System.out
就是PrintStream
类型的，只不过它的流向是系统规定的，打印在控制台上。不过，既然是流对象，我们就可以玩一个"小把戏"，改变它的流向。

 public static void main(String[] args) throws FileNotFoundException {
     System.out.println("Hello");
     PrintStream ps = new PrintStream("请打印到我这里.txt");
     System.setOut(ps);
     System.out.println("看不见我了吧");
 }

java

文章转载自Hello 帅帅，如果涉嫌侵权，请发送邮件至：contact@modb.pro进行举报，并提供相关证据，一经查实，墨天轮将立刻删除相关内容。

java文件与流

File类

构造方法

常用方法

文件获取

文件判断

文件创建与删除

目录的遍历

普通遍历

递归遍历

文件搜索

字节流

概念

OutputStream与FileOutputStream

构造函数与常用方法

文件写入

InputStream与FileInputStream

构造函数与常用方法

读取字节数据

字符流

Reader与FileReader

Writer与FileWriter

属性集

概述

缓冲流

转换流

InputStreamReader构造方法

OutputStreamWriter构造方法

序列化流

概述

打印流

构造方法

改变打印流向

评论