Java第十七课_IO流和线程

1.IO流

• 序列化

  public class Practice01 {
  
      public static void main(String[] args) throws IOException, ClassNotFoundException {
          // 一个数据            用变量
          // 多个同类型数据      用数组
          // 多个不类型数据      用对象
          // 多个对象           用对象数组 / 集合
  
          // 序列化 :
          writeObjectToFile(new User("lisi", 20, 0), "user.txt");
          User user = readObjectFromFile(User.class, "user.txt");
          System.out.println(user);
      }
  
      public static <T> T readObjectFromFile(Class<T> clazz,String fileName) throws IOException, ClassNotFoundException {
          ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(fileName));
          T t = (T) objectInputStream.readObject();
          objectInputStream.close();
          return t;
      }
  
      public static <T> void writeObjectToFile(T t, String fileName) throws IOException {
          ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(fileName));
          objectOutputStream.writeObject(t);
          objectOutputStream.close();
      }
  }
  
  public class User implements Serializable{
  
      //IO流项目中, 类都要实现Serializable(包括类中类等), 并声明一个固定的serialVersionUID.
      //      每次运行时随机分配UID的话, 可能会导致过程中类文件变动后, 找不到序列号错误
      private static final long serialVersionUID = 1024L;
  
      private String name;
      private int age;
      private double height;
      private Date birthday;
      private Fimaly fimaly = new Fimaly();
  
      public User() {
      }
  
      public User(String name, int age, double height) {
          this.name = name;
          this.age = age;
          this.height = height;
      }
  
      @Override
      public String toString() {
          return "User{" +
                  "name='" + name + '\'' +
                  ", age=" + age +
                  ", height=" + height +
                  ", birthday=" + birthday +
                  ", fimaly=" + fimaly +
                  '}';
      }
  }
  
  public class Fimaly implements Serializable {
  
      private static final long serialVersionUID = 125L;
  }
  

• 字符流

      public static void main(String[] args) throws IOException {
          // 字符流 每次读写一个字符,只能操作文本文件
  		// 字符流只可以用于字符, 读写其他资源时因为格式不同, 会乱码
          
          // Writer : 可以直接写入字符
          //      OutputStreamWriter 是字符流通向字节流的桥梁
          Writer writer = new OutputStreamWriter(new FileOutputStream("a.txt"));
          writer.write('话');
          writer.write('A');
          writer.write('B');
          writer.write('C');
          char[] chars = "华夏ABC".toCharArray();
          writer.write(chars);
          writer.write(chars, 0, 4);
          writer.close();
          System.out.println("-------------------------------");
  
          // Reader : 读出时不管字符几个字节, 会一个字符一个字符读出.
          //  InputStreamReader 是字节流通向字符流的桥梁
          Reader reader = new InputStreamReader(new FileInputStream("a.txt"));
  
          int read = reader.read();// 输出值为int, 只能看到字符的int值
          System.out.println("read = " + read);
          System.out.println((int) '话');
          read = reader.read();
          System.out.println("read = " + read);
  
          char[] chars1 = new char[6];// 常规用法是利用字符数组
          int len = reader.read(chars1);
          System.out.println("len = " + len);
          System.out.println("Arrays.toString(chars1) = " + Arrays.toString(chars1));
          len = reader.read(chars1);
          System.out.println("len = " + len);
          System.out.println("Arrays.toString(chars1) = " + Arrays.toString(chars1));// 只剩四个字符, 只覆盖前四个成员
          len = reader.read(chars1);
          System.out.println("len = " + len);
          System.out.println("Arrays.toString(chars1) = " + Arrays.toString(chars1));// 无剩余字符, 返回-1, 不会覆盖
          reader.close();
      }
  

• 字符集

      public static void main(String[] args) throws IOException {
          // 字符IO流可以设定文件中字符的格式. 但是如果设定了和字符不同的字符集, 就会出现乱码
          InputStreamReader inputStreamReader =
                  new InputStreamReader(new FileInputStream("a.txt"), "GBK");
  
          // Writer默认覆盖之前的内容, 如果想追加, 需要将参数设为true
          OutputStreamWriter outputStreamWriter =
                  new OutputStreamWriter(new FileOutputStream("a.txt", true), StandardCharsets.UTF_8);
  
          int len ;
          char[] chars = new char[1024];
          while ((len = inputStreamReader.read(chars)) != -1) {
              outputStreamWriter.write(chars, 0, len);
          }
          outputStreamWriter.close();
          inputStreamReader.close();
      }
  

