Object类、String类、StringBuffer类、StringBuilder类

——我是LGM_Hakka，请多多指教。

Object类、String类、StringBuffer类、StringBuilder类

Object类

1、概述

Object类是类层次结构的根类。

每个类都直接或间接继承Object类。

所有对象，包括数组都实现这个类的方法。 当一个类没有父类时，将被默认继承Object类。

Object类通常需要重写的方法：

A:toString()

public StringtoString():返回对象的字符串表示形式。

组成：包名...类名@内存地址值的十六进制

B:equals()

public booleanequals(Object obj);

默认比较的是对象的地址值是否相同。

一般会重写该方法。按照自己的需求进行比较。

在比较两个对象时为什么要重写 equals方法

因为该方法底层默认比较的还是地址值,而同一个类中的不同对象,地址值肯定不同。所以Object类中的equals 方法没有意义,所以我们需要重写它,比较的是对象当中的属性。

2、==和equals()的区别（面试题）

==:

         比较基本类型：比较的是基本类型的值是否相同。

         比较引用类型：比较的是引用类型的地址值是否相同。

equals():

         比较引用类型，默认比较的是引用类型的地址值是否相同。

         如果类重写了该方法，那就得按照重写后的规则进行比较。

String类

1、概述

字符串都是对象；

一旦初始化就不可以被更改，因为是常量（注意理解什么不能更改）；

【不可更的是常量池中的值，并不是变量的引用。】

2、常见的构造方法

public String():空构造
public String(byte[] bytes):把字节数组转成字符串
public String(char[] value):把字符数组转成字符串
public String(String original):把字符串常量值转成字符串

3、构造方法实例

public class StringDemo {
	public static void main(String[] args) {
		// public String():空构造
		String s1 = new String();
		System.out.println("s1:" + s1);
		System.out.println("s1.length():" + s1.length());
		System.out.println("--------------------------");
		
		// public String(byte[] bytes):把字节数组转成字符串
		byte[] bys = { 1, 2, 3, 4, 5 };
		String s2 = new String(bys);
		System.out.println("s2:" + s2);
		System.out.println("--------------------------");
		
		// public String(char[] value):把字符数组转成字符串
		char[] chs = { 'a', 'b', 'c', 'd', 'e', '我', '你', '他' };
		String s3 = new String(chs);
		System.out.println("s3:" + s3);
		System.out.println("--------------------------");
		
		// public String(String original):把字符串常量值转成字符串
		String s4 = new String("abcde");
		System.out.println("s4:" + s4);
		System.out.println("--------------------------");
	}
}

4、空与null的区别

空是指没有数据，而null是指针没有指向。

比如：字符串就是羊肉串，空就是签子，null的话就是把签子扔掉。

String s1 = "";
String s2 = null;
System.out.println(s1.isEmpty()); //true
System.out.println(s2.isEmpty()); //NullPointerException空指针异常

5、string1与string2有什么不同？

String string1 = "abcd";
String string2 = new String("abcd");

string1 创建后，在内存中只有一个对象；

string2 创建后，在内存中有两个对象。一个在常量池中，另一个在堆内存中。

System.out.println(string1==string2);    //false
System.out.println(string1.equals(string2));    //true

在String类中，“==”比较的是内存地址是否相同。

在String类中，“equals”比较的是内容是否一致。

因为String类中复写了Object类中的equals方法，建立了新得字符串判断依据，通过字符串中的内容来判断是否相同。

6、String方法中的一些方法

判断方法：

boolean equals(Object obj):比较内容是否相同,区分大小写
boolean equalsIgnoreCase(String str):比较内容是否相同,忽略大小写
boolean contains(String str):判断大字符串中是否包含小字符串
boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
boolean isEmpty():判断字符串是否为空。

获取方法：

int length():获取字符串的长度。
char charAt(int index):获取指定索引位置的字符
int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
String substring(int start):从指定位置开始截取字符串,默认到末尾。
String substring(int start,int end):从指定位置开始到指定位置结束截取字符串

转换方法：

