[学习交流] 【上海校区】java文件与流的应用

文件的操作

绝对路径：从盘符到文件，完整的路径表示形式，d:\data\a.txt

相对路径：就是指由这个文件所在的路径引起的跟其它文件（或文件夹）的路径关系。即相对某一路径下的路径。比如当前在d：/data，要描述d：/datda下的a.txt文件，只需要写a.txt

方法

exists()
createNewFile()
getName()
getPath()
getAbsolutePath()
getParent()
canRead()
canWrite()
isFile()
long lastModified()
long length()
boolean delete()

File目录

目录是一个包含其他文件和路径列表的File 类对象。
即File类主要用来获取文件（或者目录）本身的一些信息，对文件的名字，不涉及对文件内容的操作

方法

判断方法： boolean isDirectory() ；boolean exists()
获得方法： String [] list()； File[] listFiles()
其它方法： mkdir() ；mkdirs()

import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

/** File:文件的操作一*/
public class TestFile {

public static void main(String[] args)  throws IOException{
      //指定绝对路径
      //File f = new File("d:/data/a.txt");
      //没有指定绝对路径，那么相对路径在项目下
      File f = new File("a.txt");
      //父路径，子路径
      //File f = new File("d:/data","a.txt");
      //父路径
//  File f1 = new File("d:/data");
      //File f = new File(f1,"a.txt");

      //文件或目录是否存在
      System.out.println(f.exists());//false

      //新建文件
      f.createNewFile();
      System.out.println(f.exists());//true

      //获得文件名
      /*System.out.println(f.getName());

      //获得路径
      System.out.println(f.getPath());

      //获得绝对路径
      System.out.println(f.getAbsolutePath());

      //获得父路径
      System.out.println(f.getParent());

      //文件是否可读，可写
      System.out.println(f.canRead());
      System.out.println(f.canWrite());

      //判断是否文件
      System.out.println(f.isFile());

      //最后一次修改的时间
      System.out.println(f.lastModified());//1527645016120毫秒
      SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd  hh:mm:ss");
      Date date = new Date(f.lastModified());
      System.out.println(format.format(date));

      //文件内容的长度（字节数 :英文一个字节，汉字两个字节）
      long len = f.length();//"hello"
      System.out.println(len);//5

      //删除文件*/
      f.delete();
}

}
package day24;

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

public class TestFileOutStream {

public static void main(String[] args) throws IOException {
      //输出：String s = "hello" 存到d:/data/b.txt中
      //1.
      //FileOutputStream fout = new  FileOutputStream ("d:/data/b.txt" );

      File f = new File("d:/data/a.txt");
      //添加的内容变为追加而不是覆盖
      FileOutputStream fout = new FileOutputStream(f,true);

      //2.写
      String s = "hello";

      //写一个字节
      fout.write(97);
      //写一个字节数组
      fout.write(s.getBytes());
      //             从什么位置开始，写几个字节
      fout.write(s.getBytes(),2,2);//写“ll”

      //3.关闭
      fout.close();
}

}

/**文件操作示例代码*/
import java.io.File;

/**显示一个文件夹及子文件夹中的所有文件递归  */

public class Ex1 {

//显示目录下的文件
public void show(File f){
      if(f.exists()){
         if(f.isDirectory()){
            File [] fs = f.listFiles();
            if(fs == null){
                  return;
            }
            for(File ff : fs){
                  if(ff.isFile()){
                     System.out.println(ff.getName());
                  }else{
                     System.out.println("-----目录 " + ff.getName());
                     show(ff);//递归，是目录继续展示
                  }
            }
         }else{
            return;
      }
      String [] str = f.list();
}else{
      return ;
}
}

public static void main(String[] args) {
File f = new File("d:/Drivers");
System.out.println(f.exists());
new Ex1 ().show(f);

}
}

文件过滤器

文件名过滤器：
FilenameFilter
文件过滤器
FileFilter

import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;

/**File:目录操作二*/

