Java基础---字符串(String)操作类

最新推荐文章于 2022-11-03 18:39:18 发布
最新推荐文章于 2022-11-03 18:39:18 发布
阅读量607 收藏 1
点赞数
分类专栏： Java 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/airar/article/details/121227787
版权

1.String类如何创建对象

String类---不可变的字符串操作类

String类---Java的jdk提供好的开发类。【java.lang包不用import】

String类---使用final修饰符修饰的，没有子类，不可继承。

String类创建对象---构造方法

  1. String()---创建一个空字符串对象
  2. String(byte[] bytes,into offset,int length)---字节数组转换为字符串
  3. string(char[] value,into offset,int count)---字符数组转换为字符串
  4. string(string original)---字符串常量创建字符串对象
  5. String(StringBuffer buffer)---将StringBuffer转换成字符串
  6. String(StringBulider builder)---将StringBuilder转换成字符串

例如：

package com.object.test1;

public class StringClassTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//1.String()--创建一个空字符串对象  
	     String str1=new	String();
	     //2.String(byte[] bytes, int offset, int length)--字节数组转换成字符串
	     //byte[] bytes---字节数组
	     //int offset---数组起始位置
	     //int length=被转换的字节个数
	     byte bytearr[]={97,98,99,100};
	     String str2=new String(bytearr,0,bytearr.length);
	     System.out.println("str2=="+str2);
	     //3.String(char[] value, int offset, int count) --字符数组转换成字符串
	     //char[] value---字符数组
	     //int offset---数组的起始位置
	     //int count---被转换的字符个数
	     char  value[]={'h','e','l','l','o'};
	     String str3=new String(value,0,value.length);
	     System.out.println("str3=="+str3);
	     //4.String(String original) --字符串常量创建字符串对象
	     String str4=new String("hello,world");
	     //上面的写法可以简写
	     String str5="Hello,World";
	     System.out.println("str4=="+str4);
	     System.out.println("str5=="+str5);
	   
	}

}

2.String 的常用方法

  1. char charAt(int index)---从原始字符串中得到指定位置的字符元素。
  2. String concat(String str)---将指定字符串连接到该字符串的末尾。
  3. boolean contains(CharSequence s)---判断指定的字符串数据是否在原始字符串中存在。
  4. boolean endsWith(String suffix)---测试此字符串是否以指定的后缀结尾。
  5. boolean startsWith(String prefix)---测试此字符串是否以指定的前缀开头。
  6. byte[] getBytes()---将字符串通过默认的字符编码转换成字节数组。 byte[] getBytes(String charsetName)---将字符串通过指定的字符编码转换成字节数组 
  7. int indexOf(String str)---返回指定子字符串第一次出现在字符串内的索引位置
  8. lastIndexOf(String str)---返回指定子字符串最后一次出现的字符串中的索引。
  9. boolean isEmpty()---判断字符串是否为空串，此方法为true时，字符串长度一定为0
  10. int length() ---返回此字符串的长度。
  11. boolean matches(String regex)---判断字符串数据是否符合正则表达式
  12. String replace(CharSequence old, CharSequence new)---将与字面目标序列匹配的字符串的每个子字符串替换为指定的字面替换序列
  13. String[] split(String regex)---通过指定的符号将字符串拆分成一个字符串数组
  14. String substring(int beginIndex)---截取从指定的开始位置到字符串结尾的一个子字符String substring(int beginIndex, int endIndex) 截取从指定的开始位置到指定的结束位置的一个子字符串
  15. char[]  toCharArray()---将此字符串转换为新的字符数组
  16. String toLowerCase()---大写转小写
  17. toUpperCase()---小写转大写
  18. String trim()---去除原始字符串的两头空格
package com.object.test1;

public class StringMethod {

