包装类和String类的详解

包装类和String类的详解

一. 包装类

含义：基本数据类型对应的类。

出现的原因：

​ java为纯面向对象的语言（万物皆为对象），而八种基本数据类型不能创建对象，破坏了java为纯面向对象语言的特征，所以java又给这八种数据类型分别分配了对应的类，这种叫做包装类/封装类。

继承关系：

​

基本数据类型	引用数据类型
byte	Byte extends Number extends Object
short	Short extends Number extends Object
int	Integer extends Number extends Object
long	Long extends Number extends Object
float	Float extends Number extends Object
double	Double extends Number extends Object
char	Character extends Object
boolean	Boolean extends Object

注意：

1. 数值都是继承Number
2. int的包装类是Integer
3. char的包装类Character

1.1装箱拆箱

装箱： 把一个基本数类型 变成引用 数据类型

拆箱： 把引用数据类型变成 基本数据类型

	
/**
*装箱：基本数据类型 ——>包装类
*/
	int i;
	Integer integer = Integer.valueOf(i);//装箱
	System.out.peintln(i);

/**
*拆箱：包装类 ——> 基本数据类型
*/
	Integer integer = new Integer(100);
	int i = integer.valueOf();//拆箱
	System.out.println(i);
	
//JDK1.5的新特性：自动装箱、自动拆箱
/**
*自动装箱：基本数据类型 -> 包装类
*/		       
	int i = 100;
	Integer integer = i;//自动装箱（底层实现：Integer.valueOf(i);）
	System.out.println(integer);
		
/**
*自动拆箱：包装类 -> 基本数据类型 
*/		  		
	Integer integer = new Integer(100);
	int i = integer;//自动拆箱（底层实现：integer.intValue();）
	System.out.println(i);

应用场景：集合(类似数组的容器)，但是集合只能存引用数据类型，如果想存储基本数据类型，就可以把基本数据类型转换为对应的包装类对象

需求：把字符串数组{"1","2","3","4","5"}转换为int数组

		String[] ss = {"1","2","3","4","5"};
		
		int[] is = new int[ss.length];
		
		for (int i = 0; i < is.length; i++) {
			//1.将String转换为Integer对象
			//2.Integer对象自动拆箱成int数据
			int num = Integer.valueOf(ss[i]);
			
			is[i] = num;
		}
		
		for (int element : is) {
			System.out.println(element);
		}

1.2深入包装类底层源码

面试题：

				Integer integer1 = Integer.valueOf(100);
				Integer integer2 = Integer.valueOf(100);
				System.out.println(integer1 == integer2);//true
				
				Integer integer3 = Integer.valueOf(200);
				Integer integer4 = Integer.valueOf(200);
				System.out.println(integer3 == integer4);//false

总结:

​ Integer底层有个缓存类，缓存类中有个数组，存储了-128~127的Integer对象
​ Integer.valueOf(num)底层会判断num是否在-128~127这个区间，如果在内就从缓存
​ 数组中获取数据，如果不在这个区间就new对象

二. String类

2.1 不可变字符

不可变字符串指的是，一个字符串对象内容一旦赋值，不可再变化。如果对其拼接，其实就会创建一个新的字符串，然后这个引用指向了这个新的字符串。

2.1.1 String类

String 类是一个常用基础类型，但是引用数据类型，被设计为一个不可变字符串，位于java.lang包下。

2.1.2 String 创建方式

1. String(String xx)
2. String xx = “字符串内容”;

2.1.2 String 常用API

		String str = "123abc";
		
		str = str.concat("DEF123");//在此字符串末尾追加字符串，并返回新的字符串
		str = str.substring(2);//从开始下标处截取到字符串末尾，并返回新的字符串
		str = str.substring(1, 7);//从开始下标处(包含)截取到结束下标处(不包含)，并返回新的字符串
		str = str.toUpperCase();//转大写，并返回新的字符串
		str = str.toLowerCase();//转小写，并返回新的字符串
