java基础知识点，常来复习第二篇

包装类
8中基本引用类型
自动装箱，自动拆箱
最有用的，可以把字符串的数值转换为真实的数据类型。
Integer.parseInt("23");
Double.parseDouble("23.2");
方法有好多种，但是记住下面的最实用
String number = "12";
int age = Integer.valueOf(number);//返回的是int就让Integer调用。

可以把基本数据类型转换成字符串。
Integer i = 23;
String st=i.toString();

利用正则表达式去爬虫

  String msg = "手机13393029809,邮箱2219513707@qq.com,座机400-4686276," +
                "电话13309090909,邮箱baozi@163.com,邮箱baozi@173.com.cn,490-9898765";
        //1.编译正则表达式成为一个匹配规则对象
        String regex="(1[3-9]\\d{9})|([a-zA-Z0-9]{2,30}@\\w{2,3}(\\.\\w{3}){1,3})|(4\\d{2,}-?\\d{7})";
        //2.通过匹配规则对象得到一个匹配器内容的对象
        Pattern compile = Pattern.compile(regex);   
        //3.通过匹配器去爬取对象
        Matcher matcher = compile.matcher(msg);
        //4.开始找了
        while(matcher.find()){
            String group = matcher.group();
            System.out.println(group);
        }

 Arrays类，数组操作工具类，专门用于操作数组元素

返回数组内容   Arrays.toString(数组)

Arrays.sort(数组)  排序api，默认对数组元素升序排序
int index = Arrays.binarySearch(数组，值) 二分搜索技术，前提数组必须排好序，才能支持。        如果查找的元素不存在，返回，元素应该插入的位置索引 +（-1）。如果数组不排序会出现bug

自定义数组排序规则：Comparator比较器对象

 Arrays.sort() 方法对于默认有值数组是升序排序.

自定义降序排序（自定义比较器只支持引用类型）

默认o1-o2是升序排序，  o2-o1是降序排序

 Integer[] age = {3,5,9,0,12,11};
        Arrays.sort(age, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });

Student[] students=new Student[3];
        students[0] =new Student("伽罗",23,170.5);
        students[1] =new Student("刘备",22,180.3);
        students[2] =new Student("关羽",34,195.0);

        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o2.getAge()-o1.getAge(); //根据年龄降序排序
            }
        });

重写的compare方法返回类型是int类型，如何比较身高呢（身高是小数，Double.compare() 用转专门的方法比较 ）

        Student[] students=new Student[3];
        students[0] =new Student("伽罗",23,170.5);
        students[1] =new Student("刘备",22,180.3);
        students[2] =new Student("关羽",34,195.0);

        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return Double.compare(o2.getHeight(),o1.getHeight());  //比较小数
            }
        });
        System.out.println(Arrays.toString(students));

写一下二分查找算法代码，如果没有相应的值，返回-1；

public static void main(String[] args) {
      int[] arr={4,6,8,9,0,12,34,56,66,2};
      Arrays.sort(arr);
        System.out.println(binarySearch(arr, 4));

    }
    public static int binarySearch(int[] arr,int data){
        int left = 0;
        int right = arr.length-1;
        while(left<=right){
            int middleIndex = (right + left) / 2;
            if (data > arr[middleIndex]){
                left = middleIndex+1;
            }else if (data < arr[middleIndex]){
                 right = middleIndex-1;
            }else{
                return middleIndex;
            }
        }
        return -1;
    }

Lambda表达式时jdk8之后的新语法，作用简化匿名内部类的代码写法

（匿名内部类被重写方法的形参列表）-> {  被重写方法的方法体代码  }

Lambda表达式只能简化函数式接口的匿名内部类的写法形式

什么是函数式接口？ 

首先是接口、其次接口中只有一个抽象方法

通常在接口上加@FunctionalInterface注解，标记该接口必须是满足函数式接口。

public static void main(String[] args) {
//        Swimming s=new Swimming() {
//            @Override
//            public void swim() {
//                System.out.println("游泳挺好");
//            }
//        };
        Swimming s=()->{
            System.out.println("游泳挺好");
            };
        go(s);
        }
    public static void go(Swimming s){
        System.out.println("开始");
        s.swim();
        System.out.println("结束");
    }
    
    @FunctionalInterface
        interface Swimming{
        void swim();
    }

匿名对象可以直接作为方法的入参

public static void main(String[] args) {
//        go(new Swimming() {
//            @Override
//            public void swim() {
//                System.out.println("游泳挺好");
//            }
//        });
        go(()->{
                System.out.println("游泳挺好");
            });

    }
    public static void go(Swimming s){
        System.out.println("开始");
        s.swim();
        System.out.println("结束");
    }
    
    @FunctionalInterface
        interface Swimming{
        void swim();
    }

简化Comparator方法

 Double[] arr={9.0,5.2,3.2,4.4,1.9};
        Arrays.sort(arr, (Double o1, Double o2)->{
                return Double.compare(o2,o1);
        });
        System.out.println(Arrays.toString(arr));