StringBuffer-数组处理类

目录

• StringBuffer类
• StringBuffer的添加功能
• StringBuffer的删除功能
• StringBuffer的替换和反转功能
• StringBuffer的截取功能及注意事项
• StringBuffer和String的互相转换
• 练习
• 面试题（String、StringBuffer和StringBuilder的区别）
• String和StringBuffer分别作为参数传递
• 数组高级冒泡排序代码实现
• 数组高级选择排序
• 数组高级二分查找
• Arrays类的概述和方法使用
• 基本类型包装类的概述
• Integer类的概述和构造方法
• String与int的相互转换
• JDK5的新特性自动装箱和拆箱
• Integer面试题

---

返回 我的技术栈(Technology Stack)

---

StringBuffer类

---

• StringBuffer类的概述：

  • 线程安全的可变字符序列

• StringBuffer和String的区别：

  • String是一个不可变的字符序列
  • StringBuffer是一个可变的字符序列

• StringBuffer的构造方法：

  • public StringBuffer():无参构造方法

    StringBuffer sb = new StringBuffer();
    System.out.println(sb.length()); //容器的字符个数，实际值
    System.out.println(sb.capacity()); //容器的初始容量，理论值

    输出结果：0
    16

  • public StringBuffer(int capacity):指定容量的字符串缓冲区对象

    StringBuffer sb2 = new StringBuffer(10);
    System.out.println(sb2.length()); //容器的字符个数，实际值
    System.out.println(sb2.capacity()); //容器的初始容量，理论值

    输出结果：0
    10

  • public StringBuffer(String str):指定字符串内容的字符串缓冲区对象

    StringBuffer sb3 = new StringBuffer("heima");
    System.out.println(sb3.length()); //容器的字符个数，实际值
    System.out.println(sb3.capacity()); //字符串的length + 初始容量

    输出结果：5
    21

StringBuffer的添加功能

---

• public StringBuffer append(String str):可以把任意类型数据添加到字符串缓冲区里面，并返回字符串缓冲区本身

  StringBuffer sb = new StringBuffer();
  StringBuffer sb2 = sb.append(true);
  StringBuffer sb3 = sb.append("heima");
  StringBuffer sb4 = sb.append(100);

  System.out.println(sb.toString()); //StringBuffer类中重写了toString方法，显示的是对象中的属性值
  System.out.println(sb2.toString());
  System.out.println(sb3.toString());
  System.out.println(sb4.toString());

  输出结果：trueheima100
  trueheima100
  trueheima100
  trueheima100
  解释：StringBuffer是字符串缓冲区，当new的时候是在堆内存创建了一个对象，底层是一个长度为16的字符数组，
  当调用添加的方法时，不会再重新创建对象，在不断向原缓冲区添加字符

  StringBuffer sb = new StringBuffer();
  System.out.println(sb.toString());

  StringBuffer sb2 = sb.append(true);
  System.out.println(sb2.toString());

  StringBuffer sb3 = sb.append("heima");
  System.out.println(sb3.toString());

  StringBuffer sb4 = sb.append(100);
  System.out.println(sb4.toString());

  输出结果：
  true
  trueheima
  trueheima100

• public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面，并返回字符串缓冲区本身

  StringBuffer sb = new StringBuffer("1234");
  sb.insert(3,"heima"); //在指定位置添加元素，如果没有指定位置，就会报错（指定位置要在字符串中）

  System.out.println(sb);

  输出结果：123heima4
  
  

StringBuffer的删除功能

---

• public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身

  StringBuffer sb = new StringBuffer();
  //sb.deleteCharAt(5); //当缓冲区中没有这个索引上没有元素的时候，运行就会报错
  sb.append("heima");
  sb.deleteCharAt(4); //根据索引删除掉索引位置上对应的字符
  System.out.println(sb);

  输出结果：heim

• public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身

  StringBuffer sb = new StringBuffer();
  sb.append("heima");

  sb.delete(0,2); //删除的时候是包含头，不包含尾
  输出结果：ima

  sb.delete(0,sb.length()); //清空缓冲区

  sb = new StringBuffer(); //不要用这种方式清空缓冲区，原来的会变成垃圾，浪费内存
  System.out.println(sb);
  
  

StringBuffer的替换和反转功能

---

• StringBuffer的替换功能

  • public StringBuffer replace (int start,int end, String str):从start开始到end用str替换

    StringBuffer sb = new StringBuffer("heima");
    sb.replace(0,3,"bai");
    System.out.println(sb);
    输出结果：baima

• StringBuffer的反转功能

  • public StringBuffer reverse():字符串反转

    StringBuffer sb = new StringBuffer("我爱总复习");
    sb.reverse();
    System.out.println(sb);
    输出结果：习复总爱我
    
    

StringBuffer的截取功能及注意事项

---

