devbox
码创造者
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

day05-Arrays-Lambda-算法-正则表达式【JAVA】

作者：码创造者 | 2024-07-02 13:59:32

赞

踩

day05-Arrays-Lambda-算法-正则表达式【JAVA】

目录

Arrays

Lambda【重点】

方法引用

算法

正则表达式

Arrays

  • 作用

    • 用于操作数组

  • 常用方法

    • 把数组内容转换为一个字符串

      • String static toString(数组)

    • 数组排序的方法

      • 基本数据类型的数组

        • static void sort(数组)

      • 引用数据类型的数组

        • static void sort(数组)

          • JavaBean实现Comparable<泛型>

          • 重写一个 compareTo( 类型 对象名)， 指定比较规则

        • static void sort(数组 , new Comparator<泛型>(){ 重写规则 })

    • 数组元素查找的方法

      • int binarySearch(数组， 元素)

  1. import java.util.Arrays;
  2. import java.util.function.IntUnaryOperator;
  3. ​
  4. public class Test {
  5.     public static void main(String[] args) {
  6.         int[] arr = {3,2,1,4,5};
  7.         System.out.println(Arrays.toString(arr));//转为字符串输出
  8.         
  9.         int[] arr1 = Arrays.copyOfRange(arr,0,2);
  10.         System.out.println(Arrays.toString(arr1));//拷贝索引0-2的内容到新数组（不包括2）
  11.         
  12.         int[] arr2 = Arrays.copyOf(arr,4);
  13.         System.out.println(Arrays.toString(arr2));//拷贝4个元素到新数组
  14.         
  15.         Arrays.setAll(arr, new IntUnaryOperator() {
  16.             @Override
  17.             public int applyAsInt(int operand) {
  18.                 return arr[operand] += 5;
  19.             }//所有数组元素加上5
  20.         });
  21.         Arrays.sort(arr);
  22.         
  23.         System.out.println(Arrays.toString(arr));
  24.         
  25.         int num = Arrays.binarySearch(arr, 2);//查询数组中是否存在该元素，是返回0，否返回-1
  26.         System.out.println(num);
  27.     }
  28. }

Lambda【重点】

  • 作用

    • 简化匿名内部类

      • 函数式接口

        • 这个接口中有且只有一个抽象方法

        • @FunctionalInterface

  • 格式

    • (参数 ) -> { 重写的方法体 }

​


  1. public class Student implements Comparable<Student>{//实现Comparable接口并重写compareTo方法
  2.     private String name;
  3.     private int age;
  4.     private double height;
  5. ​
  6.     public Student() {
  7.     }
  8. ​
  9.     public Student(String name, double height, int age) {
  10.         this.name = name;
  11.         this.age = age;
  12.         this.height = height;
  13.     }
  14. ​
  15.     /**
  16.      * 获取
  17.      * @return name
  18.      */
  19.     public String getName() {
  20.         return name;
  21.     }
  22. ​
  23.     /**
  24.      * 设置
  25.      * @param name
  26.      */
  27.     public void setName(String name) {
  28.         this.name = name;
  29.     }
  30. ​
  31.     /**
  32.      * 获取
  33.      * @return age
  34.      */
  35.     public int getAge() {
  36.         return age;
  37.     }
  38. ​
  39.     /**
  40.      * 设置
  41.      * @param age
  42.      */
  43.     public void setAge(int age) {
  44.         this.age = age;
  45.     }
  46. ​
  47.     /**
  48.      * 获取
  49.      * @return height
  50.      */
  51.     public double getHeight() {
  52.         return height;
  53.     }
  54. ​
  55.     /**
  56.      * 设置
  57.      * @param height
  58.      */
  59.     public void setHeight(double height) {
  60.         this.height = height;
  61.     }
  62. ​
  63.     @Override
  64.     public String toString() {
  65.         return "Student{" +
  66.                 "name='" + name + '\'' +
  67.                 ", age=" + age +
  68.                 ", height=" + height +
  69.                 '}';
  70.     }
  71. ​
  72.     @Override
  73.     public int compareTo(Student o) {
  74.         return 0;
  75.     }
  76. }
  77. ​
  78. ​
  79. ​
  80. ​
  81. ///
  82. ​
  83. import java.util.Arrays;
  84. import java.util.Comparator;
  85. ​
  86. public class Test {
  87.     public static void main(String[] args) {
  88.         Student[] students = new Student[4];
  89.         students[0] = new Student("蜘蛛精", 169.5, 23);
  90.         students[1] = new Student("青霞", 163.8, 25);
  91.         students[2] = new Student("紫霞", 163.8, 26);
  92.         students[3] = new Student("至尊宝", 167.5, 24);
  93. ​
  94.         /*Arrays.sort(students, new Comparator<Student>() {
  95.             @Override
  96.             public int compare(Student o1, Student o2) {
  97.                 int num = Double.compare(o1.getHeight(), o2.getHeight());
  98.                 if (num == 0){
  99.                     num = Double.compare(o2.getAge(), o1.getAge());
  100.                 }
  101.                 return num;
  102.             }
  103.         });*/
  104.         Arrays.sort(students, (Student o1,Student o2) -> {//使用Lambda简化代码
  105.                 int num = Double.compare(o1.getHeight(), o2.getHeight());//比较大小，左大返回正整数，右大返回负整数
  106.                 if (num == 0){
  107.                     num = Double.compare(o2.getAge(), o1.getAge());
  108.                 }
  109.                 return num;
  110.         });
  111.         System.out.println(Arrays.toString(students));
  112.     }
  113. }
  114. ​
