Day13JavaSE——StringBuffer&数组常见操作&Arrays类&基本数据类型包装类

Day13JavaSE——StringBuffer&数组常见操作&Arrays类&基本数据类型包装类

StringBuffer&StringBuilder

概述

我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuffer就可以解决这个问题

public class Demo1 {
    public static void main(String[] args) {
        //我们如果对字符串进行拼接操作，每次拼接
        //都会构建一个新的String对象，既耗时，又浪费空间。
        String s="aaa";
        String s1="bbb";
        String s2="ccc";
        System.out.println(s + s1 + s2);
        System.out.println("==============================");
        //这种拼接编译器会优化，最后只构建一个对象
        String s3="aaa"+"bbb"+"ccc";
        System.out.println(s3);
    }
}

StringBuffer的方法

StringBuffer常用的功能

StringBuffer的添加功能

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

public class Test {
    public static void main(String[] args) {
        /*往容器中添加内容，返回的还是容器本身*/
        StringBuffer sb = new StringBuffer();
        StringBuffer sb1=sb.append("aksjdhc;ja").append(54554).append("dwaecasdcasfv");
        System.out.println(sb==sb1);

        //取出容器中的内容，容器中的内容会以字符串的形式返回
        //StringBuffer重写了toString()方法，把容器中的内容拼接好以字符串的形式返回
        String s = sb.toString();
        System.out.println(s);
        //默认调用toString方法
        System.out.println(sb);
    }
}

public class Test {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        //append()方法往容器中添加数据，可以把任意类型添加到容器中
        sb.append("rtgbsrgbs").append(01531341354).append(3.141592654).append(false);
        //最后你可以调用toString方法，把容器中的数据以字符串形式返回
        String s = sb.toString();
        System.out.println(s);
        System.out.println(sb);
    }
}

public class Test2 {
    public static void main(String[] args) {
        /*public StringBuffer(String str):
            指定字符串内容的字符串缓冲区对象
            构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容*/
        StringBuffer sb = new StringBuffer("abc");
        StringBuffer sb2 = sb.append("eeeee");
        StringBuffer sb3 = sb.append("hhhh");
        StringBuffer sb4 = sb.append("yyyyy");
        StringBuffer sb5 = sb.append("cccc");
        System.out.println(sb.toString());

        System.out.println(sb==sb2);
        System.out.println(sb2==sb3);
        System.out.println(sb4==sb5);
        System.out.println(sb3==sb4);

        //采用链式编程
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("eee").append("eeeee").append("ddddd");
        String string = stringBuffer.toString();
        System.out.println(string);
    }
}

StringBuffer的删除功能

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

public class Test {
    public static void main(String[] args) {
        System.out.println("==========StringBuffer的删除功能===========");
        StringBuffer sb = new StringBuffer("我是一个么的感情的恰饭机器,23333333");
        System.out.println("=======删除指定位置的字符，并返回本身=========");
        //public StringBuffer deleteCharAt(int index)
        //删除指定位置的字符，并返回本身
System.out.println(sb.deleteCharAt(0).deleteCharAt(0).deleteCharAt(0).deleteCharAt(0));
        //public StringBuffer delete(int start,int end)
        //删除从指定位置开始指定位置结束的内容，并返回本身
        System.out.println("=删除从指定位置开始指定位置结束的内容，并返回本身=");
        sb.delete(1,5);//含头不含尾，删除了从1-4的字符
        System.out.println(sb);
    }
}

StringBuffer的替换和反转功能

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

public class Test2 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("我是一个么的感情的恰饭机器,23333333");
        System.out.println("==========StringBuffer的替换功能==========");
        //根据起始索引和终止索引，替换一段内容。返回的还是容器本身
        System.out.println(sb.replace(3, 7, "5555555"));
        System.out.println("==========StringBuffer的反转功能==========");
        //反转容器中的数据,返回的还是容器本身
        System.out.println(sb.reverse());
    }
}

StringBuffer的索引功能

从前索引
	int indexOf(String str) 
 	int indexOf(String str, int fromIndex) 
