java基础13StringBuffer+冒泡选择排序+二分法查找+基本数据类型包装类

13.01_常见对象(StringBuffer类的概述)

A:StringBuffer类概述
- 通过JDK提供的API，查看StringBuffer类的说明
- 线程安全的可变字符序列
B:StringBuffer和String的区别
- String是一个不可变的字符序列
- StringBuffer是一个可变的字符序列

13.02_常见对象(StringBuffer类的构造方法)

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

package com.nono.stringbuffer;

public class Demo1_StringBuffer {

    /**
     * * A:StringBuffer的构造方法：
            * public StringBuffer():无参构造方法
            * public StringBuffer(int capacity):指定容量的字符串缓冲区对象
            * public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
        * B:StringBuffer的方法：
            * public int capacity()：返回当前容量。 理论值(不掌握)
            * public int length():返回长度（字符数）。 实际值
        * C:案例演示
            * 构造方法和长度方法的使用
     */
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        System.out.println(sb.length());            //容器中的字符个数,实际值
        System.out.println(sb.capacity());          //容器的初始容量,理论值
        
        StringBuffer sb2 = new StringBuffer(10);
        System.out.println(sb2.length());
        System.out.println(sb2.capacity());
        
        StringBuffer sb3 = new StringBuffer("Nono");
        System.out.println(sb3.length());           //实际字符的个数
        System.out.println(sb3.capacity());         //字符串的length + 初始容量
        
    }

}

13.03_常见对象(StringBuffer的添加功能)

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

package com.heima.stringbuffer;

public class Demo2_StringBuffer {

    /**
     * * A:StringBuffer的添加功能
        * public StringBuffer append(String str):
            * 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
        * public StringBuffer insert(int offset,String str):
            * 在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
        StringBuffer是字符串缓冲区,当new的时候是在堆内存创建了一个对象,底层是一个长度为16的字符数组
        当调用添加的方法时,不会再重新创建对象,在不断向原缓冲区添加字符
     */
    public static void main(String[] args) {
        //demo1();
        StringBuffer sb = new StringBuffer("1234");
        sb.insert(3, "nono");                       //在指定位置添加元素,如果没有指定位置的索引就会报索引越界异常
        
        System.out.println(sb);
    }

    private static void demo1() {
        StringBuffer sb = new StringBuffer();
        StringBuffer sb2 = sb.append(true);
        StringBuffer sb3 = sb.append("nono");
        StringBuffer sb4 = sb.append(100);
        
        
        System.out.println(sb.toString());          //StringBuffer类中重写了toString方法,显示的是对象中的属性值
        System.out.println(sb2.toString());
        System.out.println(sb3.toString());
        System.out.println(sb4.toString());
    }

}

13.04_常见对象(StringBuffer的删除功能)

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

package com.nono.stringbuffer;

public class Demo3_StringBuffer {

    /**
     * * A:StringBuffer的删除功能
        * public StringBuffer deleteCharAt(int index):
            * 删除指定位置的字符，并返回本身
        * public StringBuffer delete(int start,int end):
            * 删除从指定位置开始指定位置结束的内容，并返回本身
     */
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        //sb.deleteCharAt(5);                   //当缓冲区中这个索引上没有元素的时候就会报StringIndexOutOfBoundsException
        sb.append("nononono");
        //sb.deleteCharAt(4);                   //根据索引删除掉索引位置上对应的字符
        //sb.delete(0, 2);                      //删除的时候是包含头,不包含尾
        //System.out.println(sb);
        //sb.delete(0, sb.length());                //清空缓冲区
        //System.out.println(sb);
        
        sb = new StringBuffer();                //不要用这种方式清空缓冲区,原来的会变成垃圾,浪费内存
        System.out.println(sb);
    }

}

13.05_常见对象(StringBuffer的替换和反转功能)

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

package com.nono.stringbuffer;

public class Demo4_StringBufferMethod {

    /**
     * * A:StringBuffer的替换功能
            * public StringBuffer replace(int start,int end,String str):
                * 从start开始到end用str替换
        * B:StringBuffer的反转功能
            * public StringBuffer reverse():
                * 字符串反转
     */
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("我爱总复习");
        //sb.replace(0, 3, "bai");                  //替换
        //System.out.println(sb);
        
        sb.reverse();
        System.out.println(sb);
    }

}

13.06_常见对象(StringBuffer的截取功能及注意事项)

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

package com.nono.stringbuffer;