public class TestFile2 {

public static void main(String[] args) {
      File f = new File("d:/data");
      //文件是否存在
      System.out.println(f.exists());

      //是否是文件夹
      System.out.println(f.isDirectory());

      //创建目录方法一
      //f.mkdir();//父路径存在时，可以创建不存在的目录
      //创建目录方法二
      f.mkdirs();//可以创建不存在的父目录
      //
      System.out.println("---------目录下的文件和目录-------");
      //获得指定路径下的文件和目录名称。String[]
      String [] strs = f.list();
      for(String s : strs){
         System.out.println(s);
      }
      //过滤文件名，过滤出".txt"文本文件       文件名过滤器
/*    String [] strs1 = f.list(new FilenameFilter(){
                  @Override       //父路径                子路径
                  public  boolean accept(File dir, String name){
                     return name.endsWith("txt");
                  }
            });*/
      String [] strs1 = f.list((dir,name) -> name.endsWith("txt"));
      for(String s : strs1){
         System.out.println(s);
      }

      //获得指定目录下的，文件和目录本身的file形式
/*  File[] fs = f.listFiles();
      for(File fi : fs){
         if(fi.isFile()){
            System.out.println(fi.getName());
         }else{
            System.out.println("目录" + fi.getPath());
         }
      }*/

      //过滤文件名，过滤出".txt"文本文件
      File [] fs = f.listFiles(new FileFilter(){
         @Override
         public boolean accept(File pathname){
               return pathname.getName().endsWith("txt");
         }
      });

      for(File fi : fs){
         System.out.println(fi.getName());
      }

}

}

流

Java在java.io包定义多个流类型来实现输入和输出。对文件中的内容进行读写操作的技术。

流可以理解为一组有顺序的额，有起点和终点的动态数据集合

流的分类

按照流的运动方向，分为输入流和输出流
输入流：读，从硬盘的文件中到内存中

   a.txt       到 String s....

输出流：写,存内存到硬盘的文件中

      String s.... 到 a.txt

- 按照数据类型分：字节流，字符流

字节流：一次处理一个字节

字符流：一次处理一个字符

按照功能分为：节点流，处理流

节点流：直接对数据源（文件）读写

处理流（过滤流，包装流）

字节流

以字节为单位对数据进行读写。
字节流由两个抽象类定义：
- InputStream：所有字节输入流的父类
- int read() :从输入流中读取一个字节，到达文件末尾返回-1
- void close():关闭此输入流，并且释放与改流相关的所有资源
- OutputStream ：所有字节输出流的父类
- abstract void write(int b):将指定的字节写入此输入流
- void close关闭此输出流并释放与此流有关的所有资源
字节流包括：
- 文件流
- 转换字符流
- 缓冲流
- 数据流
- 对象流

字节流图解：

1.文件字节流FileInputStream /输入流/ 节点流FileOutputStream /输出流/ 节点流
/**FileInputStream一*/
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

public class TestFileInputStream {

public static void main(String[] args) throws IOException {
         //1.创建流对象
         File f = new File("d:/data/a.txt");
         //字节流
         FileInputStream fin = new FileInputStream(f);

         //2.读数据
         //文件字符大小
         byte [] b = new byte[(int) f.length()];
         fin.read(b);
         //存储到字节数组的其实位置，字节数
         fin.read(b, 1, 2);

         //把字节数组转换成字符串
         String s = new String (b,"gbk");
         System.out.println(s);

         //3.关闭
         fin.close();

}

}

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

/** FileInputStream二 */
public class TeatInputStream {

public static void main(String[] args) throws IOException  {
      //d:/data/a.txt文件内容读出来，在控制台显示
      //输入流 FileInputStream
      //1.创建流对象
   //FileInputStream fin = new FileInputStream("d:/data/a.txt");

      File f = new File("d:/data/a.txt");
      //字节流
      FileInputStream fin = new FileInputStream(f);
      //转换流：字符流  把字节流包装成字符流    一次处理一个字符
      InputStreamReader ir = new InputStreamReader(fin);

      //2.读数据
      /*for(int i = 0 ; i < f.length() ; i ++){
      int temp =fin.read();//读一字节
      System.out.println((char)temp);
      }*/
/*  int temp;
      while ((temp = fin.read()) != -1){
         System.out.println((char)temp);
      }*/

      int temp;
      while ((temp = ir.read()) != -1){
         System.out.println((char)temp);
      }
      //3.关流
      fin.close();
      ir.close();//由内向外关闭

}

}

/FileInputStream示例代码*/

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

