Java进阶：常用API、算法、Lambda

常用API、算法、Lambda

1. Math
   1. 数学操作类，提供的都是一些静态方法，用于完成数学计算的。
   2.  // 目标：看看Math类的方法就行了。
              // 1、取绝对值（拿到的结果一定是正数）
              System.out.println(Math.abs(-12));    // 12
              System.out.println(Math.abs(-12.2)); // 12.2
              System.out.println(Math.abs(1443));  // 1443
      
              // 2、向上取整
              System.out.println(Math.ceil(3.000001)); // 4.0
              System.out.println(Math.ceil(4.0)); // 4.0
      
              // 3、向下取整
              System.out.println(Math.floor(3.9999999)); // 3.0
              System.out.println(Math.floor(3.0)); // 3.0
      
              // 4、四舍五入
              System.out.println(Math.round(3.45555)); // 3
              System.out.println(Math.round(3.500001)); // 4
      
              // 5、取较大值
              System.out.println(Math.max(10, 20));  // 20
      
              // 6、取次方
              System.out.println(Math.pow(2, 4)); // 2^4 == 16.0
              System.out.println(Math.pow(3, 2)); // 3^2 == 9.0
      
              // 7、取随机数（用的少）
              System.out.println(Math.random()); // [0.0 - 1.0)
2. System
   1. 作用：代表系统类，提供的都是一些静态方法，用于操作系统相关的信息的。
   2.    // 目标：了解下System类的几个方法。
              // 1、获取系统的全部信息
              //    public static long currentTimeMillis();（重点）
              // 获取当前系统的时间毫秒值（从1970-1-1 00:00:00 走到此刻总的毫秒值）
              long time = System.currentTimeMillis(); // 做性能分析，做时间运算！
              SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss EEE a");
              System.out.println(sdf.format(time));
      
              // 2、获取系统全部属性信息
              Properties properties = System.getProperties();
              System.out.println(properties);
      
              // 3、干掉JVM虚拟机（程序全部死亡了，不要用，跟删库跑路一个性质~~）
              // System.exit(0); // 0是正常终止！
      
              // 4、进行数组拷贝（了解）
              int[] arr1 = {10, 20, 30, 40, 50, 60, 70, 80};
              int[] arr2 = new int[6]; // arr2 = [0, 0, 0, 0, 0, 0] ==> [0, 0, 50, 60, 70, 0]
           /*   arraycopy(Object src,int  srcPos, Object dest, int destPos,int length)
                参数一：原数组
                参数二：从哪个索引位置开始拷贝
                参数三：目标数组
                参数四：目标数组粘贴元素的起始索引位置。
                参数五：拷贝几个元素
              */
              System.arraycopy(arr1, 4, arr2, 2, 3);
              System.out.println(Arrays.toString(arr2));
      
              System.out.println("程序结束。。。。");
3. BigDecimal
   1. 封装大数据（Double）完成一些精度运算的。
   2. 为什么要用BigDecimal
      1. 因为double类型的数据运算会出现失真：0.1 + 0.2 == 0.30000000000000004....
      2. DigDecimal可以解决精度失真问题
   3. DigDecaimal第一步：封装浮点型数据成为BigDecimal对象
      1.   // 1、调用BigDecimal的方法，封装浮点型数据成为大数据对象
                 //  public static BigDecimal valueOf(double val)
                 BigDecimal a1 = BigDecimal.valueOf(a);
                 BigDecimal b1 = BigDecimal.valueOf(b);
   4. DigDecaimal第二步
      1. 调用功能进行运算

•     

•         // BigDecimal是解决精度问题的手段。
          // double才是开发的目的。
          // public double doubleValue(): 把BigDecimal又转回成double
          double m2 = c1.doubleValue();
          System.out.println(m2);

1. 日期与时间
   1. Date
      1. 作用：代表当前此刻日期和时间的。
      2. 构建对象：

• public Date()

•     Date d = new Date();

• public long getTime() : 获取时间毫秒值：从1970-1-1 00:00:00开始走到此刻的总毫秒数

•     long time = d.getTime();

• public Date(long time):

•     Date  d2 = new Date(time): 把时间毫秒值转换成日期对象。

• public void setTime(long time): 设计日期对象为当前时间毫秒值对应的日期。
  1. SimpleDateFormat
     1. 作用：格式化、解析时间的。
     2. 构建对象：public SimpleDateFormat(String pattern)
     3. 方法
• public String format(Date d)

•     格式化日期对象

• public String format(Object o)

•     格式化时间毫秒值

• public Date parse(String date):

•     把字符串时间解析成日期对象

