常见对面-day09

转载 于 2018-10-29 16:32:11 发布 · 72 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://juejin.im/post/5bd735df518825610701af05
文章标签：

#java

day09-常见对象-正则表达式

1 字符类演示

  • A:字符类
    • [abc] a、b 或 c（简单类）
    • [^abc] 任何字符，除了 a、b 或 c（否定）
    • [a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围）
    • [0-9] 0到9的字符都包括
class DemoRegular {
public static void main(String[] args) {
    String regux0="[abc]";   //a,b或c的某一个
    /*
    matches() 
    方法用于检测字符串是否匹配给定的正则表达式
    */
    System.out.println("b".matches(regux0));//“b”在regux内
    System.out.println("f".matches(regux0));//“f”不在regux内
    System.out.println("ab".matches(regux0));//必须是单个字符
    System.out.println("------------");    //打印一个分隔线
    String regux1="[^abc]";   //任何字符，除了a，b，或c
    /*
    matches() 
    方法用于检测字符串是否匹配给定的正则表达式
    */
    System.out.println("b".matches(regux1));//“b”在regux内
    System.out.println("f".matches(regux1));//“f”不在regux内
    System.out.println("ef".matches(regux1));//必须是单个字符 
    System.out.println("------------");    //打印一个分隔线 
    String regux2="[a-fA-Z]";   //a-f和A-Z内的单个字符
    /*
    matches() 
    方法用于检测字符串是否匹配给定的正则表达式
    */
    System.out.println("b".matches(regux2));//“b”在regux内
    System.out.println("g".matches(regux2));//“f”不在regux内
    System.out.println("B".matches(regux2));//“B”在regux内
    System.out.println("ef".matches(regux2));//必须是单个字符 
    System.out.println("------------");    //打印一个分隔线 
    String regux3="[0-9]";   //0-9内的单个字符（必须是字符，不是整型数）
    /*
    matches() 
    方法用于检测字符串是否匹配给定的正则表达式
    */
    System.out.println("b".matches(regux3));//“b”不在regux内
    System.out.println("2".matches(regux3));//“2”不在regux内
    System.out.println("10".matches(regux3));//10是两个字符
    }
}
/*
运行结果：
true
false
false
------------
false
true
false
------------
true
false
true
false
------------
false
true
false
*/
复制代码

2 预定义字符类演示

  • . 任何字符。
  • \d 数字：[0-9]
  • \w 单词字符：[a-zA-Z_0-9]
  • \W 非字符[^\w]
class DemoRegualar1 {
    public static void main(String[] args) {
    String regux0=".";       //一个.表示任意单个字符，两个.表示任意两个字符
    System.out.println("a".matches(regux0)); //
    System.out.println("1".matches(regux0)); 
    System.out.println("---------"); 

    String regux1="\\d";       //使用\d表示0-9的单个字符，\\d前的\表示转义
    System.out.println("2".matches(regux1)); 
    System.out.println("10".matches(regux1)); //10为两个字符
    System.out.println("---------"); 

    String regux2="\\w";       //使用\w表示a-z，A-Z以及0-9的单个字符，\\w前的\表示转义
    System.out.println("2".matches(regux2)); 
    System.out.println("b".matches(regux2)); 
    System.out.println("B".matches(regux2));
    //\W表示非字符，记[^\w]
    }
}
/*
运行结果：
true
true
---------
true
false
---------
true
true
true
*/
复制代码

3 Greedy数量词

  • X? X，一次或一次也没有
  • X* X，零次或多次
  • X+ X，一次或多次
  • X{n} X，恰好 n 次
  • X{n,} X，至少 n 次
  • X{n,m} X，至少 n 次，但是不超过 m 次
class DemoRegualar2 {
    public static void main(String[] args) {
    String regux0="a?";   //0次或1次
    System.out.println("a".matches(regux0));  //1次
    System.out.println("".matches(regux0));   //0次
    System.out.println("aa".matches(regux0));
    System.out.println("--------");

    String regux1="a*";   //任意次
    System.out.println("a".matches(regux1));   //1次
    System.out.println("".matches(regux1));    //0次
    System.out.println("aa".matches(regux1));  //2次
    System.out.println("--------");

    String regux2="a+";   //1次到多次，除了0次
    System.out.println("a".matches(regux2));   //1次
    System.out.println("".matches(regux2));    //0次
    System.out.println("aa".matches(regux2));  //2次
    System.out.println("--------");

    
    String regux3="a{5}";   //恰好n次
    System.out.println("a".matches(regux3));   //1次
    System.out.println("".matches(regux3));    //0次
    System.out.println("aaaaa".matches(regux3));  //5次
    System.out.println("--------");

    String regux4="a{5}";   //至少n次
    System.out.println("a".matches(regux4));   //1次
    System.out.println("aaaaaa".matches(regux4));    //6次
    System.out.println("aaaaa".matches(regux4));  //5次
    System.out.println("--------");

    String regux5="a{3,5}";   //至少n次，但不超过m次
    System.out.println("a".matches(regux5));   //1次
    System.out.println("aaa".matches(regux5));    //3次
    System.out.println("aaaaa".matches(regux5));  //5次
    }
}
/*
运行结果：
true
true
false
--------
true
true
true
--------
true
false
true
--------
false
false
true
--------
false
false
true
--------
false
true
true
*/
复制代码

4 正则表达式的分割功能

  • String类的功能：public String[] split(String regex)
class DemoRegular3 {
    public static void main(String[] args) {
    String regux="ab def g";
    String[] str0=regux.split(" ");   //使用空格“ ”来分隔regux
    System.out.println(str0);         //输出分割后的地址，其实没意义
    for(int i=0;i<str0.length;i++) {
        System.out.println(str0[i]);    //输出分割后的结果
    }
    }
}
复制代码

5 正则表达式的替换功能

  • String类的功能：public String replaceAll(String regex,String replacement)
class DemoRegular4 {
    public static void main(String[] args) {
        String regux="abc def";
        String str=regux.replace("ab","de");  //用de替换掉ab
        System.out.println(str);

        String regux0="abc dabef";
        String str0=regux0.replace("ab","de");  //用de替换掉ab，可以替换掉出现的所有ab
        System.out.println(str0);
    }
}
复制代码

5 正则表达式的分组功能

  • 捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C))) 中，存在四个这样的组：
  •   1     ((A)(B(C))) 
  2     (A 
  3     (B(C)) 
  4     (C) 
复制代码
class DemoRegular5 {
    public static void main(String[] args) {

        String regux0="abccdefffghiiiijk"; //要求按照叠词分隔字符串
        String[] regux1=regux0.split("(.)\\1+");
        for(int i=0;i<regux1.length;i++) {
            System.out.println(regux1[i]);
        }
  
        /*
        分组截取
        */
        
        String regux2="我我我...我...爱......爱爱......我我....我....家家家....家";
        String regux3=regux2.replaceAll("\\.","");
        System.out.println(regux3); 
        String regux4=regux3.replaceAll("(.)\\1+","$1");
        /*
        \\1表示第一组再出现一次：
        解释：第一组是相对于（）而言的，如果有两个（），例如(.)\\1(.)\\2,第二个（）就是第二组，所以定义为了\\2
        再出现一次的意思指（.）\\1表示两次，而（.）\\1表示两次以上
        $1表示第一组中的内容
        */
        System.out.println(regux4);  
    }
}
复制代码

6 Pattern和Matcher的概述

  • 模式和匹配器的典型调用顺序

  • 通过JDK提供的API，查看Pattern类的说明

  • 典型的调用顺序是

  • Pattern p = Pattern.compile("a*b");

  • Matcher m = p.matcher("aaaaab");

  • boolean b = m.matches(); 可以使用该功能进行查找信息

查找电话号码地址
import java.util.regex.Pattern;
import java.util.regex.Matcher;
class DemoFindPhone {
    public static void main(String[] args) {
        String str="ahsdb13083663322ashd13083533211shf13020669918hsdgg";
        String regux="\\d{11}";
        Pattern p=Pattern.compile(regux);   //获取正则表达式
        Matcher m = p.matcher(str);
        while(m.find()) {        //find查找是否匹配，返回值是boolean
            System.out.println(m.group());  //group将上次查找的值输出
        }
    }
}
/*
运行结果：
13083663322
13083533211
13020669918
*/
复制代码

7 Math类的概述和使用方法

  • A:Math类概述
    • Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
  • B:成员方法
    • public static int abs(int a) 取绝对值
    • public static double ceil(double a) 一个数的顶，例如12.5取为13.0
    • public static double floor(double a) 一个数的地板，例如12.5取为12.0
    • public static int max(int a,int b) min自学 取大的
    • public static double pow(double a,double b) a的b次方
    • public static double random() 0-1随机数
    • public static int round(float a) 参数也可为double，四舍五入
    • public static double sqrt(double a) 开平方
class DemoMath {
    public static void main(String[] args) {
        int i=Math.abs(16);
        System.out.println(i);
        System.out.println(Math.abs(-16));  //abs表示取绝对值
        System.out.println(Math.ceil(12.5));  //取比12.5大的最近的整数
        System.out.println(Math.floor(12.5)); //取比12.5小的最近的整数
        System.out.println(Math.max(3,5));  //取大的
        System.out.println(Math.pow(2.0,3.0)); //2的3次方
        System.out.println(Math.random()); //0-1之间随机数
        System.out.println(Math.round(3.2f)); //四舍五入
        System.out.println(Math.round(3.6f));
        System.out.println(Math.sqrt(4.0));  //开方
        
    }
}
/*
运行结果：
16
16
13.0
12.0
5
8.0
0.2943041624534042
3
4
2.0
*/
复制代码

8 Random方法概述

  • A:Random类的概述
    • 此类用于产生随机数如果用相同的种子创建两个 Random 实例，
    • 则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。
  • B:构造方法
    • public Random()
    • public Random(long seed)
  • C:成员方法
    • public int nextInt()
    • public int nextInt(int n)
import java.util.Random;
class DemoRandom {
    public static void main(String[] args) {
        Random r=new Random();
        int a=r.nextInt();
        int b=r.nextInt();
        System.out.println(a);  //输出一个随机整数
        System.out.println(b);
        Random r0=new Random(10);  //有种子标记，第二次运行时，结果不变
        int c=r0.nextInt();
        int d=r0.nextInt();
        System.out.println(c);
        System.out.println(d);
    }
}
/*
运行结果;
第一次编辑运行结果：
-468972919
803410719
-1157793070
1913984760
第二次运行结果：
-17374419
517825485
-1157793070
1913984760
*/
复制代码

转载于:https://juejin.im/post/5bd735df518825610701af05

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值