Java核心基础小册

  public static void main(String[] args) {
        char c = 'a';
        byte b = 4;
        int i = 10;
        float f = 2.22f;
        double d = 10.0;
        long ln = 1000;
        short s = 11;
        //byte转short
        short s1 = b;
        System.out.println("byte转short:"+s1);
        //short转char
        char c1 = (char) s;
        System.out.println("short转char:"+c1);
        //char转int
        int i1 = c;
        System.out.println("char转int:"+i1);
        //int转long
        long l1 = i;
        System.out.println("int转long:"+l1);
        //long转float
        float f1 = ln;
        System.out.println("long转float:"+f1);
        //float转double
        double d2 = f;
        System.out.println("float转double:"+d2);
    }

byte转short:4
short转char:
char转int:97
int转long:10
long转float:1000.0
float转double:2.2200000286102295

public static void main(String[] args) {
    Car c1 = new Car();
    c1.brand = "路虎";
    c1.color = "黑色";
    c1.maxSpeed=5000;
    c1.run();
}

c1.brand = "路虎";
c1.color = "黑色";
c1.maxSpeed=5000;

 c1.run();

外部类.内部类 变量名 = 外部类实例.new 内部类构造方法();

package 面向对象.内部类;
/**
 * @author: Tisox
 * @date: 2022/3/29 9:54
 * @description:
 * @blog:www.waer.ltd
 */
public class OutFirst {
    private int width = 1024;
    public void print(){
        //外部类中访问非静态内部类
        Inner inner = new Inner(100,50);
        inner.print();
        System.out.println("外部类中访问内部类:"+inner.width);
        System.out.println("外部类访问内部类:"+inner.height);
    }
    /**
     * 静态块中不能访问非静态
     */
    public static void show(){
        // Inner inner = new Inner()
    }

    /**
     * 非静态内部类
     */
    public class Inner{
        private int width;
        private int height;

        public Inner(int width, int height) {
            this.width = width;
            this.height = height;
        }
        public void print() {
            System.out.println("内部类:"+this.width);
            System.out.println("内部类:"+this.height);
            //在非静态内部类中访问外部类的实例成员
            System.out.println("内部类中访问外部类的成员变量:"+OutFirst.this.width);
        }
        //在非静态内部类中不能定义静态成员 ，当然，静态块、静态方法也都是不允许的
        //public static int i;
    }
}

/**
 * @author: Tisox
 * @date: 2022/3/29 10:04
 * @description: 演示在其他类中访问内部类
 * @blog:www.waer.ltd
 */
public class InnerDemo {
    public static void main(String[] args) {
        /**
         * 在外部访问非静态内部类的方式
         * 需要先对内部类所在的外部类进行实例化，
         * 再根据这个实例new一个内部类的实例
         */
        OutFirst.Inner fInner = new OutFirst().new Inner(100,233);
        fInner.print();
    }
}

外部类.内部类 变量名 = new 外部类.内部类构造方法();

package 面向对象.内部类;

/**
 * @author: Tisox
 * @date: 2022/3/29 10:42
 * @description: 外部类，配合演示静态内部类
 * @blog:www.waer.ltd
 */
public class OutSecond {
    private int  size=100;
    private static int count=200;

    public void print(){
        System.out.println("外部类中访问内部类:"+Inner.color);
        Inner.show();
        Inner inner = new Inner("test");
        System.out.println(inner.name);
        //访问内部类中的非静态的成员方法
        inner.print();
    }

    public static void show(){
        System.out.println("外部类中访问内部类:"+Inner.color);
        Inner.show();
        Inner inner = new Inner("test");
        System.out.println(inner.name);
        //访问内部类中的非静态的成员方法
        inner.print();
    }

    //静态内部类
    public static class Inner{
        private String name;
        private static String color;

        static {
            color = "RED";
        }

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

        public void print() {
            //内部类中的非静态方法中可以访问它的非静态的成员
            System.out.println("内部类Inner:"+this.name);
            //静态内部类中访问外部类的静态成员
            System.out.println("内部类Inner访问外部类静态成员:"+OutSecond.count);
            //静态内部类中不可以访问外部类的非静态成员
            //  System.out.println("内部类Inner访问外部的实例:"+OutSecond.this.size);

        }
        public static void show() {
            System.out.println("内部类:"+color);
            //内部类静态方法中不能访问本类中的非静态有
            //System.out.println("内部类:"+name);
            //在内部类中的静态方法中可以访问外部类中的静态成员
            System.out.println("内部类:"+OutSecond.count);
        }
    }
}

//静态内部类
OutSecond.Inner.show();
//通过实例访问内部类的非静态方法
OutSecond.Inner inner = new OutSecond.Inner("DEMO");
inner.print();

new 父类构造器(参数列表【如果有的话】){
    ....
}

new 待实现的接口(){
    ....
}

public static final int SPRING = 1;

