黑马程序员JAVA学习第七节

黑马程序员JAVA学习第七节

（视频链接黑马程序员全套Java教程_Java基础入门教程，零基础小白自学Java必备教程_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili）

本节主要内容是IO 特殊操作流，Properties 集合，实现多线程，对应视频302-339.

1.复制文件的异常处理（新）：

 //JDK7的改进方案
  private static void method3() {
    try(FileReader fr = new FileReader("fr.txt");
      FileWriter fw = new FileWriter("fw.txt");){
      char[] chs = new char[1024];
      int len;
      while ((len = fr.read()) != -1) {
        fw.write(chs, 0, len);
     }
   } catch (IOException e) {
      e.printStackTrace();
   }
 }
//JDK9的改进方案
  private static void method4() throws IOException {
    FileReader fr = new FileReader("fr.txt");
    FileWriter fw = new FileWriter("fw.txt");
    try(fr;fw){
      char[] chs = new char[1024];
      int len;
      while ((len = fr.read()) != -1) {
        fw.write(chs, 0, len);
     }
   } catch (IOException e) {
      e.printStackTrace();
   }
 }

IO 特殊操作流

1.标准输入流：

System 类中有两个静态的成员变量
     public static final InputStream in ：标准输入流。通常该流对应于键盘输入或由主机环境或用户指定的
另一个输入源

     public static final PrintStream out ：标准输出流。通常该流对应于显示输出或由主机环境或用户指定的
另一个输出目标

2.标准输出流

System 类中有两个静态的成员变量
public static final InputStream in ：标准输入流。通常该流对应于键盘输入或由主机环境或用户指定的
另一个输入源
public static final PrintStream out ：标准输出流。通常该流对应于显示输出或由主机环境或用户指定的
另一个输出目标
输出语句的本质：是一个标准的输出流
PrintStream ps = System.out;
PrintStream 类有的方法，System.out都可以使用

3.字节打印流

1）打印流分类
字节打印流： PrintStream
字符打印流： PrintWriter
2）打印流的特点
只负责输出数据，不负责读取数据
永远不会抛出 IOException
有自己的特有方法
3）字节打印流
PrintStream(String fileName) ：使用指定的文件名创建新的打印流
使用继承父类的方法（write）写数据，查看的时候会转码；使用自己的特有方法（print）写数据，查看的数据原样输出
可以改变输出语句的目的地
public static void setOut(PrintStream out)：重新分配“标准”输出流

4.字符打印流

 PrintWriter pw = new PrintWriter(new FileWriter("myOtherStream\\pw.txt"),true);
pw.println("hello");//自动刷新

5.对象序列化流

1）对象序列化介绍
对象序列化：就是将对象保存到磁盘中，或者在网络中传输对象
这种机制就是使用一个字节序列表示一个对象，该字节序列包含：对象的类型、对象的数据和对象中存储的属性等信息
，字节序列写到文件之后，相当于文件中持久保存了一个对象的信息，反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化
2）对象序列化流： ObjectOutputStream
将 Java对象的原始数据类型和图形写入OutputStream。 可以使用ObjectInputStream读取（重构）对象。 可以通过使用流的文件来实现对象的持久存储。 如果流是网络套接字流，则可以在另一个主机上或另一个进程中重构对象

3）构造方法

ObjectOutputStream(OutputStream out) 创建一个写入指定的OutputStream的 ObjectOutputStream

4）序列化对象的方法

void writeObject(Object obj) 将指定的对象写入ObjectOutputStream

5) 注意事项
一个对象要想被序列化，该对象所属的类必须必须实现 Serializable 接口,Serializable 是一个标记接口，实现该接口，不需要重写任何方法

6. 对象反序列化流

1)对象反序列化流： ObjectInputStream
ObjectInputStream 反序列化先前使用ObjectOutputStream编写的原始数据和对象

2)构造方法

ObjectInputStream(InputStream in) 创建从指定的InputStream读取的ObjectInputStream

3)反序列化对象的方法

Object readObject() 从ObjectInputStream读取一个对象

7.serialVersionUID&transient【应用】
serialVersionUID
1）用对象序列化流序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会不会出问题呢？
   会出问题，会抛出 InvalidClassException异常