• 1. 1.         // 目标：掌握简单日期格式化类：SimpleDateFormat的使用。
                // 1、创建一个简单日期格式化对象：封装时间格式。
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");
        
                // 2、创建日期对象
                Date d = new Date();
                System.out.println(d);
        
                // 3、开始使用简单日期格式化对象负责格式化日期成为我们喜欢的字符串时间形式
                String rs = sdf.format(d);
                System.out.println(rs);
        
                // 4、可以格式化时间毫秒值的哦
                long time = d.getTime() + 121 * 1000;
                System.out.println(sdf.format(time));
     2. public class SimpleDateFormatDemo2 {
            public static void main(String[] args) throws ParseException {
                // 目标2：掌握简单日期格式化的解析操作。
                // 需要：把字符串时间解析成日期对象
                String dateStr = "2022-11-11 11:11:12";
                // 1、创建简单日期格式化对象。
                // 注意、注意、注意: 解析时间的格式必须与被解析时间的格式一模一样，否则报错！
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        
                // 2、开始解析了(会报错的，把异常抛出去，什么意思，后面会讲的)
                Date d = sdf.parse(dateStr);
                System.out.println(d);
            }
        }
  2. Calendar
     1. 作用：代表日历，获取信息更丰富
     2. 构建对象：
•       // 目标：掌握日历类的使用。
          // 1、得到日历对象
          Calendar c = Calendar.getInstance();
          System.out.println(c);
  
          // 2、获取信息：public int get(int field):
          int year = c.get(Calendar.YEAR);
          System.out.println(year);
  
          int days = c.get(Calendar.DAY_OF_YEAR);
          System.out.println(days);
  
          // 3、获取日期对象（了解）
          Date d = c.getTime();
          System.out.println(d);
  
          // 4、时间毫秒值（了解）
          long time = c.getTimeInMillis();
          System.out.println(time);
  
          // 5、修改日历的时间（需求：问89天后是什么日子）
          // 参数一：信息字段：一年中的第几天
          // 参数二：往后加多少天。
          c.add(Calendar.DAY_OF_YEAR, 89);
          Date d1 = c.getTime();
          System.out.println(d1);
  
          c.set(Calendar.DAY_OF_YEAR, 364); // 直接修改日历到某一天！
          Date d2 = c.getTime();
          System.out.println(d2);

1. JDK8新增日期类
   1. 这些日期类，我是不总结的，我是带你们刷了一遍API，要求你们自己看明白，作为字典以后查询！
2. 正则表达式
   1. 作用：校验数据的格式的合法性。
   2. 校验方法：
      1. String提供的：public boolean matches(String regex):  判断字符串与正则表达式是否匹配成功。
   3. 校验规则：
      1.     

1. 1. 正则 表达式配合方法的使用
      1.        // 目标：掌握String提供的几个其他的与正则表达式结合的方法。
                 // 1、public String replaceAll(String regex, String newStr);
                 String data = "我affbasfbb34242b爱fsaf_44你fdsf中g4335tgfASDDDdg_国！！";
                 String rs = data.replaceAll("\\w+", "-");
                 System.out.println(rs);
         
                 // 2、public String[] split(String regex):
                 // 可以按照某个内容把字符串分割成若干个元素，放到一个字符串数组中，然后返回该字符串数组。
                 String names = "白百何fbasjfAAff33fsf马蓉fadbA33hb_fdfAd_柏芝";
                 String[] nameArr = names.split("\\w+");
                 for (int i = 0; i < nameArr.length; i++) {
                     System.out.println("人是：" + nameArr[i]);
                 }
   2. 正则表达式做爬虫
      1. public static void main(String[] args) {
                 // 目标：拓展一下（如果去一段内容中爬取我们想要的信息（爬虫思想））
                 // 1、记住一段需要爬取的内容。
                 String rs = "来黑马程序学习Java,电话020-43422424，或者联系邮箱" +
                         "itcast@itcast.cn,电话18762832633，0203232323" +
                         "邮箱bozai@itcast.cn，400-100-3233 ，4001003232";
         
                 // 2、开始爬取，邮箱，电话号码，手机号。
                 // 3、指定爬取的规则：爬取什么东西？ 指定正则表达式，交给一个匹配规则对象
                 Pattern p =
                         Pattern.compile("(1[3-9]\\d{9})|(\\w{2,20}@[\\w&&[^_]]{2,10}(\\.[\\w&&[^_]]{2,10}){1,2})|(0\\d{2,5}-?[1-9]\\d{4,15})|(400-?\\d{3,6}-?\\d{3,6})");
         
                 // 4、把匹配规则对象与需要爬取的内容结合起来，得到一个匹配器对象。
                 Matcher m = p.matcher(rs);
         
                 // 5、开启使用匹配器对象爬取信息。
                 while (m.find()){
                     // 6、提取出来
                     String data = m.group();
                     System.out.println(data);
                 }
             }
2. 包装类
   1. 作用：实现一切皆对象
   2. 有哪些
      1.     

• 1. 包装类其实可以随便用的：int integer
     1. 自动装箱
• 基本类型的数据可以赋值其给包装类
  1. 1. 自动拆箱
• 包装类的数据赋值给基本数据类型
  1. 包装类为了得到认可，加入了新功能：
     1. 1、基本类型变成字符串
