13.常见对象（StringBuffer，StringBuilder，数组常见操作（冒泡排序，选择排序，二分查找），Arrays，基本数据类型包装类）

最新推荐文章于 2023-10-30 18:05:38 发布

可儿可爱

最新推荐文章于 2023-10-30 18:05:38 发布

阅读量573

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_62520626/article/details/121274093

版权

1.StringBuffer类的概述

1.StringBuffer类概述
   我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。
   而StringBuffer就可以解决这个问题
   线程安全的可变字符序列
2.简述安全问题
3.StringBuffer和String的区别

2.StringBuffer类的构造方法

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

public class MyTest {
    public static void main(String[] args) {
      //  StringBuffer 就是一长度可变的字符容器，如果你有拼串的需求，可以采用字符容器来拼串。

        /*StringBuffer()
        构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。*/

        StringBuffer sb = new StringBuffer();
        int capacity = sb.capacity();//获取容器的容量
        System.out.println(capacity);

        sb.append("abc啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊");

        System.out.println(capacity);
        //获取容器中字符的长度
        int length = sb.length();
        System.out.println(length);


       /* StringBuffer( int capacity)
        构造一个不带字符，但具有指定初始容量的字符串缓冲区。*/

        StringBuffer stringBuffer = new StringBuffer(100);
        System.out.println(stringBuffer.capacity());

        // StringBuffer(String str)
        // 构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。
        StringBuffer sb2 = new StringBuffer("asdfasfasfasdfasf");


    }
}

3.StringBuffer的添加功能

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

public class MyTest2 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        //往容器中追加内容,返回的还是原来的容器对象。所以我就链式编程，不断的往容器中追加内容。
        sb.append("abc").append(100).append(3.14).append(true).append(new char[]{'a','b','c'});
        //StringBuffer类重写了父类的toSting方法，把容器中的的数据转换成字符串返回。
        String s = sb.toString();
        System.out.println(s);
    }
}

public class MyTest3 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append("abc").append("aaa").append("ccc");
        //根据指定的索引位置进行添加，返回的还是原来的那个容器，所以可以链式编程，不断的添加
        sb.insert(0, "你好呀").insert(3, "好好学习");
        String s = sb.toString();
        System.out.println(s);

    }
}

4.StringBuffer的删除功能

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

public class MyTest4 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append("西部开源教育科技有限公司");
        //deleteCharAt(0) 根据索引，每次删除容器中的一个字符，返回的还是容器本身
        sb.deleteCharAt(0).deleteCharAt(0).deleteCharAt(0).deleteCharAt(0);
        //sb.delete(0, 4); 根据起始索引，和终止索引，删除容器中一段内容，返回的还是容器本身，索引，含头不含尾
        sb.delete(0, 4);
        System.out.println(sb.toString());

    }
}

5.StringBuffer的替换和反转功能

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

从头查找该字符串，在容器中第一次出现的索引，如果找不到就返回-1
   int indexOf (String str)
   从指定索引处开始查找该字符串第一次出现的索引，如果找不到就返回-1
   int indexOf (String str,int fromIndex)

从后往前找
int lastIndexOf (String str)

int lastIndexOf (String str,int fromIndex)

public class MyTest {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("西部开源教育科技有限公司");
        int i = sb.indexOf("西部5555");
        System.out.println(i);
        //根据起始索引和终止索引，替换容器中的一段内容，返回的还是容器本身，索引，含头不含尾。
        sb.replace(0, 4, "好好休息");
        //反转容器中的内容，返回的还是容器本身
        sb.reverse();
        System.out.println(sb);
    }
}

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

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

public class MyTest2 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("西部开源教育科技有限公司");
        //根据起始索引和终止索引，截取容器中的一段内容，以字符串形式返回，索引含头不含尾。
        String s = sb.substring(4, 8);
        System.out.println(s);
        System.out.println(sb);
    }
}

7.StringBuffer和String的相互转换

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

public class MyTest3 {
    public static void main(String[] args) {
       // 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);


        System.out.println("==================================================");
        //StringBuffer---------------String
        StringBuffer sb4 = new StringBuffer();
        sb4.append(100).append(3.14).append(false);
        //方式1
        String s = sb4.toString(); //"1003.14false"
        System.out.println(s);
        //方式2
        String s1 = sb4.substring(0);
        System.out.println(s1);
        //方式3
       /* String(StringBuffer buffer)
        分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。*/

        String s2 = new String(sb4);
        System.out.println(s2);
    }
}

