常用类（工具类）之字符串相关

落日映苍穹つ 2022-11-05 15:55 258阅读 0赞

**字符串相关**  
**String类**

1.  所属的包java.lang 没有继承类 默认继承Object
2.  实现了三个接口 Serializable CharSequence Comparable<>
3.  String是一个非常特殊的引用数据类型，创建对象方式如下

> String str = “abc”;  
> String str = new String();  
> String str = newString(“abc”);  
> String str = new String(byte\[\] value);  
> String str = new String(char\[\] value);

1.  String类的不可变特性

> public final class String\{ private final char\[\] value; \}  
> **体现在长度及内容**  
> 长度不可变是由于: 数组的长度是固定的 用final修饰数组(引用地址不能改变)  
> 内容不可变是由于:  
> private修饰的属性只能在本类中访问

1.  String类中的常用方法

1.boolean = equals(Object obj);
    		   继承自Object类中的方法  重写啦  改变了规则  比较字符串中的字面值
    		   ==  equals()区别
    			equalsIgnoreCase();
    		2.int = hashCode();
    		   继承自Object类中的方法  重写啦  31*h+和
    		3.int = compareTo();
    		   实现自Comparable接口  实现方法   结果按照字典排布(unicode编码)顺序
    		   按照两个字符串的长度较小的那个(次数)来进行循环
    		   若每次的字符不一致 则直接返回code之差
    		   若比较之后都一致  则直接返回长度之差
    			compareToIgnoreCase();
    		4.String = toString()
    		   没有重写过的toString从Object类中继承过来的
    		   类名@hashCode(16进制形式)
    		   String类重写啦  返回的是String对象的字面值
    		-----------------------------------------------------------------------------------
    		5.char = charAt(int index);
    		   返回给定index位置对应的字符
    		   int = codePointAt(int index);
    		   返回给定index位置对应字符的code码
    		6.int = length();
    		   返回字符串的长度   (其实就是底层char[] value属性的长度)
    		   注意:  区别数组length是属性  String的length()方法    集合size()方法
    		7.String = concat(String str);
    		   将给定的str拼接在当前String对象的后面
    		   注意:  方法执行完毕需要接受返回值   String的不可变特性
    		            concat方法与   +拼接的性能问题
    		            开发中若遇到频繁的拼接字符串--->通常使用StringBuilder/StringBuffer
    	=======================================================
            8.boolean = contains(CharSequence s);
    		   判断给定的s是否在字符串中存在
    		9. startsWith(String prefix);
    		    endsWith(String suffix);
    		   判断此字符串是否已xx开头/结尾
    		10.byte[] = getBytes();   --->    getBytes(String charsetName);
    		     char[] = toCharArray();
    		   将当前的字符串转化成数组   "我爱你中国"   char[]  '我' '爱' '你' '中' '国'
    		11. int index = indexOf(int/String str [,int fromIndex] );   四个方法重载
    		   找寻给定的元素在字符串中第一次出现的索引位置   若字符串不存在则返回-1
    		      lastIndexOf(int/String str , [int fromIndex]);
    		   找寻给定的元素在字符串中最后一次出现的索引位置  若不存在则返回-1
    		12.boolean = isEmpty();
    		   判断当前字符串是否为空字符串  (length是否为0)
    		   注意： 与null之间的区别
    		13.replace();
    		     replaceAll();
    		     replaceFirst(); 换第一次出现的那个字串
    		   将给定的字符串替换成另外的字符串
    		14.String[] = split(String regex [,int limit限度界限]);
    		   按照给定的表达式将原来的字符串拆分开的
    		15.String = substring(int beginIndex [,int endIndex]);
    		   将当前的字符串截取一部分
    		   从beginIndex开始至endIndex结束  [beginIndex,endIndex)
    		   若endIndex不写 则默认到字符串最后
    		16.String = toUpperCase();
    		     String = toLowerCase();
    		  将全部字符串转换成大写/小写
    		17.String = trim();
    		  去掉字符串前后多余的空格
    		18.boolean = matches(String regex)    **下面正则说一下**
    		  regular有规律的 expression表达式
    		  正则表达式

**== 与 equals方法的区别：**  
字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中。

> 对于基本类型来说，==是进行数值的比较。  
> 对于引用类型来说，==是进行【地址值】的比较。

public class TestString {
    
        public static void main(String[] args){
            //String类  "abc"对象  常量区
            String s1 = "abc";
            String s2 = "abc";
            String s3 = new String("abc");
            String s4 = new String("abc");
            System.out.println(s1==s2);//true
            System.out.println(s1==s3);//false
            System.out.println(s3==s4);//false
            System.out.println(s1.equals(s2));//true   String类将继承自Object中的equals方法重写啦
            System.out.println(s1.equals(s3));//true   将原有比较==的方式改为比较字符值
            System.out.println(s3.equals(s4));//true
    
        }
    }

