Java学习第十五天---StringBuffer、StringBulider、数组排序(冒泡排序、选择排序、快速排序、插入排序、希尔排序)、Arrays、基本数据类型包装类

Java学习第十五天—StringBuffer、StringBulider、数组排序(冒泡排序、选择排序、快速排序、直接插入排序、希尔排序)、Arrays、基本数据类型包装类

StringBuffer

1.StringBuffer简述：
	我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。
	而StringBuffer就可以解决这个问题
	线程安全的可变字符序列
	StringBuffer和String的区别：
      StringBuffer  长度可变的字符序列
      String 长度不可变的字符序列  String s="abc"
      StringBuffer()  构造一个其中不带字符的字符串缓冲区  初始容量是16
      StringBuffer  其实可以看做是一个字符容器  可以不断的向这个容器中添加数据
2.StringBuffer的构造方法
	public StringBuffer():				无参构造方法
	public StringBuffer() {
        super(16);
    }
	public StringBuffer(int capacity):	指定容量的字符串缓冲区对象
	public StringBuffer(int capacity) {
        super(capacity);
    }
 	public StringBuffer(String str):		指定字符串内容的字符串缓冲区对象
 	第三个构造方法在计算capacity时与前两个不同，源码如下：
    public StringBuffer(String str) {
        super(str.length() + 16);//字符串长度加上默认容积
        append(str);
    }
3.StringBuffer的方法：
    public int capacity()：返回当前容量。	理论值
    public int length():返回长度（字符数）。 实际值
4.StringBuffer的添加功能
	public StringBuffer append(String str):			可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
	public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
案例演示：
public class MyTest2 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        //获取容量
        int capacity = sb.capacity();
        System.out.println(capacity);
        //获取长度
        int length = sb.length();
        System.out.println(length);

        //往字符串缓冲区中添加内容 如果超过了默认的容量，会自动扩充
        StringBuffer sb2= sb.append("abcasdfasdfasdfasdfasdfasdfasdfasdfasdfasdf");

        int length1 = sb.length();
        System.out.println(length1);
        System.out.println("=====================");

         /*  StringBuffer( int capacity)
        构造一个不带字符，但具有指定初始容量的字符串缓冲区。*/
        StringBuffer sb3 = new StringBuffer(100);
        System.out.println(sb3.capacity());
        sb3.append("abcdef");
        System.out.println(sb3.length());
    }
}
案例演示2:
public class MyTest {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        //往容器中追加内容,返回的还是缓冲区对象本身
        /*StringBuffer sb2 = sb.append("abc");
        System.out.println(sb==sb2);*/
        StringBuffer sb3 = sb.append("abc").append("bbb").append("cccc").append("ddd").append("eeee");
        System.out.println(sb==sb3);

        //取出容器中的内容  容器中的内容会以字符串的形式返回
        //StringBuffer重写了toString()方法，把容器中的内容拼接好以字符串的形式返回。
        String string = sb.toString();
        System.out.println(string);
    }
}
案例演示3：
public class MyTest3 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("aaa");
        sb.append("bbb");
        System.out.println(sb);
        //可以在指定位置插入任何数据，返回的还是字符串缓冲区本身
        sb.insert(0,"cccc");
        System.out.println(sb);
        //在索引3的前面插入数据
        sb.insert(3,"eeee");
        System.out.println(sb);
    }
}
5.StringBuffer的删除功能：
	public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身
	public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身
案例演示：
  public class MyTest1 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("好好学习，天天向上，大家五一快乐");
        //根据索引删除容器中的一个字符，返回的还是容器本身
        sb.deleteCharAt(0).deleteCharAt(0).deleteCharAt(0).deleteCharAt(0);
        System.out.println(sb);
        System.out.println("=====================");
        StringBuffer sb2 = new StringBuffer("好好学习，天天向上，大家五一快乐");
        //根据起始索引和终止索引删除一段内容，返回的还是容器本身
        sb2.delete(0,2);
        System.out.println(sb2);
    }
}
6.字符串的替代和反转功能
 public StringBuffer replace(int start,int end,String str):	从start开始到end用str替换
 public StringBuffer reverse():							字符串反转
 案例：
 public class MyTest2 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("红尘来呀来去呀去，都是一场梦");
        //根据起始索引和终止索引，替换一段内容。返回的还是容器本身
        sb.replace(0,8,"皮皮虾我们走");
        System.out.println(sb);//皮皮虾我们走，都是一场梦

        sb.reverse();
        System.out.println(sb);//梦场一是都，走们我虾皮皮
    }
}
7.字符串角标查找：
  从头查找该字符串，在容器中第一次出现的索引，如果找不到就返回-1
      int indexOf (String str)  
  从指定索引处开始查找该字符串第一次出现的索引，如果找不到就返回-1
   int indexOf (String str,int fromIndex)	
   从后往前找
   int lastIndexOf (String str)
   int lastIndexOf (String str,int fromIndex) 
