13-java学习-StringBuffer、StringBuilder、数组常见操作、Arrays、基本数据类型包装类&案例代码

13-java学习-StringBuffer、StringBuilder、数组常见操作、Arrays、基本数据类型包装类&案例代码

目录：

StringBuffer
StringBuilder
数组常见操作
Arrays
基本数据类型包装类

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():返回长度（字符数）。 实际值
	C:案例演示
		构造方法和长度方法的使用

public class cff1 {
    public static void main(String[] args) {
        //字符串：是常量，一旦定义就不能改变了
        String str="abc";  //字符串的长度不可变
        str+="eeee";
        System.out.println(str);
       //创建字符串缓冲区
        StringBuffer sb = new StringBuffer();
        //往容器中追加数据append("abc");返回的还是容器本身
        StringBuffer sb2 = sb.append("abc");
        System.out.println(sb==sb2);
       sb.append("20").append("aaaa").append("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
        String string = sb.toString();
        System.out.println(string);
        //获取容器中数据的实际长度
        int length = sb.length();
        System.out.println(length); 
        int capacity = sb.capacity();
        System.out.println(capacity); //容量
        //可以指定容量
        StringBuffer stringBuffer = new StringBuffer(2000);

        //提前给容器中放入字符串数据
        StringBuffer sb3 = new StringBuffer("你好");
        sb3.append("100").append(true).append(3.4);
        //StringBuffer 重写了toString() 把容器中的数据转换成字符串
        String string1 = sb3.toString();
        System.out.println(string1);
    }
}

3.StringBuffer的添加功能

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

//案例演示:StringBuffer的添加功能
public class cff2 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append("aaa").append("bbb");
        //在指定的位置加入数据，返回的还是字符串缓冲区本身
        StringBuffer sb2 = sb.insert(3, "ccc");
        System.out.println(sb2==sb);
        System.out.println(sb);
        //删除缓冲区的数据
        //根据索引，删除单个字符，返回的还是字符串缓冲区本身
        sb.deleteCharAt(0);
        System.out.println(sb);
        //根据首尾索引，删除缓冲区中的一段数据，返回的还是字符串缓冲区本身
        sb.delete(2, 5);
        System.out.println(sb);
    }
}

4.StringBuffer的删除功能

A:StringBuffer的删除功能
	public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身
	public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身

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 cff3 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("西部开源教育科技有限公司");
        //根据首尾索引，去替换容器中的一段内容，。返回的还是容器本身
        sb.replace(0, 3, "好好学习");
        System.out.println(sb);
        //反转容器中的数据，返回的还是容器本身
        sb.reverse();
        System.out.println(sb);

        //截取容器中的内容
        StringBuffer sb2 = new StringBuffer("西部开源教育科技有限公司");
        //根据首尾索引，截取一部分内容，以字符串形式返回
        String substring = sb2.substring(0,4);
        System.out.println(substring);
        System.out.println(sb2);
    }
}

6.StringBuffer的截取功能及注意事项

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

7.StringBuffer和String的相互转换

A:String -- StringBuffer
	a:通过构造方法
	b:通过append()方法
B:StringBuffer -- String
	a: 使用substring方法
	b:通过构造方法
	c:通过toString()方法
C:案例演示
	StringBuffer和String的相互转换

public class cff4 {
    public static void main(String[] args) {
        //String-- StringBuffer

        String str="abc";  //---->StirngBuffer
        //方式1
        StringBuffer sb = new StringBuffer(str);
        StringBuffer sb2= new StringBuffer().append(str);

       
        //StringBuffer---String
        StringBuffer sb3 = new StringBuffer("abc");
        //方式1
        String string = sb3.toString();
        //方式2
        String s = sb3.substring(0);
     /*   String(StringBuffer buffer)
        分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。*/
        String s1 = new String(sb3);
    }
}

8.把数组转成字符串

案例演示
	需求：把数组中的数据按照指定个格式拼接成一个字符串
		举例：
			int[] arr = {1,2,3};	
		输出结果：
			"[1, 2, 3]"
	用StringBuffer的功能实现

public class cff5 {
    public static void main(String[] args) {
        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 string = sb.toString();
        System.out.println(string);
    }
}

9.字符串反转

案例演示
	需求：把字符串反转
		举例：键盘录入"abc"		
		输出结果："cba"
	用StringBuffer的功能实现	

public class cff6{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一段字符串");
        String s = scanner.nextLine();
        StringBuffer stringBuffer = new StringBuffer(s);
        String string = stringBuffer.reverse().toString();
        System.out.println(string);
    }
}

10.String和StringBuffer分别作为参数传递

A:形式参数问题
	String作为参数传递 String虽然是引用类型,但是它是一个常量,所以在做传递的时候,完全可以将其看成基本数据类型数据进行传递
	StringBuffer作为参数传递 
B:案例演示
	String和StringBuffer分别作为参数传递问题

public class cff7 {
    public static void main(String[] args) {
        String str="爱生活，爱Java";
        test(str);
        System.out.println(str); //爱生活，爱Java
        StringBuffer sb = new StringBuffer("好好学习天天向上");
        test(sb);
        //引用类型，作为参数传递（引用传递，传的是地址值）形参的改变会影响实参
        System.out.println(sb.toString());

    }
    private static void test(StringBuffer sb) {
        sb.reverse();
    }
    private static void test(String str) {
        String substring = str.substring(2);
        System.out.println(substring); //活，爱Java
    }
}

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