8.把数组转成字符串

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

public class MyTest {
    public static void main(String[] args) {
      /*  A:
        案例演示
        需求：把数组中的数据按照指定个格式拼接成一个字符串
        举例：
        int[] arr = {1, 2, 3};
        输出结果：
        "[1, 2, 3]"*/


        int[] arr = {1, 2, 3,4,5,6};
        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);

    }
}

9.字符串反转

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

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

10.StringBuffer和StringBuilder的区别

1.StringBuilder的概述
通过查看API了解一下StringBuilder类
2.面试题
String,StringBuffer,StringBuilder的区别

public class MyTest3 {
    public static void main(String[] args) {
      /*  A:
        StringBuilder的概述
                通过查看API了解一下StringBuilder类*/

        //  StringBuffer 线程安全的，可变字符序列，但是效率低。
        /*
        *  该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。
        * 如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。
        * */
        // StringBuilder 线程不安全，可变字符序列，但是效率高。

    }
}

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

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

public class MyTest {
    public static void main(String[] args) {
        //参数传递：
        //基本类型，作为参数传递，属于值传递，形参的改变，不影响实参。
        //引用类型，作为参数产地，属于引用传递，传递的是地址值，形参的改变，会响实参。
        //String类型，虽说是引用数据类型，但是他作为参数传递，属于值传递，传递的是字符串的值，形参的改变，不影响实参。

        String str="哈哈";
        test(str);
        System.out.println(str); //2. "哈哈"

        StringBuffer sb = new StringBuffer("哈哈");
        test(sb);
        System.out.println(sb.toString()); //4."呵呵哈哈"

    }

    public static void test(String s1){
        s1+="呵呵";
        System.out.println(s1); //1. 哈哈呵呵
    }
    public static void test(StringBuffer sb){
        sb.append("呵呵");
        sb.reverse();
        System.out.println(sb.toString()); //3. "呵呵哈哈"
    }
}

补充：StringJoiner

StringJoiner(CharSequence delimiter)
构建了一个字符容器，指定分隔符

StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
构建了一个字符容器，指定分隔符，前缀，后缀

StringJoiner add(CharSequence newElement)
增加了一份给 CharSequence值的 StringJoiner价值的下一个元素。
int length()
返回该 StringJoiner的 String表示长度。

String toString() 把容器中的数据以字符串返回

public class MyTest2 {
    public static void main(String[] args) {
        //指定分隔符
        StringJoiner joiner = new StringJoiner("=");

        joiner.add("aaaa").add("bbbb").add("ccc");

        String s = joiner.toString();

        System.out.println(s);

        //构建了一个字符容器，指定分隔符，前缀，后缀
        StringJoiner joiner2 = new StringJoiner(",", "[", "]");

        int[] arr = {1, 2, 3, 4, 5, 6};

        for (int i = 0; i < arr.length; i++) {
            joiner2.add(String.valueOf(arr[i]));
        }
        System.out.println(joiner2.toString());
    }
}

12.数组高级冒泡排序原理图解以及代码实现

1.画图演示
   需求：
       数组元素：{24, 69, 80, 57, 13}
       请对数组元素进行排序。

2.冒泡排序原理
       相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处

public class MyTest {
    public static void main(String[] args) {
        int[] arr= {24, 69, 80, 57, 13,0,2,3,9};
        //数组元素的排序：使数组中的元素变为有序。
        //冒泡排序：数组中的元素两两比较，大的往后放，经过一轮比较，最大的元素就出现在了最后面。
        //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-0; 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));
    }
}

13.数组高级选择排序原理图解以及代码实现

1.画图演示
   需求：
       数组元素：{24, 69, 80, 57, 13}
       请对数组元素进行排序。

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

