day08-StringBuffer常见对象

1 StringBuffer类的构造方法

A: StringBuffer的构造方法：
- public StringBuffer（）：无参构造方式
- public StringBuffer（int capacity）：指定容量的字符串缓冲区对象
- public StringBuffer（String str）：指定字符串内容的字符串缓冲区对象
B: StringBuffer的方法：
- public int capacity（）：返回当前容量。理论值
- public int length（）：返回长度（字符数）。实际值
C:StringBuffer的字符串缓冲区默认容量为16个字符，当大于这个容量时，自动扩展。

class Demo_StringBuffer {
    public static void main(String[] args) {
        StringBuffer sb0=new StringBuffer(); //创建StringBuffer空参构造对象
        System.out.println(sb0.length());      //打印的是实际值
        System.out.println(sb0.capacity());    //打印的是理论值

        StringBuffer sb1=new StringBuffer(10); //10给的是字符串缓冲区容量，StringBuffer存的是字符串，10不是字符串。
        System.out.println(sb1.length()); 
        System.out.println(sb1.capacity()); 

        StringBuffer sb2=new StringBuffer("haha"); //创建StringBuffer字符串有参构造对象
        System.out.println(sb2.length());          //实际存的个数为4个
        System.out.println(sb2.capacity());        //容量个数+实际个数
    }
}
/*
运行结果：
0
16
0
10
4
20
*/

2 StringBuffer的添加功能

A:public StringBuffer append（String str）：加黑部分可以为任意类型，此为重载
- 可以把任意类型数据添加到字符串缓冲区里面，并返回字符串缓冲区本身
B：public StringBuffer insert（int offset，String str）：
- 在指定位置把任意类型的数据插入到字符串缓冲区里面，并返回字符串缓冲区本身

class Demo_StringBuffer0 {
    public static void main(String[] args) {
        StringBuffer sb=new StringBuffer();
        System.out.println(sb);
        StringBuffer sb1=sb.append("你好");  //添加字符串”你好“
        System.out.println(sb1);
        StringBuffer sb2=sb.append(10);     //添加整数10
        System.out.println(sb2);
        System.out.println(sb2.append("10").append("世界"));
        /*
        由例可见，重载类型都是以字符串形式输出，且append可连续使用。
        */
        StringBuffer sb3=new StringBuffer("你好1010世界");
        StringBuffer sb4=sb3.insert(4,"宇宙");  //从第4个位置开始添加
        System.out.println(sb4);
    }
}
/*
运行结果：

你好
你好10
你好1010世界
你好10宇宙10世界
*/

3 StringBuffer的删除功能

A:public StringBuffer deleteCharAt（int index）：
- 删除指定位置的字符，并返回本身
B：public StringBuffer delete（int start，int end）：
- 删除从指定位置开始指定位置结束的内容，并返回本身

class Demo_StringBuffer1 {
    public static void main(String[] args) {
        StringBuffer sb=new StringBuffer("你好世界你好宇宙");
        StringBuffer sb1=sb.deleteCharAt(4);  //删除4号索引位置
        System.out.println(sb1);

        StringBuffer sb2=sb.delete(2,5);     //重索引2删除到索引5
        System.out.println(sb2);             
    }
}
/*
运行结果：
你好世界好宇宙
你好宇宙
*/

4 StringBuffer的替换和反转功能

A:public StringBuffer replace（int start，int end，String str）：
- 从start开始到end用str替换
B：public StringBuffer reverse（）：
- 字符串反转

