Object ，Sring ，StringBuffer ，StringBuilder_sring 和stringbuffer-优快云博客

本文链接：https://blog.youkuaiyun.com/swop_/article/details/89480528

本文深入解析Java中Object类的功能与方法，探讨String类的特性及其常见操作，同时对比StringBuffer与StringBuilder的使用场景与性能差异。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

Object

Object类的特点

1.Object类是所有类的根类,可以利用多态创建对象
2.当一个方法的形参是Object类的时候,我们可以传入任意引用类型
3.Object满足万事万物皆对象的设计原则
4.创建任何一个类的对象都会去访问 Object 类的无参构造方法 public Object()

Object类的常用方法

1.int hashCode()
2 Class<?> getClass()
3.boolean equals(Object obj)
4.String toString()
5.protected Object clone()
6.protected void finalize()

hashCode

1.由 Object 类定义的 hashCode 方法确实会针对不同的对象返回不同的整数。（这一般是通过将该对象的内部地址转换成一个整数来实现的）
2.hashCode方法会针对不同对象返回不同的整数，这个整数结果是内部地质转换而来的。
3.两个对象的hashCode相同,不能够保证两个对象是同一个对象

Class<?> getClass()

public String getName()以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型）名称。（返回的是类名的全路径）

String toString()

String toString()默认输出的是类名全路径+@+对象的hashCode的十六进制转换。

protected Object clone()

创建并返回此对象的一个副本，可以理解为克隆

protected void finalize()

当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。用于垃圾回收，但是什么时候回收不确定。

public class ObjectDemo07 {
	public static void main(String[] args) throws Throwable {
		Student s = new Student("隔壁老李", 30);
		s = null;
		// 显示回收
		// 启动垃圾回收期
		System.gc();
		// 提醒垃圾回收期去回收垃圾对象
		System.runFinalization();
		
	}
}

String

String的特点

1.String 类代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。
2.字符串是常量；它们的值在创建之后不能更改。
3.所有的常量在内存的方法区的常量池中
4.频繁的字符串拼接操作会导致常量池容器增加,浪费内存资源
5.字符串缓冲区【StringBuffer,StringBuilder】支持可变的字符串
6.Java在编译时期会针对字符串的拼接操作使用StringBuilder改进,提高效率,节约内存资源
7.因为 String 对象是不可变的，所以可以共享
8.字符串本质是字符数组

	public class StringDemo01 {
		public static void main(String[] args) {
		/* 在编译时期会针对字符串的拼接操作使用StringBuilder改进,提高效率,节约内存资源
		 *	s = (new StringBuilder(String.valueOf(s))).append("efg").toString();
		 *	System.out.println((new StringBuilder("s:")).append(s).toString());
		 */
			String s = "abc";
			s += "efg";
			System.out.println("s:" + s);
			
			String s2 = "abc";
		}
	}

String类的构造方法

    public String()
	public String(String original)
	public String(char[] value)
	public String(char[] value, int offset, int count)
	public String(byte[] bytes)
	public String(byte[] bytes, int offset, int length)

String s = "abc"和String s = new String(“abc”);的区别
前者在方法区开辟空间
后者即在方法区,也在堆区开辟空间
一般使用前者创建字符串对象

