Java基础——StringBuffer、Integer和自动拆装箱

StringBuffer类

StringBuffer、StringBuilder、String 三者的区别：

• StringBuffer是字符串缓冲区类，是jdk1.0出现的，是线程安全的可变的字符序列 ，效率低；
• StringBuilder是jdk1.5出现的，和StringBuffer里面的所有方法一模一样，也是字符串缓冲区类，线程不安全的可变字符序列，效率高；
• String的值是不可变的字符序列， 而StringBUffer和StringBuilder 是可变的字符序列。

StringBuffer的构造方法

StringBuffer sb = new StringBuffer();//无参构造方法，默认容量是16
StringBuffer sb2 = new StringBuffer(int capacity); //指定容量的字符串缓冲区对象
StringBuffer sb3 = new StringBuffer(String str); //指定字符串内容的字符串缓冲区对象，可以把String类型的转换为StringBuffer类型的

int length(); //里面字符的个数，内容的长度
int capacity();//容量的大小

代码演示：

  public static void main(String[] args) {
  	StringBuffer sb = new StringBuffer();
  	System.out.println(sb.length());			//0 容器中的字符个数,实际值
  	System.out.println(sb.capacity());			//16 容器的初始容量,理论值
  	
  	StringBuffer sb2 = new StringBuffer(10);
  	System.out.println(sb2.length());			//0
  	System.out.println(sb2.capacity());			//10
  	
  	StringBuffer sb3 = new StringBuffer("heima");
  	System.out.println(sb3.length());			//5  实际字符的个数
  	System.out.println(sb3.capacity());	0		//21 字符串的length + 初始容量
  	
  }

StringBuffer的添加功能

public StringBuffer append(String str);//可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
public StringBuffer insert(int offset,String str);//在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

代码演示：

public static void main(String[] args) {
  demo1();
  StringBuffer sb = new StringBuffer("1234");
  sb.insert(3, "heima");//在指定位置添加元素,如果没有指定位置的索引就会报索引越界异常
  System.out.println(sb);//123heima4
}
private static void demo1() {
    StringBuffer sb = new StringBuffer();
    StringBuffer sb2 = sb.append(true);
    StringBuffer sb3 = sb.append("heima");
    StringBuffer sb4 = sb.append(100);
    System.out.println(sb.toString());
    //trueheima100  StringBuffer类中重写了toString方法,显示的是对象中的属性值
    System.out.println(sb2.toString());	//trueheima100
    System.out.println(sb3.toString());	//trueheima100
    System.out.println(sb4.toString());	//trueheima100
}

注：基本类型作为参数传递 其值不变，引用类型作为参数传递 其值改变。

​StringBuffer的删除功能

public StringBuffer deleteCharAt(int index);//删除指定位置的字符，并返回本身
public StringBuffer delete(int start,int end);//删除从指定位置开始指定位置结束的内容，并返回本身
sb.delete(0,sb.length()); //清空缓冲区

代码演示：

public static void main(String[] args) {
		StringBuffer sb = new StringBuffer();
		sb.deleteCharAt(5);//报错：字符串索引越界异常 当缓冲区中这个索引上没有元素的时候就会报StringIndexOutOfBoundsException
			
​		StringBuffer sb1 = new StringBuffer();
​		sb1.append("heima");
​		sb1.deleteCharAt(4);			//根据索引删除掉索引位置上对应的字符
​		System.out.println(sb);			// heim
​		
​		StringBuffer sb2 = new StringBuffer();
​		sb2.append("heima");
​		sb2.delete(0, 2);			//删除的时候是包含头,不包含尾
​		System.out.println(sb2);		//ima
​		
​		StringBuffer sb3 = new StringBuffer();
​		sb3.append("heima");
​		sb3.delete(0, sb.length());		//清空缓冲区

​		System.out.println(sb3);		//什么都没有打印出来
​		
​		sb3 = new StringBuffer();		//不要用这种方式清空缓冲区,原来的会变成垃圾,浪费内存
​		System.out.println(sb3);
}

StringBuffer的替换功能

public StringBuffer replace(int start,int end,String str);//从start开始到end用str替换并返回自身。

代码演示：

public static void main(String[] args) {
		StringBuffer sb = new StringBuffer("heima");
		sb.replace(0, 3, "bai");		//替换
		System.out.println(sb);			//baima
		
		sb.reverse();
		System.out.println(sb);
	}

StringBuffer的反转功能

StringBuffer reverse();反转，返回自身
public static void main(String[] args) {
	StringBuffer sb = new StringBuffer("我爱总复习");	
	sb.reverse();
	System.out.println(sb);		//习复总爱我
}

StringBuffer的截取功能

String substring(int start); 从指定位置截取到末尾，返回值类型不再是StringBuffer本身 ，返回的是字符串， 自身不发生改变
String substring(int start, int end); 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置 返回值类型不再是StringBuffer本身 ，返回的是字符串， 自身不发生改变

代码演示：

	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer("woaiheima");
		String str = sb.substring(4);	//返回值类型不再是StringBuffer本身,返回的是字符串
		System.out.println(str);	//heima		
		
		System.out.println(sb);		//woaiheima   自身不发生改变
		
		String str3 = sb.substring(4, 7);
		System.out.println(str3);	//hei
	}