public class Demo5_StringBufferMethod {

    /**
     * * A:StringBuffer的截取功能
        * public String substring(int start):
            * 从指定位置截取到末尾
        * public String substring(int start,int end):
            * 截取从指定位置开始到结束位置，包括开始位置，不包括结束位置
    * B:注意事项
        * 注意:返回值类型不再是StringBuffer本身
     */
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("woainonono");
        //String str = sb.substring(4);
        //System.out.println(str);
        
        //System.out.println(sb);
        
        String str3 = sb.substring(4, 7);
        System.out.println(str3);
    }

}

13.07_常见对象(StringBuffer和String的相互转换)

A:String -- StringBuffer
- a:通过构造方法
- b:通过append()方法
B:StringBuffer -- String
- a:通过构造方法
- b:通过toString()方法
- c:通过subString(0,length);

package com.nono.stringbuffer;

public class Demo6_StringBuffer {

    /**
     * * A:String -- StringBuffer
        * a:通过构造方法
        * b:通过append()方法
    * B:StringBuffer -- String
        * a:通过构造方法
        * b:通过toString()方法
        * c:通过subString(0,length);

     */
    public static void main(String[] args) {
        //demo1();
        StringBuffer sb = new StringBuffer("heima");
        
        String s1 = new String(sb);                     //通过构造将StringBuffer转换为String
        System.out.println(s1);
        
        String s2 = sb.toString();                      //通过toString方法将StringBuffer转换为String
        System.out.println(s2);
        
        String s3 = sb.substring(0, sb.length());       //通过截取子字符串将StringBuffer转换为String
        System.out.println(s3);
    }

    private static void demo1() {
        StringBuffer sb1 = new StringBuffer("bonobo");          //通过构造方法将字符串转换为StringBuffer对象
        System.out.println(sb1);
        
        StringBuffer sb2 = new StringBuffer();
        sb2.append("nono");                                 //通过append方法将字符串转换为StringBuffer对象
        System.out.println(sb2);
    }

}

13.08_常见对象(把数组转成字符串)

A:案例演示

需求：把数组中的数据按照指定个格式拼接成一个字符串

  举例：
      int[] arr = {1,2,3};    
  输出结果：
      "[1, 2, 3]"
      
  用StringBuffer的功能实现

package com.heima.test;

public class Test1 {

    /**
     * * 需求：把数组中的数据按照指定个格式拼接成一个字符串
    * 
            举例：
                int[] arr = {1,2,3};    
            输出结果：
                "[1, 2, 3]"
                
            用StringBuffer的功能实现
     */
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        System.out.println(arrayToString(arr));
    }

    /*
     * 将数组转换为字符串
     * 1,返回值类型String
     * 2,参数列表int[]
     * 
     * arrayToString 将数组转换为字符串
     * array2String     2与to的发音一样就用2替换了to,后来演变成了一种书写习惯
     * dom4j  domForJ
     */
    
    public static String arrayToString(int[] arr) {
        StringBuffer sb = new StringBuffer();               //创建字符串缓冲区对象
        sb.append("[");                                     //将[添加到缓冲区
        
        
        //{1,2,3}
        for (int i = 0; i < arr.length; i++) {              //遍历数组
            //sb.append(arr[i] + ", ");                     //这样做没有]
            if(i == arr.length - 1) {
                sb.append(arr[i]).append("]");              //[1, 2, 3]
            }else {
                sb.append(arr[i]).append(", ");             //[1, 2,
            }
        }
        return sb.toString();
    }
}

13.09_常见对象(字符串反转)

A:案例演示

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

package com.nono.test;

import java.util.Scanner;

public class Test2 {

    /**
     * * A:案例演示
    * 
            需求：把字符串反转
                举例：键盘录入"abc"        
                输出结果："cba"
                
            用StringBuffer的功能实现  
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);                //创建键盘录入对象
        String line = sc.nextLine();                        //将键盘录入的字符串存储在line中
        
        /*StringBuffer sb = new StringBuffer(line);         //将字符串转换为StringBuffer对象
        sb.reverse();                                       //将缓冲区的内容反转
        
        System.out.println(sb.toString());*/
        
        System.out.println(revString(line));
    }

    /*
     * 将字符串反转
     * 1,返回值类型String
     * 2,参数列表String line
     */
    
    public static String revString(String line) {
        StringBuffer sb = new StringBuffer(line);           //将字符串转换为StringBuffer对象
        sb.reverse();                                       //将缓冲区的内容反转
        
        return sb.toString();
    }
}