	public static void main(String[] args) throws Exception{
		//创建字符串对象
		String str1=new String("hello,world");
		String sta=new String("HELLO,WORLD");
		//1.char	charAt(int index) 从原始字符串中得到指定位置的字符元素。
		//System.out.println(str1.charAt(3));
		//2.String concat(String str)将指定的字符串连接到该字符串的末尾。
		//String str2=str1+",你好";
		//String str2=str1.concat(",你好");
		//System.out.println("str2=="+str2);
		//boolean contains(CharSequence s)判断指定的字符串数据是否在原始字符串中存在
		//System.out.println(str1.contains("world")); //true
		/*
		//创建保存姓名的数组
		String names[]={"张三","李四","王五","赵三","王六"};
		//4.boolean endsWith(String suffix)测试此字符串是否以指定的后缀结尾。 
		for(String name:names){
			if(name.endsWith("三")){
				System.out.println("name=="+name);
			}
		}
		//5.boolean startsWith(String prefix)测试此字符串是否以指定的前缀开头
		for(String name:names){
			if(name.startsWith("王")){
				System.out.println("name=="+name);
			}
		}
		*/
		//6.byte[] getBytes() 将字符串通过默认的字符编码转换成字节数组
		//byte[] getBytes(String charsetName)将字符串通过指定的字符编码转换成字节数组
		/*
		byte  bytearr[]={97,98,99,100};
		String  str2=new String(bytearr,0,bytearr.length); //abcd
		byte bytearr2[]=str2.getBytes("utf-8");
		for(byte value:bytearr2){
			System.out.println("val=="+value);
		}
		*/
		/*
		//7.int indexOf(String str) 返回指定子字符串第一次出现在字符串内的索引位置
		System.out.println(str1.indexOf("o"));   //4
		//8.lastIndexOf(String str)返回指定子字符串最后一次出现的字符串中的索引。
		System.out.println(str1.lastIndexOf("o"));   //7
		//9.boolean isEmpty()判断字符串是否为空串，此方法为true时，字符串长度一定为0
		System.out.println(str1.isEmpty());   //false
		//10.int length() 返回此字符串的长度。
		System.out.println(str1.length()); //11
		//12.String replace(CharSequence old, CharSequence new) 将与字面目标序列匹配的字符串的每个子字符串替换为指定的字面替换序列
		System.out.println(str1.replace("world", "世界"));
		*/
		/*
		//13.String[] split(String regex)通过指定的符号将字符串拆分成一个字符串数组
		String starr[]=str1.split(",");
		System.out.println(starr[0]);
		System.out.println(starr[1]);
		//14.String substring(int beginIndex)截取从指定的开始位置到字符串结尾的一个子字符串
		System.out.println(str1.substring(str1.indexOf(",")+1));
		//String substring(int beginIndex, int endIndex) 截取从指定的开始位置到指定的结束位置的
		System.out.println(str1.substring(0,str1.indexOf(",")));
		*/
		/*
		//15.char[]  toCharArray() 将此字符串转换为新的字符数组
		char  value[]={'h','e','l','l','o'};
		String  str3=new  String(value,0,value.length);
		char value2[]=str3.toCharArray();
		for(char val:value2){
			System.out.println("val=="+val);
		}
		*/
		//16.String toLowerCase() 大写转小写
		System.out.println(sta.toLowerCase());
		//17.toUpperCase() 小写转大写
		System.out.println(str1.toUpperCase());
	}

}

 3.字符串与基本类型转换

1.String转换成基本类型转换

   通过基本类型提供的封装类的parseXXX(String str)

   int parseInt(String) / double parseDouble(String str) / boolean parseBoolean(String  str)....

   parseXXX(String  str)方法只能被基本类型的封装类调用

   只有基本数据类型才有自己对应的封装类。

   封装类---基本数据类型对应的复合数据类型

 例如:

double dou=23.5;   //double类型的变量，没有可供使用的方法
Double dou=new Double(23.5);  //Double对象，有可供使用的变量和方法
Double就是double的封装类
基本数据类型[变量]封装类[对象]
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharacter
booleanBoolean

     自动装箱---将基本类型数据转化成对应的封装类类型

      1.封装类的构造方法

       2.将基本类型数据变量/数据值直接赋值给对应的封装类变量

   自动拆箱---将封装类类型转换成基本数据类型【直接赋值】

例如：

package com.object.test1;

public class StringTest {