​

方法引用

  • 作用

    • 简化Lambda表达式

      • 我们写的lambda里面如果只有一句代码

  • 格式

    • 静态方法引用

      • 类名::方法名;

    • 成员方法引用

      • 对象名::方法名;

    • 特定类型方法引用

      • 类型::方法名;

        • 方法上一定是有多个参数，然后第一个参数，作为对象去调用实现的方法，后面的参数作为入参

    • 构造器引用

      • 类名::new

  1. public class MyUtils {//工具类
  2. ​
  3.     // 静态方法，用于获取两个整数的最大值
  4.     public static int getMax(int a, int b) {
  5.         return a > b ? a : b;
  6.     }
  7. ​
  8.     // 实例方法，获取两个数字的最小值
  9.     public int getMin(int a, int b) {
  10.         return a < b ? a : b;
  11.     }
  12. }
  13. ​
  14. ​
  15. ​
  16. ///
  17. public class Test {
  18.     public static void main(String[] args) {
  19.         A a = MyUtils::getMax;//静态方法引用
  20.         System.out.println(a.max(10,20));
  21.         MyUtils myUtils = new MyUtils();
  22.         B b = myUtils::getMin;//成员方法引用
  23.         System.out.println(b.min(10,20));
  24.     }
  25. }
  26. interface A{
  27.     int max(int a, int b);
  28. }
  29. ​
  30. interface B{
  31.     int min(int a, int b);
  32. }

算法

  • 学习方式

    • 掌握思想

    • 再写代码实现

  • 分类

    • 冒泡排序:每次从数组中找出最大值放在数组的后面去

    • 选择排序:每轮选择当前位置，开始找出后面的较小值与该位置交换

    • 二分查找:每次排除一半的数据，查询数据的性能明显提高极多！二分查找正常的折半条件应该是开始位置left <= 结束位置right

