java基础中的--------StringBuilder+基本类型的包装类

最新推荐文章于 2024-02-06 14:46:09 发布

一个正在努力的刘小白

最新推荐文章于 2024-02-06 14:46:09 发布

阅读量210

点赞数

分类专栏： java 00 文章标签： java 编程语言

本文链接：https://blog.csdn.net/liutaiwu/article/details/107470941

版权

java 00 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

写在前面：这些都是我学习的笔记如若有错误望请纠正，不胜感谢。

一、StringBuilder

1.概述

1.StringBuilder是一个可变的字符序列，因为内部维护的字符数组不是final修饰的，引用可以发生变化，同时在类中提供修改字符串的方法。

常用的方法是append和insert,就是在StringBuilder本身上，进行修改操作。

2.StringBuilder底层和String类型一样，也是维护了一个字符数组，String类型没有对外提供公共的修改方法，所以不可以发生改变;StringBuilder封装了修改数组的公有方法。

3.String和StringBuilder的关系，都是用于描述字符串。

String是不可以改变的字符序列，没有向外提供公共的修改方法;StringBuilder是可变的字符序列，因为提供了修改字符串的共有方法。

String的长度是不可发生改变的，StringBuilder的长度可变化，可以认为就像一个可以进行伸缩的容器，存储字符串。

2.构造方法

1.StringBuilder():创建一个生成器(容器)，初始空量为16

2.StringBuilder(int capacity):创建一个生成器，初始容量为capacity大小

3.StringBuilder(String str):创建一个生成器，初始化值就是str字符串，初始大小为str.length()+16

4.获取容积的方法

capacity():获取当前生成器的容器大小

length():获取当前容器中的字符个数

public class Demo01 {

	public static void main(String[] args) {
		//容器 存储16个字符
		StringBuilder sb = new StringBuilder();
		
		sb.append("abcddsfdsfdsfdsfdsfdsfdsfdsfdsfdsfdsfdsfdsfdsfdsfdsfdsfdsfdsf");
		//sb.append("abcde");
		
		System.out.println(sb.capacity());
		System.out.println(sb.length());
		
		System.out.println("------------------------------------");
		StringBuilder sb1 = new StringBuilder(5);
		System.out.println(sb1.capacity());
		System.out.println("------------------------------------");
		StringBuilder sb2 = new StringBuilder("abcde");
		System.out.println(sb2);
		System.out.println(sb2.capacity());
		
		

	}

}

3.添加方法

1.append(任意类型)：可以将任意数据类型，转成字符，添加到容器中。

2.insert(int index,任意类型)：可以将任意类型数据添加到指定的位置。

index的范围是0~当前缓冲区的大小。

插入数据之后，数据本身的索引就是参数中指定的index.

public class Demo02 {

	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder();
		sb.append(false).append("abcd").append(3.14);//延迟方法
		sb.insert(2, "xyz");
		System.out.println(sb);
		/*System.out.println(sb.capacity());
		sb.insert(1,"xxx");*/
		System.out.println(sb);

	}

}

4.删除方法

1.deleteCharAt(int index):删除指定索引的字符

2.delete(int start,int end):删除指定范围的字符，被删除的部分包含头不包含尾

public class Demo03 {

	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder();
		sb.append(false).append("abcd").append(3.14);
		System.out.println(sb);
		//删除
		sb.deleteCharAt(3);
		System.out.println(sb);
		//删除头不删除尾
		sb.delete(2, 5);
		System.out.println(sb);
		
	}

}

5.替换和反转功能

1.replace(int start,int end,String str):将字符串缓冲区中的从start开始到end-1这部分的内容，替换成str.

2.reverse():将原有的字符序列进行反转

public class Demo04 {

	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder();
		sb.append("abcdefg");
		/*System.out.println(sb);
		sb.replace(1, 3, "xxxxxx");
		System.out.println(sb);*/
		//反转
		sb.reverse();
		System.out.println(sb);
		

	}

}

6.练习题

1.定义一个方法，接收一个String类型的字符串，返回该字符串的反转形式。 “abc”–>”cba”

public class Demo05 {

	public static void main(String[] args) {
		String str = "xyzdsfsdfsd";
		System.out.println(myReverse(str));

	}
	
	public static String myReverse(String str) {
		StringBuilder sb = new StringBuilder(str);
		sb.reverse();
		return sb.toString();
		
	}

}

2.定义一个方法，接收一个int类型的数据，返回该数组的字符串表示形式

 int[] arr = {1,2,3};--->[1,2,3]
public class Demo06 {

	public static void main(String[] args) {
		int[] arr = {3,7,2,1,9,10};
		//String result = arr2str1(arr);
		String result = arr2str2(arr);
		System.out.println(result);
		

	}

	
	private static String arr2str2(int[] arr) {
		StringBuilder sb = new StringBuilder("[");
		for(int i=0;i<arr.length;i++) {
			sb.append(arr[i]).append(i==arr.length-1?"]":",");
		}
		return sb.toString();
	}
	public static String arr2str1(int[] arr) {
		String result = "[";
		for(int i=0;i<arr.length;i++) {
			/*if(i==arr.length-1) {
				result+=arr[i]+"]";
			}else {
				result+=arr[i]+",";
			}*/
			result+=arr[i]+(i==arr.length-1?"]":",");
			
		}
		return result;
	}

}

7.String和StringBuilder拼接字符串的区别

1.使用String类型拼接字符串：时间和空间上都非常浪费，效率极低。

因为字符串是不可改变的字符序列，所以每次添加字符串的时候，会进行拼接从而生成一个新的字符串。在空间和时间极其浪费。

在这里插入图片描述

