Java——StringBuffer类

一、StringBuffer
（一）概述
我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuffer就可以解决这个问题；
线程安全的可变字符序列：一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。。
（二）构造方法

//构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。
        //StringBuffer 可以理解为长度可变的字符容器
        StringBuffer sb = new StringBuffer();
        //往字符串缓存区中追加数据
        sb.append("99999999999999");
        int capacity = sb.capacity();//获取字符串缓冲去的容量
        System.out.println(capacity);
        //length() 获取容器中实际的字符长度
        int length = sb.length();
        System.out.println(length);
        String s = sb.toString();
        System.out.println(s);

//方法摘要
        //StringBuffer append ( boolean b)
        //将 boolean 参数的字符串表示形式追加到序列。

        StringBuffer sb = new StringBuffer();
        //StringBuffer abc = sb.append("abc");
        //
        //System.out.println(sb==abc);
        //append("abc") 方法调用完毕之后，返回的还是那个容器本身，所以就可以链式编程，不断的往容器中追加内容
        sb.append("abc").append(100).append(2.14);
        String s = sb.toString();
        System.out.println(s);

//容器中的字符序列也是有索引的从0开始
        StringBuffer sb = new StringBuffer();
        sb.append("abc").append(true).append(new char[]{'a', 'b', 'c'});
        String s = sb.toString();
        System.out.println(s);

        //可以往容器中的指定位置插入数据
        sb.insert(2, 100);//在你指定的索引前面插入数据 返回的还是那个容器
        System.out.println(sb);

        //删除容器中的字符
        // sb.deleteCharAt(0);//根据索引删除一个字符
        sb.delete(0, 4);//从0索引处开始，删除4个字符 返回的还是那个容器
        System.out.println(sb);

//把字符串类型转换成字符串缓冲去类型
       // String-- StringBuffer
        String str="abc";
        //方式1
        StringBuffer sb = new StringBuffer(str);
        //方式2
        StringBuffer sb2 = new StringBuffer().append(str);
        //方式3
        StringBuffer sb3 = new StringBuffer().insert(0, str);

（三）StringBuffer和String的相互转换
A:String – StringBuffer
a:通过构造方法
b:通过append()方法
B:StringBuffer – String
a: 使用substring方法
b:通过构造方法
c:通过toString()方法
案例：/需求：把数组中的数据按照指定个格式拼接成一个字符串。

public class MyTest2 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        //输出结果：
        //"[1, 2, 3]"
        //用StringBuffer的功能实现
        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);
    }
}

（四）字符串反转

String str="abcd";
        String s = new StringBuffer(str).reverse().toString();
        System.out.println(s);

（五）StringBuffer和StringBuilder的区别

//StringBuffer 线程安全的，效率低 线程安全的可变字符序列
//StringBuilder 线程不安全，效率高
//一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，
//建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。
//两个类方法名用法都一样，只是在线程安全方面有区别
//StringBuilder sb = new StringBuilder()
（六）String和StringBuffer分别作为参数传递
//基本数据类型，作为参数传递，形参的改变，不影响实参。
//引用数据类型作为参数传递，形参的改变会影响实参

        String s="abc"; //引用数据类型，String类型虽说是引用数据类型，但是传参特点跟基本类型一样
        set(s);
        System.out.println(s);
        StringBuffer sb = new StringBuffer("123");
        StringBuffer sb2=set(sb);
        System.out.println(sb.toString());//321
        System.out.println(sb2.toString());//321
        System.out.println(sb2==sb);
    }
    private static void set(String s) {
        System.out.println(s); //
        s=s+"bbb";
        System.out.println(s);
    }
    private static StringBuffer set(StringBuffer sb) {
        sb.reverse();
        return sb;
    }

二、Arrays类的概述和方法使用
A:Arrays类概述
针对数组进行操作的工具类。
提供了排序，查找等功能。

//  类 Arrays  此类包含用来操作数组（比如排序和搜索）的各种方法。
     //static int binarySearch ( int[] a, int key)
    //使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。
      //static int binarySearch ( int[] a, int fromIndex, int toIndex, int key)
       //使用二分搜索法来搜索指定的 int 型数组的范围，以获得指定的值。
        //二分查找，数组元素必须有序
        int[] arr={10,12,34,46,40,12,1,46,0,48,59,500};
        int index = Arrays.binarySearch(arr,0, 4,12);
        System.out.println("索引是"+index);

