// 拆箱、装箱
public class Warpper01 {
    public static void main(String[] args) {
        // jdk 5 以前为手动装箱、拆箱
        // 装箱
        int n1 = 100;
        Integer integer = Integer.valueOf(n1);
        System.out.println(integer);

        // 拆箱
        int i = integer.intValue();
        System.out.println(i);

        // jdk 5 以后 为自动装箱、拆箱
        int n2 = 200;
        // 装箱
        Integer itg = n2;
        System.out.println(itg); 

        // 拆箱
        int n3 = itg;
        System.out.println(n3);
    }
}

// 包装类 与 String 相互转换
public class Wrapper02 {
    public static void main(String[] args) {
        // 包装类 与 String 相互转换
        Integer int1 = 123;
        // 包装类 -> String
        String str1 = int1 + "";
        String str2 = int1.toString();
        String str3 = String.valueOf(int1);
        
        // String -> 包装类
        Integer int2 = Integer.valueOf(str1);
        Integer integer = new Integer(str2);
    }
}

// 面试题
public class Wrapper03 {
    public static void main(String[] args) {
        // new 关键字创建的，坑定是不同的对象
        // 对象之间用 == 比较，比较的是两个对象的地址
        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1 == i2);       // false

        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3 == i4);       // false

        // 底层为 Integer.valueOf（）
        // Integer 的范围为 -128 ~ 127
        Integer i5 = 127;
        Integer i6 = 127;
        System.out.println(i5 == i6);   // true

        Integer i7 = 128;
        Integer i8 = 128;
        System.out.println(i7 == i8);   // false

        Integer i9 = 127;       // 从数组中获取
        Integer i10 = new Integer(127);     // 不同的对象
        System.out.println(i9 == i10);      // false

        // 只要有基本数据类型，== 判断的就是值是否相等
        Integer i11 = 127;
        int i12 = 127;
        System.out.println(i11 == i12);     // true 

        Integer i13 = 128;
        int i14 = 128;
        System.out.println(i13 == i14);     // true
    }
}

// 两种创建 String 对象的区别
String s1 = "hsp";

String s2 = new String("hsp");

// 两种创建 String 对象方法
public class String01 {
    public static void main(String[] args) {
        String a = "hsp";   // 指向常量池
        String b = new String("hsp");   //  b 先指向堆空间，再通过 value 属性指向常量池
        System.out.println(a.equals(b));    // true 值相等
        System.out.println(a == b);     // false 地址不同
        System.out.println(a == b.intern());    // true b.intern() 返回的是常量池的地址
        System.out.println(b == b.intern());    // false b 指向堆空间地址
    }
}

// String 常用方法案例
public class String01{
    public static void main(String[] args) {
        // 1.equals 区分大小写比较
        String s1 = "hello ";
        String s2 = "HELLO ";
        String s3 = "Where Are You Doing";
        System.out.println(s1.equals(s2));  // false
        
        // 2.equalsIgnoreCase 不区分大小写 比较
        System.out.println(s1.equalsIgnoreCase(s2));    // true
        
        // 3.length 获取数组长度
        System.out.println(s1.length());    // 6
        
        // 4. indexOf 获取字符第一次出现在字符串中的索引
        System.out.println(s1.indexOf("l"));    // 2
        
        // 5. lastIndexOf 获取字符 最后一次出现在字符串中的索引
        System.out.println(s1.lastIndexOf("l"));    // 3
        
        // 6. substring 根据下标截取字符串，左闭右开
        System.out.println(s1.substring(2));    // llo
        System.out.println(s1.substring(2,4));  // ll
        
        // 7. trim 去除前后空格
        System.out.println(s1.trim());  // hello
        
        // 8. charAt 根据下标获取字符
        System.out.println(s1.charAt(4));   // o
        
        // 9. toUpperCase 全部大写
        System.out.println(s3.toUpperCase(Locale.ROOT));    // WHERE ARE YOU DOING
        
        // 10. toLowerCase 全部小写
        System.out.println(s3.toLowerCase(Locale.ROOT));    // where are you doing
        
        // 11. concat 合并数组
        System.out.println(s3.concat(s1));  // Where Are You Doinghello
        
        // 12. replace 替换字符串中的字符
        System.out.println(s3.replace("Are",s2));   // Where HELLO  You Doing
        
        // 13. split 分割字符串
        String[] s4 = s3.split(" ");
        for (String s:s4){
            System.out.println("s3.split = " + s);
        }
        
        // 14. compareTo 比较两个字符串的大小, 前者大返回正数，后者大返回负数，相等返回 0
        System.out.println(s2.compareTo(s1));   // -32
        
        // 15. toCharArray 转换成字符数组
        char[] s5 = s2.toCharArray();
        for(char s:s5){
            System.out.println("s2.toCharArray = " + s);
        }
        
        // 16. format 字符串格式化 %s：字符串，%d：整型，%f：浮点型
        System.out.printf("%s,今年%d 岁了，有%.2f压岁钱。","小明",5,100.5); // 小明,今年5 岁了，有100.50压岁钱。
    }
}