13.10_常见对象(StringBuffer和StringBuilder的区别)

A:StringBuilder的概述
- 通过查看API了解一下StringBuilder类
B:面试题
- String,StringBuffer,StringBuilder的区别
- StringBuffer和StringBuilder的区别
- StringBuffer是jdk1.0版本的,是线程安全的,效率低
- StringBuilder是jdk1.5版本的,是线程不安全的,效率高
- String和StringBuffer,StringBuilder的区别
- String是一个不可变的字符序列
- StringBuffer,StringBuilder是可变的字符序列

13.11_常见对象(String和StringBuffer分别作为参数传递)

A:形式参数问题
- String作为参数传递
- StringBuffer作为参数传递
B:案例演示
- String和StringBuffer分别作为参数传递问题

package com.nono.stringbuffer;

public class Demo7_StringBuffer {

    /**
     * * A:形式参数问题
            * String作为参数传递
            * StringBuffer作为参数传递 
        * B:案例演示
            * String和StringBuffer分别作为参数传递问题
            * 
    基本数据类型的值传递,不改变其值
    引用数据类型的值传递,改变其值
    
    String类虽然是引用数据类型,但是他当作参数传递时和基本数据类型是一样的
     */
    public static void main(String[] args) {
        String s = "nono";
        System.out.println(s);
        change(s);
        System.out.println(s);
        
        
        System.out.println("---------------------");
        StringBuffer sb = new StringBuffer();
        sb.append("nono");
        System.out.println(sb);
        change(sb);
        System.out.println(sb);
    }

    public static void change(StringBuffer sb) {
        sb.append("itcast");
    }

    public static void change(String s) {
        s += "itcast";
    }

}

13.12_常见对象(数组高级冒泡排序原理图解)

A:画图演示

  需求：
      数组元素：{24, 69, 80, 57, 13}
      请对数组元素进行排序。
      
      冒泡排序
          相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处

![选择排序.png](https://upload-images.jianshu.io/upload_images/19233179-e2e9a32c2eb23e05.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

13.13_常见对象(数组高级冒泡排序代码实现)

A:案例演示
- 数组高级冒泡排序代码

13.14_常见对象(数组高级选择排序原理图解)

A:画图演示
- 需求：
  - 数组元素：{24, 69, 80, 57, 13}
  - 请对数组元素进行排序。
  - 选择排序
    - 从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

13.15_常见对象(数组高级选择排序代码实现)

A:案例演示
- 数组高级选择排序代码

package com.nono.array;

public class Demo1_Array {

    /**
     * * A:案例演示
    * 数组高级冒泡排序代码
     */
    public static void main(String[] args) {
        int[] arr = {24, 69, 80, 57, 13};
        bubbleSort(arr);
        //selectSort(arr);
        print(arr);
    }
    
    /*
     * 冒泡排序
     * 1,返回值类型,void
     * 2,参数列表,int[] arr
     * 
     *  第一次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3],arr[3]与arr[4]比较4次
        第二次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3]比较3次
        第三次:arr[0]与arr[1],arr[1]与arr[2]比较2次
        第四次:arr[0]与arr[1]比较1次
     */
    
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {              //外循环只需要比较arr.length-1次就可以了
            for (int j = 0; j < arr.length - 1 - i; j++) {      //-1为了防止索引越界,-i为了提高效率
                if(arr[j] > arr[j+1]) {
                    /*int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j+1] = temp;*/
                    swap(arr,j,j+1);
                }
            }
        }
    }
    
    /*
     * 打印数组
     * 1,返回值类型void
     * 2,参数列表int[]arr
     */
    
    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
    
    /*
     * 选择排序
     * 1,返回值类型void
     * 2,参数列表int[] arr
     * 
     *  第一次:arr[0]分别与arr[1-4]比较,比较4次
        第二次:arr[1]分别与arr[2-4]比较,比较3次
        第三次:arr[2]分别与arr[3-4]比较,比较2次
        第四次:arr[3]与arr[4]比较,比较1次
     */
    
    public static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {              //只需要比较arr.length-1次
            for (int j = i + 1; j < arr.length; j++) {
                if(arr[i] > arr[j]) {
                    /*int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;*/
                    swap(arr,i,j);
                }
            }
        }
    }
    
    /*
     * 换位操作
     * 1,返回值类型,void
     * 2,参数列表int[] arr.int i,int j
     * 
     * 如果某个方法,只针对本类使用,不想让其他类使用就可以定义成私有的
     */
    
    private static void swap(int[] arr,int i,int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

13.16_常见对象(数组高级二分查找原理图解)

A:画图演示
- 二分查找
- 前提：数组元素有序

13.17_常见对象(数组高级二分查找代码实现及注意事项)

A:案例演示
- 数组高级二分查找代码
B:注意事项
- 如果数组无序，就不能使用二分查找。
  - 因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。

package com.heima.array;

public class Demo2_Array {

    /**
     * * A:案例演示
            * 数组高级二分查找代码
        * B:注意事项
            * 如果数组无序，就不能使用二分查找。
                * 因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。

     */
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55,66,77};
        System.out.println(getIndex(arr, 22));
        System.out.println(getIndex(arr, 66));
        System.out.println(getIndex(arr, 88));
    }
    
    /*
     * 二分查找
     * 1,返回值类型,int
     * 2,参数列表int[] arr,int value
     */
    
    public static int getIndex(int[] arr, int value) {
        int min = 0;
        int max = arr.length - 1;
        int mid = (min + max) / 2;
        
        while(arr[mid] != value) {                  //当中间值不等于要找的值,就开始循环查找
            if(arr[mid] < value) {                  //当中间值小于了要找的值
                min = mid + 1;                      //最小的索引改变
            }else if (arr[mid] > value){            //当中间值大于了要找的值
                max = mid - 1;                      //最大的索引改变
            }
            
            mid = (min + max) / 2;                  //无论最大还是最小改变,中间索引都会随之改变
            
            if(min > max) {                         //如果最小索引大于了最大索引,就没有查找的可能性了
                return -1;                          //返回-1
            }
        }
        return mid;
    }
}

