Java常用的API（4）

//底层原理：
//因为在实际开发中，-128~127之间的数据，用的比较多。
//如果每次使用都是new对象，那么太浪费内存了
//所以，提前把这个范围之内的每一个数据都创建好对象
//如果要用到了不会创建新的，而是返回已经创建好的对象。
Integer i6 = Integer.valueOf(127);
Integer i7 = Integer.valueOf(127);
System.out.println(i6 == i7);//t
Integer i8 = Integer.valueOf(128);
Integer i9 = Integer.valueOf(128);
System.out.println(i8 == i9);//f
Integer i10 = new Integer(127);
Integer i11 = new Integer(127);
System.out.println(i10 == i11);//f
Integer i12 = new Integer(128);
Integer i13 = new Integer(128);
System.out.println(i12 == i13);//f

//将字符串类型的整数转成int类型的整数
//强类型语言:每种数据在java中都有各自的数据类型
//在计算的时候,如果不是同一种数据类型,是无法直接计算的.
int i = Integer.parseInt("123");
System.out.println(i);
System.out.println(i + 1);//124
//细节1:
//在类型转换的时候,括号中的参数只能是数字不能是其他,否则代码会报错
//细节2:
//8种包装类当中,除了Character都有对应的parseXxx的方法,进行类型转换
String str ="true";
boolean b = Boolean.parseBoolean(str);
System.out.println(b);

//键盘录入的改进：
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
String str = sc.next();
System.out.println(str);*/
//弊端:
//当我们在使用next,nextInt,nextDouble在接收数据的时候,遇到空格,回车,制表符的时候就停止了,
//键盘录入的是123 123那么此时只能接收到空格前面的数据
//我想要的是接收一整行数据
//以后我们如果想要键盘录入,不管什么类型,统一使用nextLine
//nextLine特点遇到回车才停止
String line = sc.nextLine();
System.out.println(line);
double v = Double.parseDouble(line);
System.out.println(v + 1)

//toString:将数组拼接成字符串
int[] arr = {1,2,3,4,5,6,7,8,9,10};
System.out.println(Arrays.toString(arr));
//binarySearch：二分查找法查找元素
//细节1：二分查找的前提：数组中的元素必须是有序，数组中的元素必须是升序的1/细节2：如果要查找的元素是存在的，那么返回的是真实的索引1/但是，如果要查找的元素是不存在的，返回的是-插入点-1
//疑问：为什么要减1呢？
//解释：如果此时，我现在要查找数字e，那么如果返回的值是-插入点，就会出现问题了。
//如果要查找数字0，此时0是不存在的，但是按照上面的规则-插入点，应该就是-0
//为了避免这样的情况，Java在这个基础上又减一。
System.out.println(Arrays.binarySearch(arr, 5));
System.out.println(Arrays.binarySearch(arr, 3));
System.out.println(Arrays.binarySearch(arr, 20));
//copyOf:拷贝数组
//参数一:老数组
//参数二:新数组的长度
//方法的底层会根据第二个参数来创建新的数组
//如果新数组的长度是小于老数组的长度,会部分拷贝1/如果新数组的长度是等于老数组的长度,会完全拷贝
//如果新数组的长度是大于老数组的长度,会补上默认初始值
//copyOfRange：拷贝数组（指定范围）
//细节：包头不包尾，包左不包右
int[] newArr1 = Arrays.copyOf(arr,20);
int[] newArr2 = Arrays.copyOfRange(arr,3,8);
System.out.println(Arrays.toString(newArr1));
System.out.println(Arrays.toString(newArr2));
Arrays.fill(arr,100);
System.out.println(Arrays.toString(arr));
//sort:排序.默认情况下,给基本数据类型进行升序排列.底层使用的是快速排序.
int[] arr2 = {10,2,3,5,6,1,7,8,4,9};
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
/*sort的重写方法：public static void sort(数组,排序规则)
        按照指定的规则排序
        参数一：要排序的数组
        参数二：排序的规则
        细节：只能给引用数据类型的数组进行排序
        如果数组是基本数据类型的，需要变成其对应的包装类*/
Integer[] arr3 = {2, 3, 1, 5, 6, 7, 8, 4, 9};
//第二个参数是一个接口，所以我们在调用方法的时候，需要传递这个接口的实现类对象，作为排序的规则。
// 但是这个实现类，我只要使用一次，所以就没有必要单独的去写一个类，直接采取匿名内部类的方式就可以了
//
//底层原理：
//利用插入排序+二分查找的方式进行排序的。
//默认把0索引的数据当做是有序的序列，1索引到最后认为是无序的序列。
// 遍历无序的序列得到里面的每一个元素，假设当前遍历得到的元素是A元素
// 把A往有序序列中进行插入，在插入的时候，是利用二分查找确定A元素的插入点。
//拿着A元素，跟插入点的元素进行比较，比较的规则就是compare方法的方法体
//如果方法的返回值是负数，拿着A继续跟前面的数据进行比较
//如果方法的返回值是正数，拿着A继续跟后面的数据进行比较
//如果方法的返回值是0，也拿着A跟后面的数据进行比较
//直到能确定A的最终位置为止。
//compare方法的形式参数：
//参数一01：表示在无序序列中，遍历得到的每一个元素
// 参数二02：有序序列中的元素
//返回值：
//负数：表示当前要插入的元素是小的，放在前面
// 正数：表示当前要插入的元素是大的，放在后面
//0：表示当前要插入的元素跟现在的元素比是一样的,也会放在后面
//o1-o2:升序
//o2-o1:降序
Arrays.sort(arr3, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        /*System.out.println("------");
        System.out.println("o1:"+o1);
        System.out.println("o2:"+o2);*/
        //为什么打印出来1和3比了2次？
        // 前面的有序数组是按照二分法来查找的，然后把后边的无需数组通过插入法排序
        // 1和3比了两次是因为，第一次数组[2,3]折半后的索引值是(0+(2-1))/2=0，0索引对应的值是2
        // 然后就想不明白了，找不到源码
        return o1-o2;
    }
});
System.out.println(Arrays.toString(arr3));

//将上面的Array.sort方法写成lambda表达式的形式
Integer[] arr3 = {2, 3, 1, 5, 6, 7, 8, 4, 9};
Arrays.sort(arr3, (Integer o1, Integer o2)-> {
    return o1 - o2;
});
System.out.println(Arrays.toString(arr3));

//lambda表达式的进一步省略
//小括号：数据类型可以省略，如果参数只有一个，小括号还可以省略
//大括号：如果方法体只有一行，return，分号，大括号都可以省略
Arrays.sort(arr3, (o1,o2)->o2-o1);
System.out.println(Arrays.toString(arr3));