char[] toCharArray():把字符串转换为字符数组。
static String valueOf(char[] chs):把字符数组转成字符串。
static String valueOf(int i):把int类型的数据转成字符串。
     注意：String类的valueOf方法可以把任意类型的数据转成字符串。
String concat(String str):把字符串拼接。

String类是最常用的类之一，其中的方法有很多，在学习过程中不需要死记硬背，只需要多加练习即可。忘记了就查API。

7、实例

/*
 	设计一个方法,用于获取一个字符串中指定子串出现的次数。
 	
	比如说"hanbasdnbafllgnbahjnbakqqqqlnbaxi" 在这个字符串中，多有个nba？
 */
public class FindString {
	public static void main(String[] args) {
		// 定义一个字符串
		String str = "hanbasdnbafllgnbahjnbakqqqqlnbaxi";
		//定义规则
		String reg = "nba";
		//调用方法，获取出现的次数
		int count = getFindString(str, reg);
		//打印
		System.out.println(reg + "出现的次数：" + count);
	}

	/**
	 * 这个是指定字符串中，规则出现的次数
	 * @param str	指定字符串
	 * @param reg	规则
	 * @return	返回规则出现的次数
	 */
	private static int getFindString(String str, String reg) {
		//用于统计规则出现的次数
		int count = 0;
		//用于记录出现的索引
		int index = str.indexOf(reg);
		//若查找返回的是-1，说明没有了
		while (index != -1) {
			//若查找到，次数+1
			count++;
			//查找到后，进行字符串截取
			str = str.substring(index+reg.length());
			//截取后，重新查找
			index = str.indexOf(reg);
		}
		//返回规则出现的次数
		return count;
	}
}

StringBuffer类与StringBuilder类

1、StringBuffer类概述

是一个字符串缓冲区，实质是一个容器。

长度是可变的，任意类型都行。

注意：其是将任意数据都转成字符串类型进行存储。

容器对象提供很多容器中数据的操作功能，比如：增、删、改、查。

若要对字符串缓冲区进行操作，必须将所有数据转换为字符串类型。

与数组最大的不同之处：数组存储完后，可以单独操作每一个元素，每一个元素都是独立的。字符串缓冲区，所有存储的元素都被转成字符串，而且最后拼成一个大的字符串。

2、StringBuilder类概述

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

3、String与StringBuffer区别

String一旦被赋值，值不能发生改变。而StringBuffer，值还可以改变。

原因：StringBuffer采用的是缓冲区机制。一开始，首先开辟一些空间，然后，随着数据的增加，然后，还可以继续开辟空间。这些操作针对的是同一个对象。

4、StringBuilder与StringBuffer异同点

不同点：

StringBuilder类：非同步的，单线程访问效率高。

StringBuffer类：同步的，多线程访问安全性高，效率低。

相同点：

两者都是字符串缓冲器（容器）。

5、实例

public class StringBufferDemo01 {
	public static void main(String[] args) {
		// 创建一个StringBuffer对象
		StringBuffer sb = new StringBuffer("zhangsan");
		// 打印原字符串
		System.out.println("原字符串：" + sb);
		// 将指定索引处的字符，替换为指定字符串
		System.out.println("替换后：" + sb.replace(0, 3, "XXX"));
		// 截取指定索引处开始到结尾的字符串
		System.out.println("第一次，截取后：" + sb.substring(2));
		// 验证截取方法返回的是一个新的字符串，不会影响原字符串
		System.out.println("第二次，截取后：" + sb.substring(0, 3));
		// 翻转字符串
		sb.reverse();
		System.out.println("反转：" + sb);
	}
}

（注：StringBuffer与StringBuilder类中的方法，有些是返回一个新的字符串，而有些是直接操作原字符串，需要留意。）

自动装箱与自动拆箱

概述

基本数据类型对象包装类：Java将基本数据类型值封装成了对象。

好处：可以拥有提供更多的操作基本数据类型的功能。

特点：

A、用于在基本数据和字符串之间进行转换。

B、

byte	Byte
short	Short
int	Internet
long	Long
float	Float
double	Double
boolean	Boolean
char	Character