文件流：输出流：

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个字节。
    */
   /*
       int型的1对应的2进制:00000000 00000000 00000000 00000001
       write(1):写出的1对应2进制的"低八位"
                                  vvvvvvvv
       00000000 00000000 00000000 00000001
                                  写出的字节
  
       write方法调用完毕后，fos.dat中的样子:
       00000001
    */
   fos.write(1);
   /*
       int型的3对应的2进制:00000000 00000000 00000000 00000011
       write(3):写出的3对应2进制的"低八位"
                                  vvvvvvvv
       00000000 00000000 00000000 00000011
                                  写出的字节
  
       write方法调用完毕后，fos.dat中的样子:
       00000001 00000011
    */
   fos.write(3);
  
   System.out.println("写出完毕!");
   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

       第一次调用int d = fis.read()
       读取的是fos.dat文件第一个字节:
       00000001 00000011
       ^^^^^^^^
       读取的字节
  
       read方法返回的int值2进制的样子:00000000 00000000 00000000 00000001
       因此int d = fis.read()之后d的整数为:1
    */
   int d = fis.read();
   System.out.println(d);
   /*
       fos.dat中的样子:
       00000001 00000011
  
       第二次调用d = fis.read()
       读取的是fos.dat文件第二个字节:
       00000001 00000011
                ^^^^^^^^
                读取的字节
  
       read方法返回的int值2进制的样子:00000000 00000000 00000000 00000011
       因此d = fis.read()之后d的整数为:3
    */
   d = fis.read();
   System.out.println(d);
  
   /*
       fos.dat中的样子:
       00000001 00000011
  
       第三次调用d = fis.read()
       读取的是fos.dat文件第三个字节:
       00000001 00000011
                         ^^^^^^^^
                         文件末尾!
  
       read方法返回的int值2进制的样子:11111111 11111111 11111111 11111111
       因此d = fis.read()之后d的整数为:-1
    */
   d = fis.read();
   System.out.println(d);//-1
  
   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字节)，
  之后通过当前流写出的数据会陆续写入文件中保存。

       文件流的两个构造方法为追加模式:
       FileOutPutStream(String path,boolean append)
       FileOutputStream(File file,boolean append)
       如果第二个参数为true，则文件流打开了追加模式。
       当创建文件流时如果指定的文件已经存在，则文件原数据全部保留，通过当前流写出的
       数据会陆续的追加到文件末尾
    */
  

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

    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);

    line = "如果你突然打了个喷嚏，啊~那一定是我在想你";
    data = line.getBytes(StandardCharsets.UTF_8);
    fos.write(data);


    System.out.println("写出完毕!");
    fos.close();

}

}

从文件中读取字符串：

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);

   fis.close();
  

  }
  }

用lambda表达式创建文件过滤器：

package lambda;

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

/**

• 用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<subs.length;i++){
  System.out.println(subs[i].getName());
  }
  }
  }