13.18_常见对象(Arrays类的概述和方法使用)

A:Arrays类概述
- 针对数组进行操作的工具类。
- 提供了排序，查找等功能。
B:成员方法
- public static String toString(int[] a)
- public static void sort(int[] a)
- public static int binarySearch(int[] a,int key)

package com.nono.array;

import java.util.Arrays;

public class Demo3_Arrays {

    /**
        * public static String toString(int[] a)
        * public static void sort(int[] a)
        * public static int binarySearch(int[] a,int key)
        * 
        *  public static String toString(int[] a) {
                if (a == null)                              //如果传入的数组是null
                    return "null";                          //返回null
                int iMax = a.length - 1;                    //iMax最大索引
                if (iMax == -1)                             //如果数组中没有元素
                    return "[]";                            //返回[]
        
                StringBuilder b = new StringBuilder();      //线程不安全,效率高
                b.append('[');                              //将[添加到字符串缓冲区中
                for (int i = 0; ; i++) {                    //遍历数组,判断语句没有写默认是true
                    b.append(a[i]);                         //把第一个元素添加进字符串缓冲区
                    if (i == iMax)                          //如果索引等于了最大索引值
                        return b.append(']').toString();    //将]添加到字符串缓冲区,在转换成字符串并返回
                    b.append(", ");                         //如果不等于最大索引就将, 添加到缓冲区
                }
            }
            
         private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                     int key) {
                int low = fromIndex;                //最小索引0
                int high = toIndex - 1;             //最大索引数组长度-1
        
                while (low <= high) {               //最小索引小于等于最大索引可以循环判断
                    int mid = (low + high) >>> 1;   //求出中间索引值,(最小+最大)/2
                    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.//-插入点 - 1
            }
     */
    public static void main(String[] args) {
        int[] arr = {33,22,11,44,66,55};
        System.out.println(Arrays.toString(arr));           //数组转字符串
        
        Arrays.sort(arr);                                   //排序
        System.out.println(Arrays.toString(arr));
        
        int[] arr2 = {11,22,33,44,55,66};
        System.out.println(Arrays.binarySearch(arr2, 22));
        System.out.println(Arrays.binarySearch(arr2, 66));
        System.out.println(Arrays.binarySearch(arr2, 9));   //-插入点-1
    }

}

13.19_常见对象(基本类型包装类的概述)

A:为什么会有基本类型包装类
- 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
B:常用操作
- 常用的操作之一：用于基本数据类型与字符串之间的转换。
C:基本类型和包装类的对应

  byte            Byte
  short           Short
  int             Integer
  long            Long
  float           Float
  double          Double
  char            Character
  boolean         Boolean