2）如果出问题了，如何解决呢？
   重新序列化
   给对象所属的类加一个 serialVersionUID
          private static final long serialVersionUID = 42L;
3）transient
如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢？

给该成员变量加 transient关键字修饰，该关键字标记的成员变量不参与序列化过程

Properties 集合

1.Properties 介绍
1）是一个 Map体系的集合类
2）Properties 可以保存到流中或从流中加载
3）属性列表中的每个键及其对应的值都是一个字符串

2.Properties作为Map集合的使用

 //创建集合对象
//Properties<String,String> prop = new Properties<String,String>(); //错误，不能指定类型
    Properties prop = new Properties();
    //存储元素
    prop.put("itheima001", "林青霞");
    //遍历集合
    Set<Object> keySet = prop.keySet();
    for (Object key : keySet) {
      Object value = prop.get(key);
      System.out.println(key + "," + value);
   }
 }

3.Properties 作为Map集合的特有方法

//创建集合对象
    Properties prop = new Properties();
    //Object setProperty(String key, String value)：设置集合的键和值，都是String类型，底层调用Hashtable方法put（put不限制键和值的类型）
    prop.setProperty("itheima001", "林青霞");
    //String getProperty(String key)：使用此属性列表中指定的键搜索属性
//    System.out.println(prop.getProperty("itheima001"));
//    System.out.println(prop);
    //Set<String> stringPropertyNames()：从该属性列表中返回一个不可修改的键集，其中
键及其对应的值是字符串
    Set<String> names = prop.stringPropertyNames();
    for (String key : names) {
//      System.out.println(key);
      String value = prop.getProperty(key);
      System.out.println(key + "," + value);
   }
 }

4.Properties 和IO流相结合的方法

public static void main(String[] args) throws IOException {
    //把集合中的数据保存到文件
//    myStore();
    //把文件中的数据加载到集合
    myLoad();
 }
  private static void myLoad() throws IOException {
    Properties prop = new Properties();
    //void load(Reader reader)：
    FileReader fr = new FileReader("myOtherStream\\fw.txt");
    prop.load(fr);
    fr.close();
    System.out.println(prop);
 }
  private static void myStore() throws IOException {
    Properties prop = new Properties();
    prop.setProperty("itheima001","林青霞");
    //void store(Writer writer, String comments)：
    FileWriter fw = new FileWriter("myOtherStream\\fw.txt");
    prop.store(fw,null);
    fw.close();
 }

实现多线程

1.进程和线程
进程：是正在运行的程序，是系统进行资源分配和调用的独立单位，每一个进程都有它自己的内存空间和系统资源
线程：是进程中的单个顺序控制流，是一条执行路径
单线程：一个进程如果只有一条执行路径，则称为单线程程序
多线程：一个进程如果有多条执行路径，则称为多线程程序

2.实现多线程方式一：继承Thread类

1）方法介绍

void run() 在线程开启后，此方法将被调用执行
void start() 使此线程开始执行，Java虚拟机会调用run方法()

2）实现步骤
定义一个类 MyThread继承Thread类
在 MyThread类中重写run()方法
创建 MyThread类的对象
启动线程

public class MyThread extends Thread {
  @Override
  public void run() {//为什么要重写 run()方法？因为run()是用来封装被线程执行的代码
    for(int i=0; i<100; i++) {
      System.out.println(i);
   }
 }
}
public class MyThreadDemo {
  public static void main(String[] args) {
    MyThread my1 = new MyThread();
    MyThread my2 = new MyThread();
//    my1.run(); run方法调用并没有启动线程，my1和my2是顺序执行的
//    my2.run();
    //void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
    my1.start();
    my2.start();
 }
}

3.设置和获取线程名称

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);//getName有默认值Thread-0
   }
 }
}
public class MyThreadDemo {
  public static void main(String[] args) {
    MyThread my1 = new MyThread();
    MyThread my2 = new MyThread();
    //void setName(String name)：将此线程的名称更改为等于参数 name
    my1.setName("高铁");
    my2.setName("飞机");
    //Thread(String name)
    MyThread my1 = new MyThread("高铁");
    MyThread my2 = new MyThread("飞机");
    my1.start();
    my2.start();
    //static Thread currentThread() 返回对当前正在执行的线程对象的引用
    System.out.println(Thread.currentThread().getName());
 }
}

