day13

　　

13.01 常见对象（StringBuffer类的概述）
 A.StringBuffer和String的区别
　　String是一个不可变的字符序列；StringBuffer是一个可变的字符序列
13.02 常见对象（StringBuffer类的构造方法）
 A.StringBuffer的构造方法
　　public StringBuffer(): 无参构造
　　public StringBuffer(int capacity):指定容量的字符串缓冲区对象
　　public StringBuffer(String atr):指定字符串内容的字符串缓冲区对象
 B.StringBuffer的方法：
　　public int capacity(): 返回当前容量 理论值
　　public int length(): 返回长度
 C.案例演示

public class day13_02 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();    
        System.out.println(sb.length());        //容器中的字符的个数，实际值
        System.out.println(sb.capacity());        //容器的初始容量，理论值
        
        StringBuffer sb1 = new StringBuffer(10);
        System.out.println("sb1:"+sb1.length());        //
        System.out.println("sb1:"+sb1.capacity());
        
        StringBuffer sb2 = new StringBuffer("heima");
        System.out.println(sb2.length());        //实际字符的个数
        System.out.println(sb2.capacity());        //字符串的length + 初始容量
    }
}

13.03 常见对象（StringBuffer类的添加功能）(****************001)
 A.StringBuffer的添加功能
　　public StringBuffer append（String str): 把任意数据添加到字符串缓冲区，并返回字符串缓冲区本身
　　public StringBuffer insert（into offset，String str）:指定位置把任意类型的数据插入到字符串缓冲区，并返回字符串缓冲区本身
 B.StringBuffer的删除功能
　　public StringBuffer deleteCharAt(int index): 删除指定位置的字符，并返回本身
　　public StringBuffer delete(int start,int end): 删除从指定位置开始到指定位置结束的内容，并返回本身
 C.StringBuffer的替换功能
　　public StringBuffer replace(int start, int end)
 D.StringBuffer的反转功能
　　public StringBuffer reserve（）：
 E.StringBuffer的截取功能
　　public StringBuffer substring（int start）：
　　public StringBuffer substring（int start,int end）：

public class day13_03 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        StringBuffer sb1= sb.append(true);
        StringBuffer sb2= sb.append("heimas");
        StringBuffer sb3= new StringBuffer(100);
        
        System.out.println(sb.toString());
        System.out.println(sb1.toString());
        System.out.println(sb2.toString());
        System.out.println(sb3.toString());
        //打印结果相同，因为StringBuffer是字符串缓冲区，当new的时候在堆内存这种创建了一个对象，底层是长度16的字符数组
        //当调用添加的方法时，不会再重新创建对象，在不断向原缓冲区添加字符
    }
}
------------------------------------------
public class day13_03 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();

        StringBuffer sbb = new StringBuffer();
        System.out.println(sbb.toString());
        
        StringBuffer sbb1= sb.append(true);
        System.out.println(sbb1.toString());
        StringBuffer sbb2= sb.append("heimas");
        System.out.println(sbb2.toString());
        
        StringBuffer sbb3= new StringBuffer(100);
        System.out.println(sbb3.toString());
        
    }
}

public class day13_04 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append("heima");
        sb.deleteCharAt(4);                //删除指定位置
        System.out.println(sb);            //结果：heim
        
        sb.delete(0, 2);
        System.out.println(sb);            //结果：im
        
        sb.delete(0,sb.length());        //清空
        System.out.println(sb);    
    
    }
}

public class day13_05 {
    public static void main(String[] args) {
        StringBuffer s = new StringBuffer("heima");
        s.replace(0, 3, "bai");            //替换
        System.out.println(s);
        s.reverse();                    //反转
        System.out.println(s);
    }
}
-------------------------------------
public class day13_05 {
    public static void main(String[] args) {
        StringBuffer s = new StringBuffer("woaiheima");
        String str = s.substring(4);
        System.out.println(str);        //结果==>heima

        String str2 = s.substring(4,7);
        System.out.println(str2);        //结果==>hei
    }
}

13.07 常见对象（StringBuffer和String的互换）
 A.String--StringBuffer
　　a.构造方法
　　b.append（）方法
 B.StringBuffer--String
　　a.构造方法
　　b.toString()方法
　　c.subString(0,length)

public class day13_07 {
    