B:成员方法
public static String toString(int[] a)
public static void sort(int[] a)
public static int binarySearch(int[] a,int key)
三、基本类型包装类的概述
（一）
A: 需求:
a:将100转换成二进制 , 八进制 , 十六进制
b:判断一个数是否在int的范围内
B:为什么会有基本类型包装类
为了对基本数据类型进行更多的操作,更方便的操作,java就针对每一种基本数据类型提供了对应的类类型.
C:常用操作: 常用的操作之一：用于基本数据类型与字符串之间的转换。
（二）Integer类的概述和构造方法
A:Integer类概述
Integer 类在对象中包装了一个基本类型 int 的值,
该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
还提供了处理 int 类型时非常有用的其他一些常量和方法
B:构造方法
public Integer(int value)
public Integer(String s)
（三）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)
（四）JDK5的新特性自动装箱和拆箱
A:JDK5的新特性
自动装箱：把基本类型转换为包装类类型
自动拆箱：把包装类类型转换为基本类型
B:案例演示
JDK5的新特性自动装箱和拆箱

Integer ii = 100;
ii += 200;

C:注意事项
在使用时，Integer x = null;代码就会出现NullPointerException。
建议先判断是否为null，然后再使用。

//包装类型：Java 针对每一种基本数据类型，对应的提供了一个包装类型，为了更加方便的去操作基本类型
        //自动拆装箱
        Integer[] arr = {new Integer(10), new Integer(10), new Integer(127)};
        Integer a = arr[0];
        Integer b = arr[1];
        System.out.println(a == b);
        System.out.println();
        Integer integer = Integer.valueOf(120);
        Integer integer1 = Integer.valueOf(39);
        System.out.println(integer == integer1);

        Integer integer3 = 127;//手动装箱 [1]
        Integer integer24 = 127;
        System.out.println(integer3 == integer24);

四、数组排序
（一）String 字符串类
// 任何一个字符串的字面常量值，都是该类的一个对
// 字符串是一个常量，一旦被定义其值就不能发生改变。 字符串存在方法区的常量池

//定义字符串的两种方式
        //String str = new String("abc");
        //String s="abc";
        //String s2="abc";
       // StringBuffer 可变的字符序列容器 如果想要大量拼串可以使用他
        StringBuffer abc = new StringBuffer("abc");
        StringBuffer abc1 = new StringBuffer("abc");
        boolean equals = abc.equals(abc1);
        System.out.println(equals);
        String s = abc.toString();

五、正则表达式
（一）正则表达式的概述和简单使用
正确规则的表达式 规则java给我们定的
是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。
案例：
需求：校验qq号码.
1:要求必须是5-15位数字
2:0不能开头

public class MyTest {
    public static void main(String[] args) {
        //正则表达式:是一个独立的技术，他的作用就是用来校验数据，符不符合我定义的规则，很多语言都支持正则表达式
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个QQ号码");
        String qqNum = sc.nextLine();
        //校验QQ号的组成规则
        // boolean b = checkQQNum(qqNum);
        boolean b = checkQQNumUseRegex(qqNum);
        if (b) {
            System.out.println("QQ规则正确");
        } else {
            System.out.println("QQ号不符合规则");
        }
    }
    private static boolean checkQQNumUseRegex(String qqNum) {
        //定义一个正则表达式
        String regex = "[1-9][0-9]{4,14}";
        return qqNum.matches(regex);
    }
    private static boolean checkQQNum(String qqNum) {
        //定义一个标记
        boolean flag = false;
        //先判断长度
        if (qqNum.length() >= 5 && qqNum.length() <= 15 && !qqNum.startsWith("0")) {
            //校验每个字符都是数字
            for (int i = 0; i < qqNum.length(); i++) {
                char ch = qqNum.charAt(i);
                /*if(ch>='0'&&ch<='9'){
                    flag=true;
                }else{
                  flag=false;
                    break;
                }
               static boolean isDigit ( char ch)
                确定指定字符是否为数字。*/
                if (Character.isDigit(ch)) {
                    flag = true;
                } else {
                    flag = false;
                    break;
                }
            }
        } else {
            flag = false;
        }
        return flag;
    }
}