String和StringBuffer的转换

String–>StringBuffer
StringBuffer sb = new StringBuffer(String str);
StringBuffer–>String
String s = new String(StringBuffer sb);
​String s1 = sb.toString();

代码演示：

public static void main(String[] args) {
		//demo1();
		StringBuffer sb = new StringBuffer("heima");
			
		String s1 = new String(sb);//通过构造将StringBuffer转换为String
		System.out.println(s1);
			

		String s2 = sb.toString();	//通过toString方法将StringBuffer转换为String
		System.out.println(s2);
		
		String s3 = sb.substring(0, sb.length());//通过截取子字符串将StringBuffer转换为String
		System.out.println(s3);
	}

	private static void demo1() {
        //通过构造方法将字符串转换为StringBuffer对象
		StringBuffer sb1 = new StringBuffer("heima");
		System.out.println(sb1);
		
		StringBuffer sb2 = new StringBuffer();
		sb2.append("heima");//通过append方法将字符串转换为StringBuffer对象
		System.out.println(sb2);
	}
​
			

Arrays数组工具类

static String toString(int[] arr); 数组转换为字符串
static void sort(int[] arr); 从小到大排序
static int binarySearch(int[] arr, int key);二分搜索法返回搜索元素的索引值

代码演示：

public static void main(String[] args) {
    int[] arr = {33,22,11,44,66,55};
    System.out.println(Arrays.toString(arr));//[33, 22, 11, 44, 66, 55] 数组转字符串

    Arrays.sort(arr);//[11, 22, 33, 44, 55, 66] 排序
    System.out.println(Arrays.toString(arr));

    int[] arr2 = {11,22,33,44,55,66};
    System.out.println(Arrays.binarySearch(arr2, 22));	//1
    System.out.println(Arrays.binarySearch(arr2, 66));	//5
    System.out.println(Arrays.binarySearch(arr2, 9));	//-插入点-1
}

Integer

为什么会有基本类型包装类？
将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。

基本类型和包装类的对应
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

Integer三个静态方法

public static String toBinaryString(int a);返回一个整数的二进制的字符串表现形式
public static String toOctalString(int a);返回一个整数的八进制的字符串表现形式
public static String toHexString(int a);返回一个整数的十六进制的字符串表现形式

Integer的两个常量

MAX_VALUE int范围的最大值
MIN_VALUE int范围的最小值

Integer的构造方法

public Integer(int value);
public Integer(String str); str必须是数字形式的字符串否则报异常

代码演示

public static void main(String[] args) {
	Integer i1 = new Integer(100);
	System.out.println(i1);
    
	Integer i2 = new Integer("abc");	//java.lang.NumberFormatException数字格式异常
	System.out.println(i2);		//因为abc不是数字字符串,所以转换会报错
		
	Integer i3 = new Integer("100");
	System.out.println(i3);
}

​String和int之间的转换

String --> int
​ Integer.parseInt(str);
​int --> String
​ Integer.toString(a);
​ String.valueOf(a);
​ a+"";
​
​代码演示：

public static void main(String[] args) {
    
    //demo1();
    String s1 = "true";
    boolean b = Boolean.parseBoolean(s1);
    System.out.println(b);

	//String s2 = "abc";
	//char c = Character.p			//char的包装类Character中没有pareseXxx的方法
							//字符串到字符的转换通过toCharArray()就可以把字符串转换为字符数组
}

private static void demo1() {
	//int ----> String int转换成String
	int i = 100;
	String s1 = i + "";			//推荐用
	String s2 = String.valueOf(i);		//推荐用
		
	Integer i2 = new Integer(i);
	String s3 = i2.toString();
		
    String s4 = Integer.toString(i);
    System.out.println(s1);

    //String----> int String 转换int
    String s = "200";
    Integer i3 = new Integer(s);
    int i4 = i3.intValue();	//将Integer转换成了int数

    int i5 = Integer.parseInt(s);//将String转换为int,推荐用这种
}

自动拆装箱

JDK5的新特性

自动装箱：把基本类型转换为包装类类型
自动拆箱：把包装类类型转换为基本类型
案例演示

public static void main(String[] args) {
    int x = 100;
    Integer i1 = new Integer(x);//将基本数据类型包装成对象,装箱

    int y = i1.intValue();	//将对象转换为基本数据类型,拆箱

    Integer i2 = 100;	//自动装箱,把基本数据类型转换成对象
    int z = i2 + 200;	//自动拆箱,把对象转换为基本数据类型
    System.out.println(z);

    Integer i3 = null;
    int a = i3 + 100;	//底层用i3调用intValue,但是i3是null,null调用方法就会出现
    System.out.println(a);	//空指针异常java.lang.NullPointerException
}

​ 注意事项
​ 在使用时，Integer x = null;代码就会出现NullPointerException。
​ 建议先判断是否为null，然后再使用。

好了这部分内容就先说到这了，想了解更多学习知识，请关注微信公众号“阿Q说”，获取更多学习资料吧！你也可以后台留言说出你的疑惑，阿Q将会在后期的文章中为你解答。每天学习一点点，每天进步一点点。
​