	public static void main(String[] args) {
		//String 转换成基本类型--parseXXX(String  str)---基本数据类型的封装类
			//封装类---基本数据类型对应的复合数据类型
			//基本数据类型没有可供使用的方法
			//封装类有可供使用的变量和方法。
			//自动装箱---将基本数据类型转换成对应的封装类类型
			//1.封装类的构造方法
		  Integer int1=new Integer(100);
		  int num=100;
		  Integer int2=new Integer(num);
		  System.out.println("int1=="+int1);
		  System.out.println("int2=="+int2);
		  //2.将基本数据类型变量/数据值直接赋值给对应的封装类变量
		  Integer intt1=105;
		  int num2=105;
		  Integer intt2=num2;
		  System.out.println("intt1=="+intt1);
		  System.out.println("intt2=="+intt2);
		  //自动拆箱--将封装类类型转成基本数据类型【直接赋值
		  Double doub1=new Double(12.5);
		  double dou1=doub1;
		//我们可以通过基本数据类型的封装类的静态方法parseXXX(String  str)将字符串转换成基本类型
		  String str1="12.5";
		  double dou2=Double.parseDouble(str1);
		  System.out.println(dou2+1);
		  
		  String boo1="true";
		  boolean boo2=Boolean.parseBoolean(boo1);
		 if(boo2){
			 System.out.println("基本数据类型");
		 }else{
			 System.out.println("字符串");
		 }
		
	}

}

 基本数据类型与对应封装类的区别

基本数据类型封装类
基本类型类
变量，没有可供调用的方法和变量构造出来的对象，提供了变量和方法
只在内存的栈区有数据分配内存的栈区和堆区都有分配
有各自默认的数据值 int---0默认值null  Integer---null

  2.基本类型转换成String 

      将基本数据类型转换成String[static String valueOf(基本类型数据值/变量)]

例如：

package com.object.test1;

public class StringTest {

	public static void main(String[] args) {
		//将基本数据类型转换成String【static String valueOf(基本数据类型的数据值/变量)】
		 int num1=100;
		 String strar=String.valueOf(num1);
		 System.out.println(strar.length());
		  double doub=13.5;
		  String strar2=String.valueOf(doub);
		  System.out.println(strar2.length());
	}

}

4.String类与字节数组/字符数组之间的转换

1.String类转换成字节数组

  String类的byte[] getBytes() / byte[] getBytes(String charsetName)

2.字节数组转换String类型

   String类的构造方法String(byte[] bytes, int offset, int length)

例如：

package com.object.test1;

import java.io.UnsupportedEncodingException;

public class Test {

	public static void main(String[] args) throws Exception {
		//1.String类转换成字节数组
		byte bytearr1[]={97,98,99,100};
	     String str1=new String(bytearr1,0,bytearr1.length);
	     byte byt[]=str1.getBytes();
	     for(byte byt2:byt){
	    	 System.out.println("byt2=="+byt2);
	     }
		//2.字节数组转换String类型
		byte bytearr2[]={97,98,99,100};
	     String str2=new String(bytearr2,0,bytearr2.length);
	     System.out.println("str2=="+str2);
	    
	}

}

 String类与字符数组

  1.String类转换成字符数组

     String类的”char[]  toCharArray()

   2.字符数组转换String类型

      String类的构造方法”String(char[] value, int offset, int count)”

package com.object.test1;

import java.io.UnsupportedEncodingException;

public class Test {

	public static void main(String[] args) throws Exception {
		
	     //String类与字符数组
	     //1.String类转换成字符数组
	     char cha1[]={'h','e','l','l','o'};
	     String str3=new String(cha1,0,cha1.length);
	    char charr[]=str3.toCharArray();
	    for(char ch:charr){
	    	System.out.println("ch=="+ch);
	    }
	     //2.字符数组转换String类型
	     char cha2[]={'h','e','l','l','o'};
	     String str4=new String(cha2,0,cha2.length);
	     System.out.println("str4=="+str4);
	}

}

 5.字符串操作类StringBuilder

StringBuilder---一个可变的字符序列

StringBuilder()构造一个初始容量为16个字符的空StringBuilder对象

StringBuilder(CharSequence seq)通过其他的StringBuilder对象创建一个新的StringBuilder对象

StringBuilder(int capacity)构造一个由capacity参数指定的初始容量为空的StringBuilder对象

StringBuilder(String str)构造一个初始化为指定字符串内容的StringBuilder对象

例如：

package com.object.test2;

public class TestStringBuilder {

	public static void main(String[] args) {
		//StringBuilder() 构造一个初始容量为16个字符的空StringBuilder对象。
		StringBuilder stb1=new StringBuilder();
		//StringBuilder(CharSequence seq)通过其他的StringBuilder对象创建一个新的StringBuilder对象
		StringBuilder stb2=new StringBuilder("hello,world");
		//StringBuilder(int capacity) 构造一个由 capacity参数指定的初始容量得空StringBuilder对象
		StringBuilder stb3=new StringBuilder(23);
		//StringBuilder(String str) 构造一个初始化为指定字符串内容的StringBuilder对象
		String str="hello,world";
		StringBuilder stb4=new StringBuilder(str);
	}

}