案例演示：
   public class MyTest4 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("尘红来呀来去呀去，都是一场梦");
        int index = sb.indexOf("来");
        System.out.println(index);//2
    }
}
8.StringBuffer的截取功能
    public String substring(int start):			从指定位置截取到末尾
	public String substring(int start,int end):	截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
	注意:返回值类型不再是StringBuffer本身，而是String类型
案例演示：
public class MyTest3 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("红尘来呀来去呀去，都是一场梦");
        //截取容器中的一段内容，返回的是截取到的字符串
        String s = sb.substring(3);
        System.out.println(s);//呀来去呀去，都是一场梦
        System.out.println("================================");
        //根据起始索引和终止索引，截取一段内容，以String类型返回。不会影响容器中的内容
        String s1 = sb.substring(0, 8);
        System.out.println(s1);//红尘来呀来去呀去
    }
}
9.StringBuffer和String类型的相互转换
 A:String -- StringBuffer
	a:通过构造方法
	b:通过append()方法
 B:StringBuffer -- String
	a: 使用substring方法
	b:通过构造方法
	c:通过toString()方法
案例：
public class MyTest {
    public static void main(String[] args) {
        //StringBuffer类型和String类型的相互转换

        // StringBuffer------>String
        StringBuffer sb = new StringBuffer("abcdef");
        sb.append("12345678");

        //方式1：使用toString()方法
        String string = sb.toString();
        System.out.println(string);

        //方式2：subString(0)
        String s = sb.substring(0);
        System.out.println(s);

        //方式3：可以采用String类中的构造方法
            /*  String(StringBuffer buffer)
        分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。*/
        String s1 = new String(sb);
        System.out.println(s1);

        System.out.println("============================");

        // Stirng----->StringBuffer
        String str="abc";
        //方式1：采用StringBuffer的构造方法
        StringBuffer stringBuffer = new StringBuffer(str);
        System.out.println(stringBuffer);

        //方式2：使用append() insert()方法
        StringBuffer buffer = new StringBuffer();
        buffer.append("");
        buffer.insert(0,str);
        System.out.println(buffer);
    }
}

案例1分析：
 需求：把数组中的数据按照指定个格式拼接成一个字符串
 举例：int[] arr = {1,2,3};	
 输出结果："[1, 2, 3]"
 public class MyTest1 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3,4,5};
        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);
    }
}
案例2分析：
 需求：把字符串反转
 举例：键盘录入"abc"		
 输出结果："cba"
 public class MyTest2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一段字符串");
        String s = sc.nextLine();
     
        String string = new StringBuffer(s).reverse().toString();
        System.out.println(string);
    }
}

StringBuffer和StringBuilder的区别

1.StringBuffer和StringBuilder的区别:
   StringBuffer和StringBuilder的区别
     他们两个的API是相同的。
     区别是:线程安全方面的区别
     StringBuffer是线程安全的，效率低
     StringBuilder　线程不安全的，效率高。多线程环境下，可能会存在线程安全问题

   StringBuilder　一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，
        但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，
        用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，
        建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。

StringBuffer和String分别作为参数传递

1.形式参数问题
	String作为参数传递 String虽然是引用类型,但是它是一个常量,所以在做传递的时候,完全可以将其看成基本数据类型数据进行传递，String类型输入值传递
	StringBuffer作为参数传递 则是作为引用类型传递
案例：
public class MyTest {
    public static void main(String[] args) {
        //引用类型，作为参数传递，属于引用传递，传递的是地址值，形参的改变会影响实参。(String例外，String属于值传递)
        //但是String字符串比较特殊，虽说是String引用类型。但是他作为参数传递，属于值传递。
        String str="abc";
        test(str);
        System.out.println(str);//abc
        System.out.println("=======================");
        //引用类型，作为参数传递，属于引用传递，传递的是地址值，形参的改变会影响实参。
        StringBuffer sb = new StringBuffer("好好学习");
        test(sb);
        System.out.println(sb.toString());//好好学习,天天向上
    }

    private static void test(StringBuffer sb) {
        sb.append(",天天向上");
        System.out.println(sb);
    }

    private static void test(String str) {
        str+="我爱你";
        System.out.println(str);//abc我爱你
    }
}

数组排序之冒泡排序

