本文共 13777 字，大约阅读时间需要 45 分钟。

今日学习：

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

StringBuffer类的概述

1. StringBuffer类（线程安全的可变字符序列）
   可以认为是一个字符容器，你可以不断往容器中追加内容。
2. StringBuffer和String的区别
   StringBuffer重写了toString方法，会把它容器中的内容转换成字符串形式。

StringBuffer类的构造方法

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

StringBuffer的添加功能

1. public StringBuffer append(String str)：
   可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身。
   例如 sb.append(“abc”)；
2. public StringBuffer insert(int offset,String str):
   在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身。
   例如 sb.insert(offset:0,str:0000000);

StringBuffer的删除功能

1. public StringBuffer deleteCharAt(int index):
   删除指定位置的字符，并返回本身。
   例如：sb.deletecharAt(0);
2. public StringBuffer delete(int start,int end):
   删除从指定位置开始指定位置结束的内容，并返回本身。
   例如：sb.delete(start:0,end:3);

StringBuffer的替换和反转功能

1. StringBuffer的替换功能

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

2. StringBuffer的反转功能

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

3. 从头查找该字符串，在容器中第一次出现的索引，如果找不到就返回-1:

   int indexOf (String str)

4. 从指定索引处开始查找该字符串第一次出现的索引，如果找不到就返回-1:

   int indexOf (String str,int fromIndex)
   从后往前找
   int lastIndexOf (String str)

   int lastIndexOf (String str,int fromIndex)

StringBuffer的截取功能及注意事项

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

StringBuffer和String的相互转换

1. String – StringBuffer
   (1).通过构造方法
   (2).通过append()方法
2. StringBuffer – String
   (1).使用substring方法
   (2).通过构造方法
   (3).通过toString()方法

小练习1:拼接字符串

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

**代码如下：**	public class Test {
   	    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(']').insert(0,"[");	            }else{
   	                sb.append(arr[i]).append(',');	            }	        }	        System.out.println(sb.toString());	    }	}

小练习2:字符串反转

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

**代码如下：**public class Test {
   	    public static void main(String[] args) {
   	    	        Scanner sc = new Scanner(System.in);	        System.out.println("请输入字符串:");	        String s = sc.nextLine();	        StringBuffer sb = new StringBuffer(s).reverse().toString();	        System.out.println(s1);	        	    }	}

StringBuffer和StringBuilder的特点

StringBuffer（线程安全的可变字符序列，效率低）

String和StringBuffer分别作为参数传递

String作为参数传递 String虽然是引用类型,但是它是一个常量,所以在做传递的时候,完全可以将其看成基本数据类型数据进行传递，String类型输入值传递，StringBuffer作为参数传递。

**代码如下：**public class Test {
       public static void main(String[] args) {
           //引用类型，作为参数传递，形参的改变会影响实参。        //基本类型作为参数传递，形参的改变，不影响实参。        //字符串虽说是引用类型，但是他作为参数传递，属于值传递，跟基本数据类型一致。        String str="hello";        test(str);        System.out.println(str);//2.hello        StringBuilder sb = new StringBuilder("abc");        test(sb);        System.out.println(sb.toString());//3.bbbcba    }    private static void test(StringBuilder sb) {
           sb.append("bbb");        sb.reverse();    }    private static void test(String s) {
           s+="world";        System.out.println(s); //1.helloworld    }}

StringJoiner类

1. StringJoiner(CharSequence delimiter)
   构建了一个字符容器，指定分隔符。
2. StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
   构建了一个字符容器，指定分隔符，前缀，后缀。
3. StringJoiner add(CharSequence newElement)
   增加了一份给 CharSequence值的 StringJoiner价值的下一个元素。

数组排序

1. 原理:通过对数组元素的比较替换移动位置等等，是一个无序序列，变成一个有序序列。
2. 排序方法:排序算法：冒泡排序，选择排序，插入排序，快速排序，归并排序，基数排序，堆排序。

冒泡排序原理图解

原理：相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。

**代码如下：** private static void main(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));	    }	}

冒泡排序优化代码实现

**代码如下：**	public class Test {
   	    public static void main(String []args) {
   	        int []arr={
   13,45,34,23,56,23,14,33};	        for (int i = 0; i < arr.length - 1; i++) {
   	            for (int j = 0; j < arr.length - 1 - i; j++) {
   	                if (arr[j] > arr[j + 1]) {
   	                    int temp = arr[j];	                    arr[j] = arr[j + 1];	                    arr[j + 1] = temp;	                }	            }	        }	        System.out.println(Arrays.toString(arr));	    }	}