public class MyTest2 {
    public static void main(String[] args) {
        //选择排序：每次拿一个元素，跟他后面所有的元素挨个比较，小的往前面放，经过一轮比较后，最小的元素就出现在最前面
        int[] arr= {24, 69, 80, 57, 13,20,3,8,9,5};
        //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) {
        //第一轮：从0索引处开始，比较了4次
        int index=0;
        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 = 1;
        //第二轮：从1索引处开始比较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));

        //第三轮：从2索引处开始比较2次
        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));


        //第四轮：从3索引处开始比较1次
        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));
    }
}

14.直接插入排序

public class MyTest {
    public static void main(String[] args) {
        //直接插入排序：从1索引开始，把后面的元素插入之前的有序列表中，使之仍保持有序。
        //3 9 2 8 7 10 1
        //[3] 9 2 8 7 10 1
        //[3,9] 2 8 7 10 1
        // [2,3,9] 8 7 10 1
        // [2,3,8,9] 7 10 1
        // [2,3,7,8,9]  10 1
        // [2,3,7,8,9,10]  1
        // [1,2,3,7,8,9,10]

        int [] arr={3,0,2,8,7,10,1,20,30,-4,8,9};
        //外层循环控制轮次
        for (int i = 1; i < arr.length; i++) {
            //当前元素 arr[i]  前一个元素 arr[i-1]
            int j=i;
            while (j>0&&arr[j]<arr[j-1]){
                int t=arr[j];
                arr[j]=arr[j-1];
                arr[j-1]=t;
                j--;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

public class MyTest2 {
    public static void main(String[] args) {
        int[] arr = {3, 0, 2, 8, 7, 10, 1, 20, 30, -4, 8, 9};
        //外层循环控制轮次
        for (int i = 1; i < arr.length; i++) {
            for(int j=i;j>0;j--){
                if(arr[j]<arr[j-1]){
                    int t = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

15.快速排序

分治法：比大小，再分区
1.从数组中取出一个数，作为基准数。
2.分区：将比这个数大或等于的数全放到他的右边，小于他的数全放到他的左边。
3.再对左右区间重复第二步，直到各区间只有一个数。

挖坑填数
1.将基准数挖出形成第一个坑。
2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。
3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
4.再重复执行2，3两步骤。
例如对 5391672408 进行排序

public class QuickSortUtils {
    /**
     * @param arr   要排序的数组
     * @param start 起始索引
     * @param end   终止索引
     */
    public static 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);
        }
    }
    //挖坑填数
    /*
    *
    *   1.将基准数挖出形成第一个坑。
        2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。
        3. 由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
        4. 再重复执行2，3两步骤。
    * */

    private static int getIndex(int[] arr, int start, int end) {
        //定义变量，接收传过来的的参数
        int i = start;
        int j = end;
        //定义一个基准数
        // 1. 将基准数挖出形成第一个坑。
        int x = arr[i]; //5
        // 2. 由后向前找比他小的数，找到后挖出此数填到前一个坑中。
        // 5 1 9 1 6 7  2  4 2 8
        while (i<j) {
            while (i < j && arr[j] > x) {
                j--;  //找到了比基准数小的这个数的索引
            }
            if (i < j) {
                arr[i] = arr[j];
                i++; //顺便让i递增一下
            }
            //3. 由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
            while (i < j && arr[i] <= x) {
                i++; //找到了比基准数大的这个数的索引
            }
            if (i < j) {
                arr[j] = arr[i];
                j--; //顺便让j递减一下
            }
        }
        //基准数，填的到最后一个坑中
        arr[i] = x;
        return i;
    }
}

public class MyTest {
    public static void main(String[] args) {
        int[] arr={4,8,6,2,12,85,36,14,25,35,52,200,30,68,98,58};

        QuickSortUtils.quickSort(arr,0,arr.length-1);

        System.out.println(Arrays.toString(arr));
    }
}

16.二分查找

1.画图演示
2.二分查找：前提数组元素必须有序
3.二分查找的思想：每一次都查中间索引的那个元素，比较大小就能减少一半的元素。

注意:二分查找不是找该元素第一次出现的索引。
比如下面这个数组，找4元素的索引，找出来的索引是5
int[] arr = {1,2,3,4,4,4,6,7,8,9,10};

基本查询：从头开始挨个往后找该元素第一次出现的索引。

基本查找索引方法：

public class MyTest {
    public static void main(String[] args) {
        int[] arr = {4, 8, 6, 2, 12, 85, 36, 14, 25, 35, 52, 2,200, 30, 68, 12,98, 58};
        //基本查找：根据元素找他第一次出现的索引
        int index=getIndexByEle(arr,129);
        System.out.println(index);
    }
    //基本查找，挨个找，找到就返回
    private static int getIndexByEle(int[] arr, int ele) {
        //int index=-1;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==ele){
                //index=i;
                //break;
                return i;
            }
        }
        //return index;
        return -1;
    }
}

二分法查找索引：

public class MyTest2 {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100}; //100
        //如果数组元素有序的话，我们要找这个元素的索引，可以使用二分查找。
        //二分查找，前提数组元素有序
        int index = getIndexByEle(arr, 140);
        System.out.println(index);
    }

    private static int getIndexByEle(int[] arr, int ele) {
        //定义最小索引，最大索引，中间索引
        int minIndex = 0;
        int maxIndex = arr.length - 1;
        int centerIndex = (minIndex + maxIndex) / 2;
        while (minIndex <= maxIndex) {
            if (ele > arr[centerIndex]) {
                minIndex = centerIndex + 1;
            } else if (ele < arr[centerIndex]) {
                maxIndex = centerIndex - 1;
            } else if (ele == arr[centerIndex]) {
                return centerIndex;
            }
            //重新计算中间索引
            centerIndex = (minIndex + maxIndex) / 2;
        }
        return -1;
    }
}

17.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 终止索引

3.案例演示
   通过Arrays类的功能来进排序和查找

18.Arrays类的源码解析

1.源码解析
public static String toString(int[] a)
2.源码解析
public static int binarySearch(int[] a,int key)

sort和toString方法：

public class MyTest {
    public static void main(String[] args) {
        //Java为了我们更加方便的操作数组，给我们提供了一个工具类 Arrays
        int[] arr = {4, 8, 6, 2, 12, 85, 36, 14, 25, 35, 52, 200, 30, 68, 98, 58};

        Arrays.sort(arr);

        String s = Arrays.toString(arr);

        System.out.println(s);
    }

    public static String toString(int[] a) {
        if (a == null){
            return "null";
        }

        int iMax = a.length - 1;
        if (iMax == -1){
            return "[]";
        }


        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {
            b.append(a[i]);
            if (i == iMax){
                return b.append(']').toString();
            }
            b.append(", ");
        }
    }
}

binarySearch方法：

public class MyTest2 {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100}; //100
        //二分查找，前提数组元素有序
        int index = Arrays.binarySearch(arr, 1000);
        System.out.println(index);
    }