1.冒泡排序原理：
   数组中的元素两两比较，大的往后放，经过一轮比较后，最大的元素，就出现在了最后面。
2.冒泡排序源代码：
  public class MyTest1 {
    public static void main(String[] args) {
    
        //冒泡排序：数组中的元素两两比较，大的往后放，经过一轮比较后，最大的元素，就出现在了最后面。
        int[] arr = {24, 69, 80, 57, 13, 20, 30, 1, 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));*/
        //外层循环控制轮次
        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 t = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

        private static void tuiDao(int[] arr){
            //第一轮：比较了四次
            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));

            //第二轮：比较三次
            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));
        }
    }

数组排序之选择排序

1.选择排序原理：从0索引处的元素开始，依次跟他后面的元素挨个比较，小的往前放，经过一轮比较后，最小的元素就出现在最前面
案例：
public class MyTest2 {
    public static void main(String[] args) {
        //选择排序：从0索引处的元素开始，依次跟他后面的元素挨个比较，小的往前放，经过一轮比较后，最小的元素就出现在最前面
        int[] arr = {24, 69, 80, 57, 13};
        tuiDao(arr);
        System.out.println("===============");
        for(int index=0;index<arr.length-1;index++){
            for(int i=0+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));

    }

    private static void tuiDao(int[] arr) {
        //第一轮：从角标为0开始
        int index=0;
        for(int i=0+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开始
        index=1;
        for(int i=0+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));

        //第三轮：从角标为2开始
        index=2;
        for(int i=0+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));

