黑马程序员——java基础——String类，正则表达式

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

字符串是一个特殊的对象
它最大的特点是一旦初始化就不可以被改变

String类是对字符串事物的描述。
该类定义了专门用于操作字符串的方法。

String s1 = “abc”;
String s2 = new String(“abc”);
s1和s2有什么区别？
s1在内存中有一个对象。
s2在内存中有两个对象

字符串常用的方法：
1，获取。
(1) 字符串中的包含的字符数，也就是字符串的长度。
int length():获取长度。
(2) 根据位置获取位置上某个字符。
char charAt(int index):
(3) 根据字符获取该字符在字符串中位置。
int indexOf(int ch):返回的是ch在字符串中第一次出现的位置。
int indexOf(int ch, int fromIndex) :从fromIndex指定位置开始，获取ch在字符串中出现的位置。
int indexOf(String str):返回的是str在字符串中第一次出现的位置。
int indexOf(String str, int fromIndex) :从fromIndex指定位置开始，获取str在字符串中出现的位置。
int lastIndexOf(int ch) ：获取字符最后一次出现的位置

2，判断。
(1) 字符串中是否包含某一个子串。
boolean contains(str):
indexOf(str):可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在。
所以，也可以用于对指定判断是否包含。
if(str.indexOf(“aa”)!=-1)
而且该方法即可以判断，还可以获取出现的位置。
(2) 字符中是否有内容。
boolean isEmpty(): 原理就是判断长度是否为0.
(3) 字符串是否是以指定内容开头。
boolean startsWith(String str);
(4) 字符串是否是以指定内容结尾。
boolean endsWith(String str);
(5) 判断字符串内容是否相同。复写了Object类中的equals方法。
boolean equals(String str);
(6) 判断内容是否相同，并忽略大小写。
boolean equalsIgnoreCase();

3，转换。
(1) 将字符数组转成字符串。
构造函数： new String(char[])
new String(char[],int offset,int count):将字符数组中的一部分转成字符串。
静态方法：
static String copyValueOf(char[]);
static String copyValueOf(char[] data, int offset, int count)
static String valueOf(char[]):
(2) 将字符串转成字符数组。
char[] toCharArray():
(3) 将字节数组转成字符串。
new String(byte[])
new String(byte[],int offset,int count):将字节数组中的一部分转成字符串。
(4) 将字符串转成字节数组。
byte[] getBytes():
(5) 将基本数据类型转成字符串。
static String valueOf(int i)
static String valueOf(double d)
//3+”“;//String.valueOf(3);
字符串和字节数组在转换过程中，是可以指定编码表的。

4，替换
String replace(char oldchar,char newchar);

5，切割
String[] split(String regex);

6，子串。获取字符串中的一部分。
String substring(int begin);
String substring(int begin,int end);

7，转换，去除空格，比较。
(1) 将字符串转成大写或则小写。
String toUpperCase();
String toLowerCase();
(2) 将字符串两端的多个空格去除。
String trim();
(3) 对两个字符串进行自然顺序的比较。
int compareTo(String str);

需求：获取一个字符串在另一个字符串中出现的次数。
“abkkcdkkefkkskk”
思路：
获取目标子串在字符串中出现的次数
1.定义一个计数器
2.在子串存在情况下，获取子串
3.记录可以获取子串的次数

//通过获取子串的次数
class  StringTest2
{
    public static int getSubCount(String str,String key)
    {
        int count = 0;
        int index = 0;

        while((index=str.indexOf(key))!=-1)
        {
            sop("str="+str);
            str = str.substring(index+key.length());
            count++;    
        }
        return count;
    }
    //方法二：通过获取角标查询的次数
    public static int getSubCount_2(String str,String key)
    {
        int count = 0;
        int index = 0;

        while((index= str.indexOf(key,index))!=-1)
        {
            sop("index="+index);
            index = index + key.length();//从key值出现后的下一个位置再次寻找
            count++;
        }
        return count;
    }

    public static void main(String[] args) 
    {
        String str = "kkabkkcdkkefkks";
        sop("count="+getSubCount_2(str,"kk"));
    }

    public static void sop(String str)
    {
        System.out.println(str);
    }
}

获取两个字符串中相同的最大子串
“aseivnjfsworlddhgh” “dfjworldecd”
遍历较小的那个字符串，一个个的减少然后和较大的比较
需要把较小的字符串按顺序从最多的子串到最少的子串都要遍历到，然后取相同的部分
0-s.length() 1个 1
0-s.length()-1 2个 11
0-s.length()-2 3个 111
0-s.length()-3 4个 1111
for嵌套循环，外循环是整个长度，内循环有两个变量一个为0，另一个为length()-x

class Test
{
    public static String getSubString(String s1,String s2)
    {
        String max = "",min="";
        max = (s1.length()>s2.length())? s1:s2 ;
        min = (max==s1)?s2:s1 ;

        for (int x=0;x<min.length() ;x++ )
        {
            for (int y=0,z=min.length()-x;z<min.length()+1 ;y++,z++ )//y-z为满足规定长度的字符串的首尾的角标
            {
                 String s = min.substring(y,z);
                // sop(s);
                 if(max.contains(s))
                    return s ;
            }
        }
        return "没有相同的字符串";//若return s执行，这句话就不会执行，程序直接停止了
    }
    public static void main(String[] args) 
    {
        String s1 = "dfjworldecd";
        String s2 = "aseivnjfsworlddhgh";
        sop(getMaxSubString(s2,s1));
    }