• StringBuffer的截取功能

  • public String substring(int start):从指定位置截取到末尾

    StringBuffer sb = new StringBuffer("woaiheima");
    String str = sb.substring(4);
    System.out.println(str);
    System.out.println(sb);
    输出结果：heima
    woaiheima

  • public String substring(int start,int end):截取从指定位置开始到结束位置，包括开始位置，不包括结束位置

    StringBuffer sb = new StringBuffer("woaiheima");
    String str3 = sb.substring(4,7);
    System.out.println(str3);
    输出结果：hei

• 注意事项：返回值类型不再是StringBuffer本身
  
  

StringBuffer和String的互相转换

---

• String ----> StringBuffer

  • 1、通过构造方法

  • 2、通过append()方法

    public static void main(String[] args) {
    StringBuffer sb1 = new StringBuffer("heima"); //通过构造方法将字符转换为StringBuffer对象
    System.out.println(sb1);

    StringBuffer sb2 = new StringBuffer();
    sb2.append("heima"); //通过append方法将字符串转换为StringBuffer对象
    System.out.println(sb2);
    }

    输出结果：heima
    heima

• StringBuffer ----> String

  • 1、通过构造方法

  • 2、通过toString()方法 (推荐使用)

  • 3、通过subString(0,length);

    public static void main(String[] args) {
    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);
    //可以直接写出System.out.println(sb.toString());

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

    }
    
    

练习

---

• 需求：把数组中的数据按照指定格式拼接成一个字符串

  • 如：int [] arr = {1,2,3};

  • 输出:[1,2,3];

    public static void main(String[] args) {
    int [] arr = {1,2,3};
    System.out.println(arrayToString(arr));
    }

    public static String arrayToString(int [] arr) {
    StringBuffer sb = new STringBUffer(); //创建字符串缓冲区对象
    sb.append("["); //将[添加到缓冲区

    for(int i = 0;i < arr.length;i ++) {
    if(i == arr.length - 1) {
    sb.append(arr[i].append("]"));
    }else {
    sb.append(arr[i]).append(",");
    }
    }
    return sb.toString();
    }

    输出结果：[1,2,3]

• 字符串反转

  import java.util.Scanner;
  class test {
  public static void main(String [] args) {
  Scanner sc = new Scanner(System.in); //创建键盘录入对象
  String line = sc.nextLine(); //将键盘录入的字符串存储在line中

  StringBuffer sb = new StringBuffer(line); //将字符串转换为StringBuffer对象
  sb.reverse(); //将缓冲区的内容反转

  System.out.println(sb.toString());
  }
  }

  输出结果:abc
  cba
  
  

面试题（String、StringBuffer和StringBuilder的区别）

---

• StringBuffer和StringBuilder的区别

  • StringBuffer是jdk1.0版本的，是线程安全的（同步），效率低
  • StringBuilder是jdk1.5版本的，是线程不安全的（不同步），效率高

• String、StringBuffer和StringBuilder的区别

  • String是一个不可变的字符序列
  • StringBUffer，StringBuilder是可变的字符序列
    
    

String和StringBuffer分别作为参数传递

---

• 基本数据类型的值传递，不改变其值

• 引用数据类型的值传递，改变其值

  public static void main(String[] args) {
  String s = "heima";
  System.out.println(s);
  change(s);
  System.out.println(s);
  }

  public static void change(String s) { //执行完该方法后，s = heimaitcast
  //但是，方法执行完事要弹栈的，对于主方法的S来说，S是没有发生改变的
  s += "itcast";
  }

  输出结果：heima
  heima
  解释：String类虽然是引用类型，但是他当作参数传递时和基本数据类型是一样的

  /**************************************/

  public static void main(String[] args) {
  StringBuffer sb = new StringBuffer();
  sb.append("heima");
  System.out.println(sb);
  change(sb);
  System.out.println(sb);
  }

  public static void change(StringBuffer sb) {
  sb.append("itcast");
  }

  输出结果：heima
  heimaitcast
  
  

数组高级冒泡排序代码实现

---

public static void main(String[] args) {
int[] arr = {24,69,80,57,13};
bubbleSort(arr);
print(arr);
}

