Java的IO以及线程练习

Posted 2020-08-15 handsomecui

文件的IO操作：

字节流：
 输入字节流：
  InputStream 所有输入字节流的基类，抽象类。
  FileInputStream 读取文件的输入字节流。
  BufferedInputStream 缓冲输入字节流。该类的内部就是维护了一个8kb的字节数组，为了提高读取文件效率。
  
 输出字节流：
  OutputStream 所有输出字节流的基类，抽象类。
  FileOutputStream 文件的输出字节流。
  BufferedOutputStream 缓冲输出字节流。该类的内部就是维护了一个8kb的字节数组，为了提高写文件效率。
  
 什么时候使用字节流：
  读取到的数据不需要经过编码或者解码的情况下使用字节流。例：图片数据。
 
字符流：
 字符流 = 字符流 + 编码（解码）
 
 输入字符流：
  Reader 所有输入字符流的基类，抽象类。
  FileReader 读取文件字符的输入字符流
  BufferedReader 扩展功能（readline）维护了一个长度为8192的字符数组；
  
 输出字符流：
  Writer 所有输出字符流的基类，抽象类。
  FileWriter 输出文件字符的输出字符流
  BufferedWriter 缓冲输出字符流扩展功能（newline）；
  
 什么时候使用字符流：

　　读取到的字节数需要被转换成字符数据，这时候使用字符流；
 
转换流：
 输入字节流的转换流：
  InputStreamReader
 输出字节流的转换流：
  OutputStreamWriter
 转换流的作用;
  1.可以把对应的字节流转换成字符流使用
  2.可以指定码表进行读写文件的数据；
  FileReader, FileWriter这两个类默认使用gbk编码表，不能由你来指定码表读写文件数据。

练习：

package com.java.base;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

/*
字节流：
    输入字节流：
        InputStream 所有输入字节流的基类，抽象类。
        FileInputStream 读取文件的输入字节流。
        BufferedInputStream 缓冲输入字节流。该类的内部就是维护了一个8kb的字节数组，为了提高读取文件效率。
        
    输出字节流：
        OutputStream 所有输出字节流的基类，抽象类。
        FileOutputStream 文件的输出字节流。
        BufferedOutputStream 缓冲输出字节流。该类的内部就是维护了一个8kb的字节数组，为了提高写文件效率。
        
    什么时候使用字节流：
        读取到的数据不需要经过编码或者解码的情况下使用字节流。例：图片数据。
    
字符流：
    字符流 = 字符流 + 编码（解码）
    
    输入字符流：
        Reader 所有输入字符流的基类，抽象类。
        FileReader 读取文件字符的输入字符流
        BufferedReader 扩展功能（readline）维护了一个长度为8192的字符数组；
        
    输出字符流：
        Writer 所有输出字符流的基类，抽象类。
        FileWriter 输出文件字符的输出字符流
        BufferedWriter 缓冲输出字符流扩展功能（newline）；
        
    什么时候使用字符流：读取到的字节数需要被转换成字符数据，这时候使用字符流；
    
转换流：
    输入字节流的转换流：
        InputStreamReader
    输出字节流的转换流：
        OutputStreamWriter
    转换流的作用;
        1.可以把对应的字节流转换成字符流使用
        2.可以指定码表进行读写文件的数据；
        FileReader, FileWriter这两个类默认使用gbk编码表，不能由你来指定码表读写文件数据。
        
        
*/

public class IoExercise {

    public static void main(String[] args) throws Exception  {
        //testInput();
        //writeFile();
        readFile();
    }
    
    public static void testInput() throws IOException{
        InputStream in = System.in;
        //int content = in.read();//每次读到一个字节的数据
        //需要把字节流转化成字符流使用
        InputStreamReader inputStreamReader = new InputStreamReader(in);
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        
        System.out.println(bufferedReader.readLine());
    }
    
    public static void readFile() throws Exception{
        
        //默认的使用gbk编码表，所以读的乱码
//        FileReader fileReader = new FileReader("E:\\Test\\a.txt");
//        int content = 0;
//        while((content = fileReader.read()) != -1){
//            System.out.print((char)content);
//        }
//        fileReader.close();
        
        //建立文件与程序的输入数据通道
        FileInputStream fileInputStream = new FileInputStream("E:\\Test\\a.txt");
        InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "utf-8");
        int content = 0;
        while((content = inputStreamReader.read()) != -1){
            System.out.println((char)content);
        }
        fileInputStream.close();
        
    }
    
    //utf-8把数据写到文件上
    public static void writeFile() throws Exception{
        //建立文件与程序的数据通道
        FileOutputStream fileOutputStream = new FileOutputStream("E:\\Test\\a.txt");
        //创建一个输出字节流的转换刘并且指定码表进行写数据
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream,"utf-8");
        outputStreamWriter.write("大家好");
        //关闭资源
        outputStreamWriter.close();
        
        
    }
    
}

 /*
 * 方式一：继承Thread
 *   1.自定义一个类继承Thread。
 *   2.重写Thread的run方法，把自定义线程的任务定义在run方法上。
 *   3.创建Thread子类的对象，并且调用start方法启动另一个线程。
 *
 * 方式二： 实现Runnable接口
 *   1.自定义一个类实现Runnable接口。
 *   2.实现Runnable接口中的run方法，把自定义线程的任务代码定义在run方法内。
 *   3.创建Runnable实现类的对象。
 *   4.创建Thread对象，把Runnable实现类对象作为参数传递。
 *   5.调用Thread对象的start开启线程。
 *
 * 线程安全：
 *   1.同步代码块：
 *    synchronized(锁){
 *     需要同步的代码
 *    }
 *   2.同步函数
 *    修饰符 synchronize 返回值类型 函数名(形参列表。。){
 *    
 *    }
 *   出现的根本原因：
 *    1.必须存在两个或者两个以上的线程共享着一个资源。
 *    2.操作共享资源的代码必须有两句或者两句以上。
 *   
 */

练习：

package com.java.base;

/*
 * 方式一：继承Thread
 *         1.自定义一个类继承Thread。
 *         2.重写Thread的run方法，把自定义线程的任务定义在run方法上。
 *         3.创建Thread子类的对象，并且调用start方法启动另一个线程。
 * 
 * 方式二： 实现Runnable接口
 *         1.自定义一个类实现Runnable接口。
 *         2.实现Runnable接口中的run方法，把自定义线程的任务代码定义在run方法内。
 *         3.创建Runnable实现类的对象。
 *         4.创建Thread对象，把Runnable实现类对象作为参数传递。
 *         5.调用Thread对象的start开启线程。
 * 
 * 线程安全：
 *         1.同步代码块：
 *             synchronized(锁){
 *                 需要同步的代码
 *             }
 *         2.同步函数
 *             修饰符 synchronize 返回值类型 函数名(形参列表。。){
 *             
 *             }
 *         出现的根本原因：
 *             1.必须存在两个或者两个以上的线程共享着一个资源。
 *             2.操作共享资源的代码必须有两句或者两句以上。
 *         
 */
class AnotherThread implements Runnable{
    
    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
    }
}
class MyThread extends Thread{
    public MyThread(String name){
        super(name);
    }
    @Override
    public void run() {
        
        for(int i = 0; i < 100; i++){
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
        
    }
}
public class ThreadExercise {

    public static void main(String[] args) {
        MyThread myThread = new MyThread("继承Thread的线程");
        myThread.start();
        for(int i = 0; i < 100; i++){
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
        
        AnotherThread anotherThread = new AnotherThread();
        Thread thread = new Thread(anotherThread, "实现runnable接口的线程");
        thread.start();
        
    }

}