（二）正则表达式的组成规则

规则字符在java.util.regex Pattern类中
A:字符
	x 字符 x。举例：'a'表示字符a
	\\ 反斜线字符。
	\n 新行（换行）符 ('\u000A') 
	\r 回车符 ('\u000D')
B:字符类
	[abc] a、b 或 c（简单类） 
	[^abc] 任何字符，除了 a、b 或 c（否定） 
	[a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围） 
	[0-9] 0到9的字符都包括
C:预定义字符类
	. 任何字符。我的就是.字符本身，怎么表示呢? \.
	\d 数字：[0-9]
	\w 单词字符：[a-zA-Z_0-9]
		在正则表达式里面组成单词的东西必须有这些东西组成
D:边界匹配器
	^ 行的开头 
	$ 行的结尾 
	\b 单词边界
		就是不是单词字符的地方。
		举例：hello world?haha;xixi
E:Greedy 数量词 
	X? X，一次或一次也没有 比如""空串 就是没有
	X* X，零次或多次  大于等于1次 都算多次
	X+ X，一次或多次
	X{n} X，恰好 n 次 
	X{n,} X，至少 n 次 
	X{n,m} X，至少 n 次，但是不超过 m 次 

（三）正则表达式的判断功能

/用来校验数据符不符合我们定义的规则
        //规则的定义语法
        //    A:
        //    字符
        //    x 字符 x。举例：'a' 表示字符a
        //\\反斜线字符。
        //
        //\r 回车符
        //定义正则的字符串
        String regx = "abc";
        regx="[abc]";//允许出现中括号中的字符的某一个
        regx="[a-z]";
        regx="[ABCDEFDGDGDGDG0998888283823828323]";
        regx="[a-zA-Z0-9]";
        regx="[^0-9]"; //不是列表中的字符
        // . 可以统配单个任意字符
        regx="..";
        regx="\\."; // \\ 转义字符
        regx="\\|"; //
        regx="\\d"; // \d 跟[0-9] 意思相同
        regx="\\w"; // \w 跟[a-z_A-Z0-9] 意思相同
        //我要校验这个字符串，符不符合我定义的正则
        boolean b = "1".matches(regx);
        System.out.println(b);

（四）则表达式的替换功能

System.out.println("奥巴马是美国总统".replace("奥巴马", "*"));

        String s = "特朗普是美国总统".replaceAll("奥巴马", "***");
        System.out.println(s);
        String s2= "特  b 朗    a    普   c 是d 美  国 e 总  f 统"; //特朗普是美国总统
        //根据正则替换
        String s1 = s2.replaceAll("[a-z' ']", "");
        System.out.println(s1);

（五）Pattern和Matcher的概述
正则的获取功能需要使用的类
A:Pattern和Matcher的概述
B:模式和匹配器的典型调用顺序
通过JDK提供的API，查看Pattern类的说明
典型的调用顺序是
Pattern p = Pattern.compile(“a*b”);
Matcher m = p.matcher(“aaaaab”);
boolean b = m.matches();
（六）正则表达式的获取功能
A:正则表达式的获取功能
Pattern和Matcher的结合使用
B:案例演示 使用的是 find()方法 和 group()方法 注意一定要先使用find()方法先找到 才能用group()方法获取出来
六、优化的冒泡排序

public class BubbleSortDemo {
	public static void main(String[] args) {
		// 定义一个数组
		int[] arr = {24, 69, 80, 57, 13} ;
		// 遍历方法
		System.out.print("排序前:	");
		print(arr) ;
		// 排序
		bubbleSort2(arr);
		// 排序后的输出
		System.out.print("排序后:	");
		print(arr) ;
	}
	/**
	 * 优化后的冒泡排序
	 */
	private static void bubbleSort2(int[] arr) {
		for(int x = 0 ; x < arr.length - 1 ; x++){
			/**
			 * arr.length - 1: 目的是为了防止数组角标越界
			 * arr.length - 1 - x : -x目的是为了提高效率
			 */
			for(int y = 0 ; y < arr.length - 1 - x ; y++){
				if(arr[y] > arr[y + 1]){
					int temp = arr[y] ;
					arr[y] = arr[y+1];
					arr[y+1] = temp ;
				}
			}
		}
	}
	/**
	 * 冒泡排序
	 */
	private static void bubbleSort(int[] arr) {
		// 第一次排序
		// arr.length - 1 目的: 防止数组角标越界
		for(int x = 0 ; x < arr.length - 1 - 0; x++){
			if(arr[x] > arr[ x + 1 ]){
				int temp = arr[x] ;
				arr[x] = arr[ x + 1];
				arr[ x + 1 ] = temp ;
			}
		}
		// 第二次排序
		for(int x = 0 ; x < arr.length - 1 - 1; x++){
			
			if(arr[x] > arr[ x + 1 ]){
				int temp = arr[x] ;
				arr[x] = arr[ x + 1];
				arr[ x + 1 ] = temp ;
			}
		}
		// 第三次排序
		for(int x = 0 ; x < arr.length - 1 - 2; x++){
			if(arr[x] > arr[ x + 1 ]){
				int temp = arr[x] ;
				arr[x] = arr[ x + 1];
				arr[ x + 1 ] = temp ;
			}
		}
		// 第四次排序
		for(int x = 0 ; x < arr.length - 1 - 3; x++){
			if(arr[x] > arr[ x + 1 ]){
				int temp = arr[x] ;
				arr[x] = arr[ x + 1];
				arr[ x + 1 ] = temp ;
			}
		}	
	}
	/**
	 * 遍历数组的方法
	 */
	public static void print(int[] arr){
		System.out.print("[");
		for(int x = 0 ; x < arr.length ; x++){
			if(x == arr.length - 1){
				System.out.println(arr[x] + "]");
			}else {
				System.out.print(arr[x] + ", ");
			}
		}
	}
}
//优化后的选择排序
public class SelectSortDemo {
	public static void main(String[] args) {	
		// 定义一个数组
		int[] arr = {24, 69, 80, 57, 13} ;
		// 遍历方法
		System.out.print("排序前:	");
		BubbleSortDemo.print(arr) ;
		// 选择排序
		selectSort2(arr) ;
	// 排序后的输出
		System.out.print("排序后:	");
		BubbleSortDemo.print(arr) ;
	}
	/**
	 * 选择排序
	 */
	private static void selectSort2(int[] arr) {
		for(int index = 0 ; index < arr.length - 1 ; index++){
			for(int x = 1 + index ; x < arr.length ; x++){
				if(arr[x] < arr[index]){
					int temp = arr[x] ;
					arr[x] = arr[index] ;
					arr[index] = temp ;
				}
			}
		}	
	}
	/**
	 * 选择排序的推导过程
	 */
	private static void selectSort(int[] arr) {
		// 第一次排序
		// 定义一个int类型的变量
		int index = 0 ;
		// 循环
		for(int x = 1 + index ; x < arr.length ; x++){	
			if(arr[x] < arr[index]){
				int temp = arr[x] ;
				arr[x] = arr[index] ;
				arr[index] = temp ;
			}
		}
		// 第二次排序
		index = 1 ;
		// 循环
		for(int x = 1 + index ; x < arr.length ; x++){
			if(arr[x] < arr[index]){
				int temp = arr[x] ;
				arr[x] = arr[index] ;
				arr[index] = temp ;
			}
		}
		// 第三次排序
		index = 2 ;
		// 循环
		for(int x = 1 + index ; x < arr.length ; x++){
			if(arr[x] < arr[index]){
				int temp = arr[x] ;
				arr[x] = arr[index] ;
				arr[index] = temp ;
			}
		}
		// 第四次排序
		index = 3 ;
		// 循环
		for(int x = 1 + index ; x < arr.length ; x++){
			if(arr[x] < arr[index]){
				int temp = arr[x] ;
				arr[x] = arr[index] ;
				arr[index] = temp ;
			}
		}
	}
}