13.20_常见对象(Integer类的概述和构造方法)

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

package com.nono.wrapclass;

public class Demo1_Integer {

    /**
     * * A:为什么会有基本类型包装类
            * 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
        * B:常用操作
            * 常用的操作之一：用于基本数据类型与字符串之间的转换。
        * C:基本类型和包装类的对应
        * 
                byte            Byte
                short           Short
                int             Integer
                long            Long
                float           Float
                double          Double
                char            Character
                boolean         Boolean
     */
    public static void main(String[] args) {
        System.out.println(Integer.toBinaryString(60));
        System.out.println(Integer.toOctalString(60));
        System.out.println(Integer.toHexString(60));
    }

}




package com.heima.wrapclass;

public class Demo2_Integer {

    /**
     * * A:Integer类概述
            * 通过JDK提供的API，查看Integer类的说明
        
            * Integer 类在对象中包装了一个基本类型 int 的值,
            * 该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
            * 还提供了处理 int 类型时非常有用的其他一些常量和方法
        * B:构造方法
            * public Integer(int value)
            * public Integer(String s)
        * C:案例演示
            * 使用构造方法创建对象
     */
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        
        Integer i1 = new Integer(100);
        System.out.println(i1);
        
        //Integer i2 = new Integer("abc");          //java.lang.NumberFormatException数字格式异常
        //System.out.println(i2);                       //因为abc不是数字字符串,所以转换会报错
        
        Integer i3 = new Integer("100");
        System.out.println(i3);
    }

}

13.21_常见对象(String和int类型的相互转换)

A:int -- String
- a:和""进行拼接
- b:public static String valueOf(int i)
- c:int -- Integer -- String(Integer类的toString方法())
- d:public static String toString(int i)(Integer类的静态方法)
B:String -- int
- a:String -- Integer -- int
- public static int parseInt(String s)

package com.nono.wrapclass;

public class Demo3_Integer {

    /**
     * * A:int -- String
            * a:和""进行拼接
            * b:public static String valueOf(int i)
            * c:int -- Integer -- String(Integer类的toString方法())
            * d:public static String toString(int i)(Integer类的静态方法)
        * B:String -- int
            * a:String -- Integer -- int
                * public static int parseInt(String s)
        基本数据类型包装类有八种,其中七种都有parseXxx的方法,可以将这七种的字符串表现形式转换成基本数据类型
     */
    public static void main(String[] args) {
        
        //demo1();
        String s1 = "true";
        boolean b = Boolean.parseBoolean(s1);
        System.out.println(b);
        
        //String s2 = "abc";
        //char c = Character.p      //char的包装类Character中没有pareseXxx的方法
                                    //字符串到字符的转换通过toCharArray()就可以把字符串转换为字符数组
    }

    private static void demo1() {
        //int ----> String int转换成String
        int i = 100;
        String s1 = i + "";                     //推荐用
        String s2 = String.valueOf(i);          //推荐用
        
        Integer i2 = new Integer(i);
        String s3 = i2.toString();
        
        String s4 = Integer.toString(i);
        System.out.println(s1);
        
        //String----> int String 转换int
        String s = "200";
        Integer i3 = new Integer(s);
        int i4 = i3.intValue();                 //将Integer转换成了int数
        
        int i5 = Integer.parseInt(s);           //将String转换为int,推荐用这种
    }

}

13.22_常见对象(JDK5的新特性自动装箱和拆箱)

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

package com.nono.wrapclass;

public class Demo4_JDK5 {

    /**
     * * A:JDK5的新特性
            * 自动装箱：把基本类型转换为包装类类型
            * 自动拆箱：把包装类类型转换为基本类型
        * B:案例演示
            * JDK5的新特性自动装箱和拆箱
            
            * Integer ii = 100;
            * ii += 200;
        * C:注意事项
            * 在使用时，Integer  x = null;代码就会出现NullPointerException。
            * 建议先判断是否为null，然后再使用。
     */
    public static void main(String[] args) {
//      int x = 100;
//      Integer i1 = new Integer(x);            //将基本数据类型包装成对象,装箱
//      
//      int y = i1.intValue();                  //将对象转换为基本数据类型,拆箱
        
        Integer i2 = 100;                       //自动装箱,把基本数据类型转换成对象
        int z = i2 + 200;                       //自动拆箱,把对象转换为基本数据类型
        System.out.println(z);
        
        Integer i3 = null;
        int a = i3 + 100;                       //底层用i3调用intValue,但是i3是null,null调用方法就会出现
        System.out.println(a);                  //空指针异常java.lang.NullPointerException
    }

}