    private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                     int key) {
        int low = fromIndex;
        int high = toIndex - 1;
        while (low <= high) {
            int mid = (low + high) >>> 1;
            int midVal = a[mid];
            if (midVal < key){
                low = mid + 1;
            } else if (midVal > key){
                high = mid - 1;
            } else{
                return mid; // key found
            }
        }
        return -(low + 1);  // key not found.
    }
}

equals方法：

public class MyTest3 {
    public static void main(String[] args) {
       // static boolean equals ( int[] a, int[] a2)比较两个数组中的元素，是否一样
        //比较两个数组中的元素，是否一样
        int[] arr1 = {10, 20, 30, 40};
        int[] arr2 = {10, 20, 30, 40};
       // boolean b = equals(arr1, arr2);
       // System.out.println(b);

        boolean b = Arrays.equals(arr1,arr2);
        System.out.println(b);
    }

   public static boolean equals(int[] a, int[] b){
        if(a==b){
           return true;
        }
       if (a == null ||b == null){
           return false;
       }

       if (a.length!=b.length) {
           return false;
       }
       for (int i = 0; i < a.length; i++) {
           if (a[i]!=b[i]) {
               return false;
           }
       }
       return true;
    }

}

copyof和copyofRange方法：

public class MyTest4 {
    public static void main(String[] args) {
        //static int[] copyOf ( int[] original, int newLength)复制旧数组中的元素到一个新的数组中，新的数组长度是newLength 从0开始复制旧数组
        int[] arr1 = {10, 20, 30,50,90,69, 40};

        int[] newArray = Arrays.copyOf(arr1,2);

        System.out.println(Arrays.toString(newArray));

        System.out.println("==========================");
        //static int[] copyOfRange(int[] original, int from, int to) 复制旧数组中的指定范围间的几个元素到新数组中 from 起始索引 to 终止索引
        int[] ints = Arrays.copyOfRange(arr1, 2, 6); //含头不含尾
        System.out.println(Arrays.toString(ints));
    }
}

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

