JAVA字符串，正则表达式

一、字符串

1.字符串简介：

由若干个字符组成的一个有序的序列。在Java中，使用String这个类来描述字符串。

1) java.lang.String 使用final修饰，不能被继承

2) 字符串底层封装的是字符数组及其针对数组的操作方法

3) 字符串一旦创建，对象永远无法改变，但字符串引用可以重新赋值

4) 字符串在内存中采用Unicode编码方式，任何一个字符对应两个字节的定长编码

5) 字符串的索引值从0开始

2.字符串常量池

JVM为了提升性能和减少内存开销，避免重复重复创建字符串，其维护了一种特殊的内存空间，即字符串常量池。当需要使用静态字符串（字面量、常量，变量连接的结果）时，先去检查字符串常量池是否存在该字符串，若存在，则直接返回该字符串的引用地址；若不存在，则在字符串常量池中创建字符串对象，并返回对象的引用地址。

内存位置：

在 JDK 1.7 之前，运行时常量池（包括字符串常量池）存放在方法区。

在 JDK 1.7 时，字符串常量池被从方法区转移至 Java 堆中，注意并不是运行时常量池，而是字符串常量池被单独转移到堆，运行时常量池剩下的东西还是方法区中。

在 JDK 1.8 时，此时字符串常量池还在堆中。

3.常用构造器

*  1.String() 
*      初始化一个新创建的空字符序列的字符串对象
*  2.String(String str)
*      新创建一个对象，初始化值为str
*  3.String(byte[] bytes)
*      使用默认编码集，解码byte数组，构建一个字符串对象
*  4.String (byte[] bytes,String charsetName)
*      使用指定编码集charsetName 解码byte数组，构建一个字符串对象
*  5.String(byte[] bytes,int offset,int length)
*      使用默认编码集解码byte的数组，从offset开始，length个元素，构建一个字符串对象
*  6.String(char[] value)
*      初始化一个字符串对象，使其字符序列包含参数的元素

        String string = new String("初始化对象");
        System.out.println(string);

        byte[] bytes = {97,98,99,100,101,102,103,104,105,106,107};
            //编码集对应的字符为 : abcdefghijk
        String string1 = new String(bytes);
        System.out.println(string1);

        //指定编码集为UTF-8,解码数组bytes
        String string2 = new String(bytes, UTF_8);//鵡鵢鵣鵤鵥鵦鵧鵨鵩鵪鵫
        System.out.println(string2);

        //获取从索引为2开始，长度为5的字符串
        string2 = new String(bytes,2,5);//cdefg
        System.out.println(string2);

        //将字符集存入到字符串中
        char[] value = {'q','w','e','r','t','y'};
        String string3 = new String(value);
        System.out.println(string3);

4.常用方法： 

length() ： 获取字符对象的字符个数；

indexOf ： 返回指定字符在字符串中第一次出现的索引。

subString 获取字符串

trim : 截掉两端空格

charAt : 获取字符

startWith 和 endWith  : 获取头部相应字符或尾部相应字符,返回值是boolean类型的

toUpperCase() 、toLowerCase()将字符串全部换成大写或小写

valueOf()：将其他类型转换为字符串类型

        String[] str = {"1,2,3,4,5,6,7,8"};
        Strings ss = new Strings(str,8);
        System.out.println(ss.toString());
        System.out.println(ss.toString(str));
        String str1 = "   laknadosandj aldkfn    ";
        String str2 = "问苍茫大地，谁主沉浮";
        System.out.println(str1);
        //获取字符的长度
        System.out.println(str1.length());
        //获取字符串只填一个值表示开始字符的位置
        System.out.println(str1.substring(4));
        //获取字符串，分别代表开始值和结束值
        System.out.println(str1.substring(4,8));
        //将整个字符串添加到当前字符串的后面
        System.out.println(str1.concat(str2));
        //startsWith和endsWith返回值是boolean类型的
        System.out.println(str1.startsWith("   l"));
        System.out.println(str2.endsWith("沉浮"));
        //消除字符串首尾的空格符
        System.out.println(str1.trim());
        //替换 前面的是要被替换掉的内容，后面的是替换的内容
        System.out.println(str1.replace("l","WWW"));
        //获取字符第一次出现的位置
        System.out.println(str1.indexOf('l'));
        //获取相应字符最后一次出现的位置
        System.out.println(str1.lastIndexOf('l'));

        char[] ch = str1.toCharArray();
        System.out.println(ch);