public class TestFileInputStream3 {

public static void main(String[] args) {
      //1.创建流对象
      File f = new File("d:/data/a.txt");
      //字节流
      FileInputStream fin = null;
      try {
         fin = new FileInputStream(f);
      //2.读数据
      //文件字符大小
      byte [] b = new byte[(int) f.length()];
      fin.read(b);
      //存储到字节数组的其实位置，字节数
      //fin.read(b, 1, 2);

      //把字节数组转换成字符串
      String s = new String (b,"gbk");
      System.out.println(s);
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      } finally{
      //3.关闭
         if(fin != null){
            try {
                  fin.close();
            } catch (IOException e) {
                  // TODO Auto-generated catch block
                  e.printStackTrace();
            }
         }
      }

}

}

/**字节流示例代码 */

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;

public class Ex3 {

public static void main(String[] args) throws IOException {
      //输入
      Scanner input = new Scanner(System.in);

      FileOutputStream fout  = null;
      //创建
      File f = new File("d:/data/name.txt");
      String name = " ";
      while( ! name .equals("q")){
      System.out.println("请输入姓名");
      name = input.next();
      fout = new FileOutputStream(f,true);
      //读写
      fout.write(name.getBytes());
      fout.write("\r\n".getBytes());
      }
      //关闭
      fout.close();
      input.close();

}

}

中文字出现乱码处理方法（因为一个中文字占两个字节）
1. 转换流 InputStreamReader
2. 把字节数组转换成字符串 resd(byte [])

缓冲流

作用：提高效率

BufferedInputStream
BufferedOutputStream

package day24;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Ex2 {

public static void main(String[] args) throws IOException {

      //1.创建对象
      File f1 = new File("d:/data/aoteman.jpg");
      FileInputStream fin = new FileInputStream(f1);
      //包装进缓冲流
      BufferedInputStream bfin = new BufferedInputStream(fin);//板车

      File f2 = new File("d:/data/aotemannew.jpg");
      FileOutputStream fout = new FileOutputStream(f2);
      BufferedOutputStream bfout= new BufferedOutputStream(fout);//汽车
      //1.读,写

      int temp;
      while ((temp = fin.read()) != -1){
         fout.write(temp);
      }
      bfout.flush();//刷新缓冲区，相当于把汽车的东西运到仓库

      //3.关闭
      fin.close();
      bfin.close();
      fout.close();
      bfout.close();

}

}

数据流

DataInputStream
DataOutputStream

/**数据流示例代码*/

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestDataOutputStream {

public static void main(String[] args) throws IOException {
      //写-----------------------
      File f = new File("d:/data/stu.txt");
      FileOutputStream fout = new FileOutputStream(f);
      DataOutputStream dout = new DataOutputStream(fout);
      int [] no = {11,22,33};

      String [] name = {"aa","bb","cc"};

      for(int i = 0 ; i < no.length ; i ++){
         dout.writeInt(no);
         dout.writeUTF(name);
      }
      dout.close();

      //读-----------------------------------------
      FileInputStream fin = new FileInputStream (f);
      DataInputStream din = new DataInputStream(fin);

      for(int i = 0; i < no.length ; i++){
         System.out.println(din.readInt());
         System.out.println(din.readUTF());
      }
      din.close();

}

}

对象流

永久性地保存对象
1. ObjectOutputStream
2. ObjectInputStream

package day24;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class Student implements Serializable{
private static final long serialVersionUID = 1L;//版本号
private int age;
private int no;
private String name;
public int getNo() {
      return no;
}
public void setNo(int no) {
      this.no = no;
}
public String getName() {
      return name;
}
public void setName(String name) {
      this.name = name;
}
public Student(int no, String name) {
      super();
      this.no = no;
      this.name = name;
}
public Student() {
      super();
      // TODO Auto-generated constructor stub
}

}
public class TestObject {
public static void main(String [] args) throws IOException, ClassNotFoundException{
Student zhangsan = new Student();
zhangsan.setName("张三");
zhangsan.setNo(11);
//想存储对象张三
//序列化：把对象以二进制地形式存储到文件中
//1.
File f = new File("d:/data/student.txt");
FileOutputStream fout = new  FileOutputStream(f);
ObjectOutputStream objOut = new ObjectOutputStream (fout);

//2.写，存
objOut.writeObject(zhangsan);
//3.
objOut.close();

//---------反序列化：从文件中把对象还原出来 ---------读出来，还原--------
//  FileInputStream fin = new FileInputStream(f);
//  ObjectInputStream objIn = new ObjectInputStream(fin);
//
//  //2.读，还原
//  Student stu = (Student)objIn.readObject();
//  System.out.println(stu.getName() + "," + stu.getNo());
//  objIn.close();
}

}