public static void bubbleSort(int[] arr) {
for(int i = 0; i < arr.length - 1 ; i++) { // 外循环只需比较arr.length-1 次就可以了
for(int j = 0; j < arr.length - 1 - i; j ++) { // -1为了防止索引越界，-i为了提高效率
if(arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}

public static void print(int[] arr) {
for(int i = 0; i < arr.length; i ++) {
System.out.println(arr[i] + " ");
}
}

输出结果：13 24 57 69 80

数组高级选择排序

---

public static void main(String[] args) {
int[] arr = {24,69,80,57,13};
selectSort(arr);
print(arr);
}

public static void selectSort(int[] arr) {
for(int i = 0; i < arr.length - 1 ; i++) { // 外循环只需比较arr.length-1 次就可以了
for(int j = i + 1; j < arr.length; j ++) { // -1为了防止索引越界，-i为了提高效率
if(arr[i] > arr[j]) {
int temp = arr[j];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}

public static void print(int[] arr) {
for(int i = 0; i < arr.length; i ++) {
System.out.println(arr[i] + " ");
}
}

输出结果：13 24 57 69 80

数组高级二分查找

---

public static void main(String[] args) {
int[] arr = {11,22,33,44,55,66,77};
System.out.println(getIndex(arr,22));
System.out.println(getIndex(arr,66));
System.out.println(getIndex(arr,88));
}

public static int getIndex(int [] arr,int value) {
int min = 0;
int max = arr.length - 1;
int mid = (min + max)/2;

while(arr[mid] != value) { //当中间值不等于要找的值，就开始循环查找
if(arr[mid] < value) { //当中间值小于了要找的值
min = mid + 1; //最小的索引改变
}else if (arr[mid] > value) { //当中间值大于了要找的值
max = mid - 1; //最大的索引改变
}

mid = (min + max)/2; // 无论最大还是最小改变，中间索引都会随之改变

if(min > max) { //如果最小索引大于最大索引，就没有查找的可能性
return -1; //返回-1
}

}

}

输出结果：1
5
-1

Arrays类的概述和方法使用

---

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

Arrays.sort(arr); //排序
System.out.println(Arrays.toString(arr));

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

输出结果：[33,22,11,44,66,55]
[11,22,33,44,55,66]
1
5
-2

基本类型包装类的概述

---

• 基本类型和包装类的对应

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

  public static void main(String[] args) {
  System.out.println(Integer.toBinaryString(60)); //把60转成二进制
  System.out.println(Integer.toOctalString(60)); //把60转成八进制
  System.out.println(Integer.toHexString(60)); //把60转成十六进制
  }

  输出结果：111100
  74
  3c
  
  

Integer类的概述和构造方法

---

• 构造方法

  • public Integer(int value)

  • public Integer(String s)

    Integer i1 = new Integer(100);
    System.out.println(i1);
    输出结果：100

    Integer i2 = new Integer("100");
    System.out.println(i2);
    输出结果：100

    Integer i3 = new Integer("abc"); //运行报错！ 因为abc不是数字字符串，所以转换会报错
    System.out.println(i3);
    输出结果：报错！数字格式异常
    
    

String与int的相互转换

---

• int ----> String

  • 1、和""进行拼接 (推荐使用)

    int i = 100;
    String s1 = i + "";
    System.out.println(s1);
    输出结果：100 (这是一个数字字符串)

  • 2、public static String valueOf(int i)（推荐使用）

    int i = 100;
    String s2 = String.valueOf(i);
    System.out.println(s1);
    输出结果：100 (这是一个数字字符串)

  • 3、int -- Integer -- String(Integer类的toString()方法)

    int i = 100;
    Integer i2 = new Integer(i);
    String s3 = i2.toString();
    System.out.println(s3);
    输出结果：100 (这是一个数字字符串)

  • 4、public static String toString(int i)(Integer类的静态方法)

    int i = 100;
    String s4 = Integer.toString(i);
    System.out.println(s4);
    输出结果：100 (这是一个数字字符串)

• String ----> int

  • public static String toString(String s)(推荐使用)

    String i = "200";
    int i1 = Integer.parseInt(i);
    System.out.println(i1);
    输出结果：200 (这是一个int型数据)

    /******************************************************/

    注意：基本数据类型包装类有八种，其中七钟都有parseXxx的方法，
    可以将这七钟的字符串表现形式转换成基本数据类型

    String s1 = "true";
    boolean b = Boolean.parseBoolean(s1);
    System.out.println(b);
    输出结果：true

    String s2 = "abc";
    char c = Character.parsechar(s2);
    //运行报错！char的包装类Character中没有pareseXxx的方法
    字符串到字符的转换通过toCharArray()就可以把字符串转换成字符数组

  • String -- Integer -- int

    String s = "200";
    Integer i3 = new Integer(s);
    int i4 = i3.intValue();
    System.out.println(i4);
    输出结果：200 (这是一个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);
}
输出结果：300

Integer面试题

---

public static void main(String[] args) {
Integer i1 = new Integer(97);
Integer i2 = new Integer(97);
System.out.println(i1 == i2); //false
System.out.println(i1.equals(i2)); //true

System.out.println("-----------------");

Integer i3 = new Integer(197);
Integer i4 = new Integer(197);
System.out.println(i3 == i4); //false
System.out.println(i3.equals(i4)); //true

System.out.println("-----------------");

Integer i5 = 97;
Integer i6 = 97;
System.out.println(i5 == i6); //true
System.out.println(i5.equals(i6)); //true

System.out.println("-----------------");

Integer i7 = 197;
Integer i8 = 197;
System.out.println(i7 == i8); //false
System.out.println(i7.equals(i8)); //true

System.out.println("-----------------");

Integer a = 127;
Integer b = 127;
System.out.println(a == b); // true
System.out.println(a.equals(b)); //true

System.out.println("-----------------");

Integer a1 = 128;
Integer b1 = 128;
System.out.println(a1 == b1); //false
System.out.println(a1.equals(b1)); //true

System.out.println("-----------------");

}

注意：-128到127是byte的取值范围，如果在这个取值范围内，
自动装箱就不会新创建对象，而是从常量池中获取。
如果超过了byte取值范围就会再创建新对象。