E：从后开始索引
	int lastIndexOf(String str)
	int lastIndexOf(String str, int fromIndex)

public class Test4 {
    public static void main(String[] args) {
        //从头查找该字符串，在容器中第一次出现的索引，如果找不到就返回-1
        //  int indexOf (String str)
        //从指定索引处开始查找该字符串第一次出现的索引，如果找不到就返回-1
        //  int indexOf (String str,int fromIndex)

        /*int lastIndexOf (String str)

        int lastIndexOf (String str,int fromIndex)*/
        StringBuffer sb = new StringBuffer("我是一个么的感情个的恰饭机器,23333333");
        int index1=sb.indexOf("个");
        int index2=sb.indexOf("个",index1+1);
        System.out.println("数组中第一个‘个’字的索引是"+index1);
        System.out.println("数组中第二个‘个’字的索引是"+index2);
    }
}

StringBuffer的截取功能及注意事项

public class Test3 {
    public static void main(String[] args) {
        System.out.println("=======StringBuffer的截取功能========");
        StringBuffer sb = new StringBuffer("我是一个么的感情的恰饭机器,23333333");
        //截取容器中的一段内容，返回的是截取到的字符串
        //从3索引处，截取到末尾
        System.out.println(sb.substring(3));
        //根据起始索引和终止索引，截取一段内容，以String类型返回。不会影响，容器中的内容
        System.out.println(sb.substring(2, 8));
        System.out.println(sb);
    }
}

StringBuffer和String的相互转换

A:String -- StringBuffer
	a:通过构造方法
	b:通过append()方法
B:StringBuffer -- String
	a: 使用substring方法
	b:通过构造方法
	c:通过toString()方法

public class Test1 {
    public static void main(String[] args) {
        System.out.println("======StringBuffer和String的相互转换=====");
        System.out.println("========StringBuffer----->String=======");
        StringBuffer sb = new StringBuffer("1234895");
        sb.append("abcdefg");
        System.out.println(sb);
        System.out.println("==========方式1：使用toString方法========");
        String str=sb.toString();
        System.out.println(str);

        System.out.println("===========方式2：截取，从0截取到尾========");
        String str1 = sb.substring(0);
        System.out.println(str1);

        System.out.println("=========方式3：；用String的构造方法=======");
        String s = new String(sb);
        System.out.println(s);

        System.out.println("========String----->StringBuffer========");
        System.out.println("=====方式1：采用StringBuffer的构造方法=====");
        String str2="我是一个么的感情的恰饭机器,23333333";
        StringBuffer sb2 = new StringBuffer(str2);
        System.out.println("==方式2：方式2：使用append() insert()方法==");
        StringBuffer sb3 = new StringBuffer();
        sb3.append(str);
        sb3.insert(0,str);
    }
}

案例演示

把数组转成字符串

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

public class Test {
    public static void main(String[] args) {
        /*A:案例演示
           需求：把数组中的数据按照指定个格式拼接成一个字符串
          举例：
         int[] arr = {1,2,3};
          输出结果：
         "[1, 2, 3]"
           用StringBuffer的功能实现*/
        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(",");
            }
        }
        System.out.println(sb);
    }
}

字符串反转

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

public class Test2 {
    public static void main(String[] args) {
        /*A:案例演示
           需求：把字符串反转
          举例：键盘录入"abc"
          输出结果："cba"
           用StringBuffer的功能实现 */
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入字符串");
        String s = sc.nextLine();
        String sb = new StringBuffer(s).reverse().toString();
        System.out.println(sb);
    }
}

StringBuffer和StringBuilder的区别

会出面试题

StringBuffer和StringBuilder的区别
        * 他们两个的API是一样的
        * 区别是：线程安全方面的区别
        * StringBuffer是线程安全的，效率低
        * StringBuilder线程不安全，效率高。
        * 在单线程环境下，StringBuilder的实现功能大部分比StringBuffer要快。
        * 多线程环境下 StringBuilder会产生线程安全问题
StringBuilder　一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，
        但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，
        用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，
        建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快

