api进阶Day2（低级流）文件流的输出流、读取流。向文件中写入文本数据、读 ...

文件流：输出流：
package io;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**

• JAVA IO 输入与输出  Input和Output
  
• java将读写功能按照方向划分为输入与输出:
  
• 输入负责读取，是从外界进入到我们的程序的方向
  
• 输出负责写出，是从我们的程序到外界的方向
  
• 
  
• java将IO比喻为是"流"，英文是:Stream
  
• 像水流一样，我们向着同一侧方向顺序移动的过程，只不过在java io中我们的流是字节流，流动的是
  
• 字节。
  
• 而这里JAVA的IO流可以想象为是连接我们程序与另一端的"管道"，内部向着同一侧方向顺序移动字节。
  
• 
  
• java.io.InputStream和OutputStream是所有字节输入与输出流的超类，本身是抽象类，不可以
  
• 实例化，里面定义了基本的读写字节的相关方法。
  
• 
  
• 
  
• 文件流
  
• java.io.FileInputStream和FileOutputStream
  
• 文件流是连接文件与程序的管道，负责对文件进行读写的流。
  
• java.io.FileInputStream继承自InputStream，里面定义了读取字节的相关方法。
  
• java.io.FileOutputStream继承自OutputStream，里面定义了写出字节的相关方法。
  /
  public class FOSDemo {
  public static void main(String[] args) throws IOException {
  //向当前项目目录中的文件fos.dat中写入字节数据
  //上述需求中的关键词：文件，写  应当使用文件输出流。
  FileOutputStream fos = new FileOutputStream("./fos.dat");//alt+回车  选择Add exception....
  /
  java.io.OutputStream超类上定义了写出一个字节的方法:
  void write(int d)
  写出一个字节，写出的是给定的int值对应的2进制的"低八位"
  1.      文件流实现了上述方法，作用是向文件中写入1个字节。
  2.   */
  3. /*
  4.      int型的1对应的2进制:00000000 00000000 00000000 00000001
  5.      write(1):写出的1对应2进制的"低八位"
  6.                                 vvvvvvvv
  7.      00000000 00000000 00000000 00000001
  8.                                 写出的字节
  10.      write方法调用完毕后，fos.dat中的样子:
  11.      00000001
  12.   */
  13. fos.write(1);
  14. /*
  15.      int型的3对应的2进制:00000000 00000000 00000000 00000011
  16.      write(3):写出的3对应2进制的"低八位"
  17.                                 vvvvvvvv
  18.      00000000 00000000 00000000 00000011
  19.                                 写出的字节
  21.      write方法调用完毕后，fos.dat中的样子:
  22.      00000001 00000011
  23.   */
  24. fos.write(3);
  26. System.out.println("写出完毕!");
  27. fos.close();//流使用完毕要关闭来释放资源

  复制代码
  }
  }
  

文件流：读取流：
package io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**