// StringBuffer 构造器
// 1. 创建一个大小为 16 的 char[] 数组，用于存放内容
StringBuffer s1 = new StringBuffer();

// 2. 通过构造器 指定 char[] 大小
StringBuffer s2 = new StringBuffer(100);

// 3. 给一个 字符串 创建 StringBuffer，char[]大小为 str.length() + 16
StringBuffer s3 = new StringBuffer("Hello");

// String 和 StringBuffer 相互转换
public class StringBuffer01 {
    public static void main(String[] args) {
        // String 和 StringBuffer 相互转换
        String s1 = "Hello tom";

        // String --> StringBuffer
        // 通过构造器转换
        StringBuffer sb1 = new StringBuffer(s1);
        // 通过 append 转换
        StringBuffer sb2 = new StringBuffer();
        sb2.append(s1);

        // StringBuffer --> String
        StringBuffer sb3 = new StringBuffer("study Java");
        // 通过 toString 方法转换
        String s2 = sb3.toString();
        // 通过 String 构造器转换
        String s3 = new String(sb3);
    }
}

// StringBuffer 增删改查
public class String02 {
    public static void main(String[] args) {
        // StringBuffer 增删改查
        // 增
        StringBuffer s = new StringBuffer("张三疯");
        s.append('，');
        s.append("宋无忌").append("，张翠山");
        System.out.println("增加后："+s);
        // 删
        s.delete(4,7);
        System.out.println("删除后："+s);
        // 改
        s.replace(4,5,"拳打敬老院，脚踩幼儿园");
        System.out.println("修改后："+s);
        // 查
        System.out.println("查找 张翠山 ："+s.indexOf("张翠山"));
        // 插入
        s.insert(4,"他的徒弟们，");
        System.out.println("插入后："+s);
    }
}

// 随机数 - 案例
public class Math02 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(ran(2,7));
        }
    }
    public static int ran(int a, int b){
        // 最终返回的是 a <= x < b+1 的小数
        return (int)(a + Math.random()*(b-a+1));
    }
}

// 自定义 排序，通过 Comparator接口实现
Arrays.sort(books, new Comparator<Book>() {
    @Override
    public int compare(Book o1, Book o2) {
        // 因为返回值为 int ，需要做下转换
        double num = o1.getPrice() - o2.getPrice();
        // 通过控制 返回值的正负来确定排序方向
        if (num > 0){
            return 1;
        }else if(num < 0){
            return -1;
        }else {
            return 0;
        }
    }
});

// Arrays 常用方法
public class Arrays01 {
    public static void main(String[] args) {
        int[] a1 = {1,4,-10,-32,66,43,91};
        int[] a2 = {33,44,55,-11,-22,-33};

        // toString 返回数组的字符串形式
        System.out.println(Arrays.toString(a1));

        // sort 排序（从小到大）
        Arrays.sort(a1);
        System.out.println(Arrays.toString(a1));

        // binarySearch 二分法查找，返回数组元素下标（数组必须是有序的）
        // 如果找不到，则返回负值，负值为他应该存在的位置
        // 如果数组长度不够，则最后赋值为 null
        int index = Arrays.binarySearch(a1,6);
        System.out.println(index);

        // copyOf 复制数组到新的数组 copyOf（原来的数组，复制的长度）
        int[] a3 = Arrays.copyOf(a2,3);
        System.out.println(Arrays.toString(a3));

        // fill 数组填充(替换原来数组中的所有元素）
        Arrays.fill(a2,123);
        System.out.println(Arrays.toString(a2));

        // equals 比较两个数组内容是否一致
        int[] arr1 = {1,22,333};
        int[] arr2 = {1,22,333};
        System.out.println(Arrays.equals(arr1,arr2));
    }
}