5.1 StringBuilder的方法

1. int    capacity() 返回当前容量。 

2. char    charAt(int index) 返回 char在指定索引在这个字符值。

3. int    indexOf(String str) 返回指定子字符串第一次出现的字符串内的索引。 

4. int    lastIndexOf(String str) 返回指定子字符串最右边出现的字符串内的索引。

5. int    length() 返回长度（字符数）。 StringBuilder    append(Object o) 将参数的字符串表示追加到序列中。 
6. StringBuilder    delete(int start, int end) 删除此序列的子字符串中的字符。 

7. StringBuilder    deleteCharAt(int index) 删除 char在这个序列中的指定位置。 

8. StringBuilder    insert(int offset, Object o) 将参数的字符串表示插入到此序列中指定的位置。

9. StringBuilder    reverse() 导致该字符序列被序列的相反代替。 

10. StringBuilder    replace(int start, int end, String str) 用指定的String中的字符替换此序列的子字符串中的 String 。

11. String    substring(int start) 返回一个新的 String ，其中包含此字符序列中当前包含的字符的子序列。 

12. String    substring(int start, int end) 返回一个新的 String ，其中包含此序列中当前包含的字符的子序列。 

13. String    toString() 返回表示此顺序中的数据的字符串。

package com.object.test2;

public class TestStringBuilder {

	public static void main(String[] args) {
		//StringBuilder() 构造一个初始容量为16个字符的空StringBuilder对象。
		StringBuilder stb1=new StringBuilder();
		//StringBuilder(CharSequence seq)通过其他的StringBuilder对象创建一个新的StringBuilder对象
		StringBuilder stb2=new StringBuilder("hello,world");
		//StringBuilder(int capacity) 构造一个由 capacity参数指定的初始容量得空StringBuilder对象
		StringBuilder stb3=new StringBuilder(23);
		//StringBuilder(String str) 构造一个初始化为指定字符串内容的StringBuilder对象
		String str="hello,world";
		StringBuilder stb4=new StringBuilder(str);
		
		//int	capacity() 返回当前容量。
		System.out.println(stb1.capacity());
		//StringBuilder容量扩展规则==当前容量*2+2
		//append(Object o) 将参数的字符串表示追加到序列中。 
		stb1.append("123456789012345678");
		System.out.println(stb1.capacity());
		//charAt(int index) 返回 char在指定索引在这个字符值
		System.out.println(stb2.charAt(4));
		//indexOf(String str) 返回指定子字符串第一次出现的字符串内的索引。 
		System.out.println(stb2.indexOf("l"));
		//lastIndexOf(String str) 返回指定子字符串最后边出现的字符串内的索引。
		System.out.println(stb2.lastIndexOf("l"));
		//length() 返回长度（字符数）
		System.out.println(stb2.length());
		//append(Object o) 将参数的字符串表示追加到序列中。 
		System.out.println(stb2.append("你好"));
		//delete(int start, int end) 删除此序列的子字符串中的字符。 
		System.out.println(stb2.delete(11,13));
		//insert(int offset, Object o) 将参数的字符串表示插入到此序列中指定的位置。
		//System.out.println(stb2.insert(1,"o"));
		//reverse() 导致该字符序列被序列的相反代替。
		///System.out.println(stb2.reverse());
		//replace(int start, int end, String str) 用指定的String中的字符替换此序列的子字符串中的 String 。
		System.out.println(stb2.replace(0, 5, "你好"));
		//substring(int start) 返回一个新的 String ，其中包含此字符序列中当前包含的字符的子序列。 
		//substring(int start, int end) 返回一个新的 String ，其中包含此序列中当前包含的字符的子序列。 
		//toString() 返回表示此顺序中的数据的字符串。
	}

}

 5.2 StringBuilder与String的转换

    StringBuilder--》String  

       StringBuilder的toString();

       String的构造方法String(StringBuilder builder)

   String-->StringBuilder

       StringBuilder的构造方法

例如：

package com.object.test2;

public class Main {

	public static void main(String[] args) {
		StringBuilder stb1=new StringBuilder("hello,world");
		//StringBuilder--》String  
		
		String str=stb1.toString();
		String strr=new String(stb1);
		//String-->StringBuilder
		StringBuilder str1=new StringBuilder(str);
		System.out.println(str1.capacity());
		
	}

}

