StringBuffer StringBuilder 数组常见操作 Arrays 基本数据类型包装类
(一)StringBuffer
1.常见对象(StringBuffer类的概述
A:StringBuffer类概述
我们如果对字符串进行拼接操作,每次拼接,都会构建一个新的String对象,既耗时,又浪费空间。
而StringBuffer就可以解决这个问题
2常见对象(StringBuffer类的构造方法)
A:StringBuffer的构造方法:
public StringBuffer(): 无参构造方法
public StringBuffer(int capacity): 指定容量的字符串缓冲区对象
public StringBuffer(String str): 指定字符串内容的字符串缓冲区对象
B:StringBuffer的方法:
public int capacity():返回当前容量。 理论值
public int length():返回长度(字符数)。 实际值
构造方法和长度方法的使用
public class MyTest {
public static void main(String[] args) {
//String 类
//String str="a"+"b"+"c";
// String str="abc";
// StringBuffer :他就是存储字符的容器,长度可变
//可变字符序列
//StringBuffer()
//构造一个其中不带字符的字符串缓冲区,其初始容量为 16 个字符。
//超过了默认容量,可以自动扩充
StringBuffer sb = new StringBuffer();
int capacity = sb.capacity(); //获取缓冲区的容量
System.out.println(capacity);
int length = sb.length(); //获取长度 实际你往容器中存了多少个字符
System.out.println(length);
//Object 类
//toString();
StringBuffer sb2 = sb.append("abc"); //往容器中追加内容
System.out.println(sb2.toString());//
}
}
3常见对象(StringBuffer的添加功能)
A:StringBuffer的添加功能
public StringBuffer append(String str): 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
B:案例演示
StringBuffer的添加功能
public class MyTest2 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
//StringBuffer sb2 = sb.append("abc");
//String s = sb.toString();
// String s1 = sb2.toString();
// sb.toString()==sb2.toString() s==s1
// sb == sb2
//System.out.println(sb.toString() == sb2.toString());
// System.out.println(sb==sb2); //true
//append(100) 往容器中追加内容,返回的还是原来的那个容器
sb.append(100).append(1000).append("abc");
String s = sb.toString();
System.out.println(s);
}
}
4常见对象(StringBuffer的删除功能)
A:StringBuffer的删除功能
public StringBuffer deleteCharAt(int index):删除指定位置的字符,并返回本身
public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容,并返回本身
B:案例演示
StringBuffer的删除功能
public class MyTest2 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("红尘来呀来去呀去都是一场梦");
sb.deleteCharAt(0);//根据索引删除单个字符
// sb.delete()
int index = sb.indexOf("都");
// sb.lastIndexOf()
//根据起始索引,和终止索引删除一段内容
sb.delete(index,sb.length());
System.out.println(sb);
}
}
5常见对象(StringBuffer的替换和反转功能)
A:StringBuffer的替换功能
public StringBuffer replace(int start,int end,String str): 从start开始到end用str替换
B:StringBuffer的反转功能
public StringBuffer reverse(): 字符串反转
C:案例演示
StringBuffer的替换和反转功能
public class MyTest3 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("红尘来呀来去呀去都是一场梦");
//根据起始索引和终止索引替换容器中的一段内容,返回的还是容器本身
StringBuffer replace = sb.replace(0, sb.lastIndexOf("去")+1, "abc");
System.out.println(replace);
System.out.println(sb);
System.out.println(replace==sb);
sb.reverse(); //反转容器中的数据,返回的还是原来的容器
System.out.println(sb.toString());
}
}
6常见对象(StringBuffer的截取功能及注意事项)
A:StringBuffer的截取功能
public String substring(int start): 从指定位置截取到末尾
public String substring(int start,int end): 截取从指定位置开始到结束位置,包括开始位置,不包括结束位置
B:注意事项
注意:返回值类型不再是StringBuffer本身
C:案例演示
StringBuffer的截取功能及注意事项
7常见对象(StringBuffer和String的相互转换)
A:String – StringBuffer
a:通过构造方法
b:通过append()方法
B:StringBuffer – String
a: 使用substring方法
b:通过构造方法
c:通过toString()方法
C:案例演示
StringBuffer和String的相互转换
(二)StringBuilder
1常见对象(String和StringBuffer分别作为参数传递)
A:形式参数问题
String作为参数传递 String虽然是引用类型,但是它是一个常量,所以在做传递的时候,完全可以将其看成基本数据类型数据进行传递
StringBuffer作为参数传递
(三)数组常见操作
1.常见对象(数组高级冒泡排序原理)
冒泡排序原理
相邻元素两两比较,大的往后放,第一次完毕,最大值出现在了最大索引处
public class MyTest {
public static void main(String[] args) {
int[] arr={24, 69, 80, 57, 13,30,10,-1,0};
//tuiDao(arr);
for (int j = 0; j <arr.length-1; j++) {
//第2轮比较3次
for (int i = 0; i < arr.length - 1-j; i++) {
if (arr[i] > arr[i + 1]) {
int t = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = t;
}
}
}
System.out.println(Arrays.toString(arr));
}
private static void tuiDao(int[] arr) {
//第一轮比较4次
for (int i = 0; i < arr.length-1; i++) {
if(arr[i]>arr[i+1]){
int t=arr[i];
arr[i]=arr[i+1];
arr[i+1]=t;
}
}
//第2轮比较3次
for (int i = 0; i < arr.length - 1-1; i++) {
if (arr[i] > arr[i + 1]) {
int t = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = t;
}
}
//第3轮比较2次
for (int i = 0; i < arr.length - 1 - 1-1; i++) {
if (arr[i] > arr[i + 1]) {
int t = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = t;
}
}
//第4轮比较1次
for (int i = 0; i < arr.length - 1 - 1 - 1-1; i++) {
if (arr[i] > arr[i + 1]) {
int t = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = t;
}
}
}
}
2常见对象(数组高级选择排序原理图解)
1:选择排序原理
从0索引开始,依次和后面元素比较,小的往前放,第一次完毕,最小值出现在了最小索引处
public class MyTest2 {
public static void main(String[] args) {
//选择排序:每次拿一个元素跟后面的元素挨个比较,小的往前换,经过一轮比较,最小元素就会出现在最前面
int[] arr = {24, 69, 80, 57, 13,30,30,30,100,300,-1,0};
// tuiDao(arr);
for (int index = 0; index < arr.length-1; index++) {
for (int i = 1 + index; i < arr.length; i++) {
if (arr[index] > arr[i]) {
int t = arr[index];
arr[index] = arr[i];
arr[i] = t;
}
}
}
System.out.println(Arrays.toString(arr));
}
private static void tuiDao(int[] arr) {
//第一轮 从0索引处开始比 比4次
int index = 0;
for (int i = 1; i < arr.length; i++) {
if (arr[index] > arr[i]) {
int t = arr[index];
arr[index] = arr[i];
arr[i] = t;
}
}
//第二轮
index=1;
for (int i = 1+index; i < arr.length; i++) {
if (arr[index] > arr[i]) {
int t = arr[index];
arr[index] = arr[i];
arr[i] = t;
}
}
index = 2;
for (int i = 1 + index; i < arr.length; i++) {
if (arr[index] > arr[i]) {
int t = arr[index];
arr[index] = arr[i];
arr[i] = t;
}
}
index = 3;
for (int i = 1 + index; i < arr.length; i++) {
if (arr[index] > arr[i]) {
int t = arr[index];
arr[index] = arr[i];
arr[i] = t;
}
}
}
}
(四)Arrays
1.常见对象(Arrays类的概述和方法使用)
A:Arrays类概述
针对数组进行操作的工具类。
提供了排序,查找等功能。
B:成员方法
public static String toString(int[] a)
public static void sort(int[] a)
public static int binarySearch(int[] a,int key)
(五)常见对象(基本类型包装类的概述)
1_常见对象(基本类型包装类的概述)
A: 需求:
a:将100转换成二进制 , 八进制 , 十六进制
b:判断一个数是否在int的范围内
B:为什么会有基本类型包装类
为了对基本数据类型进行更多的操作,更方便的操作,java就针对每一种基本数据类型提供了对应的类类型.
C:常用操作: 常用的操作之一:用于基本数据类型与字符串之间的转换。
D:基本类型和包装类的对应
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
2.常见对象(Integer类的概述和构造方法)
A:Integer类概述
通过JDK提供的API,查看Integer类的说明
Integer 类在对象中包装了一个基本类型 int 的值,
该类提供了多个方法,能在 int 类型和 String 类型之间互相转换,
还提供了处理 int 类型时非常有用的其他一些常量和方法
B:构造方法
public Integer(int value)
public Integer(String s)
C:案例演示
使用构造方法创建对象
public class MyTest2 {
public static void main(String[] args) {
//Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。
//
//此外,该类提供了多个方法,能在 int 类型和 String 类型之间互相转换,还提供了处理 int 类型时非常有用的其他一些常量和方法。
// B:
// 构造方法
//public Integer( int value)
//public Integer(String s)
int num=100;
Integer integer = new Integer(num);
String s = integer.toString();
System.out.println(s);//"100";
Integer integer1 = new Integer("110000"); //要的是字面上来看是一个数字的字符串
//NumberFormatException: 数字格式化异常
System.out.println(integer1);
}
}
3常见对象(String和int类型的相互转换)
A:int – String
a:和""进行拼接
b:public static String valueOf(int i)
c:int – Integer – String
d:public static String toString(int i)
B:String – int
a:String – Integer – intValue();
b:public static int parseInt(String s)
C:案例演示
String和int类型的相互转换
public class MyTest3 {
public static void main(String[] args) {
//A:
//int --String
int num=100; //"100"
//方式1:
String str=num+"";
//方式2
String s = String.valueOf(num);
//方式3
String s1 = new Integer(num).toString();
//"100"------100 String-----int
String strNum="100"; //-----100
Integer integer = new Integer(strNum);
int i = integer.intValue();
System.out.println(i);
//方式2
int num2 = Integer.parseInt(strNum);
System.out.println(num2);
}
}
4.常见对象(JDK5的新特性自动装箱和拆箱)
A:JDK5的新特性
自动装箱:把基本类型转换为包装类类型
自动拆箱:把包装类类型转换为基本类型
B:案例演示
JDK5的新特性自动装箱和拆箱
Integer ii = 100;
ii += 200;
C:注意事项
在使用时,Integer x = null;代码就会出现NullPointerException。
建议先判断是否为null,然后再使用。
public class MyTest {
public static void main(String[] args) {
//JDK1.5
//自动装箱:将一个基本类型,直接包装成他的包装类型
//自动拆箱:将一个包装类型,转化成他所对应的基本类型
int a=100;
Integer integer = new Integer(a);
Integer num = a; //自动装箱
Integer integer1 = new Integer(10);
Integer integer2 = new Integer(20);
int r= integer1 + integer2;
// 将一个包装类型,转化成他所对应的基本类型
System.out.println(r);
//都有哪些操作
Integer ii = 100; //自动装箱
ii += 200; //自动拆箱 自动装箱
System.out.println(ii);
//手动拆装箱
Integer integer3 = new Integer(10);
Integer integer4= new Integer(20);
int num11 = integer3.intValue();//手动拆箱
int num22 = integer4.intValue(); //手动拆箱
int rr=num11+num22;
Integer integer5 = Integer.valueOf(rr); //手动装箱
}
}