1.需求:
   a:将100转换成二进制 , 八进制 , 十六进制
   b:判断一个数是否在int的范围内
2.为什么会有基本类型包装类
   为了对基本数据类型进行更多的操作,更方便的操作,java就针对每一种基本数据类型提供了对应的类类型.
3.常用操作:   常用的操作之一：用于基本数据类型与字符串之间的转换。
4.基本类型和包装类的对应
   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) {
       /* A:
        需求:
        a:
        将100转换成二进制, 八进制, 十六进制
        b:
        判断一个数是否在int的范围内*/

       /*
       为了我们使用方便，Java针对我们的8中基本数据类型，都提供了他所对应的包装类型
       基本类型    包装类型
       byte ----- Byte
       short----- Short
       int -------Integer
       long-------Long
       float------ Float
       double----Double
       char------ Character
        boolean----- Boolean
       * */
       int num=100;
        //Integer integer = new Integer(num);
       /* static String toBinaryString ( int i)
        以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。
        static String toHexString ( int i)
        以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。
        static String toOctalString ( int i)
        以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。*/
        String s = Integer.toBinaryString(num);
        String s1 = Integer.toHexString(num);
        String s2 = Integer.toOctalString(num);
        System.out.println(s);
        System.out.println(s1);
        System.out.println(s2);

     /*   static int MAX_VALUE
        值为 231－1 的常量，它表示 int 类型能够表示的最大值。
        static int MIN_VALUE
        值为 －231 的常量，它表示 int 类型能够表示的最小值。
*/
        if(Integer.MIN_VALUE<=55555&&55555<=Integer.MAX_VALUE){

            System.out.println("在Int类型的范围内");
        }


    }
}

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

1.Integer类概述
   通过JDK提供的API，查看Integer类的说明

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

public class MyTest2 {
    public static void main(String[] args) {
       /* Integer( int value)
        构造一个新分配的 Integer 对象，它表示指定的 int 值。
        Integer(String s)
        构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。*/
        int num = 100;
        Integer integer = new Integer(num);
        //Integer 类重写了父类的toString()方法，把他包装的值，转换成了字符串。
        String s = integer.toString();
        System.out.println(s);

        //构造方法要的是 字面上是一个有效数字的字符串 不然就会报 NumberFormatException 异常
        Integer integer1 = new Integer("100");
        System.out.println(integer1);

    }
}

21.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)
3.案例演示
   String和int类型的相互转换

public class MyTest3 {
    public static void main(String[] args) {
        // int======String   100---------"100"
        int num=100; //"100"
        //方式1
        String s=num+"";
        //方式2
        String s1 = String.valueOf(num); //记这个
        //方式3

        String s2 = new Integer(num).toString();

        //String=======int  "100"-----100

        String a="100";
        //方式1
        Integer integer = new Integer(a);
        int i = integer.intValue();
        System.out.println(i);
        //方式2：直接调用Integer类中的静态方法
        int i1 = Integer.parseInt(a); //经常用这个
        System.out.println(i1);

    }
}

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

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

自动拆装箱：

public class MyTest4 {
    public static void main(String[] args) {
        //JDK1.5之后提供的语法
        //自动拆箱：将包装类型自动转换成他所对应的基本类型。
        //自动装箱：将基本类型自动转换成他所对应的包装类型。
        int num=100;
        //Integer integer = new Integer(num);
        Integer a=num; // 自动装箱
        Integer b=20;  // 自动装箱


        Integer x = new Integer(1);

        Integer y = new Integer(2);
        //自动拆箱
        int sum=x+y;
        System.out.println(sum);

    }
}

手动拆装箱：