public enum Season {
    /**
     * 春夏秋冬
     */
    SPRING,SUMMER,FALL,WINTER
}

package 面向对象.Enum;

/**
 * @author: Tisox
 * @date: 2022/3/29 15:34
 * @description:
 * @blog:www.waer.ltd
 */
public enum Direction {
    /**
     * 方向枚举类
     */
    EAST("东"), SOUTH("南"), WEST("西"), NORTH("北");

    private final String name;


    Direction(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }
}

package 面向对象.Enum;

import java.util.concurrent.BrokenBarrierException;

/**
 * @author: Tisox
 * @date: 2022/3/29 15:18
 * @description:
 * @blog:www.waer.ltd
 */
@SuppressWarnings({"all"})
public class EnumDemo {
    public static void main(String[] args) {
        printSeasonWord(Season.SPRING);
        //遍历枚举值
        for (Season value : Season.values()){
            System.out.println(value);
        }
        //调用带构造器的枚举类
     System.out.println(Direction.NORTH.getName());
    }

    public static void printSeasonWord(Season season){
        switch (season){
            case SPRING:
                System.out.println("春天来了兄弟们");
                break;
            case  SUMMER:
                System.out.println("阳光海滩");
                break;
            case FALL:
                System.out.println("枫叶飘飘");
                break;
            case WINTER:
                System.out.println("白雪皑皑");
                break;
        }
    }
}

package 面向对象.Enum;

/**
 * @author: Tisox
 * @date: 2022/3/29 15:56
 * @description:
 * @blog:www.waer.ltd
 */

@SuppressWarnings({"all"})
public enum Gender implements Printer{
    /**
     * 性别
     */
    MALE(){
        @Override
        public void print() {
            System.out.println("男");
        }
    },
    FEMALE(){
        @Override
        public void print() {
            System.out.println("女");
        }
    }

    //    @Override
    //    public void print() {
    //        switch (this){
    //            case MALE :
    //                System.out.println("男");
    //                break;
    //            case FEMALE:
    //                System.out.println("女");
    //                break;
    //        }
    //    }
}

interface Printer{
    void print();
}

package 面向对象.Enum;

/**
 * @author: Tisox
 * @date: 2022/3/29 16:08
 * @description:
 * @blog:www.waer.ltd
 */
public enum Status {
    /**
     * 抽象枚举类
     */
    ON(){
        @Override
        public void print() {
            System.out.println("打开");
        }
    },
    OFF(){
        @Override
        public void print() {
            System.out.println("关闭");
        }
    };

    public abstract void print();
}

file = new File("E:/Javas/demoFile/1.txt");
file.createNewFile();

file.delete()

file.renameTo(new File("E:/Javas/demoFile/2.txt"));

System.out.println("是否存在："+file.exists());
System.out.println("是否文件："+file.isFile());
System.out.println("是否可读："+file.canRead());
System.out.println("是否可写："+file.canWrite());
System.out.println("绝对路径："+file.isAbsolute());

System.out.println("文件名称："+file.getName());
System.out.println("文件路径："+file.getPath());
System.out.println("绝对路径："+file.getAbsolutePath());
System.out.println("上级目录："+file.getParent());
System.out.println("文件长度："+file.length());
System.out.println("最后修改时间："+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(file.lastModified()));

 file = new File("E:/Javas/demoFile/a");
 //创建目录
 file.mkdirs();

System.out.println(Arrays.toString(file.listFiles()));

 System.out.println(Arrays.toString(file.getParentFile().listFiles()));

files = dir.listFiles(new FileFilter() {
  @Override
  public boolean accept(File pathname) {
                if(pathname.getName().endsWith(".txt")){
                    return true;
                }
                return false;
            }
        });

files = dir.listFiles(new FilenameFilter() {
   @Override
   public boolean accept(File dir, String name) {
                if(name.endsWith(".java")){
                    return true;
                }
                return false;
            }
        });