• 便捷流

      public static void main(String[] args) throws IOException {
          // 便捷流 : 不再需要new FileIO的桥梁, 可以直接给文件名(类内部自己有new FileIO)
          // FileReader
          // FileWriter
          FileReader fileReader = new FileReader("a.txt");
          FileWriter fileWriter = new FileWriter("b.txt");
  
          int len;
          char[] chars = new char[1024];
  
          while ((len = fileReader.read(chars)) != -1) {
              fileWriter.write(chars, 0, len);
          }
          fileWriter.close();
          fileReader.close();
      }
  

• 字符缓冲流

      public static void main(String[] args)throws IOException {
          // 字符缓冲流
          // BufferedReader
          // BufferedWriter
          BufferedReader bufferedReader = new BufferedReader(new FileReader("b.txt"));
          BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("a.txt"));
  
          String info = bufferedReader.readLine();
          while (info != null) {
              bufferedWriter.write(info);
              bufferedWriter.newLine();
              bufferedWriter.flush();
              info = bufferedReader.readLine();
          }
  
          bufferedWriter.close();
          bufferedReader.close();
      }
  

• 便捷输出流

      public static void main(String[] args) throws FileNotFoundException {
          // 便捷输出流 :
          // PrintStream
          PrintStream printStream = new PrintStream(new FileOutputStream("e.txt", true));
  
          // 从键盘接收数据写入文件
          System.out.println("请输入数据(输入exit退出)");
          Scanner scanner = new Scanner(System.in);
  
          while (true) {
              String info = scanner.next();
              if ("exit".equals(info)) {
                  break;
              }
              printStream.println(info);
              printStream.flush();
          }
          printStream.close();
  
          System.out.println("---------------------");
          // PrintWriter
          PrintWriter pw = new PrintWriter(new FileOutputStream("exception.txt"), true);
  
          try {
              System.out.println(10/0);
          } catch (Exception e) {
              e.printStackTrace(pw);
          }
      }
  

• IO流阻塞

      public static void main(String[] args) throws IOException {
          // IO流阻塞 : 让IO流, 在其他任务(如System.in, 等用户先输入数据)完成后再IO
          System.out.println("请输入");
          InputStream inputStream = System.in;
          BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
          String line = bufferedReader.readLine();
          System.out.println("line = " + line);
  
          int num = 0;
          try {
              num = Integer.parseInt(line);
          } catch (NumberFormatException e) {
              throw new InputMismatchException(e.getMessage() + " 不是数字! ");
          }
          System.out.println("num = " + num);
          bufferedReader.close();
          inputStream.close();
      }
  

2.线程

• 线程01

      public static void main(String[] args) {
          // 程序/软件 : 静态的,不会自己运行的,是一堆指令,存在于硬盘上的.
          // 进程 : 程序的一次运行 , 也就是运行中的程序
          // 线程 : 进程执行过程中的分支 , 主进程也称为 主线程
  
          // Thread 线程类. 三种方式:
          //      1.类继承Thread, 并重写run函数(在run中定义任务)
          MyThread01 myThread01 = new MyThread01();
          myThread01.start();// 启动线程
  
  
          //      2(常用).类实现Runnable接口,  并重写run函数(在run中定义任务)
          MyThread02 myThread02 = new MyThread02();
          Thread thread = new Thread(myThread02);
          thread.start();
  
          for (int i = 0; i < 10; i++) {
              System.out.println("main : i = " + i);
          }
  
          // 每个线程都有自己默认的名字 :  Thread-0   -1 -2 ... 主线程是main
          //      可以在各个线程里调用Thread.currentThread()的功能
          for (int i = 100; i < 110; i++) {
              System.out.println(Thread.currentThread().getName() + "  ~~~~~~~~~  i = " + i);
          }
      }
  
  public class MyThread01 extends Thread{
  
      @Override
      public void run() {
          for (int i = 0; i < 10; i++) {
              System.out.println("MyThread01 : i = " + i);
          }
      }
  }
  
  public class MyThread02 implements Runnable{
  
      @Override
      public void run() {
          for (int i = 0; i < 10; i++) {
              System.out.println("MyThread02 : i = " + i);
          }
      }
  }
  