equals 与 ==的区别

equals：是一个方法通常用于比较对象的内容是否相等；

注意：

        1.自反性：对任意引用x，x.equals(x)的返回值一定为true;

        2.对称性：对于任意引用x,y当且仅当y.equals(x)的返回值为true时，x.equals(y)的返回值一定为true;

        3.传递性：如果x.euqals(y)=true，y.equals(z)=true,则x.equals(z)=true;

        4.非空性：任何非空的引用值x，x.equals(null)的返回值一定为false.

== ：是比较两个对象的内存地址是否相等。简而言之，如果两个对象的引用指向同一块内存区域，==比较的结果就是true；否则，结果为false。这种比较通常用于检查两个引用是否指向同一个对象，而非检查对象的内容是否相同。

        /*
            equals 和 == 的区别
            equals : 比较的是两字符串的内容是否相同，底层还是用的是==
            == ： 比较两端的值是否指向的是同一个对象，比较的是内存地址
         */
        String S1 = new String("hello");
        String S2 = new String("hello");
        String S3 = "hello";
        String S4 = "hello";
        String S5 = "hella";
        System.out.println(S1 == S2);//false
        System.out.println(S1 == S3);//false
        System.out.println(S4 == S3);//true
        System.out.println(S3.equals(S4));//true
        System.out.println(S1.equals(S2));//true
        System.out.println(S1.equals(S3));//true
        System.out.println(S1.equals(S5));//false

二、StringBuilder 和 StringBuffer

1.常用构造器

StringBuilder() : 构造一个不带任何参数的构造器，初始容量为16个字符；

StringBuilder(String str) : 初始化值为指定的字符串内容；

2.常用方法：

append()：将指定字符串追加到字符串之后

insert(int index ,String str)：将指定字符串插入到字符串的指定索引处

delete()：删除字符串中的一部分

reverse()：将字符串进行反转

toString()：将StringBuilder转化为字符串类型

replace()：替换字符串的指定部分

        StringBuilder stringBuilder = new StringBuilder("你好，世界");
        String str = new String();
        str = "hello";
        //添加字符串到原字符串stringBuilder的后面
        stringBuilder.append(str);
        stringBuilder.append(" world");
        System.out.println(stringBuilder);
        //添加字符元素到指定位置
        stringBuilder.insert(5,"    ");
        System.out.println(stringBuilder);

        //reverse 是StringBuilder的方法，只能StringBuilder类型的变量才能调用；
        //将字符串进行反转
        System.out.println(stringBuilder.reverse());
        //System.out.println(str.reverse());
        stringBuilder.reverse();

        //将StringBuilder类型转换为字符串类型
        System.out.println(stringBuilder.toString());

        //替换字符串的指定部分，输入的是区间
        System.out.println(stringBuilder.replace(5,9,"----"));
        //删除指定位置的字符，输入的是区间
        System.out.println(stringBuilder.delete(11,15));

 3.StringBuilder 和 StringBuffer的区别

1.StringBuilder是可变字符串，如果进行字符串的计算，选择StringBuilder速度会更快，性能更好，因为他是多线程的；

2.StringBuilder是final修饰的类型，不能被继承；

3.StringBuilder没有重写equals方法和toString方法；

4.StringBuilder是线程的，同步处理，性能较慢。 

三、正则表达式

1.基本语法

1）.常用方法

* boolean matches(String regex) : 是否匹配正则表达式

* String[] split(String regex) : 对匹配上的字符串进行切割，匹配的字符作为分割线

* replaceAll() : 替换掉匹配上的内容

2）.预定义字符集