6.StringBuffer类的构造方法

StringBuffer() 构造一个初始容量为16个字符的空StringBuffer对象。 

StringBuffer(CharSequence seq) 通过其他的StringBuffer对象创建一个新的StringBuffer对象

StringBuffer(int capacity) 构造一个由 capacity参数指定的初始容量得空StringBuffer对象。

StringBuffer(String str) 构造一个初始化为指定字符串内容的StringBuffer对象。 

例如：

package com.object.test3;

public class TestStringBuffer {

	public static void main(String[] args) {
		// StringBuffer() 构造一个初始容量为16个字符的空StringBuffer对象。
		StringBuffer stbu1=new StringBuffer();
		//StringBuffer(CharSequence seq) 通过其他的StringBuffer对象创建一个新的StringBuffer对象
		StringBuffer stbu2=new StringBuffer("hello");
		//StringBuffer(int capacity) 构造一个由 capacity参数指定的初始容量得空StringBuffer对象。
		StringBuffer stbu3=new StringBuffer(18);
		//StringBuffer(String str) 构造一个初始化为指定字符串内容的StringBuffer对象。
		StringBuffer stub=new StringBuffer("hello,world");
		

	}

}

6.1 StringBuffer类的方法

1.StringBuffer    append(Object o) 将参数的字符串表示追加到序列中。 

2. int    capacity() 返回当前容量。 

3. char    charAt(int index) 返回 char在指定索引在这个字符值。

4. StringBuffer    delete(int start, int end) 删除此序列的子字符串中的字符。 

5. StringBuffer    deleteCharAt(int index) 删除 char在这个序列中的指定位置。 

6. int    indexOf(String str) 返回指定子字符串第一次出现的字符串内的索引。 

7. int    lastIndexOf(String str) 返回指定子字符串最右边出现的字符串内的索引。

8. StringBuffer    insert(int offset, Object o) 将参数的字符串表示插入到此序列中指定的位置。

9. int    length() 返回长度（字符数）。 

10. StringBuffer    reverse() 导致该字符序列被序列的相反代替。 

11. StringBuffer    replace(int start, int end, String str) 用指定的String中的字符替换此序列的子字符串中的 String 。

12. String    substring(int start) 返回一个新的 String ，其中包含此字符序列中当前包含的字符的子序列。 

13. String    substring(int start, int end) 返回一个新的 String ，其中包含此序列中当前包含的字符的子序列。 

14. String    toString() 返回表示此顺序中的数据的字符串。

例如：

package com.object.test3;

public class TestStringBuffer {

	public static void main(String[] args) {
		
		// StringBuffer() 构造一个初始容量为16个字符的空StringBuffer对象。
		StringBuffer stbu1=new StringBuffer();
		//StringBuffer(CharSequence seq) 通过其他的StringBuffer对象创建一个新的StringBuffer对象
		StringBuffer stbu2=new StringBuffer("hello");
		//StringBuffer(int capacity) 构造一个由 capacity参数指定的初始容量得空StringBuffer对象。
		StringBuffer stbu3=new StringBuffer(18);
		//StringBuffer(String str) 构造一个初始化为指定字符串内容的StringBuffer对象。
		StringBuffer stub=new StringBuffer("hello,world");
		
		//capacity() 返回当前容量, 初始容量为16个字符的空StringBuffer对象
		System.out.println(stbu1.capacity());
		System.out.println(stub.capacity());
		//append(Object o) 将参数的字符串表示追加到序列中
		System.out.println(stub.append(",你好"));
		//charAt(int index) 返回 char在指定索引在这个字符值。
		System.out.println(stub.charAt(3));
		//delete(int start, int end) 删除此序列的子字符串中的字符。 
		System.out.println(stub.delete(11, 14));
		//deleteCharAt(int index) 删除 char在这个序列中的指定位置。
		System.out.println(stub.deleteCharAt(3));
		//indexOf(String str) 返回指定子字符串第一次出现的字符串内的索引。
		System.out.println(stub.indexOf("o"));
		//int	lastIndexOf(String str) 返回指定子字符串最右边出现的字符串内的索引。
		System.out.println(stub.lastIndexOf("o"));
		//insert(int offset, Object o) 将参数的字符串表示插入到此序列中指定的位置。
		System.out.println(stub.insert(3, "l"));
		//length() 返回长度（字符数）
		System.out.println(stub.length());
		//reverse() 导致该字符序列被序列的相反代替。
		System.out.println(stub.reverse());
		//StringBuffer	replace(int start, int end, String str) 用指定的String中的字符替换此序列的子字符串中的 String 。
		//String	substring(int start) 返回一个新的 String ，其中包含此字符序列中当前包含的字符的子序列。 
		//String	substring(int start, int end) 返回一个新的 String ，其中包含此序列中当前包含的字符的子序列。 
		//String	toString() 返回表示此顺序中的数据的字符串。
	}

}