javas
  .idea
     + .gitignore
     + .name
    inspectionProfiles
       + Project_Default.xml
     + misc.xml
     + modules.xml
     + workspace.xml
   + abc.txt
  demoFile
     + 1.txt
     + 2.txt
    a
     + Demo1.java
   + JavaBases.iml
  out
    production
      JavaBases
        File
           + Demo1.class
           + Demo2$1.class
           + Demo2$2.class
           + Demo2.class
           + Demo3.class
  src
    File
       + Demo1.java
       + Demo2.java
       + Demo3.java

 public static void printFile(String filePath,int depth){
        File file =  new File(filePath);
        if(!file.exists()){
            throw new IllegalArgumentException("文件不存在！");
        }
        //打印缩进
        for(int i=0;i<depth; i++){
            System.out.print("  ");
        }
        //打印名字
        if(file.isFile()){
            System.out.print(" + ");
        }
        System.out.println(file.getName());
        //对目录递归
        if(file.isDirectory()){
            File[] files = file.listFiles();
            for (File f : files) {
                printFile(f.getPath(),depth+1);
            }
        }
    }

 /**
     * 字节流实现文件拷贝
     * @param srcFilePath 来源文件
     * @param destFilePath 目标文件
     */
    public static void copyFile(String srcFilePath,String destFilePath){
        try (FileInputStream fis = new FileInputStream(srcFilePath);
            FileOutputStream fos = new FileOutputStream(destFilePath);
        ){
            byte[] bytes = new byte[128];
            //实际读取的字节数
            int len = 0;
            //到文件末尾时len==-1
            while ((len=fis.read(bytes,0,128))>0){
                fos.write(bytes,0,len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

 /**
     * 字符流实现文件拷贝
     * @param srcFilePath 源文件
     * @param destFilePath 拷贝文件
     */
    public static void copyTextFile(String srcFilePath,String destFilePath){
        try(
                FileReader fr  = new FileReader(srcFilePath);
                FileWriter fw =  new FileWriter(destFilePath);
                ){
            char[] chars = new char[128];
            int len = 0;
            while((len = fr.read(chars,0,128))>0){
                /*将该字符数组从0开始，读取len个字符，并将其转为字符串*/
                //System.out.print(String.valueOf(chars,0,len));
                fw.write(chars, 0, len);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

  public static void copyFile(String srcFilePath,String destFilePath){
        try(
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFilePath));
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));

        ){
        byte[] bytes = new byte[128];
        int len = 0;
        while((len=bis.read(bytes,0,128))>0){
            bos.write(bytes,0,len);

            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

 public static void main(String[] args) {
        try(
            InputStreamReader r = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(r);
                ){
            String line = null;
            while ((line= br.readLine())!=null){
                if(line.equalsIgnoreCase("exit")){
                    break;
                }
                System.out.println(line);
            }
        }catch (IOException e) {
            e.printStackTrace();
        }
    }

  public static void main(String[] args) {
        //testPrintStream();
        testprintWriter();
    }

    public static void testPrintStream(){
        try(
                FileOutputStream fos = new FileOutputStream("E:/Javas/demoFile/2.txt");
                PrintStream ps = new PrintStream(fos);
        ){
            //输出到文件
            ps.println("白日依山尽");
            ps.println("黄河入海流");
            ps.println("欲穷千里目");
            ps.println("更上一层楼");

        }catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void testprintWriter(){
        try (
                FileWriter fw = new FileWriter("E:/Javas/demoFile/3.txt");
                PrintWriter pw = new PrintWriter(fw);
                ){
            //输出到文件
            pw.println("白日依山尽");
            pw.println("黄河入海流");
            pw.println("欲穷千里目");
            pw.println("更上一层楼");
        }catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void testRedirectOutput(){
        try(
                PrintStream ps = new PrintStream(
                        new FileOutputStream("E:/Javas/demoFile/out.txt")
                )
                ){
            System.setOut(ps);
            System.out.println("生存还是死亡");
            System.out.println("这是一个问题");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    public static void testRedirectInput() {
        try(
                FileInputStream fis = new FileInputStream("E:/Javas/demoFile/out.txt");
        ) {
            System.setIn(fis);
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNext()){
                System.out.println(scanner.next());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

 public static void main(String[] args) {
    try (
            //rw：读写模式
            RandomAccessFile raf = new RandomAccessFile("E:/Javas/demoFile/out.txt","rw");
            ){
        //定位到末尾
        raf.seek(raf.length());
        raf.write("欲穷千里目,\n".getBytes());
        raf.write("更上一层楼,\n".getBytes());
        //定位到开头
        raf.seek(0);
        String line = null;
        while ((line=raf.readLine())!=null){
            //String->bytes(UTF-8)
            //bytes->String(ISO8859-1)
            //String->bytes(ISO8859-1)
            //bytes->String(UTF-8)
            byte[] bytes = line.getBytes("ISO8859-1");
             line = new String(bytes, "UTF-8");
            System.out.println(line);
        }
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    }

1. 创建ObjectOutputStream对象。
1. 调用该对象的writeObject()方法，以输出对象序列。

class Car implements Serializable {
    private String brand;
    private String color;
    private int maxSpeed;

    public Car(String brand, String color, int maxSpeed) {
        this.brand = brand;
        this.color = color;
        this.maxSpeed = maxSpeed;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getMaxSpeed() {
        return maxSpeed;
    }

    public void setMaxSpeed(int maxSpeed) {
        this.maxSpeed = maxSpeed;
    }

    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", color='" + color + '\'' +
                ", maxSpeed=" + maxSpeed +
                '}';
    }
}

  public static void testSerialize(){
        try (
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:/Javas/demoFile/car.txt"));
        ){
            oos.writeObject(new Car("路虎","黑色",1000));
            oos.writeObject(new Car("奔驰","白色",1000));
            oos.writeObject(new Car("法拉利","黄色",1000));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 反序列化
     */
    public static void testDeserialize(){
        try (
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:/Javas/demoFile/car.txt"));
        ){
            System.out.println(ois.readObject());
            System.out.println(ois.readObject());
            System.out.println(ois.readObject());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

private static final long serialVersionUID = ...;

    private transient String password;

private void writeObject(ObjectOutputStream out) throws IOExecption;

private void readObject(ObjectInputStram in)
throws IOException,ClassNotFountException;

public static CharBuffer allocate(int capacity);

package Thread;

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

/**
 * @author: Tisox
 * @date: 2022/2/23 16:05
 * @description:
 * @blog:www.waer.ltd
 */
public class Demo1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.
//        new First().start();
//        new First().start();
        //2.
//        new Thread(new Second()).start();
//        new Thread(new Second()).start();
        //3.
        FutureTask<String> task0 = new FutureTask<String>(new Third());
        FutureTask<String> task1 = new FutureTask<String>(new Third());
        new Thread(task0).start();
        new Thread(task1).start();
        //阻塞方法
        System.out.println("返回值-0：\t"+task0.get());
        System.out.println("返回值-1：\t"+task1.get());

        //main默认为主线程
    }

    /**
     * 第一种实现方式
     */
    private static class First extends Thread{
        @Override
        public void run() {
            for(int i=0;i<10;i++){
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
        }
    }

    /**
     * 第二种实现方式
     */
    private static class Second implements Runnable {
        @Override
        public void run() {
            for(int i=0;i<10;i++){
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
        }
    }

    /**
     * 第三种实现方式
     */
    private static class Third implements Callable {
        @Override
        public String call() throws Exception {
                for(int i=0;i<10;i++){
                    System.out.println(Thread.currentThread().getName() + "\t" + i);
                }
            return Thread.currentThread().getName();
        }
    }
}

static int MAX_PRIORITY;//10
static int MIN_PRIORITY;//1
static int NORM_PRIORITY;//5
int getPriority()//获取线程优先级
void setPriority(int newPriority)//设置一个新的优先级    

package Thread;

/**
 * @author: Tisox
 * @date: 2022/2/27 14:53
 * @description: 演示控制线程方式
 * @blog:www.waer.ltd
 */
public class Demo3 {
    public static void main(String[] args) throws InterruptedException {
       // testJoinThread();
        //testDaemonThread();
        testThreadPriroity();
    }
    private static class JoinThreadTask implements Runnable {
        @Override
        public void run() {
            for(int i = 0; i <30;i++){
                System.out.println(Thread.currentThread().getName() + "\t"+i);
            }
        }
    }

    /**
     * 线程等待
     * @throws InterruptedException ex
     */
    public static void testJoinThread() throws InterruptedException {
        //启动线程
        new Thread(new JoinThreadTask()).start();
        for (int i = 0; i < 30; i++) {
            System.out.println(Thread.currentThread().getName() + "\t\t"+i);
            if(i==10){
                //th0
                Thread thread = new Thread(new JoinThreadTask());
                thread.start();
                //main线程会等待th1线程执行结束之后再继续执行。
                thread.join();
            }
        }
    }

    /**
     * 演示后台线程
     */
    private static class  DeamdomThreadTask implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + "\t"+i);
            }
        }
    }

    /**
     * 测试后台线程
     */
    public static void testDaemonThread(){
        //后台线程
        Thread thread = new Thread(new DeamdomThreadTask());
        //注意：需要先设置为后台线程，再进行start()
        thread.setDaemon(true);
        thread.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "\t\t"+i);
        }
    }

    private static class PriorityThreadtask implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10000; i++) {
                System.out.println(Thread.currentThread().getName() + "\t"+i);
            }
        }
    }

    public static void testThreadPriroity(){
        Thread thread0 = new Thread(new PriorityThreadtask());
        Thread thread1 = new Thread(new PriorityThreadtask());

//        System.out.println(Thread.currentThread().getPriority());
//        System.out.println(thread0.getPriority());
//        System.out.println(thread1.getPriority());
        thread0.setPriority(Thread.MAX_PRIORITY);
        thread0.start();
        thread1.setPriority(Thread.MIN_PRIORITY);
        thread1.start();
    }
}

  //通过校验，成功购票
            synchronized (this){
                this.amount -= amount;
                String name = Thread.currentThread().getName();
                System.out.println(name+"购买成功，剩余数量："+this.amount);
            }

  /*买票*/
        public synchronized void buy(int amount){
            if(this.amount<amount){
                throw new IllegalArgumentException("余票不足！");
            }
            //模拟数据校验花费的时间
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //通过校验，成功购票
            this.amount -= amount;
            String name = Thread.currentThread().getName();
            System.out.println(name+"购买成功，剩余数量："+this.amount);

        }

 private Lock lock = new ReentrantLock();
  public void buy(int amount){
            if(this.amount<amount){
                throw new IllegalArgumentException("余票不足！");
            }
            //模拟数据校验花费的时间
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            lock.lock();
            try {
                //通过校验，成功购票
                this.amount -= amount;
                String name = Thread.currentThread().getName();
                System.out.println(name+"购买成功，剩余数量："+this.amount);
            }finally {
                lock.unlock();
            }

package Thread;

/**
 * @author: Tisox
 * @date: 2022/2/27 16:55
 * @description: 演示死锁
 * @blog:www.waer.ltd
 */
public class Demo5 {
    public static void main(String[] args) {
        String a = "A";
        String b = "B";
        new Thread(new FirstTask(a,b)).start();
        new Thread(new SecondTask(a,b)).start();
    }
    private static class FirstTask implements Runnable {
        private Object a;
        private Object b;

        public FirstTask(Object a, Object b) {
            this.a = a;
            this.b = b;
        }

        @Override
        public void run() {
            synchronized (a){
                try{
                    //do something
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (b){
                    System.out.println("First");
                }
            }
        }
    }


    private static class SecondTask implements Runnable {
        private Object a;
        private Object b;

        public SecondTask(Object a, Object b) {
            this.a = a;
            this.b = b;
        }

        @Override
        public void run() {
            synchronized (b){
                try{
                    //do something
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                synchronized (a){
                    System.out.println("Second");
                }
            }
        }
    }
}

package Thread;

/**
 * @author: Tisox
 * @date: 2022/2/27 17:36
 * @description: 演示线程通信[synchronized]：秒杀场景
 * @blog:www.waer.ltd
 */
public class Demo6 {
    public static void main(String[] args) throws InterruptedException {
        Product product = new Product(0);
        for (int i = 0; i < 100;i++) {
            new Thread(new BuyTask(product),"顾客"+i).start();
        }
        Thread.sleep(3000);
        new Thread(new SellTask(product),"卖家").start();
    }

    private static class Product{
        private  int amount;

        public Product(int amount) {
            this.amount = amount;
        }

        public int getAmount() {
            return amount;
        }

        public void setAmount(int amount) {
            this.amount = amount;
        }
    }

    private static class BuyTask implements Runnable {
        private Product product;

        public BuyTask(Product product) {
            this.product = product;
        }

        @Override
        public void run() {
            synchronized (product){
                String name = Thread.currentThread().getName();
                while (product.getAmount()==0){
                    try {
                        System.out.println(name+"已经做好装备，等待抢购....");
                        product.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                product.setAmount(product.getAmount()-1);
                System.out.println(name+"抢到了一件商品，剩余库存,"+product.getAmount());
            }
        }
    }

    private static class SellTask implements Runnable {
        private Product product;

        public SellTask(Product product) {
            this.product = product;
        }

        @Override
        public void run() {
            synchronized (product){
                product.setAmount(10);
                String name  = Thread.currentThread().getName();
                System.out.println(name+"上架了10件商品，剩余库存"+product.getAmount());
                //通知所有买方
                product.notifyAll();
            }
        }
    }
}

Condition condition = lock.newCondition();

package Thread;

/**
 * @author: Tisox
 * @date: 2022/2/27 17:36
 * @description: 演示线程通信[synchronized]：秒杀场景
 * @blog:www.waer.ltd
 */
public class Demo6 {
    public static void main(String[] args) throws InterruptedException {
        Product product = new Product(0);
        for (int i = 0; i < 100;i++) {
            new Thread(new BuyTask(product),"顾客"+i).start();
        }
        Thread.sleep(3000);
        new Thread(new SellTask(product),"卖家").start();
    }

    private static class Product{
        private  int amount;

        public Product(int amount) {
            this.amount = amount;
        }

        public int getAmount() {
            return amount;
        }

        public void setAmount(int amount) {
            this.amount = amount;
        }
    }

    private static class BuyTask implements Runnable {
        private Product product;

        public BuyTask(Product product) {
            this.product = product;
        }

        @Override
        public void run() {
            synchronized (product){
                String name = Thread.currentThread().getName();
                while (product.getAmount()==0){
                    try {
                        System.out.println(name+"已经做好装备，等待抢购....");
                        product.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                product.setAmount(product.getAmount()-1);
                System.out.println(name+"抢到了一件商品，剩余库存,"+product.getAmount());
            }
        }
    }

    private static class SellTask implements Runnable {
        private Product product;

        public SellTask(Product product) {
            this.product = product;
        }

        @Override
        public void run() {
            synchronized (product){
                product.setAmount(10);
                String name  = Thread.currentThread().getName();
                System.out.println(name+"上架了10件商品，剩余库存"+product.getAmount());
                //通知所有买方
                product.notifyAll();
            }
        }
    }
}

public ThreadGroup(String name)
public ThreadGroup(ThreadGroup parent,String name)    

public Thread(ThreadGroup group,String name)
public Thread(ThreadGroup group,Runnable target)
public Thread(ThreadGroup group,Runnable target,String name)     

package Thread;

/**
 * @author: Tisox
 * @date: 2022/2/27 19:15
 * @description: 线程组
 * @blog:www.waer.ltd
 */
public class Demo8 {
    public static void main(String[] args) throws InterruptedException {
        //主线程的线程组
        ThreadGroup g = Thread.currentThread().getThreadGroup();
        System.out.println(g.getName()+","+g.isDaemon()+","+g.activeCount());
        //列出所有线程
        g.list();
        //子线程组
        Thread thread = new Thread(new ThreadTask());
        thread.start();
        System.out.println(thread);
        //自定义线程组
        g = new ThreadGroup("TEST");
        g.setDaemon(true);
        thread = new Thread(g,new ThreadTask());
        thread.start();
        System.out.println(thread);
        //销毁的后台线程组
        Thread.sleep(1000);
        System.out.println(g.isDestroyed());
        //异常处理器
        Thread.setDefaultUncaughtExceptionHandler(
                new Thread.UncaughtExceptionHandler(){
                    @Override
                    public void uncaughtException(Thread t, Throwable e) {
                        System.out.println(t+"->"+e);
                    }
                }
        );
        System.out.println(6/0);
    }

    private static  class ThreadTask implements Runnable {
        @Override
        public void run() {
            System.out.println(System.currentTimeMillis());
        }
    }
}

ExecutorService newFixedthreadPool(int nThreads)
    ScheduleExecutorService newScheduleThreadPool(int corePoolSize)

package Thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * @author: Tisox
 * @date: 2022/2/28 10:47
 * @description: 线程池
 * @blog:www.waer.ltd
 */
public class Demo9 {
    private static ExecutorService threadPool = Executors.newFixedThreadPool(3);
    private static ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(3);

    public static void main(String[] args) {
        Runnable threadTask = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "execute a thread task.");
            }
        };
        for (int i = 0; i < 10;i++) {
            threadPool.submit(threadTask);
        }

        Runnable schecduledTask = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "execute a schecduledTask task.");
            }
        };
        //首次延迟5s,之后时间间隔3执行一次，时间间隔秒
        for (int i=0;i<5;i++){
            scheduledPool.scheduleAtFixedRate(schecduledTask,5,3, TimeUnit.SECONDS);
        }
    }
}

package Thread;

import java.util.concurrent.*;

/**
 * @author: Tisox
 * @date: 2022/2/28 11:33
 * @description:
 * @blog:www.waer.ltd
 */
public class Demo10 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        int[] nums = new int[100];
        for(int i = 1;i<=100;i++){
            nums[i-1] = i;
        }
        ForkJoinPool pool  = new ForkJoinPool();
       Future<Integer> future =  pool.submit(new Fjtask(nums,0,nums.length-1));
        System.out.println(future.get());
    }

    private static class Fjtask extends RecursiveTask<Integer>{
        //拆解阈值
        private static final int THRESHOLD = 10;
        private int[] nums;
        private int start,end;

        public Fjtask(int[] nums, int start, int end) {
            this.nums = nums;
            this.start = start;
            this.end = end;
        }

        @Override
        protected Integer compute() {
            System.out.printf("%-25s\t%d,%d\n",Thread.currentThread().getName(),start,end);
            Integer sum = 0;
            if(end-start<THRESHOLD){
                for(int i = start;i<=end; i++){
                    sum += nums[i];
                }
            }else {
                int middle = (start+end)/2;
                Fjtask left = new Fjtask(nums,start,middle);
                Fjtask right = new Fjtask(nums,middle+1,end);
                left.fork();
                right.fork();
                sum = left.join()+right.join();
            }
            return sum;
        }
    }
}

// 代码演示
/*本机InetAddress对象*/
InetAddress localHost = InetAddress.getLocalHost();
/*沉迷代码日渐消瘦/192.168.74.48*/
System.out.println(localHost);

/*根据指定的主机名获取InetAddress对象*/
InetAddress host1 = InetAddress.getByName("沉迷代码日渐消瘦");
System.out.println("沉迷代码日渐消瘦的[InetAddress]对象："+host1);

/*根据域名返回InetAddress对象*/
InetAddress inetAddress = InetAddress.getByName("www.waer.ltd");
System.out.println("域名[www.waer.ltd]的[InetAddress]对象:"+inetAddress);

/*通过InetAddress对象获取对应的地址*/
String hostAddress = inetAddress.getHostAddress();
System.out.println("host2对应的[IP]："+hostAddress);

/*通过InetAddress获取主机名或者域名*/
String hostName = inetAddress.getHostName();
System.out.println("host2对应的主机名或者域名:"+hostName);

public static void main(String[] args) throws IOException {
    /*监听9999端口，等待连接，请确保该端口号没有被占用*/
    ServerSocket serverSocket = new ServerSocket(9999);
    System.out.println("服务B端在[9999]端口监听，等待连接...");
    /*如果有连接，返回socket对象，程序继续，否则阻塞*/
    Socket socket = serverSocket.accept();

    System.out.println("服务端[B]socket:"+socket.getClass());

    /*读取数据*/
    InputStream inputStream = socket.getInputStream();
    /*IO读取*/
    byte[] buf = new byte[1024];
    int len = 0;
    while ((len = inputStream.read(buf))!=-1){
        System.out.println(new String(buf,0,len));
    }
    /*关闭流*/
    inputStream.close();
    socket.close();
    serverSocket.close();
}

public static void main(String[] args) throws IOException {
    /*连接本机9999端口*/
    Socket  socket = new Socket(InetAddress.getLocalHost(),9999);
    System.out.println("客户端[socket]返回:"+socket.getClass());

    /*写入数据*/
    OutputStream outputStream = socket.getOutputStream();
    outputStream.write("hello,server".getBytes());
    /*关闭资源*/
    outputStream.close();
    socket.close();
}

public static void main(String[] args) throws IOException {
    /*监听9999端口，等待连接，请确保该端口号没有被占用*/
    ServerSocket serverSocket = new ServerSocket(9999);
    System.out.println("服务B端在[9999]端口监听，等待连接...");
    /*如果有连接，返回socket对象，程序继续，否则阻塞*/
    Socket socket = serverSocket.accept();

    System.out.println("服务端[B]socket:"+socket.getClass());

    /*读取数据*/
    InputStream inputStream = socket.getInputStream();
    /*IO读取*/
    byte[] buf = new byte[1024];
    int len = 0;
    while ((len = inputStream.read(buf))!=-1){
        System.out.println(new String(buf,0,len));
    }

    /*向客户端回复消息*/
    OutputStream outputStream = socket.getOutputStream();
    outputStream.write("hello,client".getBytes());
    socket.shutdownOutput();

    /*关闭流*/
    inputStream.close();
    outputStream.close();
    socket.close();
    serverSocket.close();
}

public static void main(String[] args) throws IOException {
    /*连接本机9999端口*/
    Socket  socket = new Socket(InetAddress.getLocalHost(),9999);
    System.out.println("客户端[socket]返回:"+socket.getClass());

    /*写入数据*/
    OutputStream outputStream = socket.getOutputStream();
    outputStream.write("hello,server".getBytes());
    /*结束标记*/
    socket.shutdownOutput();
    /*接收来自服务端回复的消息*/
    InputStream inputStream = socket.getInputStream();
    byte[] buf = new byte[1024];
    int len = 0;
    while((len = inputStream.read(buf))!=-1){
        System.out.println(new String(buf,0,len));
    }
    /*关闭资源*/
    outputStream.close();
    inputStream.close();
    socket.close();
}

public static void main(String[] args) throws IOException {
    /*监听9999端口，等待连接，请确保该端口号没有被占用*/
    ServerSocket serverSocket = new ServerSocket(9999);
    System.out.println("服务B端在[9999]端口监听，等待连接...");
    /*如果有连接，返回socket对象，程序继续，否则阻塞*/
    Socket socket = serverSocket.accept();

    System.out.println("服务端[B]socket:"+socket.getClass());

    /*读取客户端法来的数据*/
    InputStream inputStream = socket.getInputStream();
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
    String s = bufferedReader.readLine();
    System.out.println(s);

    /*向客户端回复消息*/
    OutputStream outputStream = socket.getOutputStream();
    BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
    bufferedWriter.write("[字符流]hello,client,我是服务端啊");
    /*插入一个换行符，标识回复内容结束*/
    bufferedWriter.newLine();
    /*需要手动flush，否则可能无法将数据写入传输通道*/
    bufferedWriter.flush();

    /*关闭流:先打开的后关闭*/
    bufferedWriter.close();
    bufferedReader.close();
    socket.close();
}

public static void main(String[] args) throws IOException {
    /*连接本机9999端口*/
    Socket  socket = new Socket(InetAddress.getLocalHost(),9999);
    System.out.println("客户端[socket]返回:"+socket.getClass());

    /*写入数据*/
    OutputStream outputStream = socket.getOutputStream();
    BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
    bufferedWriter.write("[字符流]hello,server.我是客户端啊");
    bufferedWriter.newLine();
    bufferedWriter.flush();
    /*结束标记*/
    socket.shutdownOutput();
    /*接收来自服务端回复的消息*/
    InputStream inputStream = socket.getInputStream();
    BufferedReader bufferedReader= new BufferedReader(new InputStreamReader(inputStream));
    String s = bufferedReader.readLine();
    System.out.println(s);
    /*关闭资源*/
    bufferedReader.close();
    bufferedWriter.close();
    socket.close();
}

public static void main(String[] args) throws IOException {
    //客户端连接服务端 8888，得到Socket对象
    Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
    //创建读取磁盘文件的输入流
    //String filePath = "e:\\qie.png";
    String filePath = "e:\\temp\\可怜.jpg";
    BufferedInputStream bis  = new BufferedInputStream(new FileInputStream(filePath));

    //bytes 就是filePath对应的字节数组
    byte[] bytes = StreamUtils.streamToBytesArray(bis);

    //通过socket获取到输出流, 将bytes数据发送给服务端
    BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
    bos.write(bytes);//将文件对应的字节数组的内容，写入到数据通道
    bis.close();
    socket.shutdownOutput();//设置写入数据的结束标记

    //=====接收从服务端回复的消息=====

    InputStream inputStream = socket.getInputStream();
    //使用StreamUtils 的方法，直接将 inputStream 读取到的内容 转成字符串
    String s = StreamUtils.streamToString(inputStream);
    System.out.println(s);


    //关闭相关的流
    inputStream.close();
    bos.close();
    socket.close();
}

//Java5
List<String> list = new ArrayList<String>();
Map<String,Integer> map = new HashMap<String,Integer>();
//Java7之后
List<String> list = new ArrayList<>();
Map<String,Integer> map = new HashMap<>();

List<String> list  =   new ArrayList<>();
list.add("hello！");
//这里会报错，我们传入的泛型类型参数为String，而下面的尝试添加一个整型的元素，会报一个类型不兼容的异常。
list.add(3);
//会报错
java: 不兼容的类型: int无法转换为java.lang.String

Map<String,Integer> map = new HashMap<>();
Vector<Double> vector = new Vector<>();
Set<Float> set = new HashSet<>();
LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
.....

public interface List<E> extends Collection<E> {
     boolean add(E e);
    Interator<E> iterator();
}

public interface Map<K, V> {
         V put(K key, V value);
        Set<Map.Entry<K, V>> entrySet();
}

class Foo<T>{
    private T data;
    public Foo(T data) {
        this.data = data;
    }
    public T getData() {
        return data;
    }
}

//错误用法:这里的类型T应该传入一个具体的实际参数，而不是继续使用形参。
class Son extends Father<T>{}

//子类中T都将被替换成String类型
class Son extends Father<String>{}

//可以允许不为类型形参传入实参
class Son extends Father{}

List<String> list1  =   new ArrayList<>();
List<Double> list2  =   new ArrayList<>();
//返回true
System.out.println(list1.getClass()==list2.getClass());

class Foo<T extends Number>{}

package 泛型;

/**
 * @author: Tisox
 * @date: 2022/3/27 22:17
 * @description:
 * @blog:www.waer.ltd
 */
public class demo_3 {
    public static void main(String[] args) {
    //下面这一句代码将会报错
        First<String> first2 = new First("hello");
        First<Double> first3 = new First(100);

    }
}

class First<T extends Number>{
    private T data;

    public First(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "First{" +
            "data=" + data +
            '}';
    }
}
//异常信息
java: 类型参数java.lang.String不在类型变量T的范围内

public static void add(List<? extends Number> list)

import java.util.Arrays;
import java.util.List;

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

        // Upper Bounded Integer List
        List<Integer> list1 = Arrays.asList(4, 5, 6, 7);

        // printing the sum of elements in list
        System.out.println("Total sum is:" + sum(list1));

        // Double list
        List<Double> list2 = Arrays.asList(4.1, 5.1, 6.1);

        // printing the sum of elements in list
        System.out.print("Total sum is:" + sum(list2));
    }

    private static double sum(List<? extends Number> list)
    {
        double sum = 0.0;
        for (Number i : list) {
            sum += i.doubleValue();
        }

        return sum;
    }
}
//输出
Total sum is:22.0
Total sum is:15.299999999999999

// Java program to demonstrate Lower Bounded Wildcards

import java.util.Arrays;
import java.util.List;

class WildcardDemo {
    public static void main(String[] args)
    {
        // Lower Bounded Integer List
        List<Integer> list1 = Arrays.asList(4, 5, 6, 7);

        // Integer list object is being passed
        printOnlyIntegerClassorSuperClass(list1);

        // Number list
        List<Number> list2 = Arrays.asList(4, 5, 6, 7);

        // Integer list object is being passed
        printOnlyIntegerClassorSuperClass(list2);
    }

    public static void printOnlyIntegerClassorSuperClass(
        List<? super Integer> list)
    {
        System.out.println(list);
    }
}
//输出
[4, 5, 6, 7]
[4, 5, 6, 7]

修饰符 <S,T>返回值类型 方法名 (参数列表){...}

static void fromArrayToCollection(Object[] a, Collection<?> c) {
    for (Object o : a) { 
        c.add(o); // 编译错误
    }
}