黑马程序员__字符串、 正则表达式

毕老师视频day13  day25-正则表达式

1.字符串是一个被final修饰的类，无法被继承

最大特点：  字符串对象是常量，初始化之后不能更改(对象的引用是可以改的，"abc"这样的对象实体不能更改)

class Main
{
    public static void main(String [] args)
    {    
        String s = "abc";                 //只有一个对象
        String t = new String("abc") ;   //这里会创建一个abc的副本，出现2个对象abc，导致s、t引用地址值不同
        
        System.out.println(s==t);        //false  比较的是引用地址值 
        System.out.println(s.equals(t)); //true   String类复写了该方法，比较的是对象是否相同

    }
}

2.  常见的字符串操作：

1》获取：

　　获取字符串长度： int  length()

　　根据位置获取位置上某个字符：  char  charAt(int index)

　　根据字符获取该字符在字符串中的位置： int  indexOf(int ch)  返回在字符串第一次出现的位置，没有找到返回 -1

　　　　　　　　　　　　　　　　　　　　 int  indexOf(int ch, int fromIndex) 从指定位置开始，第一次出现的位置。

　　　　　　　　　　　　　　　　　　　　 int  indexOf(String str)  返回子串第一次出现的位置　　  　　

　　　　　　　　　　　　　　　　　　　　 int  indexOf(String str, int fromIndex) 　　

　　　　　　　　　　　　　　                  int  lastIndexOf(int ch)       int  lastIndexOf(String  str) 反向搜索　　

2》判断：

　　字符串中是否包含一个子串　boolean contains(String str)　

　　字符串是否为空   boolean isEmpty()

　　字符串是否以指定内容开头  boolean startsWith(String prefix)

　　字符串是否以指定内容结尾  boolean endsWith(String suffix)

　　判断字符串内容是否相同 boolean  equals(String str)   复写了Object的方法

　  判断字符串内容是否相同，并忽略大小写  boolean  equalsIgnoreCase(String str)  

3》转换：

　　将字符数组转成字符串      构造函数String(char[] )    静态方法 static String copyValueOf(char [])

　　将字符串转成字符数组      char[]   toCharArray()

　　将 字节数组转成字符串     String( byte[]  )            

　　将字符串转成 字节数组     byte[]  getBytes()     转换过程可指定编码表

　　将基本数据类型转成字符串   static String valueOf(int)      static String valueOf(double)  

4》替换：

　　String replace(char oldChar, char newChar)  把出现的所有的old 字符替换成 new字符

　　String replace(String target, String replacement)  

5》 切割：

　　String[]  split(String  regex)  

6》获取子串：

　　String substring(int beginIndex)

　　String substring(int beginIndex, int endIndex)   包含头，不包含尾！到角标end-1

7》 转换  去空格  比较：

　　将字符串转成大写或者小写    String toUpperCase()              String  toLowerCase() 

　　将字符串两端的多个空格去掉：  String  trim()

　　对两个字符串进行自然顺序比较      int compareTo(String str)     依次已经字母大小，返回第一个非0值

3. StringBuffer  是字符串缓冲区， 是一个容器   字符串的组成原理是通过该类实现的，可以对字符串内容进行增删 

特点：

长度是可以变化的；

可以直接操作多个数据类型；

最终会通过 toString 方法变成字符串。

存储操作：

StringBuffer  append(obj)  向容器尾部追加数据，追加后容器内容改变。

StringBuffer  insert(int offset, obj) 向容器指定位置插入数据

删除操作：

StringBuffer  delete(int start, int end) 删除指定内容，包含头不包含尾

StringBuffer  delete(int index)  删除指定角标位置的字符

获取操作：

char charAt(int index) 
int indexOf(String str) 
int indexOf(String str, int fromIndex) 
int lastIndexOf(String str, int fromIndex) 
String substring(int start) 
String substring(int start, int end) 

修改操作：

StringBuffer  replace(int start, int end, String str)  

void setCharAt(int index, char ch)  

反转操作：

StringBuffer reverse() 

void  getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)  

4.  JDK1.5版本之后，出现了StringBuilder 

StringBuffer 是线程同步的，线程安全的可变字符序列。

StringBuilder是线程不同步的，是StringBuffer 的一个简易替换，但单线程中效率更高。  多线程中是不安全的。

开发建议使用StringBuilder

java升级3个因素： 提高效率；  简化书写；  提高安全。

