API基础第二天

API基础第二天

一、.StringBuilder

• String类型的连接性能不好，java提供了StringBuilder解决字符串连接性能问题。

String s1 = "ABC";
String s2 = "def";
String s3 = s1 + s2;

package string;

public class LongDemo01 {
    public static void main(String[] args) {
        /**
         * current:当前的
         * TimeMillis:时间毫秒数
         * 1970年元旦开始到现在的毫秒数
         */
        long now = System.currentTimeMillis();
        System.out.println(now);
    }
}

/**
  * 字符串的连接性能
  */
String str = "";
long t1 = System.currentTimeMillis();//运行前的时间
    for(int i = 0; i<50000; i++){
        str = str + "A";
    }
long t2 = System.currentTimeMillis();//运行后的时间
System.put.println(t2-t1);//两者时间之差

StringBuilder用于提升String字符串的连接性能问题：

• StringBuilder成为可变字符串
• StringBuilder内部也是字符数组，其API可以直接修改其内部数组的内容
• 当数组容量不足时，会自动扩容
• 运算期间会尽力减少创建数组的数量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Eb0X3mR2-1643182741882)(E:\达内\图片\StringBuilder.png)]

1. append()

追加，在StringBuilder的后面添加字符，当容量满了，会自动扩容，扩展规则1倍+2

buf   char[]{A,A,A,B,0,0,0,0,0,0,0,0}
StringBuilder buf = new StringBuilder();
buf.append("A");
buf.append("A");
buf.append("A");
buf.append("B");

package string;

/**
 * 测试StringBuilder的连接性能
 */
public class StringBuilderDemo03 {
    public static void main(String[] args) {
        StringBuilder buf = new StringBuilder();
        long t1 = System.currentTimeMillis();
        for (int i = 0; i < 5000; i++) {
            buf.append("A");//追加
        }
        long t2 = System.currentTimeMillis();
        System.out.println(t2-t1);

    }
}

3.insert(位置，字符)插入字符

4.delete(开始位置，结束位置)

• 删除一定范围的字符，包括开始，不包括结束
• StringBuilder的API返回的大多是当前对象，可以使用.调用方法

5.replace(int startIndex,int endIndex,Sreing str)

• 用于将当前StringBuilder对象实体中的字符串的一个子字符串用参数str指定的字符串替换。
• 包括开始，不包括结束

package string;

public class StringBuilderDemo02 {
    public static void main(String[] args) {
        StringBuilder str = new StringBuilder();
        str.append("随风潜入夜");//增加字符
        System.out.println("str" + str);
        str.insert(5,"润物细无声");//插入字符
        System.out.println(str);
        str.replace(0,3,"www");//字符替换
        System.out.println(str);
        str.reverse();//反转输出
        System.out.println(str);

    }
}

二、正则表达式

1.概述

• 用于检测、测试字符串规则的表达式

• 经常用于检测字符串是否符合特定的规则，在网站上经常检测用户输入数据是否符合规范：

  • 检测用户名是否为8-10的数字 英文（大小写）
  • 检测电话号码是否符合规则
  • 检测邮箱地址是否符合规则

• 正则HelloWorld

最简单的正则表达式：“HelloWorld”：

• 一共10个字符
• 出现的顺序必须是HelloWorld
• java提供了正则API用于检测一个字符串是否符合正则规则
  • boolean matches(正则)检测当前字符串是否符合正则规则

正则规则     rule = "HelloWorld";
字符串       s1 = "HelloKitty";
字符串       s2 = "HelloWorld";
boolean b1 = s1.matches(rule);//false
boolean b2 = s2.matches(rule);//true

2.字符集

• 匹配一个有效字符范围：

语法：

[123456]//匹配任意一个字符

意义：

• 匹配一个字符
• 其有效范围：1 2 3 4 5 6 中的某一个

Hello[123456]

• 匹配6个字符
• 前5个必须是Hello
• 第6个字符，必须是1 2 3 4 5 6 中的一个

"Hello1"
"Hello2"
"Hello3"
"Hello4"
"Hello5"
"Hello6"
"Hello8"//错误

package string;

public class RegDemo06 {
    public static void main(String[] args) {
        /**
         * 测试正则
         */
        String reg = "Hello[123456]";
        String s1 = "Hello1";
        String s2 = "Hello7";
        System.out.println(s1.matches(reg));//true
        System.out.println(s2.matches(reg));//false
    }
}

字符范围

规则		范围
匹配0-9一个字符	[0123456789]	[0-9]
匹配A-Z一个字符	[ABCD…XYZ]	[A-Z]

3.预定义字符集

规则	正则	预定义字符集	例子
匹配一个数字	[0-9]	\d	Hello\d
匹配一个单词字符	[A-Z a-z 0-9 _ ]	\w	A\w
匹配一个空白字符	[空格，tab键]	\s	Hello\sWorld
匹配任意一个字符		.	A.
匹配非数字，非空白		\D \S

4.数量词

约定左侧元素出现的次数。

package string;

