import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadBasic {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyThread t = new MyThread();
        t.start();

        new Thread(t,"自定义线程名称").start();

        Thread t2 = new Thread(new MyRunnable());
        t2.start();

        Thread t3= new Thread(()->{
            System.out.println(Thread.currentThread().getName());
            System.out.println("start by lambda");
        });
        t3.start();

        Callable<String> myCallable = new MyCallable<>();
        FutureTask<String> ft= new FutureTask<>(myCallable);
        Thread t4=new Thread(ft);
        t4.start();

        //检查是否执行完成
        while(!ft.isDone()){
            System.out.println("callable线程进行中...");
            Thread.sleep(100);
        }
        String result = ft.get();
        System.out.println("callable执行结果："+result);
    }
}

class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
        System.out.println("start by thread");
    }
}

class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
        System.out.println("start by runnable");
    }
}

// Callable有个<V>,代表call函数的返回值类型
class MyCallable<String> implements Callable<String> {
    //call方法可以抛出异常，而Runnable接口的run方法不可以
    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName());
        System.out.println("start by callable");
        String result= (String) "iherr";
        return result; // Runnable接口的run函数是没有返回值的
    }
}

public class ThreadJoin {

    public static void main(String[] args) throws InterruptedException {
        Thread t1= new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println("t1: "+i);
                try {
                    TimeUnit.MILLISECONDS.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"t1");

        Thread t2= new Thread(()->{
            for (int i = 0; i < 10; i++) {
                System.out.println("t2: "+i);
                try {
                    TimeUnit.MILLISECONDS.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"t2");

        //注意2个join加不加放在不同位置，效果是不同的
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("over");

    }
}

public class ThreadInterrupt {
    public static void main(String[] args) {
        Thread t= new Thread(()->{
            while(true) {
                try {
                    TimeUnit.SECONDS.sleep(3);
                    System.out.println("running");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break; //必须用break跳出循环，才能结束线程。否则捕获异常后会继续循环执行。
                }
            }
        });
        t.start();

        try {
            TimeUnit.SECONDS.sleep(7);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t.interrupt();

    }
}

public class ThreadYieldAndPriority {
    void m(){
        for (int i = 0; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName()+": "+i);
            if ("C".equals(Thread.currentThread().getName())) //C线程进行礼让
            {
                Thread.currentThread().yield();
            }
        }
    }
    public static void main(String[] args) {
        ThreadYieldAndPriority t = new ThreadYieldAndPriority();
        Thread t1 = new Thread(t::m,"A");
        Thread t2 = new Thread(t::m,"B");
        Thread t3 = new Thread(t::m,"C");
        t1.setPriority(Thread.MIN_PRIORITY); //1，A本应该最后执行完成
        t2.setPriority(Thread.MAX_PRIORITY); //10，C先执行完成
        t3.setPriority(Thread.NORM_PRIORITY); //5，C在线程中进行了礼让，因此可能会取代A，最后执行完成
        t1.start();
        t2.start();
        t3.start();
    }
}

import org.openjdk.jol.info.ClassLayout;
import org.openjdk.jol.vm.VM;

/*
JOL功能对JDK1.8的版本有要求，如没有数据报错，请用最新版本。
 */
public class NoLock {
    public static void main(String[] args) {
        final Object lock = new Object();
        //o.hashCode();
        //打印JVM的详细信息
        System.out.println(VM.current().details());
        //打印对应的对象头信息
        System.out.println(ClassLayout.parseInstance(lock).toPrintable()); //001，代表无锁
    }
}

import java.util.concurrent.TimeUnit;

public class ThreadSynchronized1 {
    private int count =10;
    private static int staticCount =10;
    private Object o=new Object();

    public void m1(){
        synchronized(o){ //任何线程要执行下面的代码，必须获得o的锁
            count--;
            System.out.println(Thread.currentThread().getName() +" count="+count);
        }
    }

    public void m2(){
        synchronized(this){ //任何线程要执行下面的代码，必须获得this的锁
            count--;
            System.out.println(Thread.currentThread().getName() +" count="+count);
        }
    }

    public synchronized void m3(){ //等同于m2，在方法的代码执行时要synchronized(this)
        count--;
        System.out.println(Thread.currentThread().getName() +" count="+count);
    }

    public static void m4(){
        synchronized (ThreadSynchronized1.class) { //对ThreadSynchronized1这个类的class对象上锁
            staticCount--;
            System.out.println(Thread.currentThread().getName() + " staticCount=" + staticCount);
        }
    }

    public synchronized static void m5(){ //等同于m4
        staticCount--;
        System.out.println(Thread.currentThread().getName() +" staticCount="+staticCount);
    }

    public synchronized void m6(){ //可重入
        System.out.println(Thread.currentThread().getName() +" count="+count);
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        m3();
    }
}

import org.openjdk.jol.info.ClassLayout;
import java.util.concurrent.TimeUnit;

public class BiasedLock {
    public static void main(String[] args) {

        //-XX:+UseBiasedLocking：开启偏向锁（jdk6及以上默认开启）
        //-XX:BiasedLockingStartupDelay=0：偏向锁默认延迟5s启动（测试时可开启，或者sleep几秒等待延迟开启）
        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        final Object lock = new Object();
        System.out.println(ClassLayout.parseInstance(lock).toPrintable()); //101，代表偏向锁
    }
}

import org.openjdk.jol.info.ClassLayout;

public class LightLock {
    public static void main(String[] args) {
        final Object lock = new Object();
        System.out.println(ClassLayout.parseInstance(lock).toPrintable()); //001，代表无锁
        //打印对应的对象头信息
        synchronized (lock) {
            System.out.println(ClassLayout.parseInstance(lock).toPrintable()); //000，代表轻量级锁
        }

        new Thread(() -> {
            synchronized (lock) {
                System.out.println(ClassLayout.parseInstance(lock).toPrintable());//000，代表轻量级锁
            }
        }).start();
    }
}

import org.openjdk.jol.info.ClassLayout;
import java.util.concurrent.TimeUnit;

public class WeightLock {
    public static void main(String[] args) {
        final Object lock = new Object();
        System.out.println(ClassLayout.parseInstance(lock).toPrintable()); //001，代表无锁

        new Thread(() -> {
            synchronized (lock) {
                System.out.println(ClassLayout.parseInstance(lock).toPrintable());//000，代表轻量级锁
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

        synchronized (lock) {
            System.out.println(ClassLayout.parseInstance(lock).toPrintable()); //010，代表重量级锁
        }
    }
}

public class RegexBasic {
    public static void main(String[] args) {

        String s1 ="321";
        System.out.println(s1.matches("0|[1-9]\\d*")); //true，数字
        System.out.println(s1.matches("\\d{3,}")); //true，至少3位的数字

        String s2 = "11.1";
        System.out.println(s2.matches("(-?\\d+)(\\.\\d+)?")); //true，浮点数
        System.out.println(s2.matches("[0-9]+(.[0-9]{2})?")); //false，有两位小数的正实数

        String s3 = "汉字";
        System.out.println(s3.matches("[\\u4e00-\\u9fa5]+")); //汉字

        String s4 = "_xxx123";
        System.out.println(s4.matches("\\w{3,20}")); //3-20个字符

        String email ="iherr@163.com";
        System.out.println(email.matches("\\w+@\\w+\\.\\w+"));

        String ip="49.0.0.1";
        System.out.println(ip.matches("(25[0-5]|2[0-4]\\d|[01]?\\d?\\d)(\\.(25[0-5]|2[0-4]\\d|[01]?\\d?\\d)){3}"));

        String phone="+86-13888888888";
        System.out.println(phone.matches("[\\+]?\\d{2,3}[-\\s]?1[3-9]{1}\\d{9}"));

        Pattern p = Pattern.compile("(\\d{3,4})\\-(\\d{7,8})");

        Matcher m = p.matcher("010-66666666");
        if (m.matches()) {
            String g1 = m.group(1);
            String g2 = m.group(2);
            System.out.println(g1);
            System.out.println(g2);
        } else {
            System.out.println("不匹配");
        }

        //贪婪匹配
        Pattern p2 = Pattern.compile("<(.+)>");
        Matcher m2 = p2.matcher("<h2>test</h2>");
        while (m2.find()){
            System.out.println(m2.group(1)); //h2>test</h2
            System.out.println(m2.start());
            System.out.println(m2.end());
        }

        //懒惰匹配
        Pattern p3 = Pattern.compile("<(.*?)>");
        Matcher m3 = p3.matcher("<h2>test</h2>");
        while (m3.find()){
            System.out.println(m3.group(1)); //h2，/h2
        }

        //(re)，匹配括号内的表达式，并获取这一匹配
        Pattern p4 = Pattern.compile("<h2>(.*)-(he.*)</h2>");
        Matcher m4 = p4.matcher("<h2>test-herr</h2>");
        while (m4.find()){
            System.out.println(m4.group(1)); //test
            System.out.println(m4.group(2)); //herr
        }

        // (?:re)，匹配括号内的表达式，但不获取匹配结果，不存储
        Pattern p5 = Pattern.compile("<h2>(.*)-(?:he.*)</h2>");
        Matcher m5 = p5.matcher("<h2>test-herr</h2>");
        while (m5.find()){
            System.out.println(m5.group(1)); //test
            //System.out.println(m5.group(2)); //报错，没有group 2
        }

        //(re)，匹配括号内的表达式，并获取这一匹配
        Pattern p6 = Pattern.compile("(\\d+)([a-z]+)\\1\\2");
        Matcher m6 = p6.matcher("123abc123ab");
        while (m6.find()){
            System.out.println(m6.group(1));
            System.out.println(m6.group(2));
        }

        String str = "hello herr";
        System.out.println(str.replaceFirst("\\w+" , "■"));    //输出■ herr，贪婪模式，匹配尽可能多字符
        System.out.println(str.replaceFirst("\\w+?" , "■"));    //输出■ello herr，懒惰模式，匹配尽可能少字符

        // “前向”和“后向”是指正则引擎匹配顺序，字符开始->结束的顺序为前
        System.out.println(str.replaceFirst("el(?=l)" , "■"));    //输出h■lo herr。前向肯定匹配，正向环视
        System.out.println(str.replaceFirst("el(?=m)" , "■"));    //输出hello herr。el前向不是m，无法匹配
        System.out.println(str.replaceFirst("el(?!=m)" , "■"));    //输出h■lo herr，前向否定匹配，el前向不是m，匹配成功
        System.out.println(str.replaceFirst("(?<=h)el" , "■"));    //输出h■lo herr，后向肯定匹配，el后向是h，匹配成功
        System.out.println(str.replaceFirst("(?<!a|b|c)el" , "■"));    //输出h■lo herr，后向否定匹配，el后向不是abc，匹配成功

        //边界
        String str2="process macpro";
        System.out.println(str2.replaceAll("(pro)" , "■")); //■cess mac■
        System.out.println(str2.replaceAll("(pro\\b)" , "■")); //process mac■
        System.out.println(str2.replaceAll("(^pro)" , "■")); //■cess macpro
        System.out.println(str2.replaceAll("(pro$)" , "■")); //process mac■
    }
}

public class StringBasic {
    public static void main(String[] args) throws UnsupportedEncodingException {

        //基本操作
        String s1 = "Hello";
        System.out.println(s1.substring(1, 3)); // el，子字符串，index从0开始
        System.out.println(s1.hashCode()); // 哈希值
        System.out.println(s1.length()); // 5，长度
        System.out.println(s1.charAt(1)); // e，获取指定索引的字符，index从0开始
        System.out.println(s1.toLowerCase()); // 小写，hello
        System.out.println(s1.toUpperCase()); // 大写，HELLO
        System.out.println(" hello ".trim()); // hello，去除空格
        System.out.println(s1.startsWith("He")); // true
        System.out.println(s1.endsWith("ll"));  // false

        String s2 = "hello world";
        System.out.println(s2.replace("h", "H").replace("w", "W")); // 字符串替换，Hello World
        System.out.println(s2.indexOf("lo")); // 3，字符串查找，index从0开始


        //正则匹配
        String s3 = "12345";
        System.out.println(s3.matches("\\d{4,14}")); //true，4-14位数字正则匹配

        String s4 = "192.168.0.1";
        String[] firstArray = s4.split("\\."); // ( [  {  } ]  ) ?  *  + . /  ^  - $  ¦ 等特殊字符需要转义，而转义符\也需要用\\转义
        String[] secondArray = s4.split("\\.", 2);
        for (String str : firstArray) {
            System.out.println(str);
        }

        // 格式化
        System.out.println(String.format("Hello,%s", "herr"));
        System.out.println(String.format("数数,%d %d %d", 1, 2, 3)); // 十进制
        System.out.println(String.format("换行:%n%s%n%s", "第1行", "第2行"));
        System.out.println(String.format("%x", 16)); // 十六进制，10
        System.out.println(String.format("%o", 16)); // 八进制，20

        // 其他类型转String
        System.out.println(String.valueOf(1)); // 1
        System.out.println(String.valueOf(true)); // true
        System.out.println(String.valueOf('c')); // c
        System.out.println(String.valueOf(new Object())); //调用object的toString方法


        // String比较，==为内存地址相同，equal为object类的equals方法，String重写了该方法，值相同也为true
        String s10 = "hello"; //可能创建一个或者不创建对象，如常量池不存在hello，则创建字符串常量对象。如存在，直接指向即可。
        System.out.println(s10 == s1); // true，常量池，指向相同

        String s11 = "he" + "llo"; // 连接字符串，还是字符串常量池
        System.out.println(s11 == s1); //true

        String s12 = "llo";
        String s13 = "he" + s12; //有变量，需要编译，指向的是堆，也会创建常量池，由堆指向
        System.out.println(s13 == s1); //false

        String s14 = new String("hello"); // 可能创建了2个对象，一个是String对象存放在堆中，一个是字符串常量对象存放在常量池中（如果之前没有）
        String s15 = new String("hello");
        System.out.println(s15 == s14); // false。初始化使用new，不是常量池，指向不同
        System.out.println(s15.equals(s14)); /// true。值相同

        System.out.println(s15.compareTo("j")); // -2,逐个char进行ascii值比较
        System.out.println(s15.compareTo("g")); // 1
        System.out.println(s15.compareTo("Hi")); // 32

        String s21 = new String("hello") + new String("1");
        String s22 = s21.intern(); //true，系统首先会到常量池中查找是否有字面量是"hello1"的常量，没有则常量池新增一块空间来保存堆中“hello1”的地址。
        System.out.println(s21 == s22);

        String s23 = new String("hello") + new String("2");
        String s24 = "hello2";
        String s25 = s23.intern(); //false，系统首先会到常量池中查找是否有字面量是"hello2"的常量，有则返回对应的引用
        System.out.println(s23 == s25);

        // String类为不可变字符串，创建后无法改变。看起来可以赋值，实际上会重新创建一个新的String对象并指向
        String s30 = "aa";
        s30 = "bb";
        System.out.println(s30); // 打印出来的a为bb

        // StringBuffer类为可变字符串，且线程安全（方法都添加了synchronized关键字）。
        // StringBuilder类为可变字符串，线程不安全，方法基本和StringBuffer差不多，但效率较StringBuffer高。
        StringBuilder stringBuilder = new StringBuilder("aa");
        stringBuilder.setCharAt(0, 'A'); // Aa
        stringBuilder.append("bb").append("cc"); // 添加，Aabbcc
        stringBuilder.delete(2, 4);  // 删除index [2,4)位，Aacc
        stringBuilder.insert(2, "dd"); // 在index=2的位置插入，Aaddcc
        System.out.println(stringBuilder); // Aaddcc
        // 扩容规则：实例化时有str，则为str长度+16。无参构造器为16。达到容量x后，扩容后的容量2倍x+2。
        System.out.println(stringBuilder.capacity()); // 18，容量
        System.out.println(stringBuilder.length()); //6，实际长度

        // 字符集、字符编码

        // GB2312，2个字符
        byte[] b_gb2312 = "何".getBytes("GB2312");   //[-70,-50]，b_gb2312的长度为2
        String s_gb2312 = new String(b_gb2312, "GB2312"); // 何
        byte[] b_gb2312_other = "旸".getBytes("GB2312"); //[63]
        String s_gb2312_other = new String(b_gb2312_other, "GB2312"); //无法解析，有些生僻字不在该字符集中

        // GBK，2个字符
        byte[] b_gbk = "何".getBytes("GBK");  //[-70,-50]，和GB2312一样，b_gbk的长度为2
        String s_gbk = new String(b_gbk, "GBK"); // 何
        byte[] b_gbk_other = "旸".getBytes("GBK");  //b_gbk的长度为2
        String s_gbk_other = new String(b_gbk_other, "GBK"); //gbk的20000个字符包含生僻字，可解析
        // 何的gbk两个字节，bace
        String ss1 = Integer.toHexString(-70); //ffffffba，可以直接通过公式：0xffffffba & 0xff实现。即BA
        String ss2 = Integer.toHexString(-50); //ffffffce ，即CE

        // b_iso88591，1个字符
        byte[] b_iso88591 = "何".getBytes("ISO8859-1");//   b_iso88591的长度为1，为单字节，无法表示汉字
        String s_iso88591 = new String(b_iso88591, "ISO8859-1"); //无法解析
        //可以将字符串先编码成utf-8，再编码成b_iso88591。解析时先解码b_iso88591，再解码utf-8，可正常识别汉字
        String s_iso8859_1 = new String("何".getBytes("UTF-8"), "ISO8859-1");
        String s_utf8_1 = new String(s_iso8859_1.getBytes("ISO8859-1"), "UTF-8");

        // UTF-8，没有字节序
        byte[] b_utf8 = "何".getBytes("UTF-8");   //b_utf8的长度为3,[-28,-67,-107]，如-28的原码10011100，反码11100011，补码11100100
        String s_utf8 = new String(b_utf8, "UTF-8");
        // 何的utf8三个字节，E4BD95
        String sss1 = Integer.toHexString(-28); //ffffffe4，可以直接通过公式：0xffffffe4 & 0xff实现。即e4
        String sss2 = Integer.toHexString(-67); //ffffffbd ，即bd
        String sss3 = Integer.toHexString(-107); //ffffff95 ，即95

        //UTF-16，默认字节序为Big Endian（大端）：FEFF，即为-2，-1。如果是Little Endian（小端）：则为FFFE，即为-1，-2
        byte[] b_unicode = "何".getBytes("unicode");
        byte[] b_utf16 = "何".getBytes("UTF-16"); //b_unicode长度应为2，在BPM范围外的扩展为4
        String s_unicode = new String(b_unicode, "unicode");
        byte[] b_utf32 = "何".getBytes("UTF-32");
        String s_utf32 = new String(b_utf32, "UTF-32");

        //JVM规范规定了采用大端序，因此ByteBuffer默认是Big_Endian
        int x = 0x01020304;
        ByteBuffer bb = ByteBuffer.wrap(new byte[4]);
        bb.asIntBuffer().put(x);
        String ss = Arrays.toString(bb.array());
        System.out.println(bb.order() + "," + ss);

        //Intel和AMD的cpu默认一般是Little_Endian
        //bb.order(ByteOrder.LITTLE_ENDIAN);
        bb.order(ByteOrder.nativeOrder());
        bb.asIntBuffer().put(x);
        String sss = Arrays.toString(bb.array());
        System.out.println(bb.order() + "," + sss);


        System.out.println("何".length()); //1
        System.out.println("何".getBytes("UTF-8").length); //3，没有BOM + 1个3字节的UTF-8
        System.out.println("何".getBytes("UTF-16").length); //4，包括2字节的BOM + 1个2字节的UTF-16

        System.out.println("何何".length()); //2
        System.out.println("何何".getBytes("UTF-16").length); //6，包括2字节的BOM + 2个2字节的UTF-16

        String l2 = "\uD83C\uDF53"; //草莓图标，位于增补平面
        System.out.println(l2);
        System.out.println(l2.length()); //2
        System.out.println(l2.getBytes("UTF-16").length); //6，包括2字节的BOM + 1个4字节的UTF-8
    }

}

public class ArrayBasic {
    public static void main(String[] args) {

        // 声明，int是基本数据类型，但int[]是引用数据类型
        int[] arr; //等价于 int arr[];
        arr = new int[5];

        //arr[5]=1; // 数组不可变长，超出会报ArrayIndexOutOfBoundsException异常

        // 初始化，由于有类型声明，只能是同一种数据类型(对象的话可以存取子类)
        int[] arr2 = new int[]{5, 2, 8, 9}; //简化格式 int[] arr3 ={5,2,8,9};
        System.out.println(arr2.toString()); // [I@1b6d3586

        // Arrays工具类
        System.out.println(Arrays.toString(arr2)); // [5, 2, 8, 9]
        Arrays.sort(arr2);
        int[] arr3 = Arrays.copyOfRange(arr2, 0, 2); // [0.2)区间数组复制，[2,5]
        int[] arr4 = Arrays.copyOf(arr2, 6); // 数组复制，[2, 5, 8, 9, 0, 0]
        Arrays.fill(arr4, 4, 6, 1); // 数组指定元素赋值，[2, 5, 8, 9, 1, 1]

        // 遍历
        String[] arr5 = new String[2];
        arr5[0] = "aa";
        arr5[1] = "bb";
        for (String str : arr5) {
            System.out.println(str);
        }

        // 二维数组
        int[][] a = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}; // int a [][]=new int[3][4];
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.println(a[i][j]);
            }
            System.out.println();
        }

        //数组是支持协变的
        Object[] objArr = new Object[5];
        objArr[0] = "协变";
        objArr[1] = 2;
    }
}

Math.PI;   
Math.E;   
Math.sin(Math.PI);  
Math.exp(2);  
Math.log(2);  
Math.sqrt(4);  
Math.cbrt(8);  
Math.pow(2,2); //2的2次方  
Math.ceil(1.1); //大于等于参数的最小整数  
Math.floor(1.2); //小于等于参数的最大整数  
Math.rint(1.2); //最接近参数的整数，如一样近取偶数  
Math.abs(-1.1);  
Math.max(4,8);  
Math.min(4,8);

BigInteger value=new BigInteger(String val);
BigDecimal value=new BigDecimal(double val);
BigDecimal value=new BigDecimal(String val);

// enum关键字，其实是继承Enum类
enum SeasonEnum{
	SPRING,SUMMER,FALL,WINTER;
}

final class SeasonEnum extends Enum { // 继承自Enum，标记为final class
    // 每个实例均为全局唯一
    public static final int SPRING = 0;
    public static final int SUMMER = 1;
    public static final int FALL = 2;
    public static final int WINTER = 3;
    // private构造方法，确保外部无法通过new操作符调用
    private SeasonEnum() {}
}