5.基本数据类型对象包装类： Integer   Byte  Short Long Boolean   Float  Double  Character  

最常见作用： 基本数据类型和字符串类型之间做转换。

基本数据类型转字符串：  Xxx.toString(xxx)      如 Integer.toString(int x)

字符串转基本数据类型：  xxx a = Xxx.parseXxx(String str)       int a = Integer.parserInt(String str)

十进制转其他进制：    

static String toBinaryString(int i)
static String toOctalString(int i)
static String toHexString(int i)

其他进制转十进制：  static int parseInt(String s, int radix)  

Integer转int型： int intValue() 

6. JDK1.5新特性：

Integer x = new Integer(4);

Integer x = 4;     //两种方式效果一样，自动装箱，简化书写
x = x + 2;          //x进行了自动拆箱，变成int + 2，  再将和进行装箱，赋给左边。

    Integer x1 = 128;
    Integer y1 = 128;
    System.out.println(x1==y1); //false
 
 
    Integer x2 = 127;
    Integer y2 = 127;
    System.out.println(x2==y2); //true  指向了同一个对象，数值在byte范围内时，1.5新特性，如果该数值已存在，不会开辟新空间
 
 
    Integer x3 = new Integer(120);
    Integer y3 = new Integer(120);
    System.out.println(x3==y3);  //false
    System.out.println(x3.equals(y3));  //true  equals被重写，比较的是数值

正则表达式：

• 作用： 用于专门操作字符串。
• 好处：可以简化对字符串的复杂操作
• 弊端：符合定义越多，正则越长，阅读性越差

/*
[abc] a、b 或 c（简单类） 
[^abc] 任何字符，除了 a、b 或 c（否定） 


. 任何字符   当以.来分割字符串时，用\.表示
d 数字：[0-9] 
D 非数字： [^0-9] 
s 空白字符：[ 	
x0Bf
] 
S 非空白字符：[^s] 
w 单词字符：[a-zA-Z_0-9] 
W 非单词字符：[^w] 


X? X，一次或一次也没有 
X* X，零次或多次 
X+ X，一次或多次 
X{n} X，恰好 n 次 
X{n,} X，至少 n 次 
X{n,m} X，至少 n 次，但是不超过 m 次 


*/

boolean matches(String regex)      //告知此字符串是否匹配给定的正则表达式。
String[] split(String regex)       //根据给定正则表达式的匹配拆分此字符串。 
String[] split(String regex, int limit) // 根据匹配给定的正则表达式来拆分此字符串。

        String str = "abc.345.dsi";   // . 切割 reg = "\."
        str = "c:\abc\a.txt";       //reg = "\\"
        str ="adfhhhiuwkkkjkl...opq"; //叠词切割， reg = "(.)\1{2}"  
        str ="adfh,hiuwkk,jkl...opq"; //叠词切割， reg = "(.)\1{2}"  
                                      //将规则封装成组，用()完成，组都有编号,从1开始
                                      //获取已有的组，用
获取
//((A)(B(C))) 用4个组，按左括号顺序编号，  1：(A)(B(C)) 2:A 3:B(C) 4:C
//0组代表整个表达式      (?:pattern)匹配pattern，但不捕获匹配结果。    

具体操作功能：

• 匹配  String matches(regex)
• 分割  String split(regex)
• 替换  String replaceAll(regex, repstr) 

    public static void rep()
    {
        String str = "abcddddfkajjjjjpqu";  //叠词替换成单个字母
        String regex = "(.)\1+";
        String str1 = str.replaceAll(regex, "$1");  //$1代表第一组
        System.out.println(str1);
    }
    

• 获取： 将字符串中符合规则的子串取出。

操作步骤：

• 正则表达式封装成对象
• 让正则对象和要操作的字符串关联
• 关联后，获取正则匹配引擎
• 通过引擎对符合规则的子串进行操作

    public static void get()
    {
        String str = "aaabbbbccc";
    
        Pattern p = Pattern.compile("\w{2}");  //Pattern类没有对外构造函数
        Matcher mat = p.matcher(str);   //正则对象与字符串关联，得到匹配器引擎
        while(mat.find())  // 尝试查找与该模式匹配的下一个子序列。
        {
            System.out.println(mat.group());  //返回刚才匹配操作期间捕获的子序列
            System.out.println(mat.start());  //返回刚才的匹配操作期间，所捕获的子序列的初始索引
        }
    }