        //第四轮：从角标为3开始
        index=3;
        for(int i=0+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.直接插入排序原理：每次拿后面的一个元素，插入到之前的一个有序序列当中，使之仍保持有序.
案例：
public class MyTest3 {
    public static void main(String[] args) {
        //直接插入排序
        //每次拿后面的一个元素，插入到之前的一个有序序列当中，使之任保持有序.
    
        int[] arr = {10, 3, 20, 0, 1,-1,200,50,30,20,15};
        for(int i=0;i<arr.length;i++){
            int j=i;
            while(j>0 && arr[j]<arr[j-1]){
                int temp=arr[j];
                arr[j]=arr[j-1];
                arr[j-1]=temp;
                j--;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

数组排序之快速排序

案例：
public class ArrayUtils {
    //快速排序的方法
    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;
       //找一个数作为基准数
        int x=arr[i];
        //4.  重复2,3步骤
        while(i<j){
            //2.由后向前找比他小的数 找到后挖出此数填到第一个坑中
            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;//i==j   返回基准数所在的位置
    }
}
public class MyTest {
    public static void main(String[] args) {
        int[] arr = {20, 30, 2, 3, 5, 6, 8, 1, 0, 10, -1, 20, 100, 50, 30, 9, 8};
        ArrayUtils.quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
}
  

数组排序值希尔排序

1.希尔排序原理：是对插入排序的一种优化 核心思想是合理选取增量 经过一轮排序之后，会让序列大致有序
  然后不断缩小增量 进行插入排序 直到增量为1  整个排序结束
  直接插入排序 其实是增量为1 的希尔排序
案例：
public class MyTest {
    public static void main(String[] args) {
        //希尔排序：是对插入排序的一种优化 核心思想是合理选取增量 经过一轮排序之后，会让序列大致有序
        //然后不断缩小增量 进行插入排序 直到增量为1  整个排序结束
        //直接插入排序 其实是增量为1 的希尔排序
        int[] arr={46,55,13,42,17,94,5,70,9,5,6,89,50,50,255};
        shellSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void shellSort(int[] arr) {
       for(int h=arr.length/2;h>0;h/=2){
            for(int i=h;i<arr.length;i++){
                for(int j=i;j>h-1;j-=h){
                    if(arr[j]<arr[j-1]){
                        int temp=arr[j];
                        arr[j]=arr[j-1];
                        arr[j-1]=temp;
                    }
                }
            }
        }
        //克努特序列
        //int h=1;
        //h=h*3+1;
        //根据克努特序列选取第一次的增量
       /* int jiange=1;
        while(jiange<=arr.length/3){
            jiange=jiange*3+1;
        }
        for(int h=jiange;h>0;h/=2){
            for(int i=h;i<arr.length;i++){
                for(int j=i;j>h-1;j-=h){
                    if(arr[j]<arr[j-1]){
                        int temp=arr[j];
                        arr[j]=arr[j-1];
                        arr[j-1]=temp;
                    }
                }
            }
        }*/
    }
}

二分法查找

1.二分查找：前提数组元素必须有序   
  二分查找的思想：每一次都查中间的那个元素，比较大小就能减少一半的元素。
案例：
 public class MyTest2 {
    public static void main(String[] args) {
        //二分查找：前提是数组元素有序
        int[] arr = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
        //C:二分查找的思想：每一次都查中间的那个元素，比较大小就能减少一半的元素。
        int index=getIndex(arr,20);
        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) {
            //如果我们要找的元素，正好等于中间索引所对应的元素，那就直接返回中间索引
            if (ele == arr[centerIndex]) {
                return centerIndex;
                //如果我们找的元素小于中间索引所对应的元素，我们就移动最大索引
            } else if (ele < arr[centerIndex]) {
                maxIndex = centerIndex - 1;
                //如果我们要找的元素大于中间索引所对应的元素，我们就移动最小索引
            } else if (ele > arr[centerIndex]) {
                minIndex = centerIndex + 1;
            }
            //再次计算中间索引
            centerIndex = (minIndex + maxIndex) / 2;
        }
        return -1;
    }
}

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) 复制旧数组中的指定范围间的几个元素到新数组中
 案例1：
 public class MyTest2 {
    public static void main(String[] args) {
        //排序数组
        //public static void sort ( int[] a)
        int[] arr = {6,9,20, 30, 50, 2, 6, 0, 1, 4};
        Arrays.sort(arr);//升序排列  从小到大
        System.out.println(Arrays.toString(arr));
        //指定一段范围内的元素来进行排序
       /* Arrays.sort(arr,5,arr.length-1);
        System.out.println(Arrays.toString(arr));*/
        System.out.println("======================");
        Integer[] arr2 = {6, 9, 20, 30, 50, 2, 6, 0, 1, 4};
        Arrays.sort(arr2, new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b) {
                //a-b是升序  b-a是降序
                return b-a;
            }
        });
        System.out.println(Arrays.toString(arr2));
    }
}
案例2：
public class MyTest2 {
    public static void main(String[] args) {
        //排序数组
        //public static void sort ( int[] a)
        int[] arr = {6,9,20, 30, 50, 2, 6, 0, 1, 4};
        Arrays.sort(arr);//升序排列  从小到大
        System.out.println(Arrays.toString(arr));
        //指定一段范围内的元素来进行排序
       /* Arrays.sort(arr,5,arr.length-1);
        System.out.println(Arrays.toString(arr));*/
        System.out.println("======================");
        Integer[] arr2 = {6, 9, 20, 30, 50, 2, 6, 0, 1, 4};
        Arrays.sort(arr2, new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b) {
                //a-b是升序  b-a是降序
                return b-a;
            }
        });
        System.out.println(Arrays.toString(arr2));
    }
}
案例3：
public class MyTest4 {
    public static void main(String[] args) {
        int[] arr = {20, 25, 30, 70, 80, 90, 90, 100};
        int[] arr2 = {20, 25, 30, 70, 80, 90, 90,1000};
        //判断两个数组中的元素是否一样
        boolean b = Arrays.equals(arr, arr2);
        System.out.println(b);

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

            int length = a.length;
            if (a2.length != length)
                return false;

            for (int i = 0; i < length; i++)
                if (a[i] != a2[i])
                    return false;

            return true;
        }*/      
    }
}
案例4：
public class MyTest5 {
    public static void main(String[] args) {
          /*  static int[] copyOf ( int[] original, int newLength)
        复制旧数组中的元素到一个新的数组中，新的数组长度是newLength 从0开始复制旧数组*/
        int[] arr = {20, 25, 30, 70, 80, 90, 90, 100};
        //复制旧数组中的几个元素到新数组中
        int[] ints = Arrays.copyOf(arr, arr.length-3);
        System.out.println(Arrays.toString(ints));//[20, 25, 30, 70, 80]

        System.out.println("=========================");
        /*  static int[] copyOfRange ( int[] original, int from, int to)复制旧数组中的指定范围间的几个元素到新数组中*/
        // 2 起始索引  6 终止索引
        int[] ints1 = Arrays.copyOfRange(arr, 2, 6);
        System.out.println(Arrays.toString(ints1));//[30, 70, 80, 90]
    }
}

Integer类

1.基本类型包装类：为了对基本数据类型进行更多的操作,更方便的操作,java就针对每一种基本数据类型提供了对应的类类型.
  常用的操作之一：用于基本数据类型与字符串之间的转换。
  基本类型和包装类的对应：
              基本类型---------------包装类型（引用类型）
         *    byte                  Byte
         *    short                 Short
         *    int                   Integer
         *    long                  Long
         *    float                 Float
         *    double                Double
         *    char                  Character
         *    boolean                Boolean
2.Integer类的概述和构造方法
  Integer类的概述：Integer 类在对象中包装了一个基本类型 int 的值,
	该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
	还提供了处理 int 类型时非常有用的其他一些常量和方法
  Integer类的构造方法：
    public Integer(int value)
	public Integer(String s)  //要个一个字面上是数字的字符串，如果不是就会报错
案例：
public class MyTest2 {
    public static void main(String[] args) {
        //Integer
     /* Integer( int value)
        构造一个新分配的 Integer 对象，它表示指定的 int 值。
        Integer(String s)
        构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。*/

        //把一个基本类型构造成其对应的包装类
        int num=100;
        Integer integer = new Integer(num);
        System.out.println(integer);

        // NumberFormatException: 数字格式化异常
        String str="153698";
        //可以传字符串类型，但是这个字符串，字面上要是一个有效数字,会自动转换
        //如果说，你传入的这个字符串。字面上不是一个有效的数字，就会报异常。
        Integer integer1 = new Integer(str);
        System.out.println(integer1);

    }
}
3.String和int类型的相互转换
  A:int -- String
	a:和""进行拼接
	b:public static String valueOf(int i)  String类中的静态方法 valueOf
	直接用String类调用 String.valueOf(num)
	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)