     *  A.String--StringBuffer
             a.构造方法
             b.append（）方法
         B.StringBuffer--String
             a.构造方法
             b.toString()方法
             c.subString(0,length())
     
    public static void main(String[] args) {
        StringBuffer sb1 = new StringBuffer("heima");        //a.构造方法 -- String--StringBuffer
        System.out.println(sb1);
        
        StringBuffer sb2 = new StringBuffer();                //b.append（）方法  -- String--StringBuffer
        sb2.append("heima");
        System.out.println(sb2);
    }
}
-----------------------------------------
public class day13_07 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("heima");        
        String s1 = new String(sb);                            //a.构造方法
        System.out.println(s1);
        
        String s2 = sb.toString();                            //b.toString()方法
        System.out.println(s2);    
        
        String s3 = sb.substring(0,sb.length());            //c.subString(0,length)
        System.out.println(s3);
    }
}

13.08 常见对象（数组转成字符串）
　　需求：将数组中的数据按照指定格式拼接成一个字符串
　　　　举例：int[] arr ={1,2,3,4}
　　　　输出 [1,2,3,4]
　　　　使用StringBuffer

public class day13_08 {
    /**
     * 需求：使用StringBuffer 将数组中的数据按照指定格式拼接成一个字符串
        举例：int[] arr ={1,2,3,4}
        输出      [1,2,3,4]
     */
    public static void main(String[] args) {
        int [] arr = {1,2,3,4};
        System.out.println(arrayToString(arr));
    }
    /*数组转成字符串
     * 1.返回值类型String
     * 2.参数列表*/
    public static String arrayToString(int[] arr){
        StringBuffer sb = new StringBuffer();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if(i==arr.length -1){
                sb.append(arr[i]).append("]");
            }else{
                sb.append(arr[i]).append(", ");
            }
        }
        return sb.toString();
    }
}

13.09 常见对象（字符串反转）
　　需求：字符串反转
　　　　键盘录入abc
　　　　输出：abc
　　　　使用StringBuffer

/*import java.util.Scanner;
public class day13_09 {
    需求：字符串反转
            键盘录入abc
            输出：abc
        使用StringBuffer 
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("程传政请输入字符串：");
        String ss = sc.nextLine();
        StringBuffer sb = new StringBuffer(ss);
        sb.reverse();
        System.out.println(sb.toString());
    }
}
*/
import java.util.Scanner;
public class day13_09 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("程传政请输入字符串：");
        String ss = sc.nextLine();
        System.out.println(reverseCcz(ss));            //从该句传给下面的方法
    }
    public static String reverseCcz(String ss){
        StringBuffer sb = new StringBuffer();
        sb.reverse();
        return sb.toString();
    }
}

13.10 常见对象（StringBuffer和StringBuilder的区别）
　　　　StringBuffer：线程安全，但效率低
13.11 常见对象（StringBuffer和StringBuilder分别做参数传递）
　　　　基本数据类型的值传递，不改变其值
　　　　引用数据类型的值传递，改变其值

public class day13_11 {
    /**
     * 基本数据类型的值传递，不改变其值
        引用数据类型的值传递，改变其值
        String 虽然是引用数据类型，但是他当作参数传递时和基本数据类型是一样的
     */
    public static void main(String[] args) {
        String s = "heima";
        change(s);
        System.out.println("我的："+s);
        System.out.println("---------------------");
        StringBuffer sb = new StringBuffer();
        sb.append("heima");
        change(s);
        System.out.println("StringBuffer的："+s);
    }
    public static void change(String s){
        s += "itcase";
        System.out.println(s);
    }
}

13.12 常见对象（数组高级冒泡排序原理）
　　需求：数组元素{24，69，80，57，13} 进行排序
　　　　　1.冒泡排序，相邻元素两两比较，大的往后放，第一次完毕，最大值出现在最大索引处

13.13 常见对象（数组高级冒泡排序代码实现）
　　数组高级冒泡排序