选择排序原理图解

原理：从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处。

**代码如下：** private static void main(int[] arr) {
   	        //第一轮：从0索引处开始	        int index = 0;	        for (int i = 0 + 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));	        //第二轮：从1索引处开始	        index = 1;	        for (int i = 0 + index + 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));	        //第三轮：从2索引处开始	        index = 2;	        for (int i = 0 + index + 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));		        //第4轮：从3索引处开始	        index = 3;	        for (int i = 0 + index + 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));	    }	}

选择排序优化代码实现

**代码如下：**public class Test {
       public static void main(String[] args) {
           int arr[]={
   23,12,43,22,13,45,67};        for (int index = 0; index < arr.length-1; index++) {
               for (int i = 1 + index ; i < arr.length; i++) {
                   if(arr[index]>arr[i]){
                   int temp=arr[index];                arr[index]=arr[i];                arr[i]=temp;            }        }    }    System.out.println(Arrays.toString(arr));  }}

直接插入排序概述及代码实现

原理:从1索引处开始,把后面的元素插入到之前的一个有序序列中,使之扔保持有序。

代码如下：1.while循环：public class Test {
       public static void main(String[] args) {
           int arr[]={
   23,12,0,-1,5,6,43,22,13,45,67};        //外层循环控制轮次        for (int i = 1; i < arr.length; i++) {
               //由于i++和原本的j-1共用一个变量会导致冲突，故而将变量i赋给变量j            int j=i;            //由于不能无限次运用j--,故而设定到j=0前为截止            while(j>0&&arr[j]
   
     0; j--) {
                   if (arr[j] < arr[j - 1]) {
                       int temp = arr[j];                    arr[j] = arr[j - 1];                    arr[j - 1] = temp;                }            }        }        System.out.println(Arrays.toString(arr));    }}
   

快速排序概述及代码

原理:"挖坑填数"思想

**代码如下：**public class QuickSort {
       //start 默认是0    //end 是数组长度-1    public void quickSort(int[] arr, int start, int end) {
           if (start < end) {
               //获取分区索引            int index = getIndex(arr, start, end);            //对左右两个分区 再进行同样的步骤 ，即是递归调用            quickSort(arr, start, index - 1);//左半部分            quickSort(arr, index + 1, end);//右半部分        }    }    private int getIndex(int[] arr, int start, int end) {
           int i = start;        int j = end;        //定义基准数        int x = arr[i];        //循环        while (i < j) {
               //从右往左比较            while (i < j && arr[j] >= x) {
                   j--;            }            //从右往左找到比基准数小的数了后，填坑            if (i < j) {
                   //把这个数填到上一个坑位                arr[i] = arr[j];                //让 i++;                i++;            }            //从左往右找            while (i < j && arr[i] < x) {
                   i++;            }            // 找比基准数大的数，找到后填坑            if (i < j) {
                   arr[j] = arr[i];                j--;            }        }        //当上面的循环结束后把基准数填到最后一个坑位，也就一基准数为界，分成了左右两部分        arr[i] = x; //把基准数填进去        return i; //返回基准数所在位置的索引    }}

二分查找

思想(前提数组元素必须有序):每一次都查中间的那个元素，比较大小就能减少一半的元素。

**代码如下：**//底层算法编写public class Test {
       public static void main(String[] args) {
           int arr[]={
   1,2,2,3,4,5,5,6,7,8};        int index=getIndex(arr,4);        System.out.println(index);    }    //二分查找    private static int getIndex(int[] arr, int ele) {
           int minindex = 0;//最小索引        int maxindex = arr.length - 1;//最大索引        int centerindex = (minindex + maxindex) / 2;//中间索引        while (minindex <= maxindex) {
               //假如查找元素小于中间索引,将中间索引-1继续            if (ele < arr[centerindex]) {
                   minindex = centerindex - 1;            }            //假如查找元素大于中间索引,将中间索引+1继续            if (ele > arr[centerindex]) {
                   maxindex = centerindex + 1;            }            //假如查找元素恰好等于中间索引,直接将中间索引输出            else {
                   return centerindex;            }        }        return -1;    }}//调用方法public class Test1 {
       public static void main(String[] args) {
           int arr[]={
   1,2,2,3,4,5,5,6,7,8};        int i=Arrays.binarySearch(arr,4);        System.out.println(i);    }}