​

  1. import java.util.Arrays;
  2. ​
  3. ​
  4. public class Test {
  5.     public static void main(String[] args) {
  6.         int[] arr = {3,9,6,1,5,7};
  7.         //冒泡排序
  8.         for (int i = 0; i < arr.length-1; i++) {
  9.             for (int j = 0; j < arr.length-1-i; j++) {
  10.                 if (arr[j] > arr[j+1]) {
  11.                     int temp = arr[j];
  12.                     arr[j] = arr[j+1];
  13.                     arr[j+1] = temp;
  14.                 }
  15.             }
  16.         }
  17.         System.out.println(Arrays.toString(arr));
  18.         int[] arr1 = {3,9,6,1,5,7};
  19.         //选择排序
  20.         for (int i = 0; i < arr1.length; i++) {
  21.             for (int j = 0; j < arr1.length; j++) {
  22.                 if (arr1[i] < arr1[j]) {
  23.                     int temp = arr1[i];
  24.                     arr1[i] = arr1[j];
  25.                     arr1[j] = temp;
  26.                 }
  27.             }
  28.         }
  29.         System.out.println(Arrays.toString(arr1));
  30. ​
  31.         int [] arr2 = {11,12,25,34,45,58,67,78,84,99};
  32.         System.out.println(get(arr2 ,100));
  33.     }
  34. ​
  35.     //二分查找
  36.     public static int get(int[] arr , int key) {
  37.         int left  = 0;
  38.         int right = arr.length - 1;
  39.         while (left <= right) {
  40.             int mid = (left + right) / 2;
  41.             if (key > arr[mid]) {
  42.                 left = mid + 1;
  43.             }else if (key < arr[mid]){
  44.                 right = mid - 1;
  45.             }else {
  46.                 return mid;
  47.             }
  48.         }
  49.         return -1;
  50.     }
  51. }

正则表达式

  • 作用

    • 判断数据是否符合某一种规则

    • 从文本中爬取数据

  • 规则

    • [任意内容]

      • 代表一个符号

    • \d

      • 代表数字

    • \w

      • 数字、字母、下划线

    • .

      • 任意的符号，除了 \n

    • 数量词

      • {1 ,}

        • 至少出现1次，或多次

      • {1,3}

        • 至少出现1次，最多出现3次

      • {5}

        • 只能出现5次

    • ()

      • 分组

    • |

      • 或者