• 线程02

      public static void main(String[] args) throws InterruptedException {
          // 线程应该用继承还是实现?
          // 1.类与类之间单继承,类与接口之间多实现
          // 2.继承不会共享数据 , 实现可以共享数据
  
          class MyThreadA extends Thread{
              int count = 8;
              @Override
              public void run() {
                  while (count > 0) {
                      System.out.println(Thread.currentThread().getName() + " :: " + count--);
                  }
              }
          }
          MyThreadA myThreadA1 = new MyThreadA();
          MyThreadA myThreadA2 = new MyThreadA();
          // 同一个线程只能启动一次 , 否则 会有 IllegalThreadStateException
          // 开两个线程就要创建两个对象, 各自start
          myThreadA1.start();
          myThreadA2.start();
  
          MyThreadB myThreadB = new MyThreadB();// 实现可以共享数据
          Thread thread1 = new Thread(myThreadB);
          Thread thread2 = new Thread(myThreadB);
          thread1.start();
          thread2.start();
      }
  
      static class MyThreadB implements Runnable{
          int count = 8;
          @Override
          public void run() {
              while (count > 0) {
                  System.out.println(Thread.currentThread().getName() + " :: " + count--);
              }
          }
      }
  

• 线程优先级

      public static void main(String[] args) {
          // 线程优先级 : 1~10 , 默认为 5
  		// 开发中一般没用, 不会体现.(可能是因为资源充足, 等资源急缺时, 才会体现优先级)
          
          class MyThread implements Runnable{
              @Override
              public void run() {
                  for (int i = 0; i < 20; i++) {
                      System.out.println(Thread.currentThread().getName() + " :: " + Thread.currentThread().getPriority());
                  }
              }
          }
  
          Thread thread1 = new Thread(new MyThread());
          Thread thread2 = new Thread(new MyThread());
          thread1.setName("郭靖");
          thread2.setName("黄蓉^_^");
  
          thread1.setPriority(Thread.MIN_PRIORITY);
          thread2.setPriority(Thread.MAX_PRIORITY);
  
          thread1.start();// 没有体现.
          thread2.start();
      }
  

• 守护线程

      public static void main(String[] args) {
          // 守护线程 : 当所有的用户线程结束时 , 守护线程随之结束
          // 一般线程都默认为用户线程(包括主函数)
  
          Thread thread = new Thread(new Runnable() {
              @Override
              public void run() {
                  while (true) {
                      System.out.println("run forever ......");
                  }
              }
          });
          // 设为守护线程
          thread.setDaemon(true);
          thread.start();
  
          for (int i = 0; i < 20; i++) {
              System.out.println(Thread.currentThread().getName() + "  ::  " + i);
              System.out.println("thread.isDaemon() = " + thread.isDaemon());
              System.out.println("Thread.currentThread().isDaemon() = " + Thread.currentThread().isDaemon());
          }// 主函数结束后守护线程还要跑一会再结束
      }
  

• 正确的停止线程的方式

      public static void main(String[] args) {
          // 正确的停止线程的方式 :
          class MyThread implements Runnable{
              private boolean flag = true;
  
              @Override
              public void run() {
                  while (flag) {
                      System.out.println("run forever..... ");
                  }
              }
  
              public boolean isFlag() {
                  return flag;
              }
  
              public void setFlag(boolean flag) {
                  this.flag = flag;
              }
          }
          MyThread myThread = new MyThread();
          new Thread(myThread).start();
  
          for (int i = 0; i < 20; i++) {
              if (i == 10) {
                  myThread.setFlag(false);
                  System.out.println("杀死了线程..........");
              }
              System.out.println(Thread.currentThread().getName() + " :: " + i);
          }
      }