Java第二十天（序列流、字符编码、线程）

88.序列流

注意：写入读取的对象必须实现序列化接口Serializable才能够，不然会报错

一旦序列化的类有改变，以前的序列化就无效了出现报错，类再也不匹配，须要设置UID

默认状况下Intellij IDEA关闭了继承了Java.io.Serializable的类生成serialVersionUID的警告，若是须要提示生成serialVersionUID，那么须要作如下设置:在Editor->Inspections下勾选中Java->Serialization issues->Serializable class without ‘serialVersionUID’，将光标放到类名上按Atl＋Enter键就会提示生成serialVersionUID了 

import java.io.Serializable;

public class Person implements Serializable{
    //设置UID
    private static final long serialVersionUID = -7911922289599340825L;
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    public Person() {
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

序列化流

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class ObjectOutputStreamDemo {
    public static void main(String[] args) {
        ObjectOutputStream o=null;
        try {
            o=new ObjectOutputStream(new FileOutputStream("person.txt"));
            Person p=new Person("大名",20);
            Person p1=new Person("大华",16);
            Person p2=new Person("小可",12);
            o.writeObject(p);
            o.writeObject(p1);
            o.writeObject(p2);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(o!=null){
                try {
                    o.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

反序列化一次只能读取一个，读完了再读就会报错

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ObjectInputSreamDemo {
    public static void main(String[] args) {
        ObjectInputStream in=null;
        try {
            in=new ObjectInputStream(new FileInputStream("person.txt"));
            Object o=in.readObject();
            Person p=(Person)o;
            System.out.println(p.getName());
            System.out.println(o);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if(in!=null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

解决办法，放入集合中

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

public class ObjectOutputStreamDemo1 {
    public static void main(String[] args) {
        ObjectOutputStream o=null;
        try {
            o=new ObjectOutputStream(new FileOutputStream("person1.txt"));
            List<Person> personlist=new ArrayList<>();
            Person p=new Person("大名",20);
            Person p1=new Person("大华",16);
            Person p2=new Person("小可",12);
            personlist.add(p);
            personlist.add(p1);
            personlist.add(p2);
            o.writeObject(personlist);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(o!=null){
                try {
                    o.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

import sun.text.resources.cldr.om.FormatData_om;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.List;

public class ObjectInputSreamDemo1 {
    public static void main(String[] args) {
        ObjectInputStream in=null;
        try {
            in=new ObjectInputStream(new FileInputStream("person1.txt"));
            Object o=in.readObject();
            List<Person> p=(List<Person>)o;
            //所有读取
            System.out.println(p);
            //遍历逐个读取
            for (int i = 0; i < p.size(); i++) {
                System.out.println(p.get(i).getName());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if(in!=null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

89.字符编码

存储:

在计算机中存储字符都是存储的字符所对应的数值以二进制的形式表示。

展现：

去相关的编码表中去查找该值（存储的值）所对应的字符。

通常是默认UTF-8码表

经常使用码表：

ASCII表：用7bit来表示存储数据     

ISO-8859-1:拉丁码表， 用8bit来表示     

GB2312: 简体中文编码（国标码）

GBK：gb2312作了加强

GB18030：对GBK作了加强

BIG5：支持繁体

Unicode：支持多种国家的语言，这是国际标准。用2个字节来存储。 无论是什么字符都用2个字节，会有浪费。

UTF-8: 支持多种国家的语言，针对不一样的字符的范围给出不一样的字节表示。0,a,A用一个字符存储；中间的范围用二个字节 ；中文就使用3个字节。       

 写入的编码和读取的编码必需要一致，不然会有乱码。

90.线程

重点：（1）熟练掌握线程的两种实现方式，第一种必须声明为Thread的的子类重写run方法，run()是线程执行的逻辑体，启动线程是异步启动调用start()，能够经过调用getName()得到线程的名字；第二种建立方法是实现Runable接口，实现run方法重写，将子类做为参数传入线程对象的建立中；

（2）线程的生命周期：

（3）线程中出现的问题：并发问题使用同步代码，须要知足：代码被多个线程访问，代码中有共享的数据，共享数据被多条语句操做。

单独做为代码块，能够放在方法中，return的位置不受影响，语法:

synchronized(锁对象){

//操做共享资源的代码

}

修饰在方法上注意两种线程建立方式的不一样

（4）休眠：在作服务器端的程序的时候都须要给一个休眠的时间，在没有synchronized代码块里面会让出cpu的资源。有sychronized代码块里面继续占用CPU资源

（5）线程间的通讯；

注意：

1.线程间的通讯共享数据必定要有同步代码块synchronized

2.必定要有wait和notify，并且两者必定是成对出现。

3.生产者和消费者的线程实现必定是在while（true）里面

（6）设置优先级setPriority(Thread.MAX_PRIORITY)，优先执行

（7）线程的加入，join()，必须放在须要优先执行的线程start()下面

（8）让出线程，Thread.yield()

（9）守护线程，主线程结束，线程也再也不继续执行，setDaemon(true)

（10）死锁，线程锁里面的线程锁，须要避免的

package s20190523;

public class MyThread extends Thread{
    private String name;

    public MyThread(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(this.name+" 正在加载  "+i+"%!");
            try {
                //休眠，让出CPU资源
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        MyThread t=new MyThread("逗鸟外传萌宝大做战");
        MyThread t1=new MyThread("我不喜欢这世界我只喜欢你");
        t.start();
        t1.start();

    }
}

public class MyThread1 implements Runnable{
    private String name;

    public MyThread1(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(name+" 正在加载  "+i+"%!");
        }
    }
}

public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t=new Thread(new MyThread1("逗鸟外传萌宝大做战"));
        Thread  t1=new Thread (new MyThread1("我不喜欢这世界我只喜欢你"));
        t.start();
        t1.start();
    }
}

public class SaleTickets extends Thread{
    //定义共享资源属性为类属性
    static int ticket=100;
    private String name;
    //定义建立锁对象,这个对象是多个线程对象共享的数据
    static Object obj=new Object();

    public SaleTickets(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        //同步代码避免并发问题
        while(true){
            synchronized (obj){
                if(ticket>0){
                    System.out.println(this.name+"售出座位号"+(ticket--)+"火车票！");
                }else{
                    break;
                }
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(this.name+"售罄！");
    }
}

public class SaleTicketsTest {
    public static void main(String[] args) {
        SaleTickets s1=new SaleTickets("1号售票口");
        SaleTickets s2=new SaleTickets("2号售票口");
        SaleTickets s3=new SaleTickets("3号售票口");
        SaleTickets s4=new SaleTickets("4号售票口");
        s1.start();
        s2.start();
        s3.start();
        s4.start();
    }

}

另外一种方法，注意synchronized修饰在对象方法上

public class SaleTickets1 implements Runnable {
    //定义共享资源属性
    int ticket = 100;

    //定义建立锁对象
    Object obj = new Object();

    public void run() {
        //卖票是持续的
        while (true){
            //调用synchronized修饰的对象方法
            if (saleTickets()) {
                break;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //synchronized修饰在对象方法上
    public synchronized boolean saleTickets(){
        boolean flag=false;
        if(ticket>0){
            System.out.println(Thread.currentThread().getName() + "卖出座位号为" + (ticket--) + "的票");
        }else{
            System.out.println(Thread.currentThread().getName()+"售罄！");
            flag=true;
        }
        return flag;
    }

}

public class SaleTicketsTest1 {
    public static void main(String[] args) {
        SaleTickets1 s=new SaleTickets1();
        Thread s1=new Thread(s,"1号售票口");
        Thread s2=new Thread(s,"2号售票口");
        Thread s3=new Thread(s,"3号售票口");
        Thread s4=new Thread(s,"4号售票口");
        s1.start();
        s2.start();
        s3.start();
        s4.start();
    }
}

public class Basket {
    //设置一个篮子是否为空的属性
    private boolean isEmpty;
    //解封这个属性设置
    public void setEmpty(boolean empty) {
        isEmpty = empty;
    }
    //建立篮子是否为空的方法
    public boolean isEmpty() {
        return isEmpty;
    }
}

public class Producer extends Thread{
    Basket basket=new Basket();

    public Producer(Basket basket) {
        this.basket = basket;
    }

    @Override
    public void run() {
        //必定是在while（true）以内的
        while (true){
            synchronized (basket){
                try {
                    if(!(basket.isEmpty())){
                        //wait（）线程等待
                        basket.wait();
                    }else{
                        System.out.println("生产者生产水果！");
                        //注意设置篮子状态不为空
                        basket.setEmpty(false);
                        //与wait（）成对出现唤醒线程，提醒消费者消费
                        basket.notify();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Buyer extends Thread{
    private Basket basket=new Basket();

    public Buyer(Basket basket) {
        this.basket = basket;
    }

    @Override
    public void run() {
        while (true){
            synchronized (basket){
                try {
                    if(basket.isEmpty()){
                        basket.wait();
                    }else{
                        System.out.println("消费者购买水果！");
                        //注意设置篮子状态为空
                        basket.setEmpty(true);
                        basket.notify();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        Basket basket=new Basket();
        Producer p=new Producer(basket);
        Buyer b=new Buyer(basket);
        p.start();
        b.start();
    }
}

另外一种方法

public class Basket {
    //设置一个篮子是否为空的属性
    private boolean isEmpty;
    //解封这个属性设置
    public void setEmpty(boolean empty) {
        isEmpty = empty;
    }
    //建立篮子是否为空的方法
    public boolean isEmpty() {
        return isEmpty;
    }
}

public class Producer1 implements Runnable{
    private Basket basket;

    public Producer1(Basket basket) {
        this.basket = basket;
    }

    @Override
    public void run() {
        //必定是在while（true）以内的
        while (true){
            synchronized (basket){
                try {
                    if(!(basket.isEmpty())){
                        //wait（）线程等待
                        basket.wait();
                    }else{
                        System.out.println("生产者生产水果！");
                        //注意设置篮子状态不为空
                        basket.setEmpty(false);
                        //与wait（）成对出现唤醒线程，提醒消费者消费
                        basket.notify();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Buyer1 implements Runnable{
    private Basket basket;

    public Buyer1(Basket basket) {
        this.basket = basket;
    }

    @Override
    public void run() {
        while (true){
            synchronized (basket){
                try {
                    if(basket.isEmpty()){
                        basket.wait();
                    }else{
                        System.out.println("消费者购买水果！");
                        //注意设置篮子状态为空
                        basket.setEmpty(true);
                        basket.notify();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        Basket basket=new Basket();
        Producer p=new Producer(basket);
        Buyer b=new Buyer(basket);
        Thread t1=new Thread(p);
        Thread t2=new Thread(b);
        t1.start();
        t2.start();
    }
}

public class MyThread extends Thread{
    private String name;

    public MyThread(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(this.name+" 正在加载  "+i+"%!");
            try {
                //休眠，在没有synchronized代码块里面会让出cpu的资源。有sychronized代码块里面继续占用CPU资源
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class MyThreadTest {
    public static void main(String[] args) {
        MyThread t1=new MyThread("逗鸟外传萌宝大做战");
        MyThread t2=new MyThread("我不喜欢这世界我只喜欢你");
        MyThread t3=new MyThread("冰雪传奇");
        MyThread t4=new MyThread("沥川往事");
//        设置优先级
        t4.setPriority(Thread.MAX_PRIORITY);

        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }
}

public class MyThreadTest {
    public static void main(String[] args) {
        MyThread t1=new MyThread("逗鸟外传萌宝大做战");
        MyThread t2=new MyThread("我不喜欢这世界我只喜欢你");
        MyThread t3=new MyThread("冰雪传奇");
        MyThread t4=new MyThread("沥川往事");

        t2.start();
        try {
//线程加入必须放在须要优先的线程start后面才有效
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t1.start();

        t3.start();
        t4.start();

    }
}

import s20190523.MyThread;

public class MyThreadTest1 {
    public static void main(String[] args) {
        MyThread t1=new MyThread("逗鸟外传萌宝大做战");
        //设置守护线程，线程随主线程结束而结束
        t1.setDaemon(true);
        t1.start();
        System.out.println("主线程结束");

    }
}

public class Lock {
    static Lock lock1=new Lock();
    static Lock lock2=new Lock();
}

public class DeadLock extends Thread{
    int flag;
    @Override
    public void run() {
        if (flag==1){
            synchronized (Lock.lock1){
                System.out.println("进入锁1");
                synchronized (Lock.lock2){
                    System.out.println("进入锁1中的锁2");
                }
            }
        }else{
            synchronized (Lock.lock2){
                System.out.println("进入锁2");
                synchronized (Lock.lock1){
                    System.out.println("进入锁2中的锁1");
                }
            }
        }

    }
}

public class DeadLockTest {
    public static void main(String[] args) {
        DeadLock l1=new DeadLock();
        DeadLock l2=new DeadLock();
        l1.flag=1;
        l1.start();
        l2.start();
    }
}