字符流与字节流 多线程

（Input）输入流：输入流指的是将数据以字符或字节形式从外部媒介比如文件、数据库等读取到内存中。

通过JAVA程序读取硬盘上的某个文件内容就需要使用输入流。

（Output）输出流：输出流指的是将内存中的数据写入外部媒介。

通过JAVA程序将内容写入到硬盘上的某个文件就需要使用输出流。

一.什么是IO流

流：源于UNIX中管道（pipe）的概念，在UNXI中，管道是一条不间断的字节流，用来实现程序或进程的通信，或读写外围设备，外部文件等。

二.IO流的分类：

1.字节流：InputStream和OutputStream

2.字符流：Reader和Writer

字节流的概念：字节流是由字节组成的，字节流是最基本的，所有的InputStream和OutputStream的子类都是字节流，主要用在处理二进制数据，它是按字节来处理的。

字符流的概念：字符流是由字符组成的，JAVA里字符由两个字节组成，所有的Reader和Writer的子类都是字符流，主要用在处理文本内容或特定字符。

字节流和字符流的区别：

1.读写的时候一个是按字节读写，一个是按字符。

2.需要对内容按行处理，一般会选择字符流。

3.只是读写文件，和文件内容无关的（下载、复制等），一般选择字节流。

   

   复制Word 图片用字节流复制  txt文本文档，Java文件可以用字符流复制。

FileInputStream的常用方法：

1.read() 从此输入流中读取下一个数据字节。

2.close() 关闭此输入流并释放与此流关联的所有系统资源。

三.Reader子类：

1.BufferedReader从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

2.FileReader从InputStreamReader类继承而来，该类按字符读取流中数据。

四.线程

进程是在运行过程中在内存中开辟的空间。

程序不等与进程，但是程序与进程是一一对应的。

线程：程序在执行过程中，能够执行程序代码的一个执行单元。（执行任务的最小单元）。

使用多线程的两种方法

1.继承Thread类，重写run（）方法

2.实现Runnable接口，并实现该接口的run()方法 

附代码

文件的复制

package com.lenovo.www.entity;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileDemo7 {
    public static  void main(String[] args) {
        int count = 0;
        FileReader reader = null;
        BufferedReader breader = null;
        BufferedWriter writer = null;
        try {
             reader = new FileReader("D:\\java demo\\JAVA.txt");
             writer = new BufferedWriter(new FileWriter("D:\\java demo\\JAVA2"));
             breader = new BufferedReader(reader);

            String temp = "";
            while((temp= breader.readLine())!=null) {
                writer.write(temp);
                writer.newLine();

            }
            writer.flush();
            System.out.println("共循环"+count+"次");
        } catch ( FileNotFoundException e) {
            e.printStackTrace();
        }catch(IOException e) {
            e.printStackTrace();
        }finally {
            try {
                breader.close();
                reader.close();
                writer.close();
            }catch(IOException e) {
                e.printStackTrace();
            }
        }
    }

}

多线程

package com.lenovo.entity;

public class Demo {
    public static void main(String[] args) {
        int count = 0;
        new Thread(new MyThread()).start();

        new Thread(new MyThead1()).start();

        while (true) {
            System.out.println(Thread.currentThread().getName() + "--" + count++);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();

            }

        }

    }
}
    class MyThread extends Thread {
        @Override
        public void run() {
            super.run();
            int c = 0;
            while (true) {
                System.out.println(Thread.currentThread().getName() + "**" + c++);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }


class MyThead1 implements Runnable {
    @Override
    public void run() {
        int c = 0;
        while (true) {
            System.out.println(Thread.currentThread().getName() + "**" + c++);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

字符流读写

package com.lenovo.www.entity;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class FileDemo8 {
    public static void main(String[] args) {
        BufferedWriter writer = null;
     try {
         writer = new BufferedWriter(new FileWriter("D:\\java demo\\JAVA.txt",true));
         writer.newLine();
         writer.write("Hello Pig!");
         writer.newLine();
         writer.write("今天星期三");
         writer.newLine();
         writer.write("有风没雨天气晴");

         writer.flush();//冲刷缓冲区

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

}