2.使用StringBuilder拼接字符串，时间和空间上都非常节省，无论循环多少次，都只在容器中进行添加，最后把容器中的数据返回来。

在这里插入图片描述

8.String和StringBuilder的相互转换

1.String转成StringBuilder

StringBuilder的构造方法

append()方法

2.StringBuilder转成String

toString()的方法

String的构造方法

9.StringBuffer和StringBuilder的区别

1.共同点：都是字符串的缓冲区，都是字符串的生成器，都是可以变的字符序列。

2.不同点：

StringBuffer在jdk1.0出现的

StringBuilder在jdk1.5出现的

效率不同：

StringBuffer效率低

StringBuilder效率高

线程安全性不同：

StringBuffer是线程安全的，在多线程环境下仍然保证数据安全

StringBuilder是线程不安全的，在多线程环境下无法保证数据的安全

10.String和StringBuilder作为方法的参数

1.String作为方法的参数进行传递，无法修怍原值。在被调用方法中，修改引用指向的对象和主方法中的引用无关。

在这里插入图片描述

2.StringBuilder作为方法的参数进行传递，如果在被调用的方法中，修改的是StringBuilder的引用，那么不会改变原有对象中的数据;如果通过该引用修改了对象的数据，那么原值就会发生改变。

public class Demo08 {

	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder("abc");
		update(sb);
		System.out.println(sb);

	}
	public static void update(StringBuilder sb) {
		//sb = new StringBuilder("xyz");
		sb.replace(0, sb.length(), "xyz");
		System.out.println(sb);
	}

}

在这里插入图片描述

二、基本类型的包装类

1.概述

1.基本类型有八种，都是是非常简单的数据类型

2.在这些类型中，只能表示简的数据，不能包含一些操作数据的方法，需要准备一个引用数据类型，能把基本数据类型进行包装，提供一些操作基本类型的方法，定义一些描述数据的数据。

3.基本类型的包装类

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

2.Integer类型

1.各种包装类的方法，特点基本相同，只要学习一个Integer类型，其它的类型也可以举一反三。

2.Integer类型的对象中，维护一个成员变量，是一个int类型的字段，用于表示这个Integer对象要表示的数字。

3.提供了在int,Integer,String类型之间相互转换的方法

4.提供了一些常量。

3.Integer构造方法

1.Integer(int value):将一个基本类型的int值，转换成Integer类型的对象

2.Integer(String s):将一个字符串类型的数字，转换成Integer类型的对象注意数字格式异常

public class Demo01 {

	public static void main(String[] args) {
		Integer i1 = new Integer(20);
		System.out.println(i1);
		//java.lang.NumberFormatException  数字格式异常
		Integer i2 = new Integer("50");
		System.out.println(i2);

	}

}

4.Integer类型的成员方法

1.xxxValue():可以将Integer类型的对象，转成其它的基本数据类型。 doubleValue() byteValue()

2.常用静态方法

parseInt(String str):将str以十进制的方式解读为一个int类型的整数

parseInt(String str,int radix):将str以指定的radix进制解析为一个int类型的数字

toBinaryString(int i)
 toOctalString(int i)
 toHexString(int i)
 toString(int i,int radix):使用指定的radix进制，表示数字i
 valueOf(String str,int radix):将str以指定的进制radix进行解析，封装为一个Integer对象

public class Demo02 {

	public static void main(String[] args) {
		Integer i = new Integer(45);
		double d = i.doubleValue();
		System.out.println(d);
		
		int x = Integer.parseInt("123");
		System.out.println(x);
		//其它进制-->十进制
		System.out.println(Integer.parseInt("1010", 2));
		System.out.println(Integer.parseInt("101AB", 16));
		//十进制-->其它进制
		System.out.println(Integer.toBinaryString(10));
		System.out.println(Integer.toOctalString(20));
		System.out.println(Integer.toHexString(21));
		//十进制-->其它进制
		System.out.println(Integer.toString(6, 2));
		//其它进制-->十进制
		System.out.println(Integer.valueOf("101", 2));

	}

}

5.Integer类型的常量

1.MAX_VALUE:int类型的最大值

2.MIN_VALUE:int类型的最小值

3.SIZE:int类型的内存中的位数

4.TYPE:int类型在方法区中的字节码对象

public class Demo03 {

	public static void main(String[] args) {
		System.out.println(Integer.MAX_VALUE);
		System.out.println(Integer.MIN_VALUE);
		System.out.println(Integer.SIZE);
		System.out.println(Integer.TYPE);
		
		System.out.println(Double.SIZE);
		

	}

}

6.Integer,int,String类型的相互转换

1.Integer转换int类型

intValue()

2.int类型转换成Integer类型

构造方法 Integer(int i)

3.Integer到String的转换

toString()即可

4.String转Integer

Integer.valueOf()

构造方法 Integer(String str)

5.int转换成String

拼接一个空串 5+””

Integer.toString(int i)

6.String转换成int

Integer.parseInt(String str)

7.自动装箱和拆箱(jdk1.5之后)

1.装箱：将基本数据类型，封装成包装类型的对象，这个过程叫装箱，使用构造方法即可。

2.拆箱：从包装类的对象中，将其包装的基本类型的数据取出，这个过程就是拆箱，使用intValue()即可。

3.自动装箱和拆箱：自动完成，不需要手动干预。

public class Demo04 {

	public static void main(String[] args) {
		/*int i = 20;
		//装箱
		Integer in = new Integer(i);
		//拆箱
		System.out.println(in.intValue());*/
		//自动装箱
		Integer i = 20;
		System.out.println(i);
		//自动拆箱
		System.out.println(i+30);

	}

}