-----------------------------------------------------------------------------------------
		str = "   123 a  bcD EF 123        ";
		
		str = str.trim();//去除首尾空格，并返回新的字符串
		str = str.replace('2', '-');//替换字符，并返回新的字符串
		str = str.replaceFirst("3", "小明");//替换第一个出现的字符串，并返回新的字符串
		str = str.replaceAll("1", "xxx");//替换字符串，并返回新的字符串
		str = str.replaceAll(" ", "");//替换字符串，并返回新的字符串

		System.out.println("判断两个字符串内容是否相同：(区分大小写)" + str.equals("xxx-小明abcDEFxxx-3"));
		System.out.println("判断两个字符串内容是否相同：(不区分大小写)" + str.equalsIgnoreCase("XXX-小明ABCdefxxx-3"));
		System.out.println("判断此字符串是否以某个字符串开头：" + str.startsWith("xxx"));
		System.out.println("判断此字符串是否以某个字符串结尾：" + str.endsWith("-3"));
		
		System.out.println("查询此字符串第一次在目标字符串中的下标：" + str.indexOf("-"));
		System.out.println("查询此字符串最后一次在目标字符串中的下标：" + str.lastIndexOf("-"));
		
		System.out.println("获取指定下标上的字符：" + str.charAt(4));

		//xxx-小明abcDEFxxx-3	
		System.out.println(str);

注意：String是一个不可变的类， 即一旦一个String对象被创建, 包含在这个对象中的字符序列是不可改变的, 直至该对象被销毁。

		//将其他类型转换为字符串
		
		int i = 100;
		System.out.println(String.valueOf(i));
		
		boolean bool = true;
		System.out.println(String.valueOf(bool));

面试题1：下列代码创建几个String对象(考点：常量池中的值必须是唯一的)
String str1 = “abc”;
String str2 = “abc”;
答案：一个

面试题2：下列代码创建几个String对象(考点：常量池中的值必须是唯一的)
String str1 = new String(“abc”);
String str2 = new String(“abc”);
答案：三个

		/**
		 * 深入String创建对象问题
		 */
		
		String str1 = "abc";
		String str2 = "abc";
		System.out.println(str1 == str2);//true
		
		//两个常量字符串直接在编译时拼接
		String str3 = "ab" + "c";
		System.out.println(str3 == str1);//true
		
		//两个常量字符串直接在编译时拼接
		final String s1 = "ab";
		final String s2 = "c";
		String str4 = s1+s2;
		System.out.println(str4 == str1);//true
		
		//两个变量字符串拼接底层是创建StringBuilder对象
		String s3 = "ab";
		String s4 = "c";
		String str5 = s3+s4;//new StringBuilder(s3).append(s4).toString()
		System.out.println(str5 == str1);//false

2.2 可变字符

指定的是可以在现有字符串对象基础上，继续修改，频繁拼接不会出现中间状态的垃圾字符串。

2.2.1 StringBuffer

StringBuffer代表可变的字符序列。
StringBuffer称为字符串缓冲区，
它的工作原理是：
预先申请一块内存，存放字符序列，
如果字符序列满了，会重新改变缓存区的大小，以容纳更多的字符序列。
StringBuffer是可变对象，这个是String最大的不同
继承关系：StringBuffer extends AbstractStringBuilder

StringBuffer 类提供了 3 个构造方法来创建一个字符串，如下所示：

	//默认字符串缓冲区：16个字符
	StringBuffer sb = new StringBuffer();
	
	//自定义字符串缓冲区：100个字符
	StringBuffer sb = new StringBuffer(100);

	//自定义字符串缓冲区："123abc".length() + 16 : 22个字符
	StringBuffer sb = new StringBuffer("123abc");

常用API

		StringBuffer sb = new StringBuffer("123abc");
		sb.append("DEF123");//在末尾追加字符串
		sb.insert(6, "xxx");//在指定下标处插入字符串
		sb.setCharAt(3, 'A');//替换指定下标上的字符
		sb.replace(6, 9, "用良心做教育");//从开始下标处(包含)替换到结束下标处(不包含)的字符串
		
		sb.deleteCharAt(1);//删除指定下标上的字符
		sb.delete(5, 11);//从开始下标处(包含)删除到结束下标处(不包含)的字符串
		sb.reverse();//反转字符串

2.2.2 StringBulider

使用上和StringBuffer一模一样，因为他们都继承AbstractStringBuilder

2.2.3 StringBuffer和StringBuilder的区别

1. StringBuffer是线程安全, 它的所有公开方法都是同步的. StringBulider没有对方法加锁同步的 ,线程不安全的
2. StringBuilder的效率高于StringBuffer

总结:

StringBuffer 适用于用在多线程操作同一个 StringBuffer 的场景，如果是单线程场合 StringBuilder 更适合。