public class Test {
    public static void main(String[] args) {
        //引用类型作为参数传递，传递的是地址值，形参的改变会影响实参（String例外）
        //但是字符串比较特殊，虽说String是引用类型，但是他作为参数传递，属于值传递
        String str="abc";
        test(str);
        System.out.println(str);//2、abc
    }
    private static void test(String str){
        str+="I love you";
        System.out.println(str);//1、abcI love you
    }
}

数组的常见操作

数组排序：把一个无需序列，通过比较交换等手段，使其变成了一个有序序列
排序方法：冒泡排序、选择排序、插入排序、快速排序、归并排序、基数排序、堆排序等

冒泡排序

public class Test {
    public static void main(String[] args) {
        //数组排序：把一个无需序列，通过比较交换等手段，使其变成了一个有序序列
        //排序方法：冒泡排序、选择排序、插入排序、快速排序、归并排序、基数排序、堆排序等
        System.out.println("=============冒泡排序===============");
        //数组中的元素两两比较，大的往后放，经过一轮比较后，最大的元素就出现在了最后面
        int[] arr = {24, 69, 80, 57, 13};
        fun(arr);
        //时间复杂度N*N
        for (int j = 0; j < 4; j++) {
            for (int i = 1; i < arr.length; i++) {
                if (arr[i - 1] > arr[i]) {
                    int t = arr[i - 1];
                    arr[i - 1] = arr[i];
                    arr[i] = t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

    //把一块代码抽取为函数，ctrl+alt+m
    //用循环嵌套，但是要注意空间复杂度
    private static void fun(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            if (arr[i - 1] > arr[i]) {
                int t = arr[i - 1];
                arr[i - 1] = arr[i];
                arr[i] = t;
            }
        }
        System.out.println(Arrays.toString(arr));

        for (int i = 1; i < arr.length - 1; i++) {
            if (arr[i - 1] > arr[i]) {
                int t = arr[i - 1];
                arr[i - 1] = arr[i];
                arr[i] = t;
            }
        }
        System.out.println(Arrays.toString(arr));

        for (int i = 1; i < arr.length - 2; i++) {
            if (arr[i - 1] > arr[i]) {
                int t = arr[i - 1];
                arr[i - 1] = arr[i];
                arr[i] = t;
            }
        }
        System.out.println(Arrays.toString(arr));

        for (int i = 1; i < arr.length - 3; i++) {
            if (arr[i - 1] > arr[i]) {
                int t = arr[i - 1];
                arr[i - 1] = arr[i];
                arr[i] = t;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

选择排序

public class Test2 {
    public static void main(String[] args) {
        System.out.println("=============选择排序===============");
        //从0索引处元素开始，依次跟他后面的元素挨个比较，小的往前放，经过一轮比较，最小的就出现在最前面
        int[] arr={24, 69, 80, 57, 13};

        for (int i = 0; i < arr.length-1; i++) {
            for(int j=i+1;j<arr.length;j++)
            if(arr[i]>arr[j]){
                int t=arr[i];
                arr[i]=arr[j];
                arr[j]=t;
            }
            System.out.println(Arrays.toString(arr));
        }
        System.out.println(Arrays.toString(arr));
    }
}

直接插入排序

public class Test3 {
    public static void main(String[] args) {
        System.out.println("=============直接插入排序===============");
        //每次拿后面的一个元素，与前面所有的元素比较，无序则交换位置，使之仍保持有序
        //[2,3,9,9,6]此为无序序列，由小到大排列是为有序
        //[2]若序列中只有一个元素，就是有序序列
        int[] arr = {2, 7, 1, 8, 3, 6};
        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));
    }
}

快速排序

public class Test4 {
    public static void main(String[] args) {
        System.out.println("=============快速排序===============");
        /*1、从数组中取出一个数，作为基准数
        * 2、分区：将比这个数大或等于的数都方到他的右边，比他小的数都放到他的左边
        * 3、分区重复以上操作*/
        /*实现思路：挖坑填数
            从另一端寻找交换
        * 1、将基准数挖出形成第一个坑
        * 2、由后向前找比他小的数，将这个数填入前一个坑中
        * 3、再从前向后找，找到比他大的数，将这个数填入前一个坑中
        * 4、重复执行以上2、3步。
        *    …………………………*/
        int[] arr={2,7,1,8,3,6,54,46,8,45,3,68,76,84};
        ArrUtils.quickSort(0,arr.length-1,arr);
        System.out.println(Arrays.toString(arr));
    }
}

public class ArrUtils {
    /**
     * @param arr   待排序数组
     * @param start 起始索引
     * @param end   终止索引
     */
    //快速排序方法
    public static void quickSort(int start, int end, int arr[]) {
        if(start<end){
            //递归，不断分区，不断获取基数的索引，得到分区的界限（此处的分区数>=2）
            int index=getIndex(start,end,arr);
            //分区界限索引得到，对分区进行递归
            //对界限左边递归
            quickSort(start,index-1,arr);
            //对界限右边递归
            quickSort(index+1,end,arr);
        }
    }

    private static int getIndex(int start, int end, int[] arr) {
        //寻找基准数的索引位置
        int i = start;
        int j = end;
        //1、找一个数作为基准数，并将基准数挖出来
        int x = arr[i];

        //4、重复2，3两步
        while (i < j) {
            //2、由后向前找比基准数小的数，将这个数填入前一个坑中
            /************************************************************************
             * 这里不直接将if语句放在while中寻找小值是为了考虑代码的时间复杂度
             * 在考虑其他算法时，当正向考虑需要用到嵌套时
             * 不妨用while考虑为false时去执行下一段代码
             否则为真就不停执行while里面的代码
             * 尽量少用到嵌套   *************************************************************************/
            while (i<j&&arr[j] >= x) {
                j--;
            }//跳出这个循环，就是找到了比基数大的数
            //找到之后挖坑填数
            if (i < j) {
                arr[i] = arr[j];//此时索引i处的值已经小于基数
                //下一步是找比基数大的数可以不管i索引处的值，从i的下一个开始考虑
                i++;
            }

            //接着从前向后大于等于基数的数
            while(i<j&&arr[i]<x){
                i++;
            }//出了这个循环就是找到了大于等于基数的索引值i
            //上一步找最小值的时候就把索引j处的值挖出给了基准值所在的位置
            //现在将索引值填入j索引处
            if(i<j){
                arr[j]=arr[i];
                j--;
            }
        }
        //将基准值填入最后一个坑中
        arr[i]=x;
        return i;//i==j,返回基数所在位置
    }
}

二分查找

每次都找中间的数比大小

前提数组元素必须有序

public class Test6 {
    public static void main(String[] args) {
        System.out.println("==查找输入元素在数组中第一次出现的索引===");
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要索引的整数");
        int s = sc.nextInt();
        System.out.println("===============基本查找===============");
        int[] arr = {2, 7, 1, 8, 3, 6, 54, 46, 8, 45, 3, 68, 76, 84};
        System.out.println(arr[getIndex(arr, s)] + "的索引值为" + getIndex(arr, s));
        System.out.println("==============二分查找================");
        //元素必须有序,先排序，再查找
        GetSort.quickSort(0, arr.length - 1, arr);
        System.out.println(Arrays.toString(arr));
        //二分查找的思想：每一次都查中间的那个元素，比较大小就能减少一半的元素
        System.out.println(getIndex2(arr, s));
    }

    private static int getIndex2(int[] arr, int ele) {
        //定义最小索引
        int minIndex = 0;
        //定义最大索引
        int maxIndex = arr.length - 1;
        //计算中间索引
        int mediaIndex = (minIndex + maxIndex) / 2;
        //比大小
        while (minIndex <= maxIndex) {
            //如果我们要找的索引正好等于中间索引所对应的元素，就直接返回中建索引
            if (arr[mediaIndex] == ele) {
                return mediaIndex;
            } else if (ele < arr[mediaIndex]) {
                maxIndex=mediaIndex-1;
            } else if (ele>arr[mediaIndex]) {
                minIndex=mediaIndex+1;
            }
            mediaIndex=(minIndex + maxIndex)/2;
        }
        return -1;
    }

    private static int getIndex(int[] arr, int inPut) {
        int index = 0;
        for (int i = 0; i < arr.length; i++) {
            if (inPut == arr[i]) {
                index = i;
                break;
            } else {
                index = -1;
            }
        }
        return index;
    }
}

//快速排序
class GetSort {
    public static void quickSort(int start, int end, int[] arr) {
        if (start < end) {
            int index = getIndex(start, end, arr);
            quickSort(start, index - 1, arr);
            quickSort(index + 1, end, arr);
        }
    }

    private static int getIndex(int start, int end, int[] arr) {
        int x = arr[start];
        while (start < end) {
            while (start < end && arr[end] >= x) {
                end--;
            }
            if (start < end) {
                arr[start] = arr[end];
                start++;
            }
            while (start < end && arr[start] < x) {
                start++;
            }
            if (start < end) {
                arr[end] = arr[start];
                end++;
            }
        }
        arr[start] = x;
        return start;
    }
}

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)
    复制旧数组中的指定范围间的几个元素到新数组中

public class Test2 {
    public static void main(String[] args) {
        int[] arr={2,7,1,8,3,6,54,46,8,45,3,68,76,84};
        int[] arr2={2,7,1,8,3,6,54,46,8,45,3,68,76,84};
        System.out.println("============打印数组============");
        //public static String toString(int[] a)
        System.out.println(Arrays.toString(arr));
        System.out.println("============排序数组============");
        //public static void sort(int[] a)
        Arrays.sort(arr);
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arr2));

        System.out.println("============二分查找============");
        //数组必须有序
        //public static int binarySearch(int[] a,int key)
        int index = Arrays.binarySearch(arr,8);
        System.out.println(index);

        System.out.println("==比较两个数组中的元素，是否一样==");
        //static boolean equals(int[] a, int[] a2)
        System.out.println(Arrays.equals(arr, arr2));

        System.out.println("============复制数组============");
        //static int[] copyOf(int[] original, int newLength)
        // 复制旧数组中的元素到一个新的数组中，新的数组长度是newLength 从0开始复制旧数组
        System.out.println(Arrays.toString(Arrays.copyOf(arr, 8)));
        //static int[] copyOfRange(int[] original, int from, int to)
        //复制旧数组中的指定范围间的几个元素到新数组中
        System.out.println(Arrays.toString(Arrays.copyOfRange(arr, 2, 8)));
    }
}

基本数据类型包装类

概述

为了使基本数据类型之间，基本数据类型与引用类型之间，基本数据类型与二进制，八进制、十六进制之间的转换更加的简便，Java将基本数据类型进行了包装

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 Test1 {
    public static void main(String[] args) {
        /*****************************************
        *   A: 需求:
        *   a:将100转换成二进制 , 八进制 , 十六进制
        *   b:判断一个数是否在int的范围内
        *   用于基本数据类型与字符串之间的转换。
        *
        *   基本类型和包装类的对应
        *   byte			Byte
        *   short			Short
        *   int				Integer
        *   long			Long
        *   float			Float
        *   double			Double
        *   char			Character
        *   boolean		    Boolean
        *
        *   他们都是Number类的子类
         *   所有的包装类的构造方法作用都差不多
         *   只有两个构造方法，都会返回一个输入参数类型的对象
         *   所有类型的包装类都会有
         *   valueOf方法--->返回输入参数的对应基本类型数据的包装类实例
         *   toString方法--->无参：返回包装类的String对象
         *   有参：返回输入基本数据类型参数的String对象
         *   parseXXX方法--->将字符串参数解析为包装类对应的基本数据类型的有符号表示
         *   equals方法--->重写了Object类的equals，比较内容
         *   getXXX方法--->确定具有指定名称的系统属性的 long 值
         *   XXXValue方法--->以XXX形式返回包装类的值
        * *******************************************/
        System.out.println("============Integer============");
        /********************************************
         * 构造方法
         * public Integer(int value)
         *
         * public Integer(String s)
         * 要一个字面上是数字的字符串，如果不是就会报错
         * *******************************************/
        System.out.println("=================构造方法==================");
        //public Integer(int value)--->创建一个Integer对象
        //并给Integer类中的成员变量value赋值num
        int num=100;
        Integer integer = new Integer(num);
        //public Integer(String s)
        //要一个字面上是数字的字符串，如果不是就会报错
        String str="100";
        Integer integer1 = new Integer(str);
        int i = integer1.intValue();
        System.out.println(i);
    }
}

Integer为例说明构造方法和常用成员方法的作用

String和int类型的相互转换

public class Test2 {
    public static void main(String[] args) {
        System.out.println("==============int --> String==============");
        int num=100;
        System.out.println("===============方式1:拼接空串===============");
        String str=Integer.toString(num);
        System.out.println(str);
        System.out.println("======方式2:String类中的静态方法valueOf======");
        //这个常用
        String s = String.valueOf(num);
        System.out.println(s);
        System.out.println("======方式3:int --> Integer --> String======");
        Integer integer = new Integer(num);
        String s1 = integer.toString();
        System.out.println(s1);
        System.out.println("===============String --> int===============");
        String s2="200";
        System.out.println("==方式1:String --> Integer --> intValue();==");
        Integer integer1 = new Integer(s2);
        int i = integer1.intValue();
        System.out.println(i);
        System.out.println("=方式2:public static int parseInt(String s)=");
        //NumberFormatException 你传入给parseInt()方法的参数，字面上不是一个有效的数字，会报异常
        //parseInt方法会校验输入的字符串的长度
        int i1 = Integer.parseInt(s2);
        System.out.println(i1);
    }
}

Integer----->其他类型的转换

public class Test3 {
    public static void main(String[] args) {
        //Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。
        int num=100;
        String s = Integer.toBinaryString(num);
        //把一个整数值，转换成16进制
        String string = Integer.toHexString(num);
        String string1 = Integer.toOctalString(num);
        System.out.println(s);
        System.out.println(string);
        System.out.println(string1);
        System.out.println("==================================");
    }
}

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

public class Test1 {
    public static void main(String[] args) {
        //自动拆装箱：JDK1.5之后，引入的一个新特性
        //自动拆箱：将一个包装类型自动转换成他所对应的基本类型
        //自动装箱：将一个基本数据类型自动转换成他所对应的包装类型
        int num=100;
        //Integer integer = new Integer(num);
        //自动装箱
        Integer integer=num;
        Integer integer1=200;
        System.out.println("字符串类型"+integer.toString());
        //自动拆箱
        Integer a = new Integer("30000");
        //将引用类型a自动拆箱成基本类型30000
        int r=a+2;
        System.out.println(r);
    }

public class Test2 {
    public static void main(String[] args) {
        /********************************
         * 由Integer构造知，创建Integer对象，输入一个int就是int本身
         * 输入String类型，表示String参数所指定的int值
         * 可以调用所有的Integer方法去对int数据进行转化
         * *****************************/
        //一个原始类型会自动转换为对象；对象会自动转换为原始类型
        //自动装箱
        Integer a = 20, b = 20, c = 150, d = 150;
        //当你输入的整型数据在-128~127之间时，会正常缓存
        //当你输入的整型数据在-128~127之外时，会new新的对象,所以c，d不在一个对象内
        System.out.println(a == b);//true
        System.out.println(c == d);//false
        System.out.println(a.equals(b));
        System.out.println(c.equals(d));
        //intValue 手动拆箱
        int i = a.intValue();
        int i1 = b.intValue();
        //手动装箱
        int num = 300;
        String str = "40000";
        Integer integer = new Integer(num);
        Integer integer1 = Integer.valueOf(str);
        //手动拆箱
        int t=integer1.intValue();
        System.out.println(t);
    }
}

public class Test3 {
    public static void main(String[] args) {
        Integer a=20;
        Integer b=20;
        //intValue() 手动拆箱
        int i = a.intValue();
        int i1 = b.intValue();
        System.out.println(i+i1);


        //手动装箱
        //手动装箱有两种方法
        //1、用构造方法创建对象
        //2、用成员方法valueOf()创建对象
        //valueOf有方法重载，可以输入int、String等，都会返回一个封装类的对象
        int num=300;
        //Integer integer = new Integer(num);//用构造方法装箱
        Integer integer = Integer.valueOf(num);//用成员方法装箱
        System.out.println(integer.toString());
        Integer integer1 = Integer.valueOf("300000");
        int t=integer1.intValue();
        System.out.println(t);
    }
}

public class Test4 {
    public static void main(String[] args) {
        int[] arr={20,30,20};
        //Integer a=arr[0]; 自动装箱
        //自动装箱
        //Integer可以直接通过类名调用里面的valueOf来创建对象
        Integer[] arr2={20,30,20,new Integer(200),Integer.valueOf(20)};
        String string = arr2[0].toString();
        System.out.println(string);//字符串
        int t=Integer.parseInt(string);
        System.out.println(t);//t为int型数据

        //自动装箱
        Integer[] arr3 = {20, 30, 20,20,30};
        int b=arr3[0]; //自动拆箱
        Integer c=arr3[3];
        int sum=0;
        for (int i = 0; i < arr3.length; i++) {
            sum+=arr3[i];
        }
    }
}

拆装箱具有的特性以及面试中会考到，注意分析本段最后的注释代码

public class Test2 {
    public static void main(String[] args) {
        //自动装箱 在内部会调用 Integer.valueOf(128) 装箱
        Integer i5 = 128;
        Integer i6 = 128;
        //比较两个对象的地址值
        System.out.println(i5 == i6); //false

        System.out.println("-----------");
        //自动装箱 在内部会调用 Integer.valueOf(128) 装箱
        //在Integer类里面有一个静态的内部类IntegerCache他有一个静态代码块
        //当Integer类一加载，静态的的内部类IntegerCache也加载，IntegerCache他里面的静态代码块也得加载。
        //静态代码块里面会有一个Integer cache[];这个数组
        //这个数组里面，放的就是一些提前创建好的Interge对象。
        // 当我们采用 Integer i7 = 127;这种方式定义一个Integer对象时，如果值在 -128到127 之间
        //他会从cache[]数组中返回一个对象给你
        Integer i7 = 127;
        Integer i8 = 127;
        //比较两个对象的地址值
        System.out.println(i7 == i8); //true表明这是同一个对象
        //当你输入的整型数据在-128~127之外时，会new新的对象,所以c，d不在一个对象内
        Integer c=150;
        Integer d=150;
        System.out.println(c == d);//false
        System.out.println(c.equals(d));
        //装箱 调用valueOf()方法根据输入的参数会返回一个参数对应的Integer对象
     /*   public static Integer valueOf ( int i){
            if (i >= Integer.IntegerCache.low && i <= Integer.IntegerCache.high)
                return Integer.IntegerCache.cache[i + (-Integer.IntegerCache.low)];
            return new Integer(i);
        }*/
    }
}

IntegerCache他有一个静态代码块
//当Integer类一加载，静态的的内部类IntegerCache也加载，IntegerCache他里面的静态代码块也得加载。
//静态代码块里面会有一个Integer cache[];这个数组
//这个数组里面，放的就是一些提前创建好的Interge对象。
// 当我们采用 Integer i7 = 127;这种方式定义一个Integer对象时，如果值在 -128到127 之间
//他会从cache[]数组中返回一个对象给你
Integer i7 = 127;
Integer i8 = 127;
//比较两个对象的地址值
System.out.println(i7 == i8); //true表明这是同一个对象
//当你输入的整型数据在-128~127之外时，会new新的对象,所以c，d不在一个对象内
Integer c=150;
Integer d=150;
System.out.println(c == d);//false
System.out.println(c.equals(d));
//装箱 调用valueOf()方法根据输入的参数会返回一个参数对应的Integer对象
/* public static Integer valueOf ( int i){
if (i >= Integer.IntegerCache.low && i <= Integer.IntegerCache.high)
return Integer.IntegerCache.cache[i + (-Integer.IntegerCache.low)];
return new Integer(i);
}*/
}
}