6.2 StringBuffer与String的转换 

1.StringBuffer--》String  

    1.StringBuffer的toString();

    2.String的构造方法String(StringBuffer buffer)

2.String-->StringBuffer

    StringBuffer的构造方法

例如;

package com.object.test2;

public class Main {

	public static void main(String[] args) {
		
		//StringBuffer--》String  
		StringBuffer stbf=new StringBuffer("你好，张三");
		//StringBuffer的toString();
		String stri=stbf.toString();
		//String的构造方法String(StringBuffer buffer)
		String strii=new String(stbf);
		//String-->StringBuffer
		StringBuffer sti2=new StringBuffer(stri);
		System.out.println(sti2.capacity());
	}

}

6.3 StringBuilder与StringBuffer的区别?

StringBuilderStringBuffer
一个可变的字符序列号，不保证线程同步【线程安全】

一个可变的字符序列号，保证线程安全

访问速度快访问速度慢
 JDK1.5 JDK1.0 

7. String与StringBuilder/StringBuffer的区别?

 StringStringBuilderStringBuffer
可变与否不可变可变可变
线程安全与否非线程安全非线程安全线程安全
运行速度慢快较快
操作的情况 少量字符串操作[拼接]的情况单线程下字符串大量操作的情况多线程下字符串操作

8.”==” 与 equals方法的区别？ 

==equals
比较运算符  java.lang.Object中的方法
基本类型：比较数据值不能被比较
复合类型：堆内存地址【引用地址】

复合类型：

1.堆内存地址【引用地址】

2.如果被重写则比较的是  存储对象的内容