*   \d : 表示匹配数字字符中的任意一个
*   \D : 表示匹配除了数字字符串中的任意一个
*   \w : 表示匹配单词字符中的任意一个 a-z,A-Z,0-9
*   \W : 表示匹配除了单词字符中的任意一个
*   \s : 匹配空格，制表符，退格符，换行符等中的任意一个，
*   \S : 匹配除了\s中的内容中的任意一个
*    . : 用于匹配任意一个字符

3）.字符集合

* [ ]:表示匹配中括号里的任意一个字符；

* [asd]:表示匹配a,s,d,中的任意一个

* [^asd]:表示匹配除了a,s,d,中的任意一个，其他的都行

4）.数量词 

*   X* : 匹配0个或一个以上
*   X? : 匹配0个或一个
*   X+ : 匹配一个以上
*   X{n} :匹配n个
*   X{n,} : 匹配n个以上
*   X{n,m} : 匹配n个以上m个以下

5）.分组（）

在正则表达式上可以使用()来进行对一些字符分组，并可以使用逻辑运算符|来进行选择匹配

reg:
String regex = "(135|137)[\\d]{8}"  //匹配手机号是135或者是137开头的

6）.^和$

*    ^ ：表示严格从头匹配
*    & : 表示匹配到结尾

2.常用方法 

//需要定义一个Matcher 类型的变量来调用以下变量

*      matcher : 整个字符串必须满足正则表达式了，返回true，错误返回false
*      lookingAt() : 字符串的开头是否符合正则表达式，满足true,错误false
*      find() : 对字符串进行匹配，可以匹配到字符串的任何位置，每次调用，指针都会向后移动
*      reset() : 重置find()指针位置

2.Pattern 类和 Matcher 类

Pattern 类

Pattern这个类，才是真正来操作正则表达式的类，它位于java.util.regex包下。在String类中的提供的 matches 、split 、replace等方法，其实都是对这个类中的某些方法的封装。

1）.常用方法

Pattern类的构造方法是私有的，不可直接创建

可通过Pattern.complie(String regex)简单工厂方法创建一个正则表达式

Pattern p = Pattern.compile("\\w+");

 pattern() : 返回的是正则表达式的参数

p.pattern() 返回值是 \w+

 Matcher 类

Pattern类只能做一些简单的匹配操作,要想得到更强更便捷的正则匹配操作,那就需要将Pattern与Matcher一起合作.Matcher类提供了对正则表达式的分组支持,以及对正则表达式的多次匹配支持。

        String str = "12422222222222222222286";
        String str1 = "564ajbn6132hjk998sdvsb9u98273vsh d8 3gv";
        //必须要填上数量词来匹配，不然都表示为匹配错误，除非只有一个字符
        System.out.println("2".matches("\\d"));//true
        System.out.println(str.matches("\\d{18}"));//false
        System.out.println(str.matches("[0-9]{19}"));//false
        //要查中间重复的字符或数字出现了多少次，就需要完整写出该字符串的剩余的首位字符串
        System.out.println(str.matches("1242{3,}86"));//true
        //定义正则表达式的规则
        Pattern pattern = Pattern.compile("(\\d){1,}");
        //输出正则标的式的规则内容
        System.out.println(pattern.pattern());// \d
        //Matcher对象就是Pattern所定义的正则表达式的内容与字符串匹配的结果
        Matcher matcher = pattern.matcher(str);
        //直接返回的结果：java.util.regex.Matcher[pattern=\d region=0,23 lastmatch=]
        System.out.println(matcher);

        Matcher matcher1 = pattern.matcher(str1);
        System.out.println(matcher1);
        //调用matchers()方法进行匹配
        System.out.println(matcher.matches());

        //检查字符串的开头是否匹配正则表达式
        boolean b = matcher.lookingAt();
        System.out.println(b);
        matcher1.reset();
        matcher = pattern.matcher("56478");
        System.out.println(matcher.find(0));
        //检查是否匹配正则表达式，满足表达式的，当作是切割符，切割原字符串
        String[] str2 = pattern.split(str1);
        for(String i:str2){
            System.out.println(i);
        }

        //重置指针位置
        matcher.reset();
        matcher1.reset();