2021-7-21学习总结

上午9点~中午12点

学习Java，继续学习输入、输出流，特殊操作流
1，标准输入输出流：public static final InputStream in：标准输入流，通常该流对应于键盘输入或主机环境或用户指定的另一个输入源；public static final PrintStream out：标准输出流，通常对应于显示输出或主机环境或用户指定的另一个输出目标。
2，把字节流转换为字符流，用转化流，可以实现一次读取一行数据，是字符流的特有方法。
3，自己实现键盘录入数据：BufferedReader br = new BufferedReader(new InputStreamReader(System.in))，写起来太麻烦，Java就提供了一个类实现键盘输入：Scanner sc = new Scanner(System.in)；输出语句的本质就是一个标准输出流，PrintStream ps = System.out，PrintStream类由的方法，System.out都可以使用。
4，打印流：字节打印流：PrintStream；字符打印流：PrintWriter；打印流特点：只负责输出数据，不负责读取数据，有自己的特有方法。
字节打印流：PrintStream(String fileName)：使用指定的文件名创建新的打印流。使用继承父类的方法写数据，查看的时候会转码；使用自己特有的方法时，查看数据原样输出。

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;

public class PrintStreamDemo {
    public static void main(String[] args) throws IOException {
        PrintStream ps = new PrintStream(new FileOutputStream("D:\\javaProgrammer\\Lib\\fos.txt"),true);
        ps.write(97);
        ps.write("\r\n".getBytes());
        ps.write(98);
        ps.write("\r\n".getBytes());
        ps.println(97);        自己特有的方法
        ps.println(98);        
        ps.close();
    }
}

字符打印流，构造方法：PrintWriter(String fileName)：使用指定的文件名创造一个新的PrintWruter，而不需自动执行刷新，PrintWriter(Writer out,boolean autoFlush)：创建一个新的PrintWriter,out：字符输出流，autoFlush：一个布尔值，如果为真，则println，printf，或format方法将刷新输出缓冲区。
5，对象序列化流：对象序列化就是将对象保存到磁盘中，或者在网络中传输对象，就是使用一个字节序列表示一个对象，该字节序列包括：对象的类型、对象的数据和对象中存储的属性等信息，字节序列写道文件之后，相当于文件中之久保存了一个对象的信息。
对象序列化流：ObjectOutputStream，将Java对象的原始数据类型和图形写入OutputStream，可以使用ObjectInputStream读取对象，可以同过使用流的文件来实现对象的持久存储，如果是网络套接字流，可以在另一个主机上或另一个进程中重构对象。
构造方法：ObjectOutputStream(OutputStream out)：创建一个写入指定的OutputStream的ObjectOutputStream；序列化对象的方法：void writeObject(Object obj)：将指定的对象写入ObjectOutputStream。
对象反序列化流：ObjectInputStream，ObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象，构造方法：创建从指定的InputStream读取的ObjectInputStream。反序列化对象的方法：Object readObject()：从ObjectInputObject读取一个对象。
练习：

import java.io.Serializable;

public class Student implements Serializable {
    private int age;
    private String name;

    public Student() {
    }

    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }
    public String toString(){
        return "年龄为：" + this.age + "；姓名为：" + this.name;
    }

}

import java.io.*;

public class Object1 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {

        ObjectOutputStream op = new ObjectOutputStream(new FileOutputStream("D:\\javaProgrammer\\Lib\\fos.txt"));
        FileInputStream fis = new FileInputStream("D:\\javaProgrammer\\Lib\\fos.txt");
        ObjectInputStream oi = new ObjectInputStream(fis);
        Student s1 = new Student(20,"孙悟空");
        Student s2 = new Student(18,"唐僧");
        op.writeObject(s1);
        op.writeObject(s2);
        Student s3 = (Student) oi.readObject();
        Student s4 = (Student) oi.readObject();
        System.out.println(s3);
        System.out.println(s4);
        op.close();
        oi.close();
    }
}

下午3点~5点30

看视频，学习多线程
1，进程：是正在运行的程序

• 是系统进行资源分配和调用的单位
• 每个进程都有它自己的内存空间和系统资源
  2，线程：是进程中的单个顺序控制流，是一条执行路径
• 单线程：一个进程如果只有一条执行路径，则称为单线程程序
• 多线程：一个进程如果有多条路径，则称为多路径程序
  3，多线程的实现方式：
  (1)，方式一：继承Tread类
• 定义一个类继承Thread类
• 在MyThread类中重写run()方法
• 创建子类对象
• 启动线程
  (2)，方式二：实现Runnable接口
• 定义一个类实现Runnable接口
• 在类中重写run()方法
• 创建类的对象
• 创建Thread类的对象，把所定义类的对象作为构造方法的参数
  4，线程的生命周期：
  
  5，线程同步
  (1)，判断多线程程序是否会有数据安全问题
• 是否是多线程环境
• 是否有共享数据
• 是否有多条语句操作共享数据
  (2)，同步代码块：锁多条语句操作共享数据，可以使用同步代码块实现
• 格式：
  synchronized(任意对象){ 多条语句操作共享数据的代码 }
  (3)，同步方法：就是把synchronized的关键字加到方法上
• 格式：
• 修饰符synchronized返回值类型方法名(方法参数){}
  (4)，Lock锁，提供了锁和释放锁的方法
• void lock()：获得锁
• void unlock()：释放锁
  7，练习：

public class MyThread  extends  Thread{
    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            System.out.println(getName() + "：" + i);
            /*try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
        }
    }
}

public class MyThread  extends  Thread{
    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            System.out.println(getName() + "：" + i);
            /*try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
        }
    }
}