**示例代码：**

public class TestString {
    
        public static void main(String[] args){
    //        byte[] value = new byte[]{65,97,48};
    //        String str = new String(value);//Aa0
    //        System.out.println(str);//
    
    //        char[] value = {'h','e','l','l','o'};
    //        String str = new String(value,1,3);
    //        System.out.println(str);//ell
    //        str.equals(null);// 默认比较地址 this==obj  String重写啦 改成了比字符串内容
    //        str.hashCode();// 内存地址调用一个本地的native方法进行计算
    //                //"abc"   h=0
    //                //h = (0*31+97)
    //                //h = (97)*31+98
    //                //h = ((97)*31+98)*31+99
    
    
    //        TestString ts = new TestString();
    //        System.out.println(ts);
    //        String str1 = new String("abc");
    //        System.out.println(str1);//toString方法
    //        str1.toString();
    
            //数组-->length属性
            //box--->size()方法
            //String-->length()方法
    
    //        String str = "abcdef";//-->123456
    //        String result = "";
    //        for(int i=0;i<str.length();i++){
    //            int value = str.codePointAt(i);
    //            result += (char)(value-48);//密钥  U盾
    //        }
    //        System.out.println(result);
    
    //        String str = "abcdef";
    //        //String对象 (字符串常量池) value属性char[]
    //        //长度不能改变 数组地址不让改变 数组属性私有的我们操作不了
    //        str = str.concat("g");
    //        //创建一个新的String对象  (字符串常量池)  value属性  7个
    //        //刚才那个String对象value值依次取出来  存入新对象的value属性 g放在后面
    //        System.out.println(str);//abcdefg ????
    //        //String的不可变特性
    
    //        String str = "a"+"b"+"c"+"d";//数学计算  拼接符号
    //        System.out.println(str);//过程中产生了几个String对象? 字符串常量池7个
    //        //1对象-->value[] a       "a"
    //        //2对象-->value[] b       "b"
    //        //3对象-->value[] {a,b}  "ab"
    //        //4对象-->value[] c       "c"
    //        //5对象-->value[] {a,b,c} "abc"
    //        //6对象-->value[] d       "d"
    //        //7对象-->value[]         "abcd"
    
            String str = "a";
            long time1 = System.currentTimeMillis();
            for(int i=1;i<=200000;i++){
                //str+="a";//每一次利用+在原来的字符串后面拼接一个新的a  +   9447毫秒
                //str = str.concat("a");//利用concat拼接字符        5324毫秒
                //StringBuffer对象  拼接效率非常高  像以前自己封装的ArrayBox
            }
            long time2 = System.currentTimeMillis();
            System.out.println(time2-time1);
    
    
    //        System.out.println(str1.compareTo(str2));//int
            //按照两个字符串长度较短的那个作为比较循环的次数
            //挨个比较元素   str1[i]-str2[i]    循环内如果有结果
            //如果循环过后发现所有的字符都一样  len1-len2
            //返回0表示两个字符相等
    
    //        String str = "abcdefg";
    //        //判断此字符串中是否含有a
    //        boolean value = str.contains("ag");
    //        System.out.println(value);
    
            //电脑上扫描  所有.java后缀名的源文件
    //        String str = "TestString.java";
    //        boolean value = str.endsWith(".java");
    //        System.out.println(value);
    
    //        String str = "我爱你中国";
    //        byte[] b = str.getBytes();
    //        for(byte v:b){
    //            System.out.println(v);//byte
    //        }
    //        char[] c = str.toCharArray();
    //        for(char v:c){
    //            System.out.println((int)v);
    //        }
    
    //        String str = "abcdefgabc";
    //        int index = str.lastIndexOf("b",7);
    //        System.out.println(index);//1  不论从哪儿开始找寻 返回的index都是相对于整个String的
    //
    //        str.indexOf(98,3);
    
    //        String str = "a";
    //        boolean value = str.isEmpty();//NullPointerException
    //        System.out.println(value);
    
    //        String str = "拓哥很帅气拓哥很帅气拓哥很帅气";
    //        //str = str.replace('帅','骚');
    //        str = str.replace("帅气","**");
    //        System.out.println(str);
    
    //        String str = "a-b-c-d";
    //        String[] value = str.split("-",3);
    //        for(String v:value){
    //            System.out.println(v);
    //        }
    
            //登录
            //数组充当小数据库
            //一位数组 String[] int[]
            //二维数组{
       {"","333"},{"","444"}}
    //        String[] userBox = {"郑中拓-123","渡一教育-666","Java-888"};
    //        Scanner input = new Scanner(System.in);
    //        System.out.println("请输入账号:");
    //        String name = input.nextLine();
    //        System.out.println("请输入密码");
    //        String password = input.nextLine();
    //        boolean b = false;
    //        for(int i=0;i<userBox.length;i++){
    //            String[] value = userBox[i].split("-");//value[0]--name value[1]--password
    //            if(value[0].equals(name)){
    //                if(value[1].equals(password)){
    //                    System.out.println("登录成功");
    //                    b = true;
    //                }
    //                break;
    //            }
    //        }
    //        if(!b){
    //            System.out.println("用户名或密码错误");
    //        }
    