String类的一些常用方法

	char charAt(int index) //返回对应索引的字符
	int indexOf(int ch) //返回对应的字符在该字符串中的索引
	int indexOf(String str) //
	int indexOf(int ch,int fromIndex) 
		从fromIndex出开始从左往右找,第一次出现字符ch所对应的索引
	int indexOf(String str,int fromIndex)
	int lastIndexOf(int ch)  //返回对应字符在字符串中最后的位置索引  
	int lastIndexOf(int ch,int fromIndex)  
	int lastIndexOf(String str,int fromIndex) 
	String substring(int start)
	String substring(int start,int end)
	int length()  //返回字符串的长度

	public class StringDemo03 {
		public static void main(String[] args) {
			// 利用多态来创建字符串
			CharSequence sequence = "abc";
			
			String s = "HelloWorldHello";
	//		System.out.println("charAt: " + s.charAt(0));
	//		System.out.println("charAt: " + s.charAt(1));
			
			// 遍历字符串每一个字符
			for (int i = 0; i < s.length(); i++) {
				System.out.println("charAt: " + s.charAt(i));
			}
			
	//		int indexOf(int ch)
	//		int ch = 'e';
			System.out.println("indexOf(int ch): " + s.indexOf('l'));
			System.out.println("int indexOf(String str): " + s.indexOf("World"));
			System.out.println("int indexOf(int ch,int fromIndex):" + s.indexOf('o', 5));
			System.out.println("int indexOf(String str,int fromIndex):" + s.indexOf("Hello", 5));
	//		int lastIndexOf(int ch)   
			System.out.println("int lastIndexOf(int ch): " + s.lastIndexOf('l'));
	//		int lastIndexOf(int ch,int fromIndex) 
			System.out.println("int lastIndexOf(int ch,int fromIndex): " + s.lastIndexOf('l', 10));
	//		String substring(int start)
			String str = s.substring(10);
			System.out.println(str);
			String str2 = s.substring(5, 10); // 左闭右开原则
			System.out.println(str2);
			CharSequence subSequence = s.subSequence(5, 10);
			System.out.println(subSequence);
		}
	}


	boolean isEmpty()：判断字符串是否为空。
	boolean equals(Object obj)：将此字符串的内容与指定的对象比较,区分大小写。
	boolean equalsIgnoreCase(String str)：将此 String 与另一个 String 比较,忽略大小写。
	boolean contains(String str)：判断字符串中是否包含方法传入的字符串。
	boolean startsWith(String str)：判断字符串是否以某个指定的字符串开头。
	boolean endsWith(String str)：判断字符串是否以某个指定的字符串结尾。


	public class StringDemo04 {
		public static void main(String[] args) {
			char[] chs = {'a', 'b', 'c'};
			String result = "";
	    	for(int i = 0; i < chs.length; i++){
	    		result += chs[i];
	    	}
			String s = "HelloWorld"; //"" +  H + "" + e + "" + l + "" + l + ..
	//		String s = new String("");
	//		String s2 = null;
	//		String s3 = "";
	//		
	//		System.out.println(s.isEmpty()); // true
	////		System.out.println(s2.isEmpty()); // 报错
	//		System.out.println(s3.isEmpty()); // true
			
			System.out.println(s.equals("HelloWorld"));
			System.out.println(s.equalsIgnoreCase("helloWorld"));
			System.out.println(s.contains(""));
			String s2 = "http://www.baidu.com";
			String s3 = "HelloWorld.java";
			System.out.println(s2.startsWith("http"));
			System.out.println(s2.startsWith(""));
			System.out.println(s3.endsWith(".java"));
			System.out.println(s3.endsWith(""));
		}
	}


	/*  byte[] getBytes() ：将字符串转化为字节数组。
		char[] toCharArray()： 将字符串转化为字符数组。
		static String valueOf(char[] chs)： 返回 char 数组参数的字符串表示形式。
		static String valueOf(int i) ：返回 int 参数的字符串表示形式。
		String toLowerCase() ：将此 String 中的所有字符都转换为小写。
		String toUpperCase() ：将此 String 中的所有字符都转换为大写。
		String concat(String str)： 将指定字符串连接到此字符串的结尾。
	 */
	public class StringDemo05 {
		public static void main(String[] args) {
			String s = "HelloWorld";
			byte[] bys = s.getBytes();
			System.out.println(Arrays.toString(bys));
			for (byte b : bys) {
				System.out.println((char)b);
			}
			System.out.println("------------------");
			char[] chs = s.toCharArray();
			for (char c : chs) {
				System.out.println(c);
			}
			System.out.println("-------------------");
			String ss1 = String.valueOf(false);
			System.out.println(ss1);
			String ss2 = String.valueOf(2.5);
			String ss3 = String.valueOf(10);
			System.out.println(ss2 + ss3);
			String ss4 = String.valueOf(new Student());
			System.out.println(ss4);
			System.out.println("-------------------");
			String upperCase = "select * from t_student".toUpperCase();
			System.out.println(upperCase);
			String lowerCase = upperCase.toLowerCase();
			System.out.println(lowerCase);
			System.out.println("-------------------");
			System.out.println("Hello".concat("World"));
		}
	}