示例

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         System.out.println("-----------------------1、字符类(只能匹配单个字符)--------------------------------");
  4.         // 1、字符类(只能匹配单个字符)
  5.         System.out.println("a".matches("[abc]"));  // true
  6.         System.out.println("e".matches("[abcd]")); // false
  7. ​
  8.         System.out.println("d".matches("[^abc]")); // true
  9.         System.out.println("a".matches("[^abc]")); // false
  10. ​
  11.         System.out.println("b".matches("[a-zA-Z]")); // true
  12.         System.out.println("2".matches("[a-zA-Z]")); // false
  13. ​
  14.         System.out.println("k".matches("[a-z&&[^bc]]")); // true
  15.         System.out.println("b".matches("[a-z&&[^bc]]")); // false
  16. ​
  17.         System.out.println("ab".matches("[a-zA-Z0-9]")); // false
  18.         System.out.println("------------------ 2、.代表所有的字符-------------------------------------");
  19.         // 2、预定义字符(只能匹配单个字符)  .  \d  \D   \s  \S  \w  \W
  20.         System.out.println("木".matches(".")); // true
  21.         System.out.println("a".matches(".")); // true
  22.         System.out.println("沐沐".matches(".")); // false
  23.         System.out.println("------------------ \\d 预定义字符[0-9]代表数字-------------------------------------");
  24.         // \d 预定义字符[0-9]代表数字
  25.         // \是表示特殊字符的： \n换行字符  \t是空格字符
  26.         // 在开发中，如果希望后面的内容就是其原始内容，应该再加上一个\转义
  27.         System.out.println("2".matches("\\d")); // true
  28.         System.out.println("21".matches("\\d")); // false
  29.         System.out.println("a".matches("\\d")); // false
  30.         System.out.println("---------------------\\D不能是数字----------------------------------");
  31.         // \D不能是数字
  32.         System.out.println("2".matches("\\D")); // false
  33.         System.out.println("a".matches("\\D")); // true
  34.         System.out.println("---------------------\\s代表空格----------------------------------");
  35.         // \s代表空格
  36.         System.out.println(" ".matches("\\s")); // true
  37.         System.out.println("a".matches("\\s")); // false
  38.         System.out.println("-----------------------\\S不能是空格--------------------------------");
  39.         // \S不能是空格
  40.         System.out.println(" ".matches("\\S")); // false
  41.         System.out.println("a".matches("\\S")); // true
  42.         System.out.println("---------------------\\w 代表[a-zA-Z_0-9]----------------------------------");
  43.         // \w 代表[a-zA-Z_0-9]
  44.         System.out.println("a".matches("\\w")); // true
  45.         System.out.println("_".matches("\\w")); // true
  46.         System.out.println("2".matches("\\w")); // true
  47.         System.out.println("ab2".matches("\\w")); // false
  48.         System.out.println("------------------\\W 不能是 [a-zA-Z_0-9]------------------------------------");
  49.         // \W 不能是 [a-zA-Z_0-9]
  50.         System.out.println("a".matches("\\W")); // false
  51.         System.out.println("2".matches("\\W")); // false
  52.         System.out.println("中".matches("\\W")); // true
  53. ​
  54.         System.out.println("-----------------3、 ? 代表前面的内容可以出现 1次或者0次--------------------------------------");
  55. ​
  56.         // 3、数量词： ?   *   +   {n}   {n, }  {n, m}
  57.         // ? 代表前面的内容可以出现 1次或者0次
  58.         System.out.println("a".matches("\\w?")); // true
  59.         System.out.println("".matches("\\w?")); // true
  60.         System.out.println("abc".matches("\\w?")); // false
  61.         System.out.println("------------------------ * 0次或者多次-------------------------------");
  62.         //  * 0次或者多次  w[0-9a-zA-Z_]
  63.         System.out.println("abc12".matches("\\w*")); // true
  64.         System.out.println("".matches("\\w*")); // true
  65.         System.out.println("abc12张".matches("\\w*")); // false
  66.         System.out.println("----------------------+ 1次或者多次---------------------------------");
  67.         // + 1次或者多次
  68.         System.out.println("abc12".matches("\\w+")); // true
  69.         System.out.println("".matches("\\w+")); // false
  70.         System.out.println("abc12张".matches("\\w+")); // false
  71.         System.out.println("----------------------{n} 正好n次  {n, m} 至少n次最多m次  {n, } 至少n次---------------------------------");
  72.         // {n} 正好n次  {n, m} 至少n次最多m次  {n, } 至少n次
  73.         System.out.println("a3c".matches("\\w{3}")); // true
  74.         System.out.println("abcd".matches("\\w{3}")); // false
  75.         System.out.println("abcd".matches("\\w{3,}")); // true
  76.         System.out.println("ab".matches("\\w{3,}")); // false
  77.         System.out.println("abcde木".matches("\\w{3,}")); // false
  78.         System.out.println("abc232d".matches("\\w{3,9}")); // true
  79.         System.out.println("--------------------4、其他几个常用的符号：(?i)忽略大小写 、 或：| 、  分组：()-----------------------------------");
  80.         // 4、其他几个常用的符号：(?i)忽略大小写 、 或：| 、  分组：()
  81.         System.out.println("abc".matches("(?i)abc")); // true
  82.         System.out.println("ABC".matches("(?i)abc")); // true
  83.         System.out.println("-----------");
  84. ​
  85.         System.out.println("aBc".matches("a((?i)b)c")); // true
  86.         System.out.println("ABc".matches("a((?i)b)c")); // false
  87.         System.out.println("-------------------需求1：要求要么是3个小写字母，要么是3个数字。------------------------------------");
  88.         // 需求1：要求要么是3个小写字母，要么是3个数字。
  89.         System.out.println("123".matches("[a-z]{3}|\\d{3}")); // true
  90.         System.out.println("abc".matches("[a-z]{3}|\\d{3}")); // true
  91.         System.out.println("ab2".matches("[a-z]{3}|\\d{3}")); // false
  92.         System.out.println("-------------------需求2：必须是”我爱“开头，中间可以是至少一个”编程“，最后至少是1个”666“---------------------------------");
  93. ​
  94.         // 需求2：必须是”我爱“开头，中间可以是至少一个”编程“，最后至少是1个”666“
  95.         System.out.println("我爱编程编程666666".matches("我爱(编程)+(666)+")); // true
  96.         System.out.println("我爱编编程编程666666".matches("我爱(编程)+(666)+")); // false
  97.         System.out.println("我爱编程编程编程编程编程666666666".matches("我爱(编程)+(666)+")); // true
  98.     }
  99. }