案例：
  public class MyTest {
    public static void main(String[] args) {
        //String类型的数字 h和int类型的相互转化
        //int-->String
        int num=100;

        //方式1：拼接空串
        String s=num+"";
        System.out.println(s);//"100"
        
        //方式2：String类中的静态方法 valueOf
        String s1 = String.valueOf(num);
        System.out.println(s1);

        //方式3：
        Integer integer = new Integer(num);
        String string = integer.toString();
        System.out.println(string);

        System.out.println("======================");

        //String-->int
        //方式1：
        String ss="100";
        Integer integer1 = new Integer(ss);
        int i = integer1.intValue();
        System.out.println(i);

        //方式2：Integer中的静态方法
        //NumberFormatException 你传入给parseInt()方法的参数，字面上不是一个有效的数字，会报异常。
        int i1 = Integer.parseInt("5000");
        System.out.println(i1);
    }
}
4.JDK5的新特性自动装箱和自动拆箱
    自动装箱：把基本类型转换为包装类类型
	自动拆箱：把包装类类型转换为基本类型
	
	Integer ii = 100;//自动装箱
	ii += 200;//自动拆箱 自动装箱
注：在使用时，Integer  x = null;代码就会出现NullPointerException。
	建议先判断是否为null，然后再使用。
案例：
public class MyTest1 {
    public static void main(String[] args) {
        //自动拆装箱：JDK1.5之后，引入的一个新特性
        //自动拆箱：将一个包装类型自动转换成他所对应的基本类型。
        //自动装箱：将一个基本数据类型自动转换成他所对应的包装类型。
        int num=100;
        Integer integer = new Integer(num);
        //自动装箱
        Integer integer1=num;
        Integer integer2=200;

        //自动拆箱
        Integer a = new Integer(2000);
        // 将引用类型a 自动拆箱成基本类型 3000
        int r=a+2;
        System.out.println(r);
    }
}

面试题：
 public class MyTest1 {
    public static void main(String[] args) {
        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);

        System.out.println(i1 == i2); //false
        //Integer这个类，重写了父类Object的equals()方法，比较的是两个值是否相同
        System.out.println(i1.equals(i2)); //true 127==127
        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 128==128
        System.out.println("-----------");
        //自动装箱
        Integer i5 = 128; //new Integer(128)
        Integer i6 = 128; //new Integer(128)
        System.out.println(i5 == i6); //false
        System.out.println(i5.equals(i6)); //true 128==128
        System.out.println("-----------");
        //自动装箱
        Integer i7 = 127;
        Integer i8 = 127;
        System.out.println(i7 == i8); //true
        System.out.println(i7.equals(i8)); //127==127 true
    }
}
 自动装箱 在内部会调用 Integer.valueOf(128) 装箱
 在Integer类里面有一个静态的内部类IntegerCache他有一个静态代码块，当Integer类一加载，静态的的内部类IntegerCache也加载，IntegerCache他里面的静态代码块也得加载。静态代码块里面会有一个Integer cache[];这个数组
  这个数组里面，放的就是一些提前创建好的Interge对象。
  当我们采用 Integer i7 = 127;这种方式定义一个Integer对象时，如果值在 -128到127 之前，他会从cache[]数组中返回一个对象给你
  所以，在自动装箱时，当装入的数值在-128~+127之间时，所对应的的Integer对象的地址值相同，当超过这个范围时，会新new一个对象，此时，地址值就不再相同了。