• 文件输入流，用于从文件中读取字节数据
  /
  public class FISDemo {
  public static void main(String[] args) throws IOException {
  //将当前项目目录下的fos.dat文件读取回来
  FileInputStream fis = new FileInputStream("fos.dat");
  /
  java.io.InputStream超类上定义了读取一个字节的方法:
  int read()
  读取1个字节，并将对应的2进制存入返回的int值的"低八位"上，而高24位2进制全部
  补0.
  如果返回值为int型的整数-1，则表达读取到了流的末尾
  /
  /
  fos.dat中的样子:
  00000001 00000011
  1.      第一次调用int d = fis.read()
  2.      读取的是fos.dat文件第一个字节:
  3.      00000001 00000011
  4.      ^^^^^^^^
  5.      读取的字节
  7.      read方法返回的int值2进制的样子:00000000 00000000 00000000 00000001
  8.      因此int d = fis.read()之后d的整数为:1
  9.   */
  10. int d = fis.read();
  11. System.out.println(d);
  12. /*
  13.      fos.dat中的样子:
  14.      00000001 00000011
  16.      第二次调用d = fis.read()
  17.      读取的是fos.dat文件第二个字节:
  18.      00000001 00000011
  19.               ^^^^^^^^
  20.               读取的字节
  22.      read方法返回的int值2进制的样子:00000000 00000000 00000000 00000011
  23.      因此d = fis.read()之后d的整数为:3
  24.   */
  25. d = fis.read();
  26. System.out.println(d);
  28. /*
  29.      fos.dat中的样子:
  30.      00000001 00000011
  32.      第三次调用d = fis.read()
  33.      读取的是fos.dat文件第三个字节:
  34.      00000001 00000011
  35.                        ^^^^^^^^
  36.                        文件末尾!
  38.      read方法返回的int值2进制的样子:11111111 11111111 11111111 11111111
  39.      因此d = fis.read()之后d的整数为:-1
  40.   */
  41. d = fis.read();
  42. System.out.println(d);//-1
  44. fis.close();

  复制代码
  }
  }
  

向文件中写入文本数据：
package io;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
/**

• 向文件中写入文本数据
  /
  public class WriteStringDemo {
  public static void main(String[] args) throws IOException {
  //向文件fos.txt中写入字符串
  /
  文件流的两个构造方法默认为覆盖模式:
  FileOutPutStream(String path)
  FileOutputStream(File file)
  上述两个构造器创建时，如果指定的文件已经存在了，则会将该文件清空(变成0字节)，
  之后通过当前流写出的数据会陆续写入文件中保存。
  1.      文件流的两个构造方法为追加模式:
  2.      FileOutPutStream(String path,boolean append)
  3.      FileOutputStream(File file,boolean append)
  4.      如果第二个参数为true，则文件流打开了追加模式。
  5.      当创建文件流时如果指定的文件已经存在，则文件原数据全部保留，通过当前流写出的
  6.      数据会陆续的追加到文件末尾
  7.   */

  复制代码

//        File file = new File("fos.txt");
//        FileOutputStream fos = new FileOutputStream(file);

1.     FileOutputStream fos = new FileOutputStream("fos.txt",true);

复制代码

//        String line = "爱你孤身走暗巷";
String line = "爱你~";
/*
String提供的方法:
byte[] getBytes(Charset charset)
将当前字符串按照指定的字符集转换为一组字节
*/
byte[] data = line.getBytes(StandardCharsets.UTF_8);
fos.write(data);

1.     line = "如果你突然打了个喷嚏，啊~那一定是我在想你";
2.     data = line.getBytes(StandardCharsets.UTF_8);
3.     fos.write(data);
6.     System.out.println("写出完毕!");
7.     fos.close();
9. }

复制代码

}
从文件中读取字符串：
package io;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
/**

• 从文件中读取字符串
  /
  public class ReadStringDemo {
  public static void main(String[] args) throws IOException {
  //将fos.txt文件中所有字符读取回来
  File file = new File("fos.txt");
  /
  FileInputStream(String path)
  FileInputStream(File file)
  /
  FileInputStream fis = new FileInputStream(file);
  byte[] data = new byte[(int)file.length()];
  fis.read(data);
  /
  String提供的构造器
  String(byte[] data,Charset charset)
  将给定的字节数组data中所有的字节按照给定的字符集charset转换为一个字符串
  */
  String line = new String(data, StandardCharsets.UTF_8);
  System.out.println(line);
  1. fis.close();

  复制代码
  }
  }
  

用lambda表达式创建文件过滤器：
package lambda;
import java.io.File;
import java.io.FileFilter;
/**
<ul>用lambda表达式创建文件过滤器

获取当前项目目录下名字中含有字母o的所有子项
*/
public class Test {
public static void main(String[] args) {
File dir = new File(".");
File[] subs = dir.listFiles(file -> file.getName().contains("o"));
for(int i=0;i