// 排序 - 案例
public class Arrays02 {
    public static void main(String[] args) {
        Book[] books = new Book[5];
        books[0] = new Book("红楼梦", 100);
        books[1] = new Book("三国演义", 120);
        books[2] = new Book("西游记", 150);
        books[3] = new Book("水浒传", 99);
        books[4] = new Book("天龙八部", 113);

        System.out.println(Arrays.toString(books));
        
        // 自定义 排序，通过 Comparator接口实现
        Arrays.sort(books, new Comparator<Book>() {
            @Override
            public int compare(Book o1, Book o2) {
                // 因为返回值为 int ，需要做下转换
                double num = o1.getPrice() - o2.getPrice();
                // 通过控制 返回值的正负来确定排序方向
                if (num > 0){
                    return 1;
                }else if(num < 0){
                    return -1;
                }else {
                    return 0;
                }
            }
        });

        System.out.println(Arrays.toString(books));
    }
}

class Book{
    private String name;
    private double price;

    public Book(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return name + "\t" + price;
    }
}

// BigInteger - 案例
public class BigInteger01 {
    public static void main(String[] args) {
        BigInteger bi1 = new BigInteger("12313231231893485938274592784952");
        BigInteger bi2 = new BigInteger("123123");
        
        System.out.println(bi1.add(bi2));   // 加
        System.out.println(bi1.subtract(bi2));  // 减
        System.out.println(bi1.multiply(bi2));  // 乘
        System.out.println(bi1.divide(bi2));    // 除
    }
}

// BigDecimal - 案例
public class BigInteger01 {
    public static void main(String[] args) {
        BigDecimal bi1 = new BigDecimal("3.14159263453542423424343");
        BigDecimal bi2 = new BigDecimal("3.2342324123");

        System.out.println(bi1.add(bi2));   // 加
        System.out.println(bi1.subtract(bi2));  // 减
        System.out.println(bi1.multiply(bi2));  // 乘
        System.out.println(bi1.divide(bi2, BigDecimal.ROUND_CEILING));    // 除
    }
}

// 第一代 日期
public class Date01 {
    public static void main(String[] args) throws ParseException {
        // 获取当前时间
        Date time = new Date();
        System.out.println(time);

        // 格式化日期，E 为星期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年 MM月 dd日 hh:mm:ss E");
        System.out.println(sdf.format(time));

        // 将个时候后的日期转为默认日期
        // 默认会报异常，只需将异常抛出即可
        String s = "2022年 05月 17日 05:23:48 周二";
        Date parse = sdf.parse(s);
        System.out.println(parse);
    }
}

// 第二代日期 - 案例
public class Calendar_ {
    public static void main(String[] args) {
        // Calendar 是一个抽象类，他的构造器是私有化的，需要用过 getInstance 来创建对象
        Calendar c = Calendar.getInstance();
        System.out.println(c);

        System.out.println(c.get(Calendar.YEAR) + "年");
        // 月份是从 0 开始返回的，因此需要 +1
        System.out.println((c.get(Calendar.MONDAY) + 1)+ "月");
        System.out.println(c.get(Calendar.DATE) + "日");
        System.out.println(c.get(Calendar.HOUR) + "时");
        System.out.println(c.get(Calendar.MINUTE) + "分");
        System.out.println(c.get(Calendar.SECOND) + "秒");
    }
}

// 第三代日期
public class LocalDate_ {
    public static void main(String[] args) {
        LocalDateTime ld = LocalDateTime.now();
        System.out.println(ld);

        LocalDate now = LocalDate.now();
        System.out.println(now);

        LocalTime now1 = LocalTime.now();
        System.out.println(now1);

        System.out.println(ld.getYear());
        System.out.println(ld.getMonth());
        System.out.println(ld.getMonthValue());
        System.out.println(ld.getDayOfMonth());
        System.out.println(ld.getHour());
        System.out.println(ld.getMinute());
        System.out.println(ld.getSecond());
    }
}

// 格式化日期
public class LocalDate_ {
    public static void main(String[] args) {
        LocalDateTime ld = LocalDateTime.now();
        System.out.println(ld);

        // 格式化输出日期
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年 MM月 dd日 HH:mm:ss E");
        System.out.println(dtf.format(ld));
    }
}

// 时间戳
public class LocalDate_ {
    public static void main(String[] args) {
        // 获取当前时间
        Instant now = Instant.now();

        // 通过 from 方法把 Instant 转为 Date
        Date date = Date.from(now);
        System.out.println(date);

        // 通过 toInstant 方法把 date 转为 Instant
        Instant instant = date.toInstant();
        System.out.println(instant);
    }
}

// 日期的加减
public class LocalDate_ {
    public static void main(String[] args) {
        //
        LocalDateTime now = LocalDateTime.now();
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年 MM月 dd日 HH:mm:ss E");

        // 日期增加 890 天
        LocalDateTime now1 = now.plusDays(890);
        System.out.println(dtf.format(now1));

        // 日期减少 120 天
        LocalDateTime now2 = now.minusDays(120);
        System.out.println(dtf.format(now2));
    }
}