•   // 1、调用包装类继承自Object的toString方法
          String rs1 = it6.toString(); // "23"
          System.out.println(rs1 + 1); // 231
  
          // 2、调用静态方法: public static String toString(int i)
          String rs2 = Integer.toString(it6);// "23"
          System.out.println(rs2 + 1);
  
          // 3、直接加 “”
          String rs3 = it6 + ""; // "23"
          System.out.println(rs3 + 1);
  1. 1. 2、把字符串变成基本数据类型（重点）
•    System.out.println("把字符串的数值转换成基本数据类型的数据（重点）~~~");
          String age = "23";
          // int ageInt = Integer.parseInt(age);
          int ageInt = Integer.valueOf(age);
          System.out.println(ageInt + 1);
  
          String price = "98.5";
          //double priceDb = Double.parseDouble(price);
          double priceDb = Double.valueOf(price);
          System.out.println(priceDb + 0.5);

1. Arrays类
   1. 作用：代表数组操作类，工具类，里面都是操作数组的静态方法
   2. 方法:
      1. public static String toString(类型[] arr)

• 返回数组内容
  1. 1. public static  void sort(类型[] arr) : 默认按照值特性升序排序，如果是字符串数组按照首字母编号排序。
  2. 如果定制排序（难点）
     1. 1、让对象的类实现比较规则：
• // 方式一：让类实现比较规则接口Comparable
  public class Student implements Comparable<Student>{
      private String name;
      private int age;
      private double height;
  
      ....
  
      @Override
      public String toString() {
          return "Student{" +
                  "name='" + name + '\'' +
                  ", age=" + age +
                  ", height=" + height +
                  '}';
      }
  
      /**
        比较方法
        比较者：this
        被比较者：o
       * @param o
       * @return
       */
      @Override
      public int compareTo(Student o) {
          // 制定比较规则：（升序规则）
          // 如果认为比较者大于被比较者 返回正整数。
          // 如果认为比较者小于被比较者 返回负整数。
          // 如果认为比较者等于被比较者 返回0。
          // 按照年龄排序（升序）
  //        if(this.age > o.age) {
  //            return 1;
  //        }else if(this.age < o.age){
  //            return -1;
  //        }
  //        return 0;
          //return this.age - o.age; // 搞定了（升序）
          return  o.age - this.age ; // 搞定了（降序了）
      }
  }
   
  1. 1. 2、sort方法自带比较器：public stativ void sort(类型[] arr, Comparator<T>  c):
•      Arrays.sort(students, new Comparator<Student>() {
              @Override
              public int compare(Student o1, Student o2) {
                  // 制定比较规则：（升序规则）
                  // 如果认为比较者大于被比较者 返回正整数。
                  // 如果认为比较者小于被比较者 返回负整数。
                  // 如果认为比较者等于被比较者 返回0。
  //                if(o1.getHeight() > o2.getHeight()){
  //                    return 1;
  //                }else if(o1.getHeight() < o2.getHeight()){
  //                    return -1;
  //                }
  //                return 0;
                  // return Double.compare(o1.getHeight(), o2.getHeight()); // 升序
                  return Double.compare(o2.getHeight(), o1.getHeight()); // 降序
              }
          });
          System.out.println(Arrays.toString(students));
  1. 1. 注意：sort方法自带比较器，类实现了比较规则，优先用自带的比较器（更近）
  2. 方法：二分检索
     1. public static int binarySearch(类型[] arr,  类型 key)
• 注意：二分检索的前提是数组必须是排好序的！！
• 返回元素的索引，找不到元素返回负数

1. 常见算法
   1. 冒泡排序
   2. 选择排序
   3. 二分检索
   4. 参见代码
      1. 学算法的心得

• 1、理解算法的思想和执行流程。
• 2、去程序中推敲。

1. Lambda表达式
   1. 作用：简化函数式接口的匿名内部类的写法的。
      1. 啥是函数式接口：1、必须是接口 2、有且仅有一个抽象方法。
   2. 格式： 
      1.     

1. 1. 实战
      1.         Integer[] ages = { 87, 99, 123, 12 ,50, 16, 18, 20, 25, 200};
         
                 // Arrays.sort(ages); // 升序。降序必须自己指定规则
         //      Arrays.sort(ages, new Comparator<Integer>() {
         //             @Override
         //             public int compare(Integer o1, Integer o2) {
         //                 return o2 - o1;
         //             }
         //       });
         
         //        Arrays.sort(ages, (Integer o1, Integer o2) -> {
         //                return o2 - o1;
         //        });
   2. 省略规则：
      1. Lambda表达式的省略写法（进一步在Lambda表达式的基础上继续简化）
         参数类型可以省略不写。
         如果只有一个参数，参数类型可以省略，同时()也可以省略。
         如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写,同时要省略分号！
         如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写。此时，如果这行代码是return语句，必须省略return不写，同时也必须省略";"不写