13.23_常见对象(Integer的面试题)

A:Integer的面试题

  看程序写结果
  
  Integer i1 = new Integer(97);
  Integer i2 = new Integer(97);
  System.out.println(i1 == i2);
  System.out.println(i1.equals(i2));
  System.out.println("-----------");

  Integer i3 = new Integer(197);
  Integer i4 = new Integer(197);
  System.out.println(i3 == i4);
  System.out.println(i3.equals(i4));
  System.out.println("-----------");

  Integer i5 = 97;
  Integer i6 = 97;
  System.out.println(i5 == i6);
  System.out.println(i5.equals(i6));
  System.out.println("-----------");

  Integer i7 = 197;
  Integer i8 = 197;
  System.out.println(i7 == i8);
  System.out.println(i7.equals(i8));

package com.heima.wrapclass;


public class Demo5_Integer {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Integer i1 = new Integer(97);
        Integer i2 = new Integer(97);
        System.out.println(i1 == i2);               //false
        System.out.println(i1.equals(i2));          //true
        System.out.println("-----------");
    
        Integer i3 = new Integer(197);
        Integer i4 = new Integer(197);
        System.out.println(i3 == i4);               //false
        System.out.println(i3.equals(i4));          //true
        System.out.println("-----------");
    
        Integer i5 = 127;
        Integer i6 = 127;
        System.out.println(i5 == i6);               //true
        System.out.println(i5.equals(i6));          //true
        System.out.println("-----------");
    
        Integer i7 = 128;
        Integer i8 = 128;
        System.out.println(i7 == i8);
        System.out.println(i7.equals(i8));          //true
        
        /*
         * -128到127是byte的取值范围,如果在这个取值范围内,自动装箱就不会新创建对象,而是从常量池中获取
         * 如果超过了byte取值范围就会再新创建对象
         * 
         * public static Integer valueOf(int i) {
                assert IntegerCache.high >= 127;
                if (i >= IntegerCache.low && i <= IntegerCache.high)            //i>= -128 && i <= 127
                    return IntegerCache.cache[i + (-IntegerCache.low)];
                return new Integer(i);
            }
         */
    }

}

13.24_day13总结

把今天的知识点总结一遍。

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 216,470评论 6赞 501
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 92,393评论 3赞 392
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 162,577评论 0赞 353
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 58,176评论 1赞 292
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 67,189评论 6赞 388
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 51,155评论 1赞 299
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 40,041评论 3赞 418
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 38,903评论 0赞 274
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 45,319评论 1赞 310
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 37,539评论 2赞 332
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 39,703评论 1赞 348
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 35,417评论 5赞 343
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 41,013评论 3赞 325
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 31,664评论 0赞 22
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,818评论 1赞 269
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 47,711评论 2赞 368
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 44,601评论 2赞 353

java基础13StringBuffer+冒泡选择排序+二分法查找+基本数据类型包装类

13.01_常见对象(StringBuffer类的概述)

13.02_常见对象(StringBuffer类的构造方法)

13.03_常见对象(StringBuffer的添加功能)

13.04_常见对象(StringBuffer的删除功能)

13.05_常见对象(StringBuffer的替换和反转功能)

13.06_常见对象(StringBuffer的截取功能及注意事项)

13.07_常见对象(StringBuffer和String的相互转换)

13.08_常见对象(把数组转成字符串)

13.09_常见对象(字符串反转)

13.10_常见对象(StringBuffer和StringBuilder的区别)

13.11_常见对象(String和StringBuffer分别作为参数传递)

13.12_常见对象(数组高级冒泡排序原理图解)

13.13_常见对象(数组高级冒泡排序代码实现)

13.14_常见对象(数组高级选择排序原理图解)

13.15_常见对象(数组高级选择排序代码实现)

13.16_常见对象(数组高级二分查找原理图解)

13.17_常见对象(数组高级二分查找代码实现及注意事项)

13.18_常见对象(Arrays类的概述和方法使用)

13.19_常见对象(基本类型包装类的概述)

13.20_常见对象(Integer类的概述和构造方法)

13.21_常见对象(String和int类型的相互转换)

13.22_常见对象(JDK5的新特性自动装箱和拆箱)

13.23_常见对象(Integer的面试题)

13.24_day13总结

推荐阅读更多精彩内容