public class day13_13 {
    /**
     * 需求：数组元素{24，69，80，57，13}     进行排序
           冒泡排序，相邻元素两两比较，大的往后放，第一次完毕，最大值出现在最大索引处
     */
    public static void main(String[] args) {
        int[] arr = {24,69,80,57,13};
        bubbleSort(arr);
        print(arr);
    }
    public static void bubbleSort(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {        //arr.length-1-i
                if(arr[j]>arr[j+1]){                    //换位置
                    int temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;        
                }
            }
        }
    }
    public static void print(int[] arr){                    //打印
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

13.14 常见对象（数组高级选择排序原理）
　　需求：数组元素{24，69，80，57，13} 进行排序
　　　　2.选择排序，从0索引开始，一次和后面元素比较，小的往前放，第一次完毕，最小值出现在最小索引处

13.15 常见对象（数组高级选择排序代码实现）

public class day13_15 {
    public static void main(String[] args) {
        int[] arr = {24,69,80,57,13};
        selectSort(arr);
        print(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++) {
            for (int j = i+1; j < arr.length; j++) {    //j = i+1
                if(arr[i]>arr[j]){
                    int temp = arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
    }
    public static void print(int[] arr){                    //打印
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

13.16 常见对象（数组高级二分法原理）
13.17 常见对象（数组高级二分法代码实现）

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 day13_18 {
    /**
     * Arrays类是针对数组进行操作的工具类。提供了排序，查找功能
     */
    public static void main(String[] args) {
        int[] arr = {33,22,44,55,99,44,77};
        System.out.println(Arrays.toString(arr));    //数组转字符串
        
        Arrays.sort(arr);                            //对原数组进行修改。排序
        System.out.println(Arrays.toString(arr));
         
        int[] arr2 = {22, 33, 44, 44, 55, 77, 99};    //binarySearch，查找元素的位置
        System.out.println(Arrays.binarySearch(arr2, 22));
        System.out.println(Arrays.binarySearch(arr2, 77));
        System.out.println(Arrays.binarySearch(arr2, 23));    //（-插入点-1） ；此处的23插入在1索引，前面加-即-1；再-1得-2
    }
}

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

public class day13_19 {
    public static void main(String[] args) {
        System.out.println(Integer.toBinaryString(60));
        System.out.println(Integer.toOctalString(60));
        System.out.println(Integer.toHexString(60));
    }
}

13.20 常见对象（Integer类的概述和构造方法）
 A.Integer类在对象中包装了一个基本类型int 的值，
　　该类提供了多个方法，能在int String类之间相互转换
 B.构造方法
　　public Integer（int value） 输入int类型的值
　　public Integer（String s） 输入String类型的值
 C.案例演示
　　使用构造方法创建对象

public class day13_20 {
    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");    abc 不是数，格式转换异常
        System.out.println(i2);*/
        
        Integer i11 = new Integer("100");        //将一个字符串数转成数值
        System.out.println(i11);
    }
}

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)
 C.基本数据类型包装类有8种，其中7种有parseXxx（）方法

public class day13_21 {
    public static void main(String[] args) {
        int i = 100;
        String s1 = i + "";                    //1.a.和""进行拼接
        String s2 = String.valueOf(i);        //2.valueOf（int i）
        System.out.println(s1);
        System.out.println(s2);
        
        Integer i2 = new Integer(i);        //3.int -- Integer -- String(Integer类的toString方法)
        String s3 = i2.toString();
        System.out.println(s3);
        
        String s4 = Integer.toString(i);    //4.d.public static String toString(int i)  (Integer类的静态方法)
        System.out.println(s4);
        
        
        // B.String -- int 
        String s = "200";
        Integer i3 = new Integer(s);
        int i4 = i3.intValue();
        System.out.println(i4);
        
        int i5 = Integer.parseInt(s);        //2.调用Integer里面的parseInt(s)方法
        System.out.println(i5);
        
        //C.基本数据类型包装类有8种，其中7种有parseXxx（）方法
        String ss = "true";
        boolean b = Boolean.parseBoolean(ss);
        System.out.println(b);
    }
}

13.22 常见对象（JDK5的新特性自动拆装箱）

public class day13_22 {
    public static void main(String[] args) {
        int x = 100;
        Integer i1 = new Integer(x);        //将基本数据类型包装成对象。装箱
        System.out.println(i1);
        
        int y = i1.intValue();                //将对象转成基本数据类型。拆箱
        System.out.println(y);
        
        //
        Integer i2 = 100;        //自动装箱
        int z = i2 + 200;        //自动拆箱
        System.out.println(z);
    }
}

13.23 常见对象（Integer的面试题）