class Demo_StringBuffer2 {
    public static void main(String[] args) {
        StringBuffer sb=new StringBuffer("合家欢乐团圆");
        StringBuffer sb1=sb.replace(2,4,"幸福");  //左闭右开，2的索引被替换，4的不被替换
        System.out.println(sb1);

        StringBuffer sb2=sb.reverse();  //反转
        System.out.println(sb2);
        
        System.out.println(sb);
        System.out.println(sb1);
        System.out.println(sb2);
    }
}
    }
}
/*
运行结果：
合家幸福团圆
圆团福幸家合
圆团福幸家合
圆团福幸家合
圆团福幸家合
*/
/*
结果分析：
我猜测出现“圆团福幸家合”的原因是因为StringBuffer是缓存区，“合家欢乐团圆”被替换为“合家幸福团圆”，再反转后缓存区里便只剩下“圆团福幸家合”了。
*/

5 StringBuffer的截取功能

A:public String substring（int start）：
- 从指定位置截取到末尾，留下的是从指定位置到末尾
B：public String substring（int start，int end）：
- 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
注意事项:
- 返回值类型不再是StringBuffer本身，而是String

class Demo_StringBuffer3 {
    public static void main(String[] args) {
        StringBuffer sb=new StringBuffer("合家欢乐团圆");
        String sb1=sb.substring(4);   //保留从索引4截取到末尾的字符串
        System.out.println(sb1);
        System.out.println(sb);    //并不改变sb的值 

        String sb2=sb.substring(2,4);   //保留索引2,不保留4,左开右闭
        System.out.println(sb2);
        System.out.println(sb);    //并不改变sb的值 
    }
}
/*
运行结果：
团圆
合家欢乐团圆
欢乐
合家欢乐团圆
*/

6 StringBuffer与String的相互转换

A String转向StringBuffer
- a：通过构造方法
- b：通过append（）方法
B StringBuffer转向String
- a：通过构造方法
- b：通过toString（）方法
- c：通过subString（0,length）;

7 遍历，排序，二分

遍历
- public static String toString(int[] a)
排序
- public static void sort(int[] a)
二分查找法，根据数组元素找索引位置
- public static int binarySearch(int[] a，int key)

import java.util.Arrays;

class DemoArray3 {
    public static void main(String[] args) {
        int[] arr={22,66,44,11,33,55};
        System.out.println(Arrays.toString(arr));  //对数组进行遍历

        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));  //对数组进行排序

        int[] arr0={11,22,33,44,55,66};
        System.out.println(Arrays.binarySearch(arr0,22)); //22的索引位置为1
        System.out.println(Arrays.binarySearch(arr0,66)); //66的索引位置为5
        System.out.println(Arrays.binarySearch(arr0,88)); //88的索引是按照负的插入点-1计算的
        //88应该插入的位置是索引6,-6-1=-7,所以为-7
        System.out.println(Arrays.binarySearch(arr0,15)); //位置为-1-1=-2
    }
}
/*
运行结果：
[22, 66, 44, 11, 33, 55]
[11, 22, 33, 44, 55, 66]
1
5
-7
-2
*/

8 基本类型包装类

常用的作用：
- 用于基本数据类型与字符串之间的转换。
基本数据类型和包装类的对应：
- byte Byte
- short Short
- int Integer
- long Long
- float Float
- double Double
- char Character
- boolean Boolean
Integer类的概述和构造方法
Integer类在对象中包装了一个基本类型int值。
Interger类提供了多个方法，能在int和String类型之间互相转换。

class DemoInteger {
    public static void main(String[] args) {
        System.out.println(Integer.toBinaryString(30));
        /*
        Integer是一个类，toBinaryString方法是将十进制转换为二进制
        */
        System.out.println(Integer.toOctalString(30));//将十进制转换为八进制
        System.out.println(Integer.toHexString(30));//将十进制转换为十六进制
    }
}
/*
运行结果：
11110
36
1e
*/

int和Integer的区别：

装箱和拆箱：
- x=10;
- Integer i=new Integer(x); //把基本数据类型转换为包装类，此处的i变为了对象，这叫装箱
- int i0=i.valueOf(); //把包装类转换为基本数据类型，此处的i0变为了基本数据类型，这叫拆箱
自动装箱和拆箱（JDK1.5版本以后有的）
- Integer i=10; //自动装箱，将基本数据类型10转换为包装类
- int i0=i+5; //自动拆箱，将包装类i转换为基本数据类型
Ingeter是int的包装类，int的初值为0，Ingeter的初值为null。除此之外还有区别，请看代码：