airar
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中String类（字符串操作）的10个常见问题和解决方法
09-04
主要介绍了Java中String类（字符串）操作的10个常见问题,需要的朋友可以参考下
for(String name : names)
AAAhxz的博客
10-12 1654
这是java5.0之后出现的foreach循环，foreach语法在其他语言中早就存在。 for(ElementType元素类型 element元素 : arrayName集合（比如list、数组等）) { }; 例如： int[] numArray = { 1, 2, 3, 4, 5, 6 }; for (int i : numArray) { System.out.print(i); } 等...
java知识3-----核心2-面向对象高级 续3
jakezhang1990的专栏
08-24 141
Object类、包装类、匿名内部类
【Java】三个特殊类——Object类、包装类、String类
m0_50987960的博客
11-03 676
Object类、包装类、String类的内容以及其特有的方法等。
嘉明的java学习笔记（11）之API、Object类、String类、StringBuilder与StringBuffer类、Date和Calendar类、基本类型的包类
Zcymatics的博客
11-25 264
API 什么是API？ java中组件的层次结构 如何访问API ==>（点这里）API文档入口https://docs.oracle.com/en/java/javase/11/docs/api/index.html 打开后可以看到里面的名字不是以java开头就是jdk开头的。 然后我们随便打开一个文件，可以看到上面显示的是package 再打开一层 可以看到interface和class 这说明了java的组件层次结构是由 module 到 package 再到 package/inte
Object类-----java
wxx200008的博客
04-05 654
Object类看这个就够了！！！
JAVA字符串操作类CTool.java字符转换类.rar
07-10
JAVA字符串操作类CTool.java字符转换类，此类中收集Java编程中WEB开发常用到的一些工具。为避免生成此类的实例，构造方法被申明为private类型的。封装的功能：字符串从GBK编码转换为Unicode编码、对字符串进行md5...
Java学习笔记（六）–字符串String类
12-21
文章目录字符串一、String 类1.1 声明字符串1.2 创建字符串二、连接字符串2.1 连接多个字符串2.2 连接其他数据类型三、获取字符串信息3.1 获取字符串长度3.2 字符串查找3.3 获取指定索引位置的字符四、字符串操作4.1...
Java CTool.java一个好用的字符串操作类.rar
07-10
分享一个Java字符串操作类CTool.java源代码下载，包括了字符串转换功能，此类中收集Java编程中WEB开发常用到的一些工具。为避免生成此类的实例，构造方法被申明为private类型的。这个类的功能可实现将数据从数据库中...
关于String类和Object类
qq_53014458的博客
01-02 580
标题String类 它是引用数据类型，也是我们经常会用到的。它的直接赋值就可以创建它的对象，对象就能使用它的属性和方法。 ** 比较的是地址值，equals比较的是字面值。 String是引用类型在创建String时两种方法一种是直接赋值这个时候会把值存到常量池中不会重新分配地址。第二种用new的方式每次new都会分配一个新的地址,所以用比较就是false而String底层重写了equals和hashCode方法只需要比较具体值是否相同,所以结果是true** **下面是常用的一些方法: 1.判断当前字符串
Java学习笔记(四)String、StringBuilder、StringBuffer
AndroidXiXi的博客
05-25 215
String public final class String implements java.io.Serializable, Comparable<String>, CharSequence String类属于Object的子类 String实现的接口有：Serializable（序列化）, Comparable（可排序）, CharSequence（对字符序列提供...
SpringBoot自动配置原理
weixin_47093374的博客
04-13 406
SpringBoot自动配置原理SpringBoot自动配置原理1.SpringBoot特点1.1依赖管理1.2自动配置 SpringBoot自动配置原理 1.SpringBoot特点 1.1依赖管理 父项目做依赖管理（帮我们做好了版本控制） 依赖管理 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent<
2020-12-19——Java中的字符串操作类
weixin_53371536的博客
12-19 253
Java中的字符串操作类【String】 7.1.String类如何创建对象,有哪些常用方法？ String类---表示一个字符串类【处理字符串数据的操作方法】 String类是使用final修饰符修饰的，说明它没有子类，不可被继承。 public final class String Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。 字符串不变; 它们的值在创建后不能被更改。 String类的构造方法： String() 初始化新创建的 String对象，使其表示空
String对象创建的方式
m0_60431736的博客
09-17 2022
字符串对象创建
详述如何创建String对象
weixin_43964847的博客
08-04 469
详述如何创建String对象 在研究String是如何创建对象之前，我们先来看一下基本数据类型和引用类型是如何赋值的。 关系运算符 “==”，判断值是否相等。基本数据类型：由于变量与值同在栈中，所以比较的是值是否相等。引用数据类型：因为变量存的是对象的地址，所以比较的是地址是否相等。 public class Test { public static void main(String[] arg...
21. 不可变集合、Stream、异常
蓝胖子 (*^_^*)的博客
02-27 318
创建不可变集合 public class Test { public static void main(String[] args) { // 不可变的List集合 List<Double> lists = List.of(569.5 ,700.5 ,523.0 ,570.4); // lists.add(689.5); // 异常 // lists.set(2, 100.2); // 异常 ...
04SpringBoot 启动类配置及自动配置原理
qq_41946216的博客
05-14 7489
上一章中我们提到，springboot通过父项目依赖和starter的场景启动器来管理和启动相关组件，以 spring-boot-starter-web 场景管理器为例，它能够为提供 Web 开发场景所需要的几乎所有依赖，因此在使用 Spring Boot 开发 Web 项目时，只需要引入该 Starter 即可，而不需要额外导入 Web 服务器和其他的 Web 依赖。 但我们在启动springboot项目时候，springboot是如何按需加载所需要的自动配置配置项？引入哪些场景，这些场景的自动配置才会
Object类和String类
qq_52463861的博客
08-21 1732
Object类与String类
字符串操作的三个类
weixin_44094842的博客
06-07 283
字符串操作的三个类 字符串操作有String 、 StringBuilder、StringBuffer三个类 String String 所维护的数组是一个final修饰的数组，是不可变的，所以String字符串的每次修改操作都会新建一个字符串对象，非常的耗资源。 StringBuilder StringBuilder 是一个继承了一个 AbstractStringBuilder 类 这个类中维护的是一个普通的char数组，他的操作是通过appand()方法进行操作的 只有在最后toString的时候
练习-java字符串之string类并置运算之字符串拼接
最新发布
06-28
回答2：</h3><br/>Java字符串是指由零个或多个Unicode字符组成的有限序列。在Java编程中，字符串是非常常见的一种数据类型。Java中有许多种创建字符串对象的方法，其中最常见的一种是使用String类。 在Java中，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值