Arrays类的概述和方法使用

1. Arrays类概述
   针对数组进行操作的工具类;提供了排序，查找等功能。
2. 成员方法
   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)
   通过指定初始索引和终止索引，从旧数组中拷贝几个元素到新数组中（from是起始索引，to是终止索引，“含头不含尾”）

基本类型包装类的概述

1. 定义：为了对基本数据类型进行更多的操作,更方便的操作,java就针对每一种基本数据类型提供了对应的类类型。
2. 常用操作:用于基本数据类型与字符串之间的转换。
3. 对应方式如下表：

Integer类的概述和构造方法

1. Integer类概述
   Integer 类在对象中包装了一个基本类型 int 的值,该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。
2. 构造方法
   public Integer(int value)
   public Integer(String s) //要个一个字面上是数字的字符串，如果不是就会报错

String和int类型的相互转换

1. int – String
   a:和""进行拼接
   b:public static String valueOf(int i)
   c:int – Integer – String
   d:public static String toString(int i)
2. String – int
   a:String – Integer – intValue();
   b:public static int parseInt(String s)

**代码如下:**	public class MyTest {
   	    public static void main(String[] args) {
   	       // String和int类型的相互转换	        //int---String	        int num=100;	        String str=num+""; //"100"	        String s = String.valueOf(num); //"100"	        //方式3：	        Integer integer = new Integer(num);	        String s1 = integer.toString();		        //String---int  "666" -----  666		        String ss="666";	        //NumberFormatException	        int i = Integer.parseInt(ss); //这个字符串，字面上一定是个数字	        System.out.println(i);		        Integer integer1 = new Integer(ss);	        int i1 = integer1.intValue();	        System.out.println(i1);		    }	}

JDK1.5的新特性:自动装箱和拆箱

1. JDK5的新特性
   自动装箱：把基本类型转换为包装类类型
   自动拆箱：把包装类类型转换为基本类型
2. 注意事项
   在使用时，Integer x = null;代码就会出现NullPointerException。
   建议先判断是否为null，然后再使用。

代码如下：public class Test {
   	    public static void main(String[] args) {
   	        Integer ii = 100; //自动装箱		        ii += 200; //自动拆箱，自动装箱。		        //手动拆装箱。		        int num=100;	        //手动装箱 valueOf(num)	        Integer integer = Integer.valueOf(num);		        //手动拆箱 intValue()	        int i = integer.intValue();	        System.out.println(i);	        int b=20+i;	        System.out.println(b);	    }	}

Integer的面试题

看程序写结果

Integer i1 = new Integer(127);	Integer i2 = new Integer(127);    //Integer类也重写了父类equals()方法，比较的是包装的值是否等	System.out.println(i1 == i2);//false	System.out.println(i1.equals(i2));//true	System.out.println("-----------");	Integer i3 = new Integer(128);	Integer i4 = new Integer(128);	System.out.println(i3 == i4);//false	System.out.println(i3.equals(i4));//true	System.out.println("-----------");	Integer i5 = 128;	Integer i6 = 128;	/*	Integer类也重写了父类toString()方法，把包装的值转换成字符串。	但这里有一个范围（-128-127）若超出这个范围就会导致重新new，从而导致地址值不同。	*/	System.out.println(i5 == i6);//false	System.out.println(i5.equals(i6));//true	System.out.println("-----------");	Integer i7 = 127;	Integer i8 = 127;	System.out.println(i7 == i8);//true	System.out.println(i7.equals(i8));//true

注意：

当我们采用自动装箱 Integer i7 = 127 这种方式 底层调用的是valueOf()来进行装箱的时候，在 valueOf() 方法里面有这个判断，当我们装箱的值大于127 小于 -128 就会创建一个新的Integer对象返回。如果说我们包装的这个值，在 -128 <=值<=127 之间，他会从 IntegerCache 这个内部类中的cache[] 数组中取一个Integer对象返回给你，IntegerCache 他已经提前帮你创建好了 256个Integer对象到这个cache[]中的。

转载地址：https://blog.csdn.net/yzl109zj125/article/details/116596192 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！