    //        String str = "abcdefgh";
    //        //str = str.substring(3);//从3号索引开始一直到最后
    //        str = str.substring(-3,1);//从3号索引开始到5号索引结束   [3,5)
    //        System.out.println(str);
    
    //        String str = "abcdefg";
    //        str = str.toUpperCase();
    //        System.out.println(str);
    //        str = str.toLowerCase();
    //        System.out.println(str);
    
    
    //        String str = "  zheng zhongtuo    ";
    //        str = str.trim();
    //        System.out.println(str.equals("zhengzhongtuo"));
    
            String str1 = "abc";
            String str2 = "ABC";
            System.out.println(str1.equals(str2));//false
            System.out.println(str1.equalsIgnoreCase(str2));//true
            System.out.println(str1.compareTo(str2));//32
            System.out.println(str1.compareToIgnoreCase(str2));//0
    
    	}
    }

**String不可变特性 private final char\[\] value;  
频繁的修改其内容的时候 性能很不好**

**StringBuffer**  
**StringBuilder**

1.  所属的包 java.lang包
2.  继承AbstractStringBuilder 间接继承 Object

> 实现接口Serializable,CharSequence,Appendable  
> StringBuffer/StringBuilder没有compareTo方法  
> StringBuffer/StringBuilder含有一个String没有的方法 append();拼接

1.  特性  
    可变字符串 char\[\] value; 动态扩容
2.  对象的构建

//无参数构造方法  构建一个默认长度16个空间的对象  char[]
    	StringBuilder builder = new StringBuilder();
    	//利用给定的参数 构建一个自定义长度空间的对象 char[]
    	StringBuilder builder = new StringBuilder(20);
    	//利用带String参数的构造方法  默认数组长度字符串长度+16个
    	StringBuilder builder = new StringBuilder("abc");

1.  StringBuilder中常用的方法

最主要的方法 append()  频繁的拼接字符串的时候使用此方法 提高性能
    		ensureCapacity(int minimumCapacity)  确保底层数组容量够用
    		capacity();//字符串底层char[]的容量
    		length();//字符串有效元素个数(长度)
    		setLength();//设置字符串的有效元素个数
    		char = charAt(int index);
    		int = codePointAt(int index);
    		String = substring(int start [,int end]);
    			注意需要接受返回值 看见截取出来的新字符串效果
    		StringBuilder = delete(int start [,int end]);
    			StringBuilder类中独有的方法String类没有
    			将start到end之间的字符串删掉  不用接受返回值就看到效果啦
    		StringBuilder = deleteCharAt(int index);
    			String类中没有的方法
    			将给定index位置的某一个字符删除掉啦
    		int = indexOf(String str [,int fromIndex]);
    		int = lastIndexOf(String str [,int fromIndex])
    			找寻给定的str在字符串中第一次出现的索引位置  带重载 则从某一个位置开始找
    		insert(int index,value);
    			将给定的value插入在index位置之上
    		replace(int start,int end,String str);
    			将start和end之间的部分替换成str
    			builder.replace(2,5,"zzt");
    		setCharAt(int index,char value);
    			将index位置的字符改成给定的value
    		reverse()
    		    将字符串反转
    		toString()
    			将StringBuilder对象 构建成一个string对象 返回
    		trimToSize()
    			将数组中无用的容量去掉  变成length长度的数组

**示例代码：**

public class TestStringBuilder {
    
