//创建一个默认的 Calendar对象
Calendar calendar=Calendar.getInstance();
/从 Calendar对象中取出Date对象
Date date=calendar.getTime();

//通过Date对象获得对应的Calendar对象
Calendar calendar=Calendar.getInstance();
calendar. setTime(new Date());

// 获取今天的日历
Calendar c = Calendar.getInstance();
// 取出年
System.out.println(c.get(YEAR));
// 取出月份
System.out.println(c.get(MONTH));
// 取出日
System.out.println(c.get(DATE));
System.out.println("-------------------------");
// 分别设置年、月、日、小时、分钟、秒
c.set(2003, 10, 23, 12, 32, 23); // 2003-11-23 12:32:23
System.out.println(c.getTime());
// 将Calendar的年前推1年
c.add(YEAR, -1); // 2002-11-23 12:32:23
System.out.println(c.getTime());
System.out.println("-------------------------");
// 将Calendar的月前推8个月
c.roll(MONTH, -8); // 2002-03-23 12:32:23
System.out.println(c.getTime());

System.out.println("-------------------------");
Calendar cal3 = Calendar.getInstance();
cal3.set(2003, 7, 23, 0, 0, 0); // 2003-8-23
// MONTH字段“进位”，但YEAR字段并不增加
cal3.roll(MONTH, 6); // 2003-8-23 => 2003-2-23
System.out.println(cal3.getTime());

System.out.println("-------------------------");
Calendar cal4 = Calendar.getInstance();
cal4.set(2003, 7, 31, 0, 0, 0); // 2003-8-31
// MONTH字段“进位”后变成2，2月没有31日，
// YEAR字段不会改变，2003年2月只有28天
cal4.roll(MONTH, 6); // 2003-8-31 => 2003-2-28
System.out.println(cal4.getTime());

import java.util.*;
import static java.util.Calendar.*;

public class LenientTest {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        // 结果是YEAR字段加1，MONTH字段为1（二月）
        cal.set(MONTH, 13); // ①
        System.out.println(cal.getTime());
        
        // 关闭容错性
        cal.setLenient(false);
        // 导致运行时异常
        cal.set(MONTH, 13); // ②
        System.out.println(cal.getTime());
    }
}

import java.util.*;
import static java.util.Calendar.*;

public class LazyTest {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        cal.set(2003, 7, 31); // 2003-8-31
        // 将月份设为9，但9月31日不存在。
        // 如果立即修改，系统将会把cal自动调整到10月1日。
        cal.set(MONTH, 8);

        // 下面代码输出10月1日
        System.out.println(cal.getTime()); //①
        
        // 设置DATE字段为5
        cal.set(DATE, 5); // ②
        System.out.println(cal.getTime()); // ③
    }
}

import java.util.Date;

public class DateTest {
    public static void main(String[] args) {
        Date date1 = new Date();
        Date date2 = new Date(System.currentTimeMillis() + 100);
        System.out.println(date2);
        System.out.println(date1.compareTo(date2));
        System.out.println(date2.after(date1));
    }
}

import java.math.*;

public class BigDecimalTest
{
    public static void main(String[] args)
    {
        BigDecimal f1 = new BigDecimal("0.05");
        BigDecimal f2 = BigDecimal.valueOf(0.01);

        BigDecimal f3 = new BigDecimal(0.05);
        System.out.println("使用String作为BigDecimal构造器参数：");
        System.out.println("0.05 + 0.01 = " + f1.add(f2));
        System.out.println("0.05 - 0.01 = " + f1.subtract(f2));
        System.out.println("0.05 * 0.01 = " + f1.multiply(f2));
        System.out.println("0.05 / 0.01 = " + f1.divide(f2));
        
        System.out.println("使用double作为BigDecimal构造器参数：");
        System.out.println("0.05 + 0.01 = " + f3.add(f2));
        System.out.println("0.05 - 0.01 = " + f3.subtract(f2));
        System.out.println("0.05 * 0.01 = " + f3.multiply(f2));
        System.out.println("0.05 / 0.01 = " + f3.divide(f2));
    }
}

import java.math.*;

public class Arith {
    // 默认除法运算精度
    private static final int DEF_DIV_SCALE = 10;

    // 构造器私有，让这个类不能实例化
    private Arith() {
    }

    // 提供精确的加法运算。
    public static double add(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.add(b2).doubleValue();
    }

    // 提供精确的减法运算。
    public static double sub(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.subtract(b2).doubleValue();
    }

    // 提供精确的乘法运算。
    public static double mul(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.multiply(b2).doubleValue();
    }

