Java期末根据提纲复习（四）

23）FileReader和FileWriter，使用字符数组，注意追加模式
a. FileReader构造方法
a) FileReader(File file)
b) FileReader(String fileName)
b. FileReader重要方法
a) public int read() throws IOException 读取单个字符，返回一个int型变量代表读取到的字符
b) public int read(char [] c, int offset, int len) 读取字符到c数组，返回读取到字符的个数
c. FileWriter构造方法
a) FileWriter(File file)
b) FileWriter(File file, boolean append)
c) FileWriter(String fileName, boolean append)
d. FileWriter重要方法
a) public void write(int c) throws IOException
b) public void write(char [] c, int offset, int len)
c) public void write(String s, int offset, int len)
（参考：https://blog.csdn.net/qq_36765367/article/details/79666651）
用FileReader(String fileName)方法:

import java.io.*;
public class Test1{
public static void main(String[] args) throws IOException { 
 // TODO Auto-generated method stub 
 /**          * 测试：FileReader类的使用          */   
 FileReader fr = new FileReader("D:/abc.txt");
 /**          * 用Reader中的read方法读取字符。          */ 
 int ch = 0;   
 while((ch = fr.read()) != -1){ 
  System.out.print((char)ch); 
  }       
 fr.close();
 }
}

其中

 while((ch = fr.read()) != -1){ 
  System.out.print((char)ch); 

这两句很常用
FileReader(File file)这个方法好像不常见，没有找到一个应用的例子
代码出处

import java.io.*;
public class Test2 {
 private static final String LINE_SEPARATOR = System.getProperty("line.separator");
 //定义全局换行符 
 public static void main(String[] args) throws IOException { 
  // TODO Auto-generated method stub  
  /**      
   * 创建一个可以往文件中写入字符数据的字符流输出流对象     
   * 创建时必须明确文件的目的地         
   * 如果文件不存在，这会自动创建。如果文件存在，则会覆盖。          
   * 当路径错误时会抛异常         
   * 当在创建时加入true参数，会实现对文件的续写，使用false则会实现对文件的覆盖。          */ 
  FileWriter fw = new FileWriter("d:\\abc.txt",true);   
  /** 
   * 调用该对象的write方法，向文件写入字符。      
   * 此时数据被写入到了临时存储缓冲区中          */      
  fw.write("hello"+LINE_SEPARATOR+"world!");       
  fw.write("hahaha");     
  /**          * 进行刷新，将数据写到文件中。          */  
  fw.flush();
  //flush()方法刷新缓冲区   
  fw.close();
  }
 }

24）DataInputStream和DataOutputStream，数据操作方法
（参考：https://blog.csdn.net/lili13897741554/article/details/81876443）
代码来源

import java.io.*;
public class Test3 {
   public static void main(String[] args) throws IOException { 
    DataOutputStream dos = new DataOutputStream(new FileOutputStream("D:\\abc.txt"));  
    dos.writeUTF("α");  
    dos.writeInt(1234567);   
    dos.writeBoolean(true); 
    dos.writeShort((short)123);  
    dos.writeLong((long)456);  
    dos.writeDouble(99.98);  
    DataInputStream dis = new DataInputStream(new FileInputStream("D:\\abc.txt"));
    System.out.println(dis.readUTF()); 
    System.out.println(dis.readInt());  
    System.out.println(dis.readBoolean()); 
    System.out.println(dis.readShort()); 
    System.out.println(dis.readLong());  
    System.out.println(dis.readDouble()); 
    dis.close();    
    dos.close(); 
    }
   }

这个是会覆盖原来文本文件的内容，没有做到续写，而且打开文本文件会乱码（可能否是因为我用的ANSI）
（在FileOutputStream后加了true也做不到续写，还是乱码）

终于摸到了多线程的脚。。。
25）多线程的作用
多线程可以改善任务等待执行的时间
（参考：https://blog.csdn.net/liu123641191/article/details/80904522）

总结起来，使用多线程编程具有以下优点：
（1）进程之间不能共享内存，但线程之间可以，且十分容易
（2）系统创建进程是需要为该进程重新分配系统资源，但创建线程则代价小得多，因此使用多线程来实现多任务并发比多进程的效率高。

26）多线程的四种状态转换，及相关方法，常见方法sleep wait notify stop

（参考：https://www.cnblogs.com/jijijiefang/articles/7222955.html）

1、新建状态(New)：新创建了一个线程对象。
2、就绪状态(Runnable)：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于“可运行线程池”中，变得可运行，只等待获取CPU的使用权。即在就绪状态的进程除CPU之外，其它的运行所需资源都已全部获得。
3、运行状态(Running)：就绪状态的线程获取了CPU，执行程序代码。
4、阻塞状态(Blocked)：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。

public class Test4 implements Runnable{
    private int tickets;
    @Override
    public void run() {
        for(int i=0;i<20;i++){
            System.out.println(Thread.currentThread().getName()+"--------"+i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        Test4 td = new Test4();
        Thread t1 = new Thread(td,"t1");
        Thread t2 = new Thread(td,"t2");
        t1.start();
        t2.start();
        for(int i=0;i<20;i++) {
            System.out.println(Thread.currentThread().getName() + "-"+i);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

27）Thread类，Runnable接口
a. Thread类提供了7种重载的构造方法
b. public Thread()
c. public Thread(Runnable target)
d. public Thread(RUnnable target, String name)
e. public Thread(String name)
f. public Thread(ThreadGroup group, Runnable target)
g. public Thread(ThreadGroup group, String name)
h. public Thread(ThreadGroup group, Runnable taget, String name)
i. 使用该接口，可以不用定义专门的线程类，而直接使用原有的类
j. 通过在类声明时增加class MyThreadClass implements Runnable
k. 在创建类对象时采用Thread(Runnable)构造函数MyThreadClass thd1 = new MyThreadClass()Thread myThread = new Thread(thd1)
Thread类中带有Runnable接口的构造方法有
public Thread(Runnable target)
p. public Thread(Runnable target, String name)
public Thread(String name)
public Thread(ThreadGroup group, Runnable target)
public Thread(ThreadGroup group, Runnable target, String name)

28）覆盖public void run()，通过start()调用
a. Runnable接口中只有一个方法：public void run(),一个类实现Runable接口，必须覆盖run()方法，并在这个方法中编写线程程序。线程运行后自动执行run()中的代码，run()方法不需要在程序中调用。
b. 通过集成Thread创建线程对象的步骤：
a) 定义线程类继承Thread,并覆盖run（）方法
b) 在run()方法中编写线程执行的代码
c) 使用new调用线程类的构造方法创建线程对象，并调用start()方法。d) 调用start()方法后线程对象处于就绪状态，如果获得CPU资源，线程自动运行run()方法。有多个线程对象同时处于就绪状态时，这些线程交替使用CPU。

多线程真的好难啃啊，所以这个应该是最后一篇提纲复习文了，十天的复习目的优先只是为了先考个好成绩，四篇文章里还留了很多flag，之后几天还得做做题，所以匆匆收尾也是没有办法，多线程最后决定是用刷题的方式补一下，如果光从提纲入手会抓不住。