黑马程序员——Java基础---String、StringBuffer和正则表达式

最新推荐文章于 2022-09-15 09:16:22 发布
最新推荐文章于 2022-09-15 09:16:22 发布
阅读量1.2k 收藏 3
点赞数 2
分类专栏： Java学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23868283/article/details/41519115
版权
------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------


String、StringBuffer和正则表达式

一、String类。

        所谓String类就是对字符串这一类事物的描述，该类定义了专用于操作字符串的方法。

class StringDemo{
      public static void main(String[] args){
               String s1 = new String("abc"); 
             }
}
        以上是该String类最传统的定义方法，其中s1是一个String类的引用，“abc”是一个对象，字符串最大的特点是：一被初始化后该对象就不能够再被改变。 
package com.itheima;
class StringDemo{
    public static void main(String[] args){
             String s1 = new String("abc"); //传统构造方法
             String s2 = "abc";
             System.out.println(s1==s2);//false 
             System.out.println(s1.equals(s2));//true
           }
}
        由上面这段程序可以看出，我们构造String类对象可以有两种方法。但是从程序运行的结构来说，s1与s2是不相等的。为什么呢？这是因为s1里面存储的是一个String类对象的引用与s2里面存储的引用不是同一个，s1存在两个对象(s1本身new一个对象，“abc"也是一个对象)，而s2只有一个对象("abc")。而调用equals()方法打印出来的是true，说明s1和s2指向对象封装的内容是相等的。

        说明：在String类中的equals()方法是复写了Object类中的equals()方法。它的功能是对两个String类对象内部的字符串进行相同性的比较。

        再来一段程序：

package com.itheima;
class StringDemo{
    public static void main(String[] args){
             String s1 = new String("abc"); //传统构造方法
             String s2 = "abc";//简易构造法
             String s3 = "abc";
             System.out.println(s1==s2);//false
             System.out.println(s2==s3);//true
             System.out.println(s1.equals(s2));//true
           }
}
        为什么s2和s3是想等的呢？这是因为s1和s3内部存放的都是对象"abc"的引用！(s3没有new一个对象，在堆内存中就没有重新分配一个空间产生新地址)

        我们学习String类对象-字符串主要是为了学习其内部封装的字符串的处理方法。因为在后期的开发中，对字符串的处理是最基础中的基础工作，所以这个类是十分重要的类。下面我们来一一看一下String类里到底封装了哪些对字符串的操作。

        1、获取

        char charAt(int index);//获取某一角标代表的字符串。

        int length();//获取该字符串长度

        int indexOf(int char);//正序地获取字符char(int类型)在字符串里的位置，若该字符串没有char则返回-1

        int indexOf(int char a,int fromindex);//正序地从字符串的角标fromindex位置之后获取字符char(int类型)的位置，若该字符串没有'a'则返回-1

        int indexOf(String str);//正序地获取字符串str在字符串中的位置，若该字符串没有str则返回-1

        int indexOf(String str,int fromindex);//正序地从fromindex位置之后获取str在字符串中的位置，若没找到则返回-1

        int lastIndexOf(int char)//倒序地获取字符char(int类型)在字符串里的位置，若该字符串没有char则返回-1，之后还有3个如上函数倒推可得

package com.itheima;
public class StringMethodDemo {
	public static void main(String[] args){
		huoquMethod("haha.java");
	}public static void  huoquMethod(String s1){
		System.out.println(s1.length());
		System.out.println(s1.charAt(10));
		System.out.println(s1.indexOf(66));
		System.out.println(s1.indexOf(66,3));
		System.out.println(s1.indexOf("wwwww"));
		System.out.println(s1.indexOf("wwwww",3));
		System.out.println(s1.lastIndexOf(66));//之后以上面的类推
	}
}
            2、判断

        boolean contains(String str);//字符串是否包含str字串

        boolean isEmpty();//字符串是否为空

        boolean endWith(String str);//字符串是否以str字符串结尾

        boolean startWith(String str);//字符串是否以str字符串开头

        boolean equals(Object obj);//复写了Object类的equals()方法，两个字符串是否相等

        boolean equalsIgnoreCase();//比较并且忽略大小写

package com.itheima;
public class StringMethodDemo {
	public static void main(String[] args){
		panduanMethod("haha.java");
	}
	public static void panduanMethod(String s1){
		System.out.println(s1.isEmpty());
		System.out.println(s1.contains("sadada"));
		System.out.println(s1.endsWith("java"));
		System.out.println(s1.startsWith("haha"));
		System.out.println(s1.equals("suidhau"));
	}
}
        3、转换

        将字符数组转成字符：

        构造函数形式：String(char[] arr);

                                 String(char[] arr,int setoff,int count);//将字符数组setoff角标之后的字符转成字符串

        静态方法形式：static String copyValueOf(char[] arr);

                                 static String copyValueOf(char[] arr,int setoff,int count);//将字符数组setoff角标之后的字符转成字符串

        将字符串转化成字符数组：char[] toCharArray(String str)

        将字符串转化成字节数组：byte[] getBytes()

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

        将基本数据类型转化成字符串静态方法：static String valueOf(int)...

package com.itheima;
public class StringMethodDemo {
	public static void main(String[] args){
		zuanhuaMethod("haha.java");
	}
	public static void zuanhuaMethod(String s1){
		char[] arr={'a','b','c'};
		byte[] arr1="saujhdade".getBytes();
		System.out.println(String.copyValueOf(arr));
		System.out.println(String.copyValueOf(arr, 1, 2));
		System.out.println(new String(arr));
		System.out.println(new String(arr,1,2));
		System.out.println(s1.getBytes());
		System.out.println(new String(arr1));
		System.out.println(s1.toCharArray());
		System.out.println(String.valueOf(true));
		
	}
}
          4、替换

        String replace(char oldchar,char newchar);//将字符串中某一老字符换成新字符

package com.itheima;
public class StringMethodDemo {
	public static void main(String[] args){
		tihuanMethod("haha.java");
	}
	public static void tihuanMethod(String s1){
		System.out.println(s1.replace("haha", "hehe"));
	}
            5、切割

         String[] split(regex);//将字符串按照正则表达式切割。

package com.itheima;
public class StringMethodDemo {
	public static void main(String[] args){
		qiegeMethod("haha.java");
	}
	public static void qiegeMethod(String s1){
		String[] arr=s1.split("\\.");
		for(int i=0;i<arr.length;i++){
			System.out.println(arr[i]);
		}
	}
           6、字串

        String subString(int begin);从begin位置到字符串末尾获得字串

        String subString(int begin,int end); //从begin位置到end-1角标位置获得字串，包含头不包含尾

package com.itheima;
public class StringMethodDemo {
	public static void main(String[] args){
		zichuanMethod("haha.java");
	}
	public static void zichuanMethod(String s1){
		System.out.println(s1.substring(1,3));
	}
           7、转换大小写，去空格，比较

        String toUpperCase();//转换成大写

        String toLowerCase();//转换成小写

        String trim();//去空格

        boolean compareTo(String s);//将当前字符串和s进行自然顺序的比较

package com.itheima;
public class StringMethodDemo {
	public static void main(String[] args){
		OtherMethod("haha.java");
	}
	public static void OtherMethod(String s1){
		System.out.println(s1.toUpperCase());
		System.out.println(s1.toLowerCase());
		System.out.println(s1.trim());
		System.out.println(s1.compareTo("heihei.java"));
	}

二、StringBuffer类

        所谓StringBuffer类，其实就是一个字符串缓冲区，它就是一个容器。它有三个特点：1、长度是可变化的       

                                                                                                                                              2、可以字节形式操作多个数据类型

                                                                                                                                              3、最终会通过toString()方法变成字符串

        StringBuffer类主要也在于对其内部封装的方法的使用上，这些方法是：

        1、存储

        StringBuffer append(数据);//在该容器中增加一个元素

        StringBuffer insert(int index,数据);//在该容器指定位置插入一个元素

package com.itheima;
public class StringBufferDemo {
	public static void main(String[] args){
		StringBuffer sb = new StringBuffer();
		sb.append("wode").append("java").append("xuexi").append("biji");
		sb.insert(2, "daxing");
	}

        2、删除

        StringBuffer delete(begin,end);//删除角标为begin到end-1之间的元素

<span style="font-size:18px;">package com.itheima;
public class StringBufferDemo {
	public static void main(String[] args){
		StringBuffer sb = new StringBuffer();
		sb.append("wode").append("java").append("xuexi").append("biji");
		sb.insert(2, "daxing");                             
                deleteMethod(sb);
                }
public static void deleteMethod(StringBuffer sb){
               sb.delete(1, 2);
               System.out.println(sb);}
}

 

 
         3、获取 

 

        char charAt(int index);
 

        int indexOf(String str) ;同String类
 

        int lastIndexOf(String str) ;同String类      
 

        int length() ;同String类        
 

        String substring(int start, int end) ;同String类
 

        太过雷同，不在举例子了！
 

        4、修改
 

        StringBuffer replace(start,end,数据);//将StringBuffer里面的第start号元素到第end-1号元素全部替换成数据
 

 
 
package com.itheima;
public class StringBufferDemo {
	public static void main(String[] args){
		StringBuffer sb = new StringBuffer();
		sb.append("wode").append("java").append("xuexi").append("biji");
		sb.insert(2, "daxing");
		xiugaiMethod(sb);
	}
public static void xiugaiMethod(StringBuffer sb){
        sb.replace(1, 5, "javajava");
        System.out.println(sb);
    }
}

 
 
 

 


         
      5、反转 

 

        StringBuffer reverse();//将当前容器的元素反转
 

 
 
package com.itheima;
public class StringBufferDemo {
	public static void main(String[] args){
		StringBuffer sb = new StringBuffer();
		sb.append("wode").append("java").append("xuexi").append("biji");
		sb.insert(2, "daxing");                  
                reverseMethod(sb);
        }
public static void reverseMethod(StringBuffer sb){
                sb.reverse();
                System.out.println(sb);
            }
}

 
 
 

 

 
         在JDK1.5版本以后出现了StringBuilder类，它与StringBuffer类的功能几乎是一模一样，但是他们的区别在于：StringBuffer是线程同步的而StringBuilder是线程不同步的。大部分情况下，为了减少操作步骤，我们一般都使用StringBuilder容器，当出现多线程同步时，可以再代码上自主添加锁，也不用StringBuffer了！ 

 

        三、正则表达式
 

        所谓正则表达式，就是符合一定规则的表达式，
 

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

        它的好处是：可以简化对字符串的复杂操作
 

        弊端：符号定义多阅读性极其差。
 

        正则表达式也是一个字符串，它用于对字符串的操作，一般主要的正则符号有以下几种(注意使用下面带有\的功能时，需要在字符串内表示为\\)：
 

 
 

字符类
[abc]a、b 或 c（简单类）
[^abc]任何字符，除了 a、b 或 c（否定）
[a-zA-Z]a 到 z 或 A 到 Z，两头的字母包括在内（范围）
[a-d[m-p]]a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]]d、e 或 f（交集）
[a-z&&[^bc]]a 到 z，除了 b 和 c：[ad-z]（减去）
[a-z&&[^m-p]]a 到 z，而非 m 到 p：[a-lq-z]（减去）
 
预定义字符类
\d数字：[0-9]
\D非数字： [^0-9]
\s空白字符：[ \t\n\x0B\f\r]
\S非空白字符：[^\s]
\w单词字符：[a-zA-Z_0-9]
\W非单词字符：[^\w]
 

 

 
 

边界匹配器
^行的开头
$行的结尾
\b单词边界
\B非单词边界
\A输入的开头
\G上一个匹配的结尾
\Z输入的结尾，仅用于最后的结束符（如果有的话）
\z输入的结尾
 
Greedy 数量词
X?X，一次或一次也没有
X*X，零次或多次
X+X，一次或多次
X{n}X，恰好 n 次
X{n,}X，至少 n 次
X{n,m}X，至少 n 次，但是不超过 m 次
 

 

        正则表达式的应用主要在四个方面：
 

        1、匹配：
 

        使用了String类中的matches()方法,具体用法如下：
 

package com.itheima;
public class RegexDemo {
    public static void main(String[] args){
        matchesMethod();
    }
    public static void matchesMethod(){
        String qq = "196788342";
        String regex="[1-9]\\d{4,14}";//代表qq号第一位只能是1-9的数，而其后面全是数字且只能是4-14个。
        System.out.println("qq数字是"+qq.matches(regex));
    }
}
      
   2、切割 

 

        使用了String类中的split()方法。注意：在定义切割标标记时，若标记已经在正则表达式中具有特殊含义，需要在该标记之前加上\\以示区别。
 

 

package com.itheima;
public class RegexDemo {
	public static void main(String[] args){
		splitMethod();
	}
	public static void splitMethod(){
		String files = "wozueiaidejavachengxu.txt.bmp.java";
		String regex = "java";
		String regex1= "\\.";
		String[] arr = files.split(regex); 
		for(String s:arr){//超级for循环
			System.out.println(s);
		}
		String[] arr1 = files.split(regex1);
		for(String s:arr1){
			System.out.println(s);
		}
	}
        
 3、替换 

 

        使用了String类中的replace()方法。
 

 

package com.itheima;
public class RegexDemo {
	public static void main(String[] args){
		replaceMethod();
	}
	public static void replaceMethod(){
		String s1 = "wow4874687aiudufh45789451fhuibuh54785dhuasd";
		String regex = "\\w+";
		System.out.println(s1.replaceAll(regex, "@"));
		
	}
 

     
     4、获取。注意，该方法需要import java.util.regex.*; 

 

        步骤：1、将规则封装成对象  Pattern p = pattern.compile(regex);
 
 

                   2、将规则对象和需要作用的字符串联系起来 matcher m = p.matcher(string);
 

                   3、关联后获取正则匹配引擎
 

                   4、通过引擎对符合规则的字串进行操作
 
 

package com.itheima;
import java.util.regex.*;
public class RegexDemo {
	public static void main(String[] args){
		getMethod();
	}
	public static void getMethod(){
		String str = "wo zuei ai de bian cheng yu yan shi java";//获取只有3个字符的字符串
		String regex = "\\d[a-z]{3}\\d";
		Pattern p =Pattern.compile(regex);//将规则封装成对象
		Matcher m = p.matcher(str);//将规则对象和字符串联系起来
		while(m.find()){
			System.out.println(m.group());
			System.out.println(m.start()+"。。。。。"+m.end());
		}
	}
        注意，网页爬虫也就是通过网络获得的字符串信息中进行以上获取操作来获得合法的邮箱地址，其规则一般是”\\w+@\\w+(\\.\\w+)\\1+“ 

 

四、基本数据类型包装类。
 

        基本数据类型包装类主要有：
 

        int------------integer
 

        byte---------Byte
 

        short--------Short
 

        long---------Long
 

        char---------Character
 

        boolean----Boolean
 

        float---------Float
 

        double------Double
 

        基本数据类型包装类最常见的作用就是用于基本数据类型和字符串之间的转换。
 

        基本数据类型转换成字符串方法：基本数据类型值+”“;
 

                                                              基本数据类型包装类.toString(基本数据类型值)
 

                                                                                                       String.valueOf(基本数据类型值)
 

 

public class IntegerDemo {
	public static void main(String[] args){
		changeToStringMethod();
	}
    public static void changeToStringMethod(){
    	Integer x = 321;//自动装箱！
    	if((x+"" instanceof String))
    		System.out.println("转换成功啦！");
    	else
    		System.out.println("转换失败啦！");
    	if((Integer.toString(x) instanceof String))
    		System.out.println("转换成功啦！");
    	else
    		System.out.println("转换失败啦！");
    	if((String.valueOf(x) instanceof String))
    		System.out.println("转换成功啦！");
    	else
    		System.out.println("转换失败啦！");
    }
}
        
    字符串转换成基本数据类型，以Integer类为列子：Integer.parseint("必须是整型数字字符串") 

 

package com.itheima;
public class IntegerDemo {
	public static void main(String[] args){
		changeToInteger();
	}
	public static void changeToInteger(){
		if((Integer.parseInt("123")+4)==127)
			System.out.println("转换成功啦！");
		else
			System.out.println("转换失败啦！");
	}
  
       此外，基本数据类型包装类还有其他应用，以Integer为列子： 

 

        数制转换：
 

        Integer toBinaryString();//将十进制数变成二进制，然后在变成字符串
 

        Integer toHexString();//将十进制变成十六进制
 

        Integer toOctalString();//将十进制变成八进制
 

        小知识：
 

        Integer x=3这种初始化Integer对象的方法叫做自动装箱，可以如此初始化。也可以System.out.println(x//相当于x.value()，叫做自动拆箱)
 

        当自动装箱的值小于127的时候，此时：
 

        Integer x=127；
 

        Integer y=127；
 

        System.out.println(x==y)
 

        此时打印的结果是true，这是因为自动装箱的数值小于byte类型可以表示的最大值时，装箱相同的数值是不会重新产生一个对象的。x和y都是同一个对象的引用。
 


 
 


 
 


 
 

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

                

        

        

    




    

      

        

            

              
                
                  彭攀的家
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    2
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    3
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
java [字符串]-[StringBuffer]-[正则表达式]

				
			

			

				

					VIPGuiBin的专栏
				

				

					12-30
					
					3569
					
				

			

		

		

			
				
------- android培训、java培训、期待与您交流！ 
 ----------

一字符串  二StringBuffer 与 StringBuilder三正则表达式 

一、字符串
 
String 是一个final类 不能复写 不能有子类
1. 用双引号引起的都是字符串对象 , 该对象位于常量池中
 
2. 字符串中==与equals的区别

  1--> S

			
		

	



                

              
                



	

		

			

				
					
String类，StringBuffer方法，正则表达式，Data,DateFormat。

				
			

			

				

					gorgeoustudy的博客
				

				

					07-25
					
					180
					
				

			

		

		

			
				
1
			char charAt(int index)
			返回指定索引处的 char 值。
		2
			int compareTo(Object o)
			把这个字符串和另一个对象比较。
		3
			int compareTo(String anotherString)
			按字典顺序比较两个字符串。
		4
			int compareToIgnoreCase(St...

			
		

	



                


  
              

                


	

		

			

				
					
String,Stringbuilder,Stringbuffer及正则表达式

				
			

			

				

					qq_58692689的博客
				

				

					09-15
					
					129
					
				

			

		

		

			
				
String,Stringbuilder,Stringbuffer及正则表达式案例

			
		

	





	

		

			

				
					
8：正则表达式及stringbuffer

				
			

			

				

					dw379936691的专栏
				

				

					06-05
					
					397
					
				

			

		

		

			
				
正则表达式: 负责的字符串匹配处理规则, 应用广泛.
  学习建议: 1 要能够读懂"正则表达式"
           2 能够写出简单的"正则表达式"
           3 不要过多的分配学习时间!
  可以应用于: java grep vi
  1 字符集: [1234] 表示 1,2,3,4 之一
            [^12] 表示除了 1,2
          

			
		

	



		

			
		



	

		

			

				
					
黑马程序员_StringBuffer&正则表达式总结

				
			

			

				

					enjoy628888的专栏
				

				

					01-13
					
					615
					
				

			

		

		

			
				
------------------------------------------------android培训、java培训、期待与您交流！-----------------------------------------------
StringBuffer
①特点
是一个容器,长度是可变化的,可以字节操作多个数据类型,最终会通过toString方法变成字符串
②重要方法

			
		

	





	

		

			

				
					
java必备-菜鸟的最爱-正则表达式.docx

				
			

			

				

					12-24
				

			

		

		

			
				
如`replaceAll(String replacement)`替换所有匹配的部分，`replaceFirst(String replacement)`仅替换第一次匹配的部分，以及`appendReplacement(StringBuffer sb, String replacement)`和`appendTail(StringBuffer ...

			
		

	





	

		

			

				
					
Java面试题-每日一题：String、StringBuffer、StringBuilder的区别

					
最新发布

				
			

			

				

					07-23
				

			

		

		

			
				
Java面试题-每日一题：String、StringBuffer、StringBuilder的区别

			
		

	





	

		

			

				
					
java-regex正则表达式

				
			

			

				

					07-23
				

			

		

		

			
				
Java正则表达式是编程语言Java中用于处理文本模式匹配和替换的重要工具。它基于一套特殊的语法，允许程序员高效地检查字符串是否符合特定的模式，或者根据这些模式进行字符串的替换和提取。以下是对Java正则表达式...

			
		

	





	

		

			

				
					
JAVA正则表达式实例教程.pdf

				
			

			

				

					04-12
				

			

		

		

			
				
Java正则表达式是编程语言Java中用于处理文本模式匹配和替换的重要工具。它基于一套特殊的语法，允许程序员高效地检查、查找、提取甚至替换文本中的特定模式。在这篇实例教程中，我们将深入理解Java正则表达式的核心...

			
		

	





	

		

			

				
					
Java 中 String，StringBuffer 和 StringBuilder 的区别及用法

				
			

			

				

					08-31
				

			

		

		

			
				
"Java 中 String、StringBuffer 和 StringBuilder 的区别及用法"  Java 中 String、StringBuffer 和 StringBuilder 是三个常用的字符串操作类，了解它们之间的区别对 Java 开发者来说非常重要。本文将详细介绍这三者...

			
		

	





	

		

			

				
					
String和StringBuffer详细用法总结

				
			

			

				

					04-11
				

			

		

		

			
				
对于新手来说，可以大大区别。
对于老手来说，可以清晰思维。
它包含很多细节问题和注意题，总结是高效的，也是一种精髓。

			
		

	





	

		

			

				
					
Java语言中StringBuffer的用法

				
			

			

				

					07-05
				

			

		

		

			
				
StringBuffer的常用方法实例，如：append、insert等等。其中，StringBuffer与String的区别详细做了例子。

			
		

	





	

		

			

				
					
java 正则数字金额转换为大写

				
			

			

				

					05-20
				

			

		

		

			
				
输入字符，通过正则验证是否为金额不超过万亿精确到小数点后两位，然后将数字转换为大写

包括后台java正则验证及前台js验证


请输入一个数字（精确到小数点后两位）：
fdsa54325.54
fdsa54325.54
false
请输入一个数字（金额不超过万亿精确到小数点后两位）

请输入一个数字（精确到小数点后两位）：
9909010256300.30
9909010256300.30
true
玖万玖仟零玖拾亿壹仟零贰拾伍万陆仟叁佰元叁角整

			
		

	





	

		

			

				
					
正则表达式、Math类、StringBuffer类和StringBuilder类

				
			

			

				

					余心所善
				

				

					04-11
					
					456
					
				

			

		

		

			
				
一、Java中的正则表达式 
        1.正则表达式就是记录文本规则的代码。用于进行文本匹配的工具，也是一个匹配的表达式。 
    先上一个小例子： 
    根据给定正则表达式的匹配拆分此字符串，得到拆分好的字符串数组。public class RegexTest{
    public static void main(String[] args){
    String str =

			
		

	





	

		

			

				
					
Java中的StringBuffer与StringBuilder及正则表达式

				
			

			

				

					
				

				

					01-27
					
					1529
					
				

			

		

		

			
				
StringBuffer是安全的，同步的，效率低
StringBuilder是不安全的，不是同步的，效率高
String与StringBuffer、StringBuilder：
                        String是一个不可变的字符序列；
                         StringBuffer、StringBuilder是可变的字符序列 ；
S

			
		

	





	

		

			

				
					
StringBuffer、StringBuilder、String区别以及正则表达式

				
			

			

				

					你好，Java！的博客
				

				

					05-05
					
					141
					
				

			

		

		

			
				
StringBuilder和StringBuffer区别

StringBuffer早期版本1.0
StringBuilder早期版本1.5
早期版本 线程同步 安全性比较高 执行效率相对较低
后期版本 线程非同步 安全性比较低 执行效率相对较高

String和StringBuilder区别

String不可变字符串
　　　JDK1.0
　　　有一个接口Comparable
　　　不可变体现在...

			
		

	





	

		

			

				
					
（java） String类：String的构造方法、字符串的常见方法、StringBuffer和StringBuilder、正则表达式

				
			

			

				

					XJC_jin的博客
				

				

					09-24
					
					225
					
				

			

		

		

			
				
protected Object clone()
标记接口：没有任何抽象方法的接口称为标记接口。
CloneNotSupportedException
异常名称：克隆不支持异常
产生原因：需要克隆的对象没有实现Cloneable接口
Student s1=new Student(“老王”，40);
Student s2=s1;——多个引用指向同一个堆区空间
Object s1clone=s1.cl...

			
		

	





	

		

			

				
					
javaSE第五章_＜API常用类(2)＞【替换,正则表达式,StringBuffer类,Random类,System类,Date-Calendar,BigInteger_BigDecimal】

				
			

			

				

					SDWESCES的博客
				

				

					03-20
					
					414
					
				

			

		

		

			
				
文章目录替换功能正则表达式

替换功能
正则表达式
正则 表达式
规则
是一种字符串模式匹配语言
指定规则：手机号规则
     注册手机号
       手机号 15111111111 11位 数字 以1开头 ---格式
       邮箱   wrwuert7254632@re23.com
 */
  /*Scanner s=new Scanner(System.in);
    System.out.println("请输入手机号");
    String phone=s.next(); */
  

			
		

	





	

		

			

				
					
黑马成员---StringBuffer，StringBuilder，Integer，自动装箱和拆箱，正则表达式：匹配，切割，替换，查找

				
			

			

				

					yangsing0的专栏
				

				

					11-12
					
					556
					
				

			

		

		

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


1.      第十三天内容回顾 String类，特性，不new对象，不变性，方法熟练。
  构造，判断，获取，转换，其他
  StringBuffer缓冲区，底层可变数组，自动扩容复制数组，提示字符串的操作效率
  ""  构造方法，空参数，String类型重载  append

			
		

	





	

		

			

				
					
Java String和StringBuffer的使用、正则表达式

				
			

			

				

					07-27
				

			

		

		

			
				
Java中，String和StringBuffer都是用来存储和操作字符串的类。String是字符串常量，不可更改的常量，而StringBuffer是字符串变量，可以扩充和修改的对象。\[2\]  String的使用方法包括字符串的拼接、截取、替换等...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值