    // 提供（相对）精确的除法运算，当发生除不尽的情况时.
    // 精确到小数点以后10位的数字四舍五入。
    public static double div(double v1, double v2) {
        BigDecimal b1 = BigDecimal.valueOf(v1);
        BigDecimal b2 = BigDecimal.valueOf(v2);
        return b1.divide(b2, DEF_DIV_SCALE, RoundingMode.HALF_UP).doubleValue();
    }

    public static void main(String[] args) {
        System.out.println("0.05 + 0.01 = " + Arith.add(0.05, 0.01));
        System.out.println("1.0 - 0.42 = " + Arith.sub(1.0, 0.42));
        System.out.println("4.015 * 100 = " + Arith.mul(4.015, 100));
        System.out.println("123.3 / 100 = " + Arith.div(123.3, 100));
    }
}

import java.util.*;

public class RandomTest {
    public static void main(String[] args) {
        // 使用当前时间作为种子
        Random rand = new Random();
        // 生成随机的boolean值
        System.out.println("rand.nextBoolean()：" + rand.nextBoolean());

        byte[] buffer = new byte[16];
        rand.nextBytes(buffer);
        System.out.println("rand.nextBytes(buffer):"+Arrays.toString(buffer));

        // 生成0.0~1.0之间的伪随机double数
        System.out.println("rand.nextDouble()：" + rand.nextDouble());

        // 生成0.0~1.0之间的伪随机float数
        System.out.println("rand.nextFloat()：" + rand.nextFloat());

        // 生成平均值是 0.0，标准差是 1.0的 伪高斯数
        System.out.println("rand.nextGaussian()：" + rand.nextGaussian());

        // 生成一个处于int整数取值范围的 伪随机整数
        System.out.println("rand.nextInt()：" + rand.nextInt());

        // 生成0~26之间的伪随机整数
        System.out.println("rand.nextInt(26)：" + rand.nextInt(26));
        
        // 生成一个处于long整数取值范围的伪随机整数
        System.out.println("rand.nextLong()：" + rand.nextLong());
    }
}

import java.util.Random;

public class RandomIntN2MTest {

    public static void main(String[] args) {
        Random random = new Random();
        int times = 20;
        for (int i = 0; i < times; i++) {
            // 生成[0,2)之间的随机整数,也就是[0,1]之间的随机整数
            System.out.print(random.nextInt(2) + ",");
        }
        System.out.println();
        int min = 2, max = 4;
        for (int i = 0; i < times; i++) {
            // 生成[min,max)之间的随机正整数
            System.out.print((random.nextInt(max - min) + min) + ",");
        }
        System.out.println();
        for (int i = 0; i < times; i++) {
            // 生成[min,max]之间的随机正整数
            System.out.print((random.nextInt(max - min + 1) + min) + ",");
        }
    }
}

import java.util.*;

public class SeedTest {
    public static void main(String[] args) {
        Random r1 = new Random(50);
        System.out.println("第一个种子为50的Random对象");
        System.out.println("r1.nextBoolean():\t" + r1.nextBoolean());
        System.out.println("r1.nextInt():\t\t" + r1.nextInt());
        System.out.println("r1.nextDouble():\t" + r1.nextDouble());
        System.out.println("r1.nextGaussian():\t" + r1.nextGaussian());
        System.out.println("%%%%%%%%%%%%%%%%%%%%%%%%%%%%");

        Random r2 = new Random(50);
        System.out.println("第二个种子为50的Random对象");
        System.out.println("r2.nextBoolean():\t" + r2.nextBoolean());
        System.out.println("r2.nextInt():\t\t" + r2.nextInt());
        System.out.println("r2.nextDouble():\t" + r2.nextDouble());
        System.out.println("r2.nextGaussian():\t" + r2.nextGaussian());
        System.out.println("%%%%%%%%%%%%%%%%%%%%%%%%%%%%");
        
        Random r3 = new Random(100);
        System.out.println("种子为100的Random对象");
        System.out.println("r3.nextBoolean():\t" + r3.nextBoolean());
        System.out.println("r3.nextInt():\t\t" + r3.nextInt());
        System.out.println("r3.nextDouble():\t" + r3.nextDouble());
        System.out.println("r3.nextGaussian():\t" + r3.nextGaussian());
        System.out.println("%%%%%%%%%%%%%%%%%%%%%%%%%%%%");
    }
}

public class MathTest {
    