4.线程优先级

1）线程调度
（1）两种调度方式
分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些
Java 使用的是抢占式调度模型
（2）随机性
假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

//public final int getPriority()：返回此线程的优先级
    System.out.println(tp1.getPriority()); //5
    //public final void setPriority(int newPriority)：更改此线程的优先级
    tp1.setPriority(10); //IllegalArgumentException

5.线程控制

6.线程的生命周期

7. 实现多线程方式二：实现Runnable接口

1)Thread 构造方法

Thread(Runnable target) 分配一个新的Thread对象
Thread(Runnable target, String name) 分配一个新的Thread对象

2)实现步骤
   定义一个类 MyRunnable实现Runnable接口
   在 MyRunnable类中重写run()方法
   创建 MyRunnable类的对象
   创建 Thread类的对象，把MyRunnable对象作为构造方法的参数
   启动线程

public class MyRunnable implements Runnable {
  @Override
  public void run() {
    for(int i=0; i<100; i++) {
      System.out.println(Thread.currentThread().getName()+":"+i);//不同之处-----------
   }
 }
}
public class MyRunnableDemo {
  public static void main(String[] args) {
    //创建MyRunnable类的对象
    MyRunnable my = new MyRunnable();
    //创建Thread类的对象，把MyRunnable对象作为构造方法的参数
    //Thread(Runnable target)
//    Thread t1 = new Thread(my);
//    Thread t2 = new Thread(my);
    //Thread(Runnable target, String name)
    Thread t1 = new Thread(my,"高铁");
    Thread t2 = new Thread(my,"飞机");
    //启动线程
    t1.start();
    t2.start();
 }
}

3）多线程的实现方案有两种
   继承 Thread类
   实现 Runnable接口
4）相比继承 Thread类，实现Runnable接口的好处
   避免了 Java单继承的局限性
   适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想

8.同步代码块解决数据安全问题

1）安全问题出现的条件
   是多线程环境
   有共享数据
   有多条语句操作共享数据

2）如何解决多线程安全问题呢 ?
   基本思想：让程序没有安全问题的环境
3）怎么实现呢 ?
   把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
   Java 提供了同步代码块的方式来解决

4）同步代码块格式

synchronized (任意对象) {//就相当于给代码加锁了，任意对象就可以看成是一把锁
多条语句操作共享数据的代码
}

5)同步的好处和弊端
   好处：解决了多线程的数据安全问题
   弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

public class SellTicket implements Runnable {
  private int tickets = 100;
  private Object obj = new Object();
  @Override
  public void run() {
    while (true) {
      synchronized (obj) {
        //t1进来后，就会把这段代码给锁起来
        if (tickets > 0) {
          try {
            Thread.sleep(100);
            //t1休息100毫秒
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
          //窗口1正在出售第100张票
           System.out.println(Thread.currentThread().getName() + "正在出售
第" + tickets + "张票");
          tickets--; //tickets = 99;
       }
     }
      //t1出来了，这段代码的锁就被释放了
   }
 }
}

9.同步方法解决数据安全问题

1)同步方法的格式

修饰符 synchronized 返回值类型 方法名(方法参数) {//同步方法：就是把synchronized关键字加到方法上
方法体；
}//同步方法的锁对象是什么呢? this
//private synchronized void sellTicket() 

2)静态同步方法

修饰符 static synchronized 返回值类型 方法名(方法参数) {
方法体；
}
//同步静态方法：就是把synchronized关键字加到静态方法上
//同步静态方法的锁对象是什么呢?  类名.class
//private static synchronized void sellTicket()

10.Lock锁

为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock,Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化

public void run() {
    while (true) {
      try {
        lock.lock();
        if (tickets > 0) {
          try {
            Thread.sleep(100);
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
          System.out.println(Thread.currentThread().getName() + "正在出售
第" + tickets + "张票");
          tickets--;
       }
     } finally {
        lock.unlock();
     }
   }
 }
}

11.Object 类的等待和唤醒方法