Java高级编程

线程

线程基础

继承Thread

public class Demo {
    public static void main(String[] args) {
        new MyThread("线程A").start();
        new MyThread("线程B").start();
        new MyThread("线程C").start();
    }
}
class MyThread extends Thread {
    private String title;
    public MyThread(String title) {
        this.title = title;
    }
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(title + ":" + i);
        }
    }
}

实现Runnable

public class Demo {
    public static void main(String[] args) {
        new Thread(new MyThread("线程A")).start();
        new Thread(new MyThread("线程B")).start();
        new Thread(new MyThread("线程C")).start();
    }
}
class MyThread implements Runnable {
    private String title;
    public MyThread(String title) {
        this.title = title;
    }
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(title + ":" + i);
        }
    }
}

Lambda简写

public class Demo {
    public static void main(String[] args) {
        for(int j=0; j<3; j++) {
            String title = "线程" + j;
            new Thread(()->{
                for (int i = 0; i < 10; i++) {
                    System.out.println(title + ":" + i);
                }
            }).start();
        }
    }
}

实现Callable

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class Demo {
    public static void main(String[] args) throws Exception {
        FutureTask<String> task = new FutureTask<String>(new MyThread());
        new Thread(task).start();
        System.out.println(task.get());
    }
}
class MyThread implements Callable<String> {
    public String call() throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println("线程执行:" + i);
        }
        return "线程执行完成";
    }
}

线程常用方法

获取线程名称