    public static void main(String[] args) {
        /*---------下面是三角运算---------*/
        // 将弧度转换角度
        System.out.println("Math.toDegrees(1.57)：" + Math.toDegrees(1.57));
        // 将角度转换为弧度
        System.out.println("Math.toRadians(90)：" + Math.toRadians(90));
        
        // 计算反余弦，返回的角度范围在 0.0 到 pi 之间。
        System.out.println("Math.acos(1.2)：" + Math.acos(1.2));
        // 计算反正弦；返回的角度范围在 -pi/2 到 pi/2 之间。
        System.out.println("Math.asin(0.8)：" + Math.asin(0.8));
        // 计算反正切；返回的角度范围在 -pi/2 到 pi/2 之间。
        
        System.out.println("Math.atan(2.3)：" + Math.atan(2.3));
        // 计算三角余弦。
        System.out.println("Math.cos(1.57)：" + Math.cos(1.57));
        // 计算值的双曲余弦。
        System.out.println("Math.cosh(1.2 )：" + Math.cosh(1.2));
        // 计算正弦
        System.out.println("Math.sin(1.57 )：" + Math.sin(1.57));
        // 计算双曲正弦
        System.out.println("Math.sinh(1.2 )：" + Math.sinh(1.2));
        // 计算三角正切
        System.out.println("Math.tan(0.8 )：" + Math.tan(0.8));
        // 计算双曲正切
        System.out.println("Math.tanh(2.1 )：" + Math.tanh(2.1));
        
        // 将矩形坐标 (x, y) 转换成极坐标 (r, thet));
        System.out.println("Math.atan2(0.1, 0.2)：" + Math.atan2(0.1, 0.2));
        
        /*---------下面是取整运算---------*/
        // 取整，返回小于目标数的最大整数。
        System.out.println("Math.floor(-1.2 )：" + Math.floor(-1.2));
        // 取整，返回大于目标数的最小整数。
        System.out.println("Math.ceil(1.2)：" + Math.ceil(1.2));
        // 四舍五入取整
        System.out.println("Math.round(2.3 )：" + Math.round(2.3));
        
        /*---------下面是乘方、开方、指数运算---------*/
        // 计算平方根。
        System.out.println("Math.sqrt(2.3 )：" + Math.sqrt(2.3));
        // 计算立方根。
        System.out.println("Math.cbrt(9)：" + Math.cbrt(9));
        // 返回欧拉数 e 的n次幂。
        System.out.println("Math.exp(2)：" + Math.exp(2));
        // 返回 sqrt(x2 +y2)
        System.out.println("Math.hypot(4 , 4)：" + Math.hypot(4, 4));
        // 按照 IEEE 754 标准的规定，对两个参数进行余数运算。
        System.out.println("Math.IEEEremainder(5 , 2)：" + Math.IEEEremainder(5, 2));
        // 计算乘方
        System.out.println("Math.pow(3, 2)：" + Math.pow(3, 2));
        // 计算自然对数
        System.out.println("Math.log(12)：" + Math.log(12));
        // 计算底数为 10 的对数。
        System.out.println("Math.log10(9)：" + Math.log10(9));
        // 返回参数与 1 之 和 的自然对数。
        System.out.println("Math.log1p(9)：" + Math.log1p(9));
        
        /*---------下面是符号相关的运算---------*/
        // 计算绝对值。
        System.out.println("Math.abs(-4.5)：" + Math.abs(-4.5));
        // 符号赋值，返回带有第二个浮点数符号的第一个浮点参数。
        System.out.println("Math.copySign(1.2, -1.0)：" + Math.copySign(1.2, -1.0));
        // 符号函数；如果参数为 0，则返回 0；如果参数大于 0，
        // 则返回 1.0；如果参数小于 0，则返回 -1.0。
        System.out.println("Math.signum(2.3)：" + Math.signum(2.3));
        
        /*---------下面是大小相关的运算---------*/
        // 找出最大值
        System.out.println("Math.max(2.3 , 4.5)：" + Math.max(2.3, 4.5));
        // 计算最小值
        System.out.println("Math.min(1.2 , 3.4)：" + Math.min(1.2, 3.4));
        // 返回第一个参数和第二个参数之间与第一个参数相邻的浮点数。
        System.out.println("Math.nextAfter(1.2, 1.0)：" + Math.nextAfter(1.2, 1.0));
        // 返回比目标数略大的浮点数
        System.out.println("Math.nextUp(1.2 )：" + Math.nextUp(1.2));
        // 返回一个伪随机数，该值大于等于 0.0 且小于 1.0。
        System.out.println("Math.random()：" + Math.random());
    }
}

import java.util.Objects;