public class MyTest5 {
    public static void main(String[] args) {
        Integer x = new Integer(1);

        Integer y = new Integer(2);

         //手动拆箱
        int a = x.intValue();
        int b = y.intValue();

        System.out.println(a+b);


        //手动装箱

        Integer integer = Integer.valueOf(100);

        //自动装箱，起始编译后 用的 Integer.valueOf(100); 来装的箱
        Integer u = 100;

    }
}

练习：

public class MyTest6 {
    public static void main(String[] args) {
        Integer ii = 100; //自动装箱
        ii += 200; //自动拆箱，自动装箱。

    }
}

23.Integer的面试题

A:Integer的面试题
   看程序写结果

   Integer i1 = new Integer(127);
   Integer i2 = new Integer(127);
   System.out.println(i1 == i2);//false
  //Integer类，他重写了父类的equals()方法，比较的是他包装的值是否相等。 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;
   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

public class MyTest2 {
    public static void main(String[] args) {
        //自动装箱:底层调用的是  Integer.valueOf(128); 来装的箱
        Integer i5 = 128; // new Integer(128);
        Integer i6 = 128; // new Integer(128);
        System.out.println(i5 == i6); //false
        System.out.println("-----------");
        //自动装箱
        Integer i7 = 127;
        Integer i8 = 127;
        System.out.println(i7 == i8); //true

        /* 自动装箱:底层调用的是  Integer.valueOf(128); 来装的箱
        *
        *  public static Integer valueOf(int i) {
                if (i >= IntegerCache.low && i <= IntegerCache.high){

                  return IntegerCache.cache[i + (-IntegerCache.low)];

                }

                return new Integer(i);
            }
        *  当我们包装的这个值 不在    -128<= 包装的值 <=127 这个范围 就会返回一个新的Integer对象   return new Integer(i);
        *
        *   当我们包装的这个值在    -128<= 包装的值 <=127 范围
        *
        *   Integer类中有一个私有的静态内部类 IntegerCache 他有一个静态代码块，静态代码块里面 会创建一个 Integer[]  cache
        *  会创建256个Integer 对象放到数组中
        * 当我们包装的这个值 在  当我们包装的这个值在    -128<= 包装的值 <=127 范围 就会从  Integer[]  cache 这个数中返回一个Integer对象
        *
        * cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
        *
        * */
    }

}

24.其他数据类型对应得包装类型

double------Double：

public class MyTest {
    public static void main(String[] args) {
         /*
       为了我们使用方便，Java针对我们的8中基本数据类型，都提供了他所对应的包装类型
       基本类型    包装类型
       byte ----- Byte
       short----- Short
       int -------Integer
       long-------Long
       float------ Float
       double----Double
       char------ Character
        boolean----- Boolean
       * */
         double num=3.14; //"3.14"

        Double aDouble = new Double(num);
        String s = aDouble.toString();

        String str="1.36"; //1.36
        double v = Double.parseDouble(str);
        System.out.println(v);

        Double aDouble1 = new Double(str);
        double v1 = aDouble1.doubleValue();

        Double aDouble2 = Double.valueOf("3.145");
        Double aDouble3 = Double.valueOf(3.14);


        Double a=36.9;
    }
}

long-----Long：
boolean-----Boolean：

public class MyTest2 {
    public static void main(String[] args) {
        long num=100L;

        String s = String.valueOf(num);

        String s1 = new Long(num).toString();
        System.out.println(s1);

        long l = Long.parseLong("155555555555555555");

        Long aLong = new Long("55555555555555555555");
        long l1 = aLong.longValue();

        Long num2=2000L;


        String  ss="true"; //true

        Boolean aBoolean = new Boolean(ss);
        boolean b = aBoolean.booleanValue();
        boolean aFalse = Boolean.parseBoolean("false");

        Boolean aBoolean1 = Boolean.valueOf(true);

        Boolean b5=false;


    }
}

char-----character：

public class MyTest3 {
    public static void main(String[] args) {
        //char
       // Character

        char ch='a';

        boolean lowerCase = Character.isLowerCase(ch);
        System.out.println(lowerCase);

        boolean letter = Character.isLetter(ch);
        System.out.println(letter);

        boolean digit = Character.isDigit(ch);
        System.out.println(digit);

        Character.isLetterOrDigit(ch);

        boolean spaceChar = Character.isSpaceChar(ch);
        System.out.println(spaceChar);

    }
}