String replace(char old,char new) ：替换功能。
	String replace(String old,String new) ：替换功能。
	String trim()：去除字符串两空格。
	int compareTo(String str) ：按字典顺序比较两个字符串。
	int compareToIgnoreCase(String str)：按字典顺序比较两个字符串，忽略大小写。
	public String[] split(String regex)：分隔字符串成字符数组。

public class StringDemo06 {
	public static void main(String[] args) {
		String s = "Hello你好World我好Java他也好";
		System.out.println(s.replace('l', 'X'));
		System.out.println(s.replace("Java", "Android"));
		System.out.println(s.replaceAll("[\\u4e00-\\u9fa5]+", "*"));
		
		String s2 = "  Hello  World   ";
		System.out.println(s2.trim() + "===========");
		String s3 = "abcd";
		String s4 = "abcd";
		System.out.println(s3.compareTo(s4)); 
		// 中文比较
		Collator collator = Collator.getInstance(Locale.CHINA);
		int compare = collator.compare("蠢", "贼");
		System.out.println(compare);
		// 这个是后面使用比较器 Comparator的核心方法
		
		// public String[] split(String regex)：分隔字符串成字符数组。
		String s5 = "Hello_World_Java";
		String s6 = "Hello32341World32534Java";
		String[] strs = s5.split("_");
		System.out.println(Arrays.toString(strs));
		System.out.println(Arrays.toString(s6.split("\\d")));
		
		// 合并
		CharSequence[] chs = {"Hello", "World", "Java"};
		String join = String.join("+", chs);
		System.out.println(join);
		
	}
}

StringBuffer

StringBuffer类概述

线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。

StringBuffer构造方法

StringBuffer() ：构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。
StringBuffer(CharSequence seq)：构造一个字符串缓冲区，它包含与指定CharSequence 相同的字符。
StringBuffer(int capacity) ：构造一个不带字符，但具有指定初始容量的字符串缓冲区。
StringBuffer(String str)：构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。

增：

	StringBuffer append(String str) 
	StringBuffer insert(int offset, String str)

删：

StringBuffer deleteCharAt(int index) 
StringBuffer delete(int start, int end)

改：

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

其他：

	public StringBuffer reverse() //倒置
	public String substring(int start)//
	public String substring(int start,int end)//

	public class StringBufferDemo02 {
		public static void main(String[] args) {
			StringBuffer sb = new StringBuffer();
			sb.append("Hello");
			System.out.println("sb: " + sb); // ""
			
			sb.append("World").append(20).append('c').append(new Object());
			System.out.println(sb);
			
	//		sb.insert(5, "Java");
			sb.insert(sb.indexOf("W"), "Java");
			System.out.println(sb);
			
			sb.deleteCharAt(sb.indexOf("2"));
			System.out.println(sb);
			
			sb.delete(sb.indexOf("j"), sb.length());
			System.out.println(sb);
			
			sb.delete(sb.indexOf("J"), sb.indexOf("W"));
			System.out.println(sb);
			
			sb.replace(sb.indexOf("W"), sb.indexOf("0"), "Good");
			System.out.println(sb);
			
	//		sb.reverse();
	//		System.out.println(sb);
			
	//		public String substring(int start)
			String substring = sb.substring(sb.indexOf("0"));
			System.out.println(sb);
			System.out.println(substring);
			
			System.out.println(sb.substring(sb.indexOf("G"), sb.indexOf("0")));
			
		}
	}

StringBuilder

一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。用法完全和StringBuffer一样。

String StringBuffer StringBuilder 三者的区别

StringBuffer StringBuilder二者是完全兼容的,二者都是字符串缓冲区,支持可变的字符串操作
StringBuffer 线程安全,同步,效率低
StringBuilder线程不安全,不同步,效率高
String 长度不可变,线程不安全,效率高
String频繁的字符串拼接操作会导致常量池容器增加,浪费内存资源
字符串缓冲区【StringBuffer,StringBuilder】支持可变的字符串