public class ObjectsTest {
    // 定义一个obj变量，它的默认值是null
    static ObjectsTest obj;

    public static void main(String[] args) {
        // 输出一个null对象的hashCode值，输出0
        System.out.println(Objects.hashCode(obj));
        // 输出一个null对象的toString，输出null
        System.out.println(Objects.toString(obj));
        // 要求obj不能为null，如果obj为null则引发异常
        System.out.println(Objects.requireNonNull(obj, "obj参数不能是null！"));
    }
}

class Address {
    String detail;

    public Address(String detail) {
        this.detail = detail;
    }
}

// 实现Cloneable接口
class User implements Cloneable {
    int age;
    Address address;

    public User(int age) {
        this.age = age;
        address = new Address("花果山水帘洞");
    }

    // 通过调用super.clone()来实现clone()方法
    public User clone() throws CloneNotSupportedException {
        return (User) super.clone();
    }
}

public class CloneTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        User u1 = new User(29);
        // clone得到u1对象的副本。
        User u2 = u1.clone();
        // 不是相同的对象
        System.out.println(u1 == u2);
        // 只复制成员变量的值,不产生新对象,所以两个实例变量是同一个对象的引用
        System.out.println(u1.address == u2.address);
    }
}

public class RuntimeTest {
    public static void main(String[] args) {
        // 获取Java程序关联的运行时对象
        Runtime rt = Runtime.getRuntime();
        System.out.println("处理器数量：" + rt.availableProcessors());
        System.out.println("空闲内存数：" + rt.freeMemory());
        System.out.println("总内存数：" + rt.totalMemory());
        System.out.println("可用最大内存数：" + rt.maxMemory());
    }
}

public class ExecTest {
    public static void main(String[] args) throws Exception {
        Runtime rt = Runtime.getRuntime();
        // 运行记事本程序
        rt.exec("notepad.exe");
    }
}

import java.util.concurrent.*;

public class ProcessHandleTest {
    public static void main(String[] args) throws Exception {
        Runtime rt = Runtime.getRuntime();
        // 运行记事本程序
        Process p = rt.exec("notepad.exe");
        ProcessHandle ph = p.toHandle();
        System.out.println("进程是否运行: " + ph.isAlive());
        System.out.println("进程ID: " + ph.pid());
        System.out.println("父进程: " + ph.parent());
        // 获取ProcessHandle.Info信息
        ProcessHandle.Info info = ph.info();
        // 通过ProcessHandle.Info信息获取进程相关信息
        System.out.println("进程命令: " + info.command());
        System.out.println("进程参数: " + info.arguments());
        System.out.println("进程启动时间: " + info.startInstant());
        System.out.println("进程累计运行时间: " + info.totalCpuDuration());
        // 通过CompletableFuture在进程结束时运行某个任务
        CompletableFuture<ProcessHandle> cf = ph.onExit();
        cf.thenRunAsync(() -> {
            System.out.println("程序退出");
        });
        Thread.sleep(5000);
    }
}

package system.test;

public class PrintArgs {
    public static void main(String args[]) {
        // 获取类名
        String simpleName = PrintArgs.class.getSimpleName();
        System.out.println("----- " + simpleName + " start -----------------------------------");
        for (int i = 0; i < args.length; i++) {
            System.out.println("[args-" + i + "]:" + args[i]);
        }
        System.out.println("----- " + simpleName + " end   -----------------------------------");
    }
}

package system.test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * 进程执行器.
 */
public class ProcessRunner {
    /**
     * 运行cmd命令,默认cmd的编码为gbk.
     *
     * @param commandStr cmd命令.cmd命令以空格作为分隔符,第一个参数表示要执行的程序,后面的的参数是该程序的命令行参数.
     * @return 程序的标准输出.
     */
    public String runProcess(String commandStr) {
        return runProcess(commandStr, "gbk");
    }