        public static void main(String[] args){
    //        //无参数构造方法  构建一个默认长度16个空间的对象  char[]
    //        StringBuilder builder = new StringBuilder();
    //        //利用给定的参数 构建一个自定义长度空间的对象 char[]
    //        StringBuilder builder = new StringBuilder(20);
            //利用带String参数的构造方法  默认数组长度字符串长度+16个
            //StringBuilder builder = new StringBuilder("abc");
    
    //        String str = "a";
    //        long time1 = System.currentTimeMillis();
    //        for(int i=1;i<=200000;i++){
    //            //str+="a";//利用+拼接  10030
    //            str = str.concat("a"); //5320
    //        }
    //        long time2 = System.currentTimeMillis();
    //        System.out.println(time2-time1);
    
    //        StringBuilder builder = new StringBuilder("a");//17
    //        long time1 = System.currentTimeMillis();
    //        for(int i=1;i<=200000;i++){
    //            builder = builder.append("a");//7毫秒
    //        }
    //        long time2 = System.currentTimeMillis();
    //        System.out.println(time2-time1);
    
    //        StringBuilder builder = new StringBuilder("abcdefg");//7+16 capacity
    //        System.out.println(builder.capacity());//底层那个数组的容量
    //        System.out.println(builder.length());//长度  有效元素的个数
    
    //        StringBuffer buffer = new StringBuffer();
    //        buffer.append("");
    //
    //        StringBuilder builder = new StringBuilder("abcdefg");// 7+16
    //        builder.append("");
    //
    //        System.out.println(builder.length());//7
    //        System.out.println(builder.capacity());//23
    //        builder.setLength(15);//length--15
    //        builder.trimToSize();
    //        System.out.println(builder.length());//15
    //        System.out.println(builder.capacity());//15
    
    
    
    
    //        System.out.println(builder.length());//7
    //        System.out.println(builder.capacity());//23
    //        builder.setLength(20);
    //        System.out.println(builder.length());//20
    //        System.out.println(builder.capacity());//23
    //        builder.toString();//将一个StringBuilder对象 转化成String对象
    
    
    
            //builder.setCharAt(2,'z');
            //System.out.println(builder);
    
            //builder.reverse();
            //System.out.println(builder);
    
    
    //        builder.replace(2,5,"zzt");
    //        System.out.println(builder);
    
    
    //        builder.append("m");//abcdefgm
    //        System.out.println(builder);
    //        builder.insert(1,"n");
    //        System.out.println(builder);
    
            //builder.deleteCharAt(2);
            //System.out.println(builder);
            //builder.delete(2,5);
            //System.out.println(builder);
    
    //        String value= builder.substring(2,5);//2索引开始5索引结束
    //        System.out.println(value);
    
    
        }
    }

**补充：**  
Regular有规律的 Expression表达式  
**正则表达式regex**  
一个带有一定规律的表达式  
匹配字符串格式的  
**正则表达式通常的作用如下:**

> 1.字符串的格式校验 String类中提供的一个方法 boolean = str.matches(“regex”);  
> 2.字符串的拆分及替换 String类中提供的方法replace split  
> 3.字符串的查找 Pattern模式 Matcher匹配器

如下的所有都用来描述字符的信息
    		[abc]	abc其中的一个
    		[^abc]	不能是abc其中的一个 其他都可以
    		[a-zA-Z]	表示必须是这两个范围内的
    		[a-z&&[^bc]]  表示a-z其中的一个但不能是b和c
    		|	或者
    		. 代表任意一个字符
    		\d  digit数字   [0-9]
    		\D  非数字       [^0-9]
    		\s  space留白  一个空格 一个回车 一个换行。。。
    		\S  非留白
    		\w  word单词  [0-9A-Za-z]  数字或字母都可以
    		\W 非单词        [^0-9A-Za-z]
    
    		如下的所有都用来描述字符出现的次数
    		?   0-1次    [0-9]?
    		*   0-n次
    		+  1-n次
    		{n} 固定n次
    		{n,} 至少出现n次
    		{m,n}  m-n次

**示例代码：**

public class TestRegex {
    
        public static void main(String[] args){
    //        Scanner input = new Scanner(System.in);
    //        System.out.println("请您输入一个字符串");
    //        String str = input.nextLine();
            //判断输入的str字符串内容是否满足什么样的格式
    
            //第一个字母必须是a 第二个字母是abc其中的一个
    //        boolean result1 = str.matches("[A-Za-z]{6,10}");
    //        System.out.println(result1);
    
            //第一个字母必须是a 第二个字母是非abc任意的其他一个
    //        boolean result2 = str.matches("a[^abc]");
    //        System.out.println(result2);
    
            //第一个字母必须是a 第二个任意范围之内的一个字母
    //        boolean result = str.matches(".[a-zA-Z]");
    //        System.out.println(result);
    
            //a-z都可以 不能是b和c
    //        boolean result = str.matches("[a-z&&[^bc]]");
    //        System.out.println(result);
    
    //        String value = "a,b+c#d";
    //        String[] result = value.split(",|\\+|#");
    //        System.out.println(result.length);
    
            //所有的字串中找寻满足如下规则的信息  邮政编码
            String str = "123456abc222333abc654321abc";
            //1.利用Pattern类创建一个模式   理解为是一个正则表达式对象
            Pattern pattern = Pattern.compile("\\d{6}");//邮编
            //2.需要提供一个字符串
            //3.利用pattern模式对象创建一个匹配器
            Matcher matcher = pattern.matcher(str);
            //4.找寻字符串中出现满足上述格式的字串
            while(matcher.find()){
                System.out.println(matcher.group());//找到满足字符串格式的那一串文字
            }
        }
    }