day13<常见对象+>

常见对象(StringBuffer类的概述)

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

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

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

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

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

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

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

常见对象(字符串反转)

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

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

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

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

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

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

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

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

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

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

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

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

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

常见对象(Integer的面试题)

 

###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:案例演示
     构造方法和长度方法的使用

    StringBuffer sb = new StringBuffer();

    System.out.println(sb.length()); //0 //容器中的字符个数,实际值

    System.out.println(sb.capacity()); //16 //容器的初始容量,理论值

    StringBuffer sb2 = new StringBuffer(10);

    System.out.println(sb2.length()); //0

    System.out.println(sb2.capacity()); //10

    StringBuffer sb3 = new StringBuffer("heima");

    System.out.println(sb3.length()); //5 //实际字符的个数

    System.out.println(sb3.capacity()); //21 //字符串的length + 初始容量

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

    StringBuffer是字符串缓冲区,当new的时候是在堆内存创建了一个对象,底层是一个长度为16的字符数组

    当调用添加的方法时,不会再重新创建对象,在不断向原缓冲区添加字符

     public StringBuffer append(String str):
         可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身

    StringBuffer sb = new StringBuffer();

    StringBuffer sb2 = sb.append(true);

    StringBuffer sb3 = sb.append("heima");

    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()); //trueheima100

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

    StringBuffer sb = new StringBuffer("1234");

    sb.insert(3, "heima"); //在指定位置添加元素,如果没有指定位置的索引就会报索引越界异常

    System.out.println(sb); //123heima4

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

    StringBuffer sb = new StringBuffer();

    //sb.deleteCharAt(5); //当缓冲区中这个索引上没有元素的时候就会报

    StringIndexOutOfBoundsException

    sb.append("heima");

    sb.deleteCharAt(4); //heim //根据索引删除掉索引位置上对应的字符

    sb.delete(0, 2); //ima //删除的时候是包含头,不包含尾

    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():
         字符串反转

    //StringBuffer sb = new StringBuffer("heima");

    StringBuffer sb = new StringBuffer("我爱总复习");

    //sb.replace(0, 3, "bai"); //替换

    //System.out.println(sb); //baima

    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本身

    StringBuffer sb = new StringBuffer("woaiheima");

    //String str = sb.substring(4);

    //System.out.println(str);  //heima

    //System.out.println(sb); //woaiheima

    String str3 = sb.substring(4, 7);

    System.out.println(str3); //hei

###13.07_常见对象(StringBuffer和String的相互转换)
 A:String -- StringBuffer
     a:通过构造方法
     b:通过append()方法

    StringBuffer sb1 = new StringBuffer("heima"); //通过构造方法将字符串转换为StringBuffer对象

    System.out.println(sb1); //heima

 

    StringBuffer sb2 = new StringBuffer();

    sb2.append("heima"); //通过append方法将字符串转换为StringBuffer对象

    System.out.println(sb2); //heima

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

    StringBuffer sb = new StringBuffer("heima");

    String s1 = new String(sb); //通过构造将StringBuffer转换为String

    System.out.println(s1); //heima

    String s2 = sb.toString();//通过toString方法将StringBuffer转换为String

    System.out.println(s2); //heima

 

    String s3 = sb.substring(0, sb.length()); //通过截取子字符串将StringBuffer转换为String

    System.out.println(s3); //heima

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

public class Test1 {

    public static void main(String[] args) {

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

System.out.println(arrayToString(arr));

    }

    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的功能实现    

public class Test2 {

    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));

    }

    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分别作为参数传递问题

     基本数据类型的值传递,不改变其值;引用数据类型的值传递,改变其值.

     String类虽然是引用数据类型,但是他当作参数传递时和基本数据类型是一样的

public class Demo7_StringBuffer {

    /**

    基本数据类型的值传递,不改变其值

    引用数据类型的值传递,改变其值

    String类虽然是引用数据类型,但是他当作参数传递时和基本数据类型是一样的*/