public class GegDemo07 {
    public static void main(String[] args) {
        /**
         * 测试 用户名规则
         * - \ 在 java字符串中需要进行转义为\\
         *
         */
        //正则表达式：
        //String reg = "\\w\\w\\w\\w\\w\\w";
        String reg = "\\w{6}";//等同于上面的写法
        System.out.println(reg);
        //被检查的字符串
        String s1 = "Jerry1";
        String s2 = "Tom-12";
        String s3 = "Andy";
        System.out.println(s1.matches(reg));//true
        System.out.println(s2.matches(reg));//false
        System.out.println(s3.matches(reg));//false
    }
}

例如，判断手机号，我们用正则表达式\x{11}
规定左侧x字符出现11次
x{n,m}规定左侧x出现最少n次，最多m次
例如：网站用户名是8-16个单词字符：\w{8,16}
x{,m}规定左侧x最多出现n次
x{n,}规定左侧x最少出现n次
x?  和   x{0,1}等价，x可以没有或者有一个
x+  和   x{1,}等价，x至少有一个，多了随意，简称：一个以上。
x*  和   x{0,}等价，x至少有0个，多了随意，简称：0个以上
匹配Hollo World,中间至少有一个空格：Hello\s+World   

• 匹配Hollo World,中间至少有一个空格：Hello\s+World
  • 不能匹配：“HelloWorld”
  • 不能匹配：“Hello World!”
  • 能匹配：“Hello World”

package string;

public class RegDemo09 {
    public static void main(String[] args) {
        String reg = "Hello\\s+World";
        String s1 = "HelloWorld";//不能通过
        String s2 = "Hello World";//
        String s3 = "Hello   World";
        System.out.println(s1.matches(reg));//false
        System.out.println(s2.matches(reg));//true
        System.out.println(s3.matches(reg));//true
    }
}

5.特殊转义字符

如何匹配字符[]?+*.,使用\特殊字符进行转义

如下：

• www.tedu.cn匹配：

  • www.tedu.cn
  • wwwAteduAcn
  • www-tedu-cn

• www\.tedu\.cn匹配

• www.tedu.cn通过

\.匹配.
\[匹配[
\?匹配？
\*匹配*
注意：在Java中要用\\代表一个\

案例：如何检查一个字符串是否为正确的IPv4地址

“192.168.1.25” “192.199.1.1” //true

“10-10-10-10”//false

package string;
/**
*判断IP地址是否正确
*/
public class RegDemo11 {
    public static void main(String[] args) {
        //转义规则
        String reg = "\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}";
        //被检查字符串
        String s1 = "192.168.10.1";
        String s2 = "10-10-10-10";
        System.out.println(s1.matches(reg));//true
        System.out.println(s2.matches(reg));//flase
    }
}

6…分组

讲一组规则作为整体进行处理

1."\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}"

2."（\d{1,3}\.)(\d{1,3}\.)(\d{1,3}\.)(\d{1,3})"

3."（\d{1,3}\.){1,3}\d{1,3}"

package string;
/**
*多次出现可以利用分组来写也就是加（）
*/
public class RegDemo11 {
    public static void main(String[] args) {
        String reg = "(\\d{1,3}\\.){1,3}\\d{1,3}";//分组laixie
        String s1 = "192.168.10.1";
        String s2 = "10-10-10-10";
        System.out.println(s1.matches(reg));//true
        System.out.println(s2.matches(reg));//flase
    }
}

7. java正则API

• matches检查字符串是否符合正则表达式
• split劈开
• replaceAll全部替换

（1）split劈开字符串，将一个字符串分为几个字符串

• “192.168.5.140"劈开为"192” “168” “5” “140”

使用：
str 存储的是劈开的字符串
正则  用于匹配劈开的位置点，如：，或者\.
返回值  是劈开以后的数组，每个元素是劈开的字符串段落，劈开以后，匹配的位置就没有了
 String[] arr = str.split(正则);

案例：
String str = "1,Tom,110,tom@tedu.cn";
arr = "1" "Tom" "110" "tom@tedu.cn"
String

package string;
/**
*split()劈开字符串
*/
public class SplitDemo13 {
    public static void main(String[] args) {
        String str = "boo:and:foo";
        String[] arr = str.split(":");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        /*劈开时候，会自动舍弃后面的空字符串
        "boo:and:foo"
        //oo oo
        "b" "" ":and:f"
        boo:  nd:foo
         */
        arr = str.split("o");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        arr = str.split("a");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

（2）replaceAll()

public String replace(CharSequence target,
                      CharSequence replacement

参数：

target - 要被替换的 char 值序列

replacement - char 值的替换序列

package string;

import java.util.Scanner;

public class ReplaceAllDemo {
    public static void main(String[] args) {
        /**
         * replaceAll()字符串替换
         * 请输入：
         * 我去
         *  **
         */
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入：");
        String str = scanner.nextLine();
        String s = str.replaceAll("我[去操]","**");
        System.out.println(s);
    }
}

string;

import java.util.Scanner;

public class ReplaceAllDemo {
public static void main(String[] args) {
/**
* replaceAll()字符串替换
* 请输入：
* 我去
* **
*/
Scanner scanner = new Scanner(System.in);
System.out.println(“请输入：”);
String str = scanner.nextLine();
String s = str.replaceAll(“我[去操]”,"**");
System.out.println(s);
}
}