Java-StringBuffer、StringBuilder、数组基本操作及基本数据类型的包装

StringBuffer类的概述

• StringBuffer类概述：
  我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。
  而StringBuffer就可以解决这个问题
  他就是可以存储字符的容器，长度可变。初始容量为16
  线程安全的可变字符序列
• StringBuffer和String的区别：
  String 他是一个长度固定的字符序列，一旦定义就不能被改变
  StringBuffere 他是换一个长度可变的字符序列，是一个容器，可以往里面不断的追加数据

StringBuffer类的构造方法

• A:StringBuffer的构造方法：
  public StringBuffer(): 无参构造方法
  public StringBuffer(int capacity): 指定容量的字符串缓冲区对象
  public StringBuffer(String str): 指定字符串内容的字符串缓冲区对象
• B:StringBuffer的方法：
  public int capacity()：返回当前容量。 理论值
  public int length():返回长度（字符数）。 实际值

StringBuffer的添加及删除功能

• StringBuffer的添加功能：
  public StringBuffer append(String str): 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
  public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
• StringBuffer的删除功能：
  public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身
  public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身

StringBuffer的替换和反转功能

• StringBuffer的替换功能：
  public StringBuffer replace(int start,int end,String str): 从start开始到end用str替换
• StringBuffer的反转功能：
  public StringBuffer reverse():字符串反转

StringBuffer的截取功能及注意事项

• StringBuffer的截取功能：
  public String substring(int start): 从指定位置截取到末尾
  public String substring(int start,int end): 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
• 注意事项：
  注意:返回值类型不再是StringBuffer本身而是返回一个String类型的返回值

StringBuffer和String的相互转换

• String-int：

1. 调用parseInt(String str)方法
2. 调用Integer()方法创建int的对象，然后再调用intValue()方法

• int-String:

1. 调用valueof(int i)方法
2. 直接与””进行拼接
3. 调用toString()方法

StringBuffer和StringBuilder的区别

1.StringBuffer是多线程的，比较安全
2.StringBuilder是单线程的，不太安全

String和StringBuffer分别作为参数传递

形式参数问题：
String作为参数传递 String虽然是引用类型,但是它是一个常量,所以在做传递的时候,完 全可以将其看成基本数据类型数据进行传递
StringBuffer作为参数传递 ,需要传StringBuffer的对象

用StringBuffer的练习

• 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);
    }
}

• 字符串反转及替换

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);//结果是true
       sb.reverse(); //反转容器中的数据，返回的还是原来的容器
        System.out.println(sb.toString());
    }
}

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

public class MyDemo2 {
    public static void main(String[] args) {
        //A:
        //案例演示
        //需求：把数组中的数据按照指定格式拼接成一个字符串
        //举例：
        //int[] arr = {1, 2, 3};
        //输出结果：
        //"[1, 2, 3]"
        //用StringBuffer的功能实现
        int[] arr = {1, 2, 3};
        StringBuffer sb = new StringBuffer("[");
        for (int i = 0; i < arr.length; i++) {
            if(i==arr.length-1){
                sb.append(arr[i]).append("]");
            }else{
                sb.append(arr[i]).append(",");
            }
        }
        String s = sb.toString();
        System.out.println(s);
    }
}

• 根据索引截取StringBuffer容器中的数据

public class MyTest4 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append("红尘来呀来去呀去都是一场梦");
        //根据索引截取容器中的数据，返回的是一个截取到的新的字符串
        String substring = sb.substring(2);//返回的不是StringBuffer类型而是String类型
        String substring1 = sb.substring(2, 5); //含头不含尾
        System.out.println(sb);
        System.out.println(substring);
        System.out.println(substring1);
    }
}

数组高级冒泡排序及图解

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));
    }

数组高级选择排序及图解

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));
    }

Arrays类的概述

• Arrays类概述：
  针对数组进行操作的工具类。
  提供了排序，查找等功能。
• 成员方法：
  public static String toString(int[] a)
  public static void sort(int[] a)
  public static int binarySearch(int[] a,int key)

基本类型包装类的概述

• 为什么会有基本类型包装类
  为了对基本数据类型进行更多的操作,更方便的操作,java就针对每一种基本数据类型提供了对应的类类型.
• 基本类型和包装类的对应
  byte----Byte
  short----Short
  int----Integer
  long----Long
  float----Float
  double----Double
  char----Character
  boolean----Boolean

Integer类的概述和构造方法

• Integer类概述：
  Integer 类在对象中包装了一个基本类型 int 的值,
  该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
  还提供了处理 int 类型时非常有用的其他一些常量和方法
• 构造方法：
  public Integer(int value)
  public Integer(String s)

String和int类型的相互转换

• String-int：

1. 调用parseInt(String str)方法
2. 调用Integer()方法创建int的对象，然后再调用intValue()方法

• int-String:

1. 调用valueof(int i)方法
2. 直接与””进行拼接
3. 调用toString()方法

JDK5的新特性自动装箱和拆箱

• JDK5的新特性：
  自动装箱：把基本类型转换为包装类类型
  自动拆箱：把包装类类型转换为基本类型
• 案例演示
  JDK5的新特性自动装箱和拆箱
  Integer ii = 100; //自动装箱
  ii += 200; //先自动拆箱，然后运算完成之后又自动装箱
• 注意事项：
  在使用时，Integer x = null;代码就会出现NullPointerException。
  建议先判断是否为null，然后再使用

Integer的面试题

看程序写结果
	
	Integer i1 = new Integer(127);
	Integer i2 = new Integer(127);
	System.out.println(i1 == i2);
	System.out.println(i1.equals(i2));
	System.out.println("-----------");

	Integer i3 = new Integer(128);
	Integer i4 = new Integer(128);
	System.out.println(i3 == i4);
	System.out.println(i3.equals(i4));
	System.out.println("-----------");

	Integer i5 = 128;
	Integer i6 = 128;
	System.out.println(i5 == i6);//false  因为 超过了一个字节的范围 会new 一个Integer对象
	System.out.println(i5.equals(i6));
	System.out.println("-----------");

	Integer i7 = 127;
	Integer i8 = 127;
	System.out.println(i7 == i8);//true 没有超过一个字节的范围 因为在方法区中存在一个 字节常量池 范围-128---127
	System.out.println(i7.equals(i8));

-128~127之间，封装的对象是从数组里取的，不用new，对应的索引就是变量的值
超过这个范围，每封装一次，new一次对象