    public static void main(String[] args) {

String s = "heima";

System.out.println(s); //heima

change(s);

System.out.println(s); //heima

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

StringBuffer sb = new StringBuffer();

sb.append("heima");

System.out.println(sb); //heima

change(sb);

System.out.println(sb); //heimaitcast

    }

    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}
            请对数组元素进行排序。
            
            冒泡排序
                相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处


###13.13_常见对象(数组高级冒泡排序代码实现)
 A:案例演示
     数组高级冒泡排序代码

public class Demo1_Array {

    public static void main(String[] args) {

int[] arr = {24, 69, 80, 57, 13};

bubbleSort(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;

}

    }

}

    }

    /*

     * 打印数组

     * 1,返回值类型void

     * 2,参数列表int[]arr

     */

    public static void print(int[] arr) {

for (int i = 0; i < arr.length; i++) {

     System.out.print(arr[i] + " ");

   }

     }

}

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


###13.15_常见对象(数组高级选择排序代码实现)
 A:案例演示
     数组高级选择排序代码

public class Demo1_Array {

    public static void main(String[] args) {

int[] arr = {24, 69, 80, 57, 13};

 selectSort(arr);

 print(arr);

    }

    /*

     * 打印数组

     * 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:注意事项
     如果数组无序，就不能使用二分查找。
         因为如果你排序了，但是你排序的时候已经改变了我最原始的元素索引。

public class Demo2_Array {

    public static void main(String[] args) {

int[] arr = {11,22,33,44,55,66,77};

System.out.println(getIndex(arr, 22));  //1

System.out.println(getIndex(arr, 66));  //5

System.out.println(getIndex(arr, 88));  //-1

    }

    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)

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)); //[33, 22, 11, 44, 66, 55] //数组转字符串

Arrays.sort(arr); //排序

System.out.println(Arrays.toString(arr)); //[11, 22, 33, 44, 55, 66]

int[] arr2 = {11,22,33,44,55,66};

System.out.println(Arrays.binarySearch(arr2, 22)); //1

System.out.println(Arrays.binarySearch(arr2, 66));//5

System.out.println(Arrays.binarySearch(arr2, 9));//-1  //-插入点-1

    }

}

###13.19_常见对象(基本类型包装类的概述)
 A:为什么会有基本类型包装类
     将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
 B:常用操作
     常用的操作之一：用于基本数据类型与字符串之间的转换。
 C:基本类型和包装类的对应
 
        byte           Byte
        short          Short
        int            Integer
        long           Long
        float          Float
        double         Double
        char           Character
        boolean        Boolean

    System.out.println(Integer.toBinaryString(60)); //111100

    System.out.println(Integer.toOctalString(60)); //74

    System.out.println(Integer.toHexString(60)); //3c

###13.20_常见对象(Integer类的概述和构造方法)
 A:Integer类概述
     通过JDK提供的API，查看Integer类的说明

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

    System.out.println(Integer.MAX_VALUE); //2147483647

    System.out.println(Integer.MIN_VALUE); //-2147483648

    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); //100

###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)

     基本数据类型包装类有八种,其中七种都有parseXxx的方法,可以将这七种的字符串表现形式转换成基本数据类型

    //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); //100

    //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,推荐用这种

    String s1 = "true";

    boolean b = Boolean.parseBoolean(s1);

    System.out.println(b); //true

    //String s2 = "abc";

    //char c = Character.p //char的包装类Character中没有pareseXxx的方法

    //字符串到字符的转换通过toCharArray()就可以把字符串转换为字符数组

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

    // int x = 100;

    // Integer i1 = new Integer(x); //将基本数据类型包装成对象,装箱

    //

    // int y = i1.intValue(); //将对象转换为基本数据类型,拆箱

    Integer i2 = 100; //自动装箱,把基本数据类型转换成对象

    int z = i2 + 200; //自动拆箱,把对象转换为基本数据类型

    System.out.println(z); //300

    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); //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); //false

    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总结
     把今天的知识点总结一遍。

   把总结中的案例练习一遍