打印输出字节流

PrintStream

package day24;

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

public class TestPrintStream {

public static void main(String[] args) throws IOException {
      //把一个文件地内容读出来，在控制台上显示
      System.out.println("abc");

      //读
      //1.
      FileInputStream fin = new FileInputStream ("d:/data/a.txt");
      //2.
      byte [] b = new byte[fin.available()];//获得流中读取的字节数
      fin.read(b);
      String s = new String(b,"gbk");
      //3.
      fin.close();

      //写PrintStream
      //System.in 键盘输入 System.out控制台输出
      PrintStream p = new PrintStream(System.out);
      p.println("内容"+s);
      p.close();

}

}

package day24;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Scanner;

public class TestScanner {

public static void main(String[] args) throws IOException {
      //Scanner
      //                         键盘输入源
      //                         （数据源）
//    Scanner input = new Scanner(System.in);
//    int n = input.nextInt();
//
//    if(input.hasNextInt()){
//       n = input.nextInt();
//       System.out.println(n);
//    }else{
//       System.out.println("不是整数");
//    }

//
//    FileInputStream fin = new FileInputStream("d:/data/a.txt");
//    //从流中获得数据源
//    Scanner input = new Scanner(fin);
//
//    //获得一行
//    String s = input.nextLine();
//    System.out.println(s);
//
//    fin.close();
//    input.close();

      Scanner input = new Scanner("aaa bb cc dd");
      //String s = input.next();
      String s1 = input.nextLine();
      //System.out.println(s);
      System.out.println(s1);
}

}

========================================================================================================================
字符流字符流的使用
操作字符提高效率。
Reader和Writer
Reader是定义Java的流式字符输入模式的抽象类

int read （）：读一个字符
close（）：关闭字符流

Writer 是定义流式字符输出的抽象类

void close（）：关闭流
void write（int c）throws IOException写入c
3.字符流包括：
文件流
缓冲流
文本输出流

字符流图解：
文件字符流
FileWriter
FileReader
/**读取字符示例代码*/
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Ex1 {

public static void main(String[] args) throws IOException {
      //读取d:/data/a.txt
      //1.
      FileReader fr = new FileReader("d:/data/a.txt");

      //2.读
      int temp1;
      while((temp1 = fr.read()) != -1){
      //System.out.println(temp1);
      System.out.println((char)temp1);
      }

      //
      fr.close();
}

}
缓冲流

/**缓冲流示例代码*/
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class TestBufferReader {

public static void main(String[] args) throws IOException {
      //1
      FileReader fr = new FileReader("d:/data/temp.txt");
      //2.
      BufferedReader bfr = new BufferedReader(fr);

//    String s = bfr.readLine();//读一行
//    System.out.println(s);

      String s;
      while((s= bfr.readLine()) != null){
         System.out.println(s);
      }

      fr.close();

}

}
打印输出字符流

PrintWriter

/**PrintWriter示例代码一：*/
import java.io.FileNotFoundException;
import java.io.PrintWriter;

public class TestPrintWriter {

public static void main(String[] args) throws FileNotFoundException {

      PrintWriter pw = new PrintWriter("d:/data/num.txt");

      for(int i = 0 ; i < 5; i++){
         pw.println(i);
      }

      pw.close();

}

自动资源释放

try（声明要释放资源的流）{

}catch（）{

}

/**自动释放资源示例代码*/
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class TestPrintWriter2 {

public static void main(String[] args) throws IOException {
      //BufferedReader  读一行
      //PrintWriter 写一行
      //try(){}catch(){}自动资源释放，要实现AutoCloseable的才可以

      //1
      //包装一个字符流
      try( BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));
            PrintWriter pw = new PrintWriter("d:/data/name.txt");){

         //2
         String sr; //读到的内容存储
         while(true){
            sr = bfr.readLine();
            if(sr.equals("q")){
                  break;
            }
            pw.print(sr);
         }
      }catch(IOException e){
         System.out.println(e.getMessage());
      }

/*  bfr.close();
      pw.close();*/

}

}

吴琼老师 · 吴琼老师

小影姐姐 · 小影姐姐

牛牛牛！

wuqiong · wuqiong

不二晨 · 不二晨

奈斯

帐号		自动登录	找回密码
密码			加入黑马

[学习交流] 【上海校区】java文件与流的应用

4 个回复