乐趣区

关于java:Java基础12正则表达式Lambda表达式和排序算法

jiezi

1. 正则表达式

正则表达式是用一些规定的字符制订规定，用这个规定来校验数据的合法性。

比方在用户输出注册昵称时，必须对其进行合法性校验。比方长度，大家可能会想，间接用字符串长度办法加 if 不就行了，然而如果判断长度的同时还须要判断字符串 是否有敏感词。你可能会说，多重判断不是就能够实现性能，大量能够实现，数量
较多的话那可想而知代码量。

1.1 元字符

字符串中提供了匹配正则表达式办法：

// 匹配胜利返回 true，否则返回 false
public boolean matches(String regex)

// 应用正则替换所有
public String replaceAll(String regex,String newStr)

// 应用正则宰割字符串
public String[]split(String regex)：
  1. 匹配单个字符：
字符 阐明
[a,b,c] 合乎 abc 中任意一个即可
[^a,b,c] 除 abc 中任意一个即可
[a-zA-Z] 蕴含 a - z 或 A - Z 中任意一个即可
[a-p[q-z]] a 到 p 或者 q -z
[a-z&&[d,e,f]] 蕴含 a - z 并且合乎 d,e,f
[a-z&&[^d,e,f]] 蕴含 a - z 并且除 d,e,f
. 匹配任意字符
\d 匹配一个数值
\D 匹配字符为非数值
\s 匹配一个空白字符：[\t\n\x0B\f\r]
\S 匹配非空白字符串
\w 匹配数字，字符和下划线
\W 匹配非单词字符
  1. 匹配多个字符：
字符 阐明
x? x 匹配一次或者 0 次
x* x 匹配 0 次或者屡次
x+ x 匹配一次或者屡次
x{n} x 匹配 n 次
x{n,} x 匹配至多 n 次
x{n,m} x 匹配 n 到 m 次

1.2 示例

public class StringMatchesTest {public static void main(String[] args) {System.out.println("a".matches("[a,b,c,d,e]"));

        System.out.println("abc".matches("[a-z]"));
        System.out.println("abc".matches("[a-z]+"));

        System.out.println("9".matches("[\\d]"));

        System.out.println("991607476".matches("[\\d]{6,20}"));


        String temp = "asb121b4b54jb656";
        // 将所有数值替换成 A
        String a = temp.replaceAll("[\\d]+", "A");
        System.out.println(a);
        // 以字母进行宰割
        System.out.println(Arrays.toString(temp.split("[a-zA-Z]+")));
    }
}

2.Lambda 表达式

这是一个 java8 新个性之一，简化匿名类外部类写法。Lambda 表达式实现的匿名外部类必须是函数式接口

// Lambda 格局
(被重写办法的形参列表)->{代码；}

函数式接口：


@FunctionInterface
public interface 接口名 {
    // 仅且只能有这一个形象办法
    返回值类型 办法名称(参数列表);
}

2.1 示例

// 接口
@FunctionalInterface
public interface Animal {void bark();
}

// 测试类
public class LambdaTest {public static void main(String[] args) {
        // 以往应用匿名外部类
        animalBark(new Animal() {
            @Override
            public void bark() {System.out.println("当初是通过匿名外部类实现的，喵喵喵。。。");
            }
        });

        // 应用 Lambda 表达式
        animalBark(() -> {System.out.println("当初是通过 Lambda 实现的，汪汪汪。。。");
        });
    }

    public static void animalBark(Animal animal) {animal.bark();
    }
}

2.2 Lambda 表达式简写

  • 参数类型能够不写
  • 只有一个参数时，参数类型和 () 能够省略
  • 如果实现类只有一行代码，则能够省略{}，同时也要省略;
  • 如果实现的代码只有一行并且这行代码为 return 语句，{}和; 能够省略并且 return 也要省略
// 示例
@FunctionalInterface
public interface FunctionInterface1 {int add(int x, int y);
}

@FunctionalInterface
public interface FunctionInterface2 {void showParam(String str);
}

public class LambdaTest2 {public static void main(String[] args) {
        // 就是如此简略
        showFunctionInterface1((a, b) -> a * 2 + b * 2);
        showFunctionInterface2(a -> a.trim());
    }

    public static void showFunctionInterface1(FunctionInterface1 functionInterface1) {int add = functionInterface1.add(1, 2);
        System.out.println(add);
    }

    public static void showFunctionInterface2(FunctionInterface2 functionInterface2) {functionInterface2.showParam("Hello World");
    }
}

3. 排序算法

从字面意思了解，是对数据进行肯定规定的排序。比方全校学生的某课问题进行正 序排序。需要并不难实现，然而要在计算速度上有要求就变得有意思了。这时算法 就派上用场，起码的资源进行雷同的运算。应用不同的算法对下列数组进行排序。

[94,58,95,4,13,18,70,0,59,21]

3.1 冒泡排序

public class Bubble {public static int[] x = {94, 58, 95, 4, 13, 18, 70, 0, 59, 21};

    public static void main(String[] args) {System.out.println("排序前：" + Arrays.toString(Bubble.x));
        for (int i = 0; i < x.length - 1; i++) {for (int y = 0; y < x.length - 1 - i; y++) {if (x[y] < x[y + 1]) {int temp = x[y];
                    x[y] = x[y + 1];
                    x[y + 1] = temp;
                }
            }
        }
        System.out.println("排序后：" + Arrays.toString(Bubble.x));
    }
}

下图是网上找的 gif 图，下面写的与这个有点出入，我是向数组尾部冒泡的:

3.2 抉择排序

public class Select {public static void main(String[] args) {System.out.println("排序前：" + Arrays.toString(Bubble.x));
        // 进行正序排序
        for (int i = 0; i < Bubble.x.length - 1; i++) {for (int y = i + 1; y < Bubble.x.length; y++) {if (Bubble.x[i] < Bubble.x[y]) {int temp = Bubble.x[i];
                    Bubble.x[i] = Bubble.x[y];
                    Bubble.x[y] = temp;
                }
            }
        }
        System.out.println("排序后：" + Arrays.toString(Bubble.x));
    }
}

思路如下图：

3.3 二分抉择（非排序算法）

二分法是为了实现疾速找到查找的算法。应用此办法必须先对数组进行排序。

示例：
对以上办法进行排序，而后以最快的速度查找到 13。每次取个别进行判断，如果小于
则向下再取一半，否则向上取一半。

public class Dichotomy {public static void main(String[] args) {
        // 先为数组进行排序
        Bubble.sort();

        int length = Bubble.x.length;
        int index = length / 2;

        int select = 95;

        while (index >= 0) {if (Bubble.x[index] == select) {break;}

            if (Bubble.x[index] > select) {index = index + (length - index) / 2;
            }

            if (Bubble.x[index] < select) {index = index / 2;}
        }
        System.out.println(index);
    }
}

本章完结，用于集体学习和小白入门，大佬勿喷！心愿大家多多点赞珍藏撑持撑持！

源码【GitHub】【码云】

退出移动版