案例

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         System.out.println(checkTime("20200810")); // true
  4.         System.out.println(checkTime("2020-08-10")); // true
  5.         System.out.println(checkTime("2020-08-31")); // true
  6.         System.out.println(checkTime("2020-08-41")); // false
  7.         System.out.println(checkTime("2020-00-21")); // false
  8.         System.out.println("------------------------------------");
  9.         System.out.println(checkEmail("326370094@qq.com")); // true
  10.         System.out.println(checkEmail("326370094@qq.com.cn")); // true
  11.         System.out.println(checkEmail("326370094@qq1234.com.cn")); // false
  12.         System.out.println(checkEmail("326370094中@qq14.com.cn")); // false
  13.         System.out.println(checkEmail("326370094@qq14")); // false
  14.         System.out.println(checkEmail("326370094@qq14.com.com.com")); // false
  15.         System.out.println("------------------------------------");
  16.         System.out.println(checkPhone("18512516758"));
  17.         System.out.println(checkPhone("1851251675"));
  18.         System.out.println(checkPhone("010-98951256"));
  19.         System.out.println(checkPhone("010-08951256"));
  20.         System.out.println(checkPhone("01098951256"));
  21.         System.out.println(checkPhone("400-618-9090"));
  22.         System.out.println(checkPhone("400-618-90900"));
  23.         System.out.println(checkPhone("4006189090"));
  24.         System.out.println("-------------------------");
  25.         System.out.println(checkPhone("400-6189090"));
  26.     }
  27. ​
  28.     /*
  29.         电话：手机 + 座机 + 热线电话
  30.               手机格式： 首位为1，中间是[3-9]的数字，后面9个都是数字
  31.               座机： 前面三个数字是区号(第一个一定是0后面2个数字可以是0-9之间的数字),
  32.                     中间可以有横杠(-)也可以没有，
  33.                     最后就是八个数字(第一个一定不是0)
  34.               热线电话：
  35.                      前面三个数字就是400，可以有横杠，也可以没有(-)，再来三个数字，再来一个横杠，可以有可以没有,最后再来4个数字
  36. ​
  37.      */
  38.     public static boolean checkPhone(String number){
  39.         String regex = "(1[3-9]\\d{9})|(0\\d{2}-?[1-9]\\d{7})|(400-\\d{3}-\\d{4})|(400\\d{3}\\d{4})";
  40.         return number.matches(regex);
  41.     }
  42. ​
  43.     /*
  44.         邮箱：
  45.                可以是字母可以出现多个 加上一个@符号,可以是数字，
  46.                可以是字母，至少有2个 加上一个.加上域名，可以是两个字母，
  47.                也可以是三个 ,可以有一段，也可以有两段
  48.                326370094@qq.com
  49. ​
  50.      */
  51.     public static boolean checkEmail(String email) {
  52.         String regex = "[a-zA-Z0-9]{1,}@[a-zA-Z0-9]{2,5}(\\.[a-z]{2,3}){1,2}";
  53.         return email.matches(regex);
  54.     }
  55. ​
  56.     /*
  57.         时间：
  58.                 20230813
  59.                 2023-08-31
  60.                  前面四个是数字，中间可以有横杠也可以没有，月份[以0开始，后面的数字只能是1-9 , 如果是以1开头 第二个数字只能是 0 1 2 ]
  61.                  日[0开头后面只能是[1-9], 12开头后面数字就可以是[0-9] , 3[0,1]]
  62.      */
  63.     public static boolean checkTime(String time) {
  64.         String regex = "\\d{4}-?((0[1-9])|(1[012]))-?((0[1-9])|([12]\\d)|(3[01]))";
  65.         return time.matches(regex);
  66.     }
  67. }
  68. ​

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/码创造者/article/detail/779834
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号