//数组高级冒泡排序代码
public class cff1 {
    public static void main(String[] args) {
        //数组排序：对一组序列，进行比较交换，使他变成一个有序的序列
        //排序方式：冒泡排序，选择排序，插入排序，希尔排序，快速排序，归并排序 基数排序，堆排序
        //冒泡排序：数组中的元素，两两比较，把大的元素往后放，经过一轮比较后，最大的元素就会放在最后面
        int[] arr= {24, 69, 80, 57, 13,2,0,1};
       // tuiDao(arr);
        for (int j = 0; j <arr.length-1; j++) {
            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;
            }
        }
        System.out.println(Arrays.toString(arr));

        //第二轮：比较了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;
            }
        }
        System.out.println(Arrays.toString(arr));
        //第三轮：比较了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;
            }
        }
        System.out.println(Arrays.toString(arr));
        //第四轮：比较了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;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

12.数组高级选择排序原理

//选择排序原理:从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处
public class cff2 {
    public static void main(String[] args) {
        //选择排序：从0索引开始，每次拿一个元素，跟后面的每个元素进行比较，把小的往前放，经过一轮比较后，最小的元素就会在最前面。

        int[] arr= {24, 69, 80, 57, 13,20,14,30,100};
        //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) {
        //第一轮
        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;
            }
        }

        System.out.println(Arrays.toString(arr));
        //第一二轮
        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;
            }
        }
        System.out.println(Arrays.toString(arr));

        //第三轮
        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;
            }
        }
        System.out.println(Arrays.toString(arr));

        //第四轮
        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;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

13.二分查找

//二分查找：前提数组元素必须有序  
public class cff3 {
    public static void main(String[] args) {
        int[] arr = {100, 200, 300, 400,500,500,600, 700,700, 800, 900, 1000};
        //二分查找：前提，数组中的元素有序，就可以使用二分查找。如果没有序，你使用基本查找，挨个找
        int index = getIndex(arr, 500);
        System.out.println(index);
    }

    private static int getIndex(int[] arr, int num) {
        //定义三个索引
        int minIndex = 0;
        int maxIndex = arr.length - 1;
        int centIndex = (minIndex + maxIndex) / 2;
        while (minIndex <= maxIndex) {
            if (num == arr[centIndex]) {
                return centIndex;
            } else if (num < arr[centIndex]) {
                maxIndex = centIndex - 1;
            } else if (num > arr[centIndex]) {
                minIndex = centIndex + 1;
            }
            //重新计算中间索引
            centIndex = (minIndex + maxIndex) / 2;
        }
        return -1;
    }
}

14.Arrays类的概述和方法使用

A:Arrays类概述
	针对数组进行操作的工具类。
	提供了排序，查找等功能。
B:成员方法
	public static String toString(int[] a)
	public static void sort(int[] a)
	public static int binarySearch(int[] a,int key)
	static boolean equals(int[] a, int[] a2) 比较两个数组中的元素，是否一样
    static int[] copyOf(int[] original, int newLength)  复制旧数组中的元素到一个新的数组中，新的数组长度是newLength 从0开始复制旧数组
    static int[] copyOfRange(int[] original, int from, int to) 复制旧数组中的指定范围间的几个元素到新数组中	

//通过Arrays类的功能来进排序和查找
public class MyTest2 {
    public static void main(String[] args) {
        int[] arr={50,4,3,8,9,10,25,14,-1,20,20,90,700,1000};
        QuickSortUtils.quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
}

15.基本类型包装类的概述

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

public class MyTest {
    public static void main(String[] args) {
        //Java为了我们更加方便的去操作，这些基本数据类型，针对这些基本数据类型，提供了对应的包装类（引用类型）
        //可以使用包装类，把基本类型，包装成一个引用类型，这样就可以调用方法跟属性，进而对这些基本类型的数据方便的操作
        
        //将100转换成二进制, 八进制, 十六进制
        int num = 100;
        Integer integer = new Integer(num);

        String string = integer.toBinaryString(num);
        System.out.println(string);
        System.out.println(Integer.toHexString(num));
        String string1 = Integer.toOctalString(num);
        System.out.println(string1);
//判断一个数是否在int的范围内
        int maxValue = Integer.MAX_VALUE;
        int minValue = Integer.MIN_VALUE;
        if(2000000>=minValue&& 2000000<=maxValue){
            System.out.println("在Int范围内");
        }
    }
}

16.Integer类的概述和构造方法

A:Integer类概述
	通过JDK提供的API，查看Integer类的说明
	Integer 类在对象中包装了一个基本类型 int 的值,
	该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
	还提供了处理 int 类型时非常有用的其他一些常量和方法
B:构造方法
	public Integer(int value)
	public Integer(String s)
C:案例演示
	使用构造方法创建对象

17.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)

//String和int类型的相互转换
public class cff2 {
    public static void main(String[] args) {
        //int ------------ Integer
        int num=100;
        Integer integer = new Integer(num);
        System.out.println(integer);
        System.out.println("=======================");
        //这个构造，想要一个字面上是数字的字符串
        Integer integer1 = new Integer("20");
        System.out.println(integer1);
    }
}

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

A:JDK5的新特性
	自动装箱：把基本类型转换为包装类类型
	自动拆箱：把包装类类型转换为基本类型
B:案例演示
	JDK5的新特性自动装箱和拆箱

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

//案例演示:JDK5的新特性自动装箱和拆箱
public class cff3 {
    public static void main(String[] args) {
        int a=200;
        //自动装箱
        Integer num=a;
        Integer integer=new Integer(20);
        Integer integer2 = new Integer(120);
        //自动拆箱
        int r=integer+integer2;

        System.out.println(r);
        System.out.println("===========================");
        Integer ii = 100; //自动装箱
        ii += 200; //自动拆箱 自动装箱
    }
}