public class Demo {
    public static void main(String[] args) {
        new Thread(new MyThread(),"线程A").start();
        new Thread(new MyThread()).start();
        new Thread(new MyThread()).start();
        new Thread(new MyThread(),"线程B").start();
    }
}
class MyThread implements Runnable {
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

线程休眠

public class Demo {
    public static void main(String[] args) {
        new Thread(new MyThread()).start();
    }
}
class MyThread implements Runnable {
    public void run() {
        System.out.println(Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("OK");
    }
}

线程中断

public class Demo {
    public static void main(String[] args) throws Exception {
        Thread thread = new Thread(new MyThread());
        thread.start();
        Thread.sleep(1000);
        thread.interrupt();
    }
}
class MyThread implements Runnable {
    public void run() {
        try {
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(3000);
            System.out.println("OK");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

强制执行

public class Demo {
    public static void main(String[] args) throws Exception {
        Thread mainThread = Thread.currentThread();
        new Thread(()-> {
            try {
                for(int i=0; i<20; i++) {
                    if(i == 5) mainThread.join();
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        for(int i=0; i<20; i++) {
            Thread.sleep(100);
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

线程礼让

public class Demo {
    public static void main(String[] args) throws Exception {
        new Thread(()-> {
            try {
                for(int i=0; i<20; i++) {
                    if(i%3 == 0) {
                        Thread.yield();
                        System.out.println("礼让");
                    }
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        for(int i=0; i<20; i++) {
            Thread.sleep(100);
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

线程优先级

public class Demo {
    public static void main(String[] args) throws Exception {
        for(int j=0; j<3; j++) {
            Thread thread = new Thread(()-> {
                for(int i=0; i<100; i++) {
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            });
            if(j == 2) {
                thread.setPriority(Thread.MAX_PRIORITY);
            }else {
                thread.setPriority(Thread.MIN_PRIORITY);
            }
            thread.start();
        }
    }
}

同步

同步代码块

public class Demo {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        new Thread(myThread).start();
        new Thread(myThread).start();
        new Thread(myThread).start();
    }
}
class MyThread implements Runnable {
    private int count = 10;
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                synchronized (this) {
                    Thread.sleep(100);
                    if (count == 0) break;
                    System.out.println(Thread.currentThread().getName() + ":" + count);
                    count--;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

同步方法

public class Demo {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        new Thread(myThread).start();
        new Thread(myThread).start();
        new Thread(myThread).start();
    }
}
class MyThread implements Runnable {
    private int count = 10;
    private synchronized boolean fun() {
        try {
            Thread.sleep(100);
            if (count == 0) return true;
            System.out.println(Thread.currentThread().getName() + ":" + count);
            count--;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return false;
    }
    public void run() {
        for (int i = 0; i < 10; i++) {
            if(fun()) break;
        }
    }
}

死锁

public class Demo implements Runnable {
    private Jian jian = new Jian();
    private Qiang qiang = new Qiang();
    public static void main(String[] args) {
        new Demo();
    }
    public void run() {
        jian.say(qiang);
    }
    public Demo() {
        new Thread(this).start();
        qiang.say(jian);
    }
}
class Jian {
    public synchronized void say(Qiang qiang) {
        System.out.println("Jian要过去");
        qiang.get();
    }
    public synchronized void get() {
        System.out.println("Jian过去了");
    }
}
class Qiang {
    public synchronized void say(Jian jian) {
        System.out.println("Qiang要过去");
        jian.get();
    }
    public synchronized void get() {
        System.out.println("Qiang过去了");
    }
}

生产者消费者

public class Demo {
    public static void main(String[] args) {
        Meaasge meaasge = new Meaasge();
        for (int i = 1; i <= 3; i++) {
            new Thread(new Consumer(meaasge), "Consumer" + i).start();
        }
        for (int i = 1; i <= 3; i++) {
            new Thread(new Producer(meaasge), "Producer" + i).start();
        }
    }
}
// 消息
class Meaasge {
    private String contents;
    private boolean available = false;
    public synchronized void get() {
        while (available == false) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        available = false;
        System.out.println(Thread.currentThread().getName() + "消费:" + contents);
        notifyAll();
    }
    public synchronized void put(String value) {
        while (available == true) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        contents = value;
        available = true;
        System.out.println(Thread.currentThread().getName() + "生产:" + contents);
        notifyAll();
    }
}
// 消费者
class Consumer implements Runnable {
    private Meaasge meaasge;
    public Consumer(Meaasge meaasge) {
        this.meaasge = meaasge;
    }
    public void run() {
        for (int i = 0; i < 5; i++) {
            meaasge.get();
        }
    }
}
// 生产者
class Producer implements Runnable {
    private Meaasge meaasge;
    public Producer(Meaasge meaasge) {
        this.meaasge = meaasge;
    }
    public void run() {
        for (int i = 0; i < 5; i++) {
            meaasge.put(String.valueOf(Math.random()));
            try {
                Thread.sleep((int) (Math.random() * 500));
            } catch (Exception e) {
            }
        }
    }
}

停止线程

public class Demo {
    private static boolean flag = true;
    public static void main(String[] args) throws Exception {
        new Thread(new Runnable() {
            public void run() {
                while (flag) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Math.random());
                }
            }
        }, "执行线程").start();
        Thread.sleep(4000);
        flag = false;
    }
}

守护线程

public class Demo {
    public static void main(String[] args) throws Exception {
        Thread userThread = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + i);
                }
            }
        }, "用户线程");
        Thread daemonThread = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 100; i++) {
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + i);
                }
            }
        }, "守护线程");
        daemonThread.setDaemon(true);
        daemonThread.start();
        userThread.start();
    }
}

volatile关键字

public class Demo {
    public static void main(String[] args) throws Exception {
        MyThread myThread = new MyThread();
        new Thread(myThread, "卖票线程A:").start();
        new Thread(myThread, "卖票线程B:").start();
        new Thread(myThread, "卖票线程C:").start();
        new Thread(myThread, "卖票线程D:").start();
        new Thread(myThread, "卖票线程E:").start();
    }
}
class MyThread implements Runnable {
    // volatile表示直接操作内存，不用拷贝数据计算后再赋值回去，它没有synchronized的功能
    private volatile int ticket = 5;
    public void run() {
        synchronized (this) {
            if (ticket > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + ticket);
                ticket--;
            }
        }
    }
}

基础类库

字符串

public class Demo {
    public static void main(String[] args) throws Exception {
        // 字符串
        String str = "Hello" + "World" + 12345;
        System.out.println(str);
        // 线程安全的
        StringBuffer buffer = new StringBuffer();
        buffer.append("Hello");
        buffer.append("World");
        buffer.append(12345);
        System.out.println(buffer);
        // 线程不安全
        StringBuilder builder = new StringBuilder();
        builder.append("Hello");
        builder.append("World");
        builder.append(12345);
        System.out.println(builder);
    }
}

字符序列

public class Demo {
    public static void main(String[] args) throws Exception {
        String str = "Hello" + "World" + 12345;
        print(str);
        StringBuffer buffer = new StringBuffer();
        buffer.append("Hello");
        buffer.append("World");
        buffer.append(12345);
        print(buffer);
        StringBuilder builder = new StringBuilder();
        builder.append("Hello");
        builder.append("World");
        builder.append(12345);
        print(builder);
    }
    public static void print(CharSequence sequence) {
        System.out.println(sequence);
    }
}

自动关闭

public class Demo {
    public static void main(String[] args) throws Exception {
        try (Message message = new MyMessage()) {
            message.send();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
interface Message extends AutoCloseable {
    public void send();
}
class MyMessage implements Message {
    public void close() throws Exception {
        System.out.println("关闭通道");
    }
    public void send() {
        System.out.println("发送消息");
    }
}

运行时（Runtime）

public class Demo {
    public static void main(String[] args) throws Exception {
        Runtime runtime = Runtime.getRuntime();
        System.out.println("CPU核数:" + runtime.availableProcessors());
        memory(runtime);
        String str = "";
        for(int i=0; i<50000; i++) {
            str += i + "";
        }
        System.out.println("字符串长度:" + str.length());
        memory(runtime);
        runtime.gc();
        Thread.sleep(1000);
        memory(runtime);
    }
    private static void memory(Runtime runtime) {
        System.out.println("------------------------------");
        System.out.println("最大内存:" + toGB(runtime.maxMemory()));
        System.out.println("总内存:" + toGB(runtime.totalMemory()));
        System.out.println("可以内存:" + toGB(runtime.freeMemory()));
    }
    private static String toGB(long size) {
        return Math.floor(size / 1.0 / 1024 / 1024 / 1024 * 100) / 100 + "GB";
    }
}

系统（System）

public class Demo {
    public static void main(String[] args) throws Exception {
        long start = System.currentTimeMillis();
        {
            String str = "";
            for(int i=0; i<1000; i++) {
                str += i + "";
            }
            System.out.println("字符串长度:" + str.length());
        }
        System.gc();
        long end = System.currentTimeMillis();
        System.out.println("操作耗时:" + (end-start));
    }
}

public class Demo {
    public static void main(String[] args) throws Exception {
        // 打印所有Propertie的简单方法
        System.getProperties().list(System.out);
    }
}

清理（Cleaner）

import java.lang.ref.Cleaner;
public class Demo {
    public static void main(String[] args) {
        try(MemberCleaning memberCleaning = new MemberCleaning()) {
            System.out.println(memberCleaning);
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}
class Member implements Runnable {
    public Member() {
        System.out.println("创建");
    }
    public void run() {
        System.out.println("销毁");
    }
}
// Java9以上版本支持
class MemberCleaning implements AutoCloseable {
    private Member member;
    private Cleaner.Cleanable cleanable;
    private static final Cleaner CLEANER = Cleaner.create();
    public MemberCleaning() {
        this.member = new Member();
        this.cleanable = CLEANER.register(this, this.member);
    }
    public void close() throws Exception {
        this.cleanable.clean();
    }
}

克隆

public class Demo {
    public static void main(String[] args) throws Exception {
        Member member1 = new Member("张三", 18);
        Member member2 = member1.clone();
        System.out.println(member1);
        System.out.println(member2);
    }
}
class Member implements Cloneable {
    private String name;
    private int age;
    public Member(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String toString() {
        return super.toString() + " [name=" + name + ", age=" + age + "]";
    }
    protected Member clone() throws CloneNotSupportedException {
        return (Member) super.clone();
    }
}

数字操作类

数学计算

public class Demo {
    public static void main(String[] args) throws Exception {
        System.out.println(Math.abs(-7));
        System.out.println(Math.max(8, 20));
        System.out.println(Math.random());
        System.out.println(Math.round(3.14159));
        System.out.println(myRound(3.14159, 2));
        System.out.println(myRound(3.14159, 3));
    }
    // 自定义保留N位小数的四舍五入
    public static double myRound(double num, int scale) {
        return Math.round(num * Math.pow(10,scale)) / Math.pow(10,scale);
    }
}

随机数

import java.util.Random;
public class Demo {
    public static void main(String[] args) throws Exception {
        Random random = new Random();
        System.out.println(random.nextBoolean());
        System.out.println(random.nextDouble());
        for(int i=0; i<10; i++) {
            System.out.print(random.nextInt(100) + "、");
        }
    }
}

大数处理

import java.math.BigDecimal;
import java.math.BigInteger;
public class Demo {
    public static void main(String[] args) throws Exception {
        BigInteger num1 = new BigInteger("2353464378658920397684376893768957828937529487543897698389376935");
        BigInteger num2 = new BigInteger("83957928375247");
        System.out.println("加法:" + num1.add(num2));
        System.out.println("减法:" + num1.subtract(num2));
        System.out.println("乘法:" + num1.multiply(num2));
        System.out.println("除法:" + num1.divide(num2));
        BigInteger[] result = num1.divideAndRemainder(num2);
        System.out.println("商:" + result[0]);
        System.out.println("余数:" + result[1]);
        BigDecimal num3 = new BigDecimal("3.141596976431634531351035435456465431315465465465465456465465464654654");
        BigDecimal num4 = new BigDecimal("654646.321654");
        System.out.println(num3.add(num4));
    }
}

日期操作

日期类

import java.util.Date;
public class Demo {
    public static void main(String[] args) throws Exception {
        Date date = new Date();
        System.out.println(date.getTime());
        System.out.println(new Date());
        System.out.println(new Date(System.currentTimeMillis()));
    }
}

日期格式化

import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo {
    public static void main(String[] args) throws Exception {
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        // 日期转字符串
        System.out.println(sdf.format(date));
        // 字符串转日期
        date = sdf.parse("2021-05-15 15:16:41.337");
        System.out.println(date);
    }
}

开发支持

正则表达式

import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Demo {
    public static void main(String[] args) {
        System.out.println("123456".matches("\\d+"));
        System.out.println("a".matches("[abc]"));
        System.out.println("d".matches("[^abc]"));
        System.out.println("F".matches("[a-zA-Z]"));
        System.out.println("5".matches("[0-9]"));
        System.out.println("3.14159".matches("\\d+(\\.\\d+)?"));
        System.out.println("hg2341@jgjh67^hvh^&*(434jhbj^jbsf)*!mbh".replaceAll("\\W", ""));
        System.out.println(Arrays.toString("a65876d987987f888g987987s78789".split("\\d+")));
        String str = "INSERT INTO user(id,username,password) VALUES (#{id},#{username},#{password})";
        String regex = "#\\{\\w+\\}";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
        while(matcher.find()) {
            System.out.println(matcher.group(0));
        }
    }
}

国际化

i18n.properties

info=Hi
msg=Hi {0} , Welcome to {1}

i18n_en_US.properties

info=Hello
msg=Hello {0} , Welcome to {1}

i18n_zh_CN.properties

info=Ni Hao
msg=Ni Hao {0} , Huan ying lai dao {1}

import java.text.MessageFormat;
import java.util.Locale;
import java.util.ResourceBundle;
public class Demo {
    public static void main(String[] args) {
        Locale locale = new Locale("zh", "CN");
        ResourceBundle bundle = ResourceBundle.getBundle("i18n", locale);
        System.out.println(bundle.getString("info"));
        String str = MessageFormat.format(bundle.getString("msg"), "张三", "三亚");
        System.out.println(str);
    }
}

UUID

import java.util.UUID;
public class Demo {
    public static void main(String[] args) {
        System.out.println(UUID.randomUUID().toString());
    }
}

Optional

import java.util.Optional;
public class Demo {
    public static void main(String[] args) throws Exception {
        System.out.println(getCarInsuranceName1(null));
        System.out.println(getCarInsuranceName2(null));
    }
    public static String getCarInsuranceName1(Person person) {
        if(person != null) {
            Car car = person.getCar();
            if(car != null) {
                Insurance insurance = car.getInsurance();
                if(insurance != null) {
                    return insurance.getName();
                }
            }
        }
        return "Unknown";
    }
    public static String getCarInsuranceName2(Person person) {
        return Optional.ofNullable(person)
                .map(Person::getCar)
                .map(Car::getInsurance)
                .map(Insurance::getName)
                .orElse("Unknown");
    }
}
class Person {
    private Car car;
    public Car getCar() {
        return car;
    }
}
class Car {
    private Insurance insurance;
    public Insurance getInsurance() {
        return insurance;
    }
}
class Insurance {
    private String name;
    public String getName() {
        return name;
    }
}

ThreadLocal

public class Demo {
    public static void main(String[] args) throws Exception {
        new Thread(new Runnable() {
            public void run() {
                Message message = new Message();
                message.setInfo("AAAAA");
                Channel.setMessage(message);
                Channel.send();
            }
        }, "线程A").start();
        new Thread(new Runnable() {
            public void run() {
                Message message = new Message();
                message.setInfo("BBBBB");
                Channel.setMessage(message);
                Channel.send();
            }
        }, "线程B").start();
        new Thread(new Runnable() {
            public void run() {
                Message message = new Message();
                message.setInfo("CCCCC");
                Channel.setMessage(message);
                Channel.send();
            }
        }, "线程C").start();
    }
}
class Channel {
    private static final ThreadLocal<Message> THREAD_LOCAL = new ThreadLocal<Message>();
    private Channel() { }
    public static void setMessage(Message message) {
        THREAD_LOCAL.set(message);
    }
    public static void send() {
        System.out.println(Thread.currentThread().getName() + "发送消息:" + THREAD_LOCAL.get().getInfo());
    }
}
class Message {
    private String info;
    public String getInfo() {
        return info;
    }
    public void setInfo(String info) {
        this.info = info;
    }
}

定时调度

import java.util.Timer;
import java.util.TimerTask;
public class Demo {
    public static void main(String[] args) throws Exception {
        Timer timer = new Timer();
//        timer.schedule(new MyTask(), 0);
        timer.scheduleAtFixedRate(new MyTask(), 100, 1000);
    }
}
class MyTask extends TimerTask {
    public void run() {
        System.out.println(Thread.currentThread().getName() + "执行了");
    }
}