public class TestInteger {
    public static void main(String[] args) {
        int i = 128;
        Integer i2 = 128;
        Integer i3 = new Integer(128);
        System.out.println(i == i2); //Integer会自动拆箱为int，所以为true
        System.out.println(i == i3); //true，理由同上
        Integer i4 = 127;//编译时被翻译成：Integer i4 = Integer.valueOf(127);
        Integer i5 = 127;
        System.out.println(i4 == i5);//true
        Integer i6 = 128;
        Integer i7 = 128;
        System.out.println(i6 == i7);//false
        Integer i8 = new Integer(127);
        System.out.println(i5 == i8); //false
        Integer i9 = new Integer(128);
        Integer i10 = new Integer(123);
        System.out.println(i9 == i10);  //false
    }
}

   为什么i4和i5比是true，而i6和i7比是false呢？关键就是看valueOf()函数了，这个函数对于-128到127之间的数，会进行缓存， Integer i4 = 127时，会将127进行缓存，下次再写Integer i5 = 127时，就会直接从缓存中取，就不会new了。所以i4和i5比是true，而i6和i7比是false。

而对于后边的i5和i8，以及i9和i10，因为对象不一样，所以为false。

以上的情况总结如下：

1，无论如何，Integer与new Integer不会相等。不会经历拆箱过程，new出来的对象存放在堆，而非new的Integer常量则在常量池（在方法区），他们的内存地址不一样，所以为false。

2，两个都是非new出来的Integer，如果数在-128到127之间，则是true,否则为false。因为java在编译Integer i2 = 128的时候,被翻译成：Integer i2 = Integer.valueOf(128);而valueOf()函数会对-128到127之间的数进行缓存。

3，两个都是new出来的,都为false。还是内存地址不一样。

4，int和Integer(无论new否)比，都为true，因为会把Integer自动拆箱为int再去比。

构造方法：
- punlic Integer（int value）
- public Integer（String s）

class DemoInteger {
    public static void main(String[] args) {
        Integer i=new Integer(50); //50为常量，i=50,但已经由整数提升为Integer
        System.out.println(i);

        Integer i0=new Integer("50"); //50为字符串，此处只能转换字符串数字，不能转换字符串字母
        System.out.println(i0);
    }
}
/*
运行结果：
50
50
*/

8 int类型和String类型的相互转换

int类型转String类型
- 1 和“”进行拼接实现 //推荐使用
- 2 public static String valueOf（int i） //推荐使用
- 3 int -- Integer -- String（Integer类的toString方法（））
- 4 public static String toString（int i）（Intrger类的静态方法）
String类型转向int类型
- 1 String -- Integer -- int
- public static int parseInt（String s） //推荐使用

class DemoInteger {
    public static void main(String[] args) {
        /*
        int类型转换为String类型
        */
        int i=30;
        String s=i+"";     //整数+“”变转换为了String类型
        System.out.println(s);

        System.out.println(String.valueOf(i));//把字符数组转换为字符串

        Integer i0=new Integer(i);  //将int转换为Integer类的int
        String i1=i0.toString();
        System.out.println(i1);

        String i2=Integer.toString(i);  //直接使用Integer的toString方法
        System.out.println(i2);

        /*
        String类型转换为int类型
        */
        String str="30";
        Integer i3=new Integer(str);  //将String转换为Integer
        System.out.println(i3.intValue());  //intvalue将Integer转换为int

        System.out.println(Integer.parseInt(str));//Integer类里的parseInt可以直接将字符串转换为int

    }
}
/*
运行结果:
30
30
30
30
30
*/

常见对象-day08