    public static void sop(String str)
    {
        System.out.println(str);
    }
}

基本数据类型对象包装类
int Integer
short Short
long Long
char Character
double Double
float Float
boolean Boolean
byte Byte

1.基本数据类型转换为字符串
基本数据类型+”“;
Integer.toString(int i);
Long.toString(long l);
Short.toString(short s);
Character.toString(char c);
Byte.toString(byte b);
Double.toString(double d);
Boolean.toString(boolean boo);
Float.toString(float f);

2.字符串转为基本数据类型
Integer.parseInt(“123”); 123
Long.parseLong(“123”); 123
Short.parseShort(“123”); 123
Byte.parseByte(“123”); 123
Double.parseDouble(“12.31”);12.31
Float.parseFloat(“12.31”); 12.31
Boolean.parseBoolean(“true”);true
注意：Character类不具备此功能，因为其本身就是字符

3.十进制转其他进制
Integer.toBinaryString(60); 十进制转二进制
Integer.toHexString(60); 十进制转十六进制
Integer.toOctalString(60); 十进制转八进制

4.其他进制转十进制
Integer.parseInt(“110”,2); 将二进制的110转为十进制
Integer.parseInt(“74”,8); 将八进制的74转为十进制
Integer.parseInt(“60”,10); 将十进制的60转为十进制
Integer.parseInt(“3c”,16); 将十六进制的3c转为十进制

正则表达式：符合一定规则的表达式
作用：用于专门操作字符串
特点：用于一些特定的符号来表示一些代码操作。这样就简化书写
所以学习正则表达式，就是在学些特殊符号的使用

好处：可以简化对字符串的复杂操作
弊端：符号定义越多，正则越长，阅读性越差

具体功能：
1.匹配：String matches方法，用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false
2.切割：String split();
3.替换：String replaceAll(regex,str);如果regex中有定义组，可以在第二参数中通过$符号获取正则表达式中的已有的组。
4.获取：将字符串中的符合规则的子串取出

class RegexDemo
{
    public static void main(String[] args) 
    {
        checkTel();

        splitDemo("zb,cd,ef",",");//按逗号切割
        splitDemo("zb  cd hf    ge"," +");//按多个空格切割
        splitDemo("ab.de.gj.jejje.gd","\\.");//按.切割  正则表达式里的 \. 才表示 .  所以要先用转义字符\将\转义
        splitDemo("c:\\abc\\2.txt","\\\\");//按\\切割  java里面的\\都是成对出现的，因为转义字符
        splitDemo("abccdessghddfg","(.)\\1");//按叠词切割  . 表示任意字符
        splitDemo("vfhhjfiiidessdppppahdhjh","(.)\\1+");//按一个或一个以上的叠词切割
        /*
        按叠词完成切割
        为了可以让规则的结果被重用，可以将规则封装成一个组，用()完成
        组的出现都有编号，从1开始，想要使用自己的组可以通过\n(n就是组的编号)的形式获取
        (.)\\1 第一位定义的组在第二位再一次的出现了，后一位和前一位的结果是一样的
        */

        String str = "gsajg656254144hgueeu1234djgk6789";//将数字替换成*;
        eplace(str,"\\d{1,}","*");

        String s = "ssdfjjjiwtuossssuwyruydddddtcnfg";//将叠词替换成一个字符
        replace(s,"(.)\\1+","#");

        String s2 = "ssdfjjjiwtuossssuwyruydddddtcnfg";//将重叠的字符替换成单个字符 如：dddd-->d
        replace(s2,"(.)\\1+","$1");   //用$获取组
    }

    //替换
    public static void replace(String str, String regex, String newele)
    {
        str = str.replaceAll(regex,newele);
        System.out.println(str);
    }

    //切割
    public static void splitDemo(String str , String regex)
    {
        String[] arr = str.split(regex);
        for(String s : arr)
        {
            System.out.println(s);
        }
    }

    /*
    需求：
    校验一个手机号
    13xxxx 15xxxxx   16xxxx  18xxxxx   十一位
    */
    //匹配:
    public static void checkTel()
    {
        String tel = "18111211111";
        String regex = "1[3568]\\d{9}";
        boolean b = tel.matches(regex);
        if(b)
            System.out.println(tel);
        else
            System.out.println("不是电话号码");
    }
}

获取:将字符串中的符合规则的子串取出。
操作步骤：
1，将正则表达式封装成对象。
2，让正则对象和要操作的字符串相关联。
3，关联后，获取正则匹配对象。
4，通过引擎对符合规则的子串进行操作，比如取出。

import java.util.regex.*;

class RegexDemo2 
{
    public static void main(String[] args) 
    {
        getDemo();
    }
    public static void getDemo()
    {
        String str = "hao xiang qu hei ma xue xi bian cheng";
        System.out.println(str);
        String reg = "\\b[a-z]{2}\\b";// \\b是单词的边界

        //将规则封装成对象。
        Pattern p = Pattern.compile(reg);

        //让正则对象和要作用的字符串相关联。获取匹配器对象。
        Matcher m  = p.matcher(str);

       //将规则作用到字符串上，并进行符合规则的子串查找
        while(m.find())
        {
            //获取匹配后结果。
            System.out.println(m.group());
        }
    }
}