    /**
     * @param commandStr  cmd命令.cmd命令以空格作为分隔符,第一个参数表示要执行的程序,后面的的参数是该程序的命令行参数.
     * @param cmdEncoding cmd的编码.
     * @return 程序的标准输出.
     */
    public String runProcess(String commandStr, String cmdEncoding) {
        BufferedReader br = null;
        StringBuilder sb = new StringBuilder();
        try {
            Process p = Runtime.getRuntime().exec(commandStr);
            br = new BufferedReader(new InputStreamReader(p.getInputStream(), cmdEncoding));
            String line;
            while ((line = br.readLine()) != null) {
                sb.append(line.concat("\n"));
            }
            // 等待进程运行结束.
            int exitCode = p.waitFor();
            // 如果进程的返回值不是0,则表明进程执行失败.
            if (exitCode != 0)
                // 返回null表示程序执行失败.
                return null;

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return sb.toString();
    }

    /**
     * 执行进程生成器中的程序和参数,并返回程序的输出.默认cmd的编码为gbk.
     *
     * @param processBuilder
     * @return 程序执行的结果字符串.
     */
    public String runProcess(ProcessBuilder processBuilder) {
        return runProcess(processBuilder, "gbk");
    }

    /**
     * 执行进程生成器中的程序和参数,并返回程序的输出.
     *
     * @param processBuilder 进程生成器.进程生成器中存放了要执行的程序,该程序的参数,该程序的工作空间等.
     * @param cmdEncoding    cmd的编码.程序将按照这个编码来读取程序的标准输出。
     * @return 程序执行的结果字符串.
     */
    public String runProcess(ProcessBuilder processBuilder, String cmdEncoding) {
        Process process = null;
        StringBuffer sb = new StringBuffer();
        try {
            process = processBuilder.start();
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream(), cmdEncoding));
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line + "\n");
            }
            // 等待进程运行结束
            int exitCode = process.waitFor();
            // 进程结束了,关闭接收流.
            reader.close();
            // 如果线程返回值不是0则表示线程执行失败.
            if (exitCode != 0)
                return null;

        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
        return sb.toString();
    }
}

package system.test;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class ProcessTest {
    public static void main(String[] args) {
        // 测试通过Runable来执行一个进程.
        testRuntime();

        // 测试通过ProcessBuilder来执行一个进程.
        testProcessBuilder();
    }

    private static void testRuntime() {
        // Runtime启动的进程的工作目录和父进程一样
        String jarPath = "E:\\dev2\\idea_workspace\\Test\\src\\system\\test\\PrintArgs.jar";
        System.out.println(new ProcessRunner().runProcess("java -jar " + jarPath + " 1 2 3"));
    }

    private static void testProcessBuilder() {
        List<String> command = new ArrayList<>();
        command.add("java");
        command.add("-jar");
        command.add("PrintArgs.jar");
        command.add("1");
        command.add("2");
        command.add("3");
        // java -jar PrintArgs.jar 1 2 3
        ProcessBuilder processBuilder = new ProcessBuilder(command);
        // ProcessBuilder方法启动的进程可以指定工作目录,如果不指定则和父进程的工作目录相同
        processBuilder.directory(new File("E:\\dev2\\idea_workspace\\Test\\src\\system\\test"));
        String processOutput = new ProcessRunner().runProcess(processBuilder);
        System.out.println(processOutput);
    }
}

import java.io.*;
import java.util.*;

public class SystemTest {
    public static void main(String[] args) throws Exception {
        // 获取系统所有的环境变量
        Map<String, String> env = System.getenv();
        // 遍历输出所有的环境遍历
        for (String name : env.keySet()) {
            System.out.println(name + " ---> " + env.get(name));
        }
        // 获取指定的环境变量
        System.out.println("-----------------------------------------------");
        String[] envKeys = { "JAVA_HOME", "CLASSPATH" };
        for (int i = 0; i < envKeys.length; i++) {
            System.out.println(envKeys[i] + " ---> " + System.getenv(envKeys[i]));
        }
        System.out.println("-----------------------------------------------");

        // 获取所有的系统属性
        Properties props = System.getProperties();
        // 将所有系统属性保存到props.txt文件中
        props.store(new FileOutputStream("props.txt"), "System Properties");
        // 输出特定的系统属性
        System.out.println(System.getProperty("os.name"));
    }
}

public class IdentityHashCodeTest {
    public static void main(String[] args) {
        // 下面程序中s1和s2是两个不同对象
        String s1 = new String("Hello");
        String s2 = new String("Hello");
        // String重写了hashCode()方法——改为根据字符序列计算hashCode值，
        // 因为s1和s2的字符序列相同，所以它们的hashCode方法返回值相同
        System.out.println(s1.hashCode() + "----" + s2.hashCode());

        // s1和s2是不同的字符串对象，所以它们的identityHashCode值不同
        System.out.println(System.identityHashCode(s1) + "----" + System.identityHashCode(s2));
        // 相同的字符串直接量放在常量池中,是同一个对象
        String s3 = "Java";
        String s4 = "Java";

        // s3和s4是相同的字符串对象，所以它们的identityHashCode值相同
        System.out.println(System.identityHashCode(s3) + "----" + System.identityHashCode(s4));
    }
}