JAVASE第13天笔记

Day13课堂笔记

标签（空格分隔）： java基础

---

StringBuffer概述

StringBuffer和String有什么区别？
String:不可以改变字符序列 (“abc”)
StringBuffer:可以改变的字符序列,(字符串缓冲区) 线程安全

构造方法
空参构造 StringBuffer() :开发常用空参
默认容量 :16
有参构造 StringBuffer(int 容量) 举例: new StringBuffer(10)
StringBuffer(String 字符串) 举例 new StringBuffer("abc")
StringBuffer(String 字符串):根据你的实际传入的字符串,容量自动增长

成员方法:
int capacity(): 返回当前容量 ,理论值
int length():返回的是字符串长度,实际

添加方法(非常非常非常重要)
append(数据) 可以把任意数据类添加到缓冲区,并且返回本身.(最常用,必须会),通常我们都是添加字符串.
举例

StringBuffer  sb = new StringBuffer();
sb.append("http://www.jd.com/");
sb.append("0001.jpg");
System.out.println(sb);

删除方法

deleteCharAt(int 指定索引)  : 索引从0开始
举例
StringBuffer sb = new StringBuffer();
sb.append("helloworld");
sb.deleteCharAt(1);//删除e

替换和反转
replace(int 起始位置,int 结束位置,String 替换字符串)替换方法
可以返回字符串缓冲区本身

        //1,创建对象
        StringBuffer sb = new StringBuffer();
        //2,调用添加方法
        sb.append("13588881234");
        //3,调用方法
        sb.replace(3, 7, "****");
        //4,输出
        System.out.println(sb);
    }

StringBuffer shuai = new StringBuffer();
        shuai.append("超帅很帅?");
        shuai.replace(4, 5, "!!!!");
        System.out.println(shuai);

reverse();反转方法

截取方法(非常非常重要)
subString(int 起始位置):这个方法是从你指定的位置开始截取到末尾
subString(int 起始位置,int 结束位置): 这个是指定截取区间段
注意:
subString截取方法返回的不再是字符串缓冲区本身,而是一个新的字符串,是你截取到的字符串,原来的StringBuffer对象没有改变
举例:

需求:去掉字符串"超帅很帅?"中的?号
public static void main(String[] args) {
        StringBuffer shuai = new StringBuffer();
        shuai.append("超帅很帅?");
        String str = shuai.substring(0, 4);
        System.out.println(str); //输出 超帅很帅
    }

转换功能
String—>StringBuffer:
append(添加)
构造方法
StringBuffer–>String
StringBuffer :字符串缓冲区
toString():将字符串缓冲区 转成 字符串 (开发最常见)
subString(0,字符串缓冲区.length()): 转字符串(非常常量)
举例:

StringBuffer shuai = new StringBuffer();
        shuai.append("超帅超级无敌好好好.......帅?");
        String str = shuai.substring(0, shuai.length()-1);
        System.out.println(str);

案例优化

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("[");                                     //将[添加到缓冲区

        //作数据拼接:我们通常是采用StringBuffer /StringBuilder 来做,不采用String来做,是因为String类做的话,会产生字符串垃圾
        //{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,
            }*/
            sb.append(arr[i]).append(",");
        }
        //return sb.replace(sb.length()-1,sb.length(), "]").toString();
        //return sb.substring(0, sb.length()-1) + "]";
        return sb.substring(0, sb.length()-1).concat("]");
    }
}

字符串反转案例
““java
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();
}

}

###面试题(非常非常重要)
StringBuffer和StringBuilder有什么区别？
线程安全角度
StringBuffer:线程安全 效率低 JDK1.0版本
StringBuilder:方法和StringBuffer一样的,线程不安全的 效率高 JDK1.5版本
String和StringBuffer,StringBuilder有什么区别？
String:字符序列不可变,一旦被初始化就无法改变
StringBuffer和StringBuilder可以改变字符序列,有字符串缓冲区,做数据拼接都用这两个,如果考虑线程安全,用StringBuffer,如果不考虑,用StringBuilder. 开发中,经常会用StringBuilder效率高

###注意:
空参 new StringBuffer();
添加 append("helloworld...")  sb.append(true);  返回的字符串缓冲区本身
    insert()
删除  deleteCharAt(索引) 0
length() :1
替换  replace(起始位置,结束位置,替换的元素字符串) 
截取: subString(起始位置int类型) 截取到终止
subString(起始位置,结束位置):截取区间  注意点:返回的是截取到字符串String类型 不再是本身
反转 reverse()
StringBuffer ---> String   toString方法 

### String作为参数传递时候的注意事项
    String类虽然是引用数据类型,但是他当作参数传递时和基本数据类型是一样的。
```java
    基本数据类型的值传递,不改变其值
    引用数据类型的值传递,改变其值

    String类虽然是引用数据类型,但是他当作参数传递时和基本数据类型是一样的
     */
    public static void main(String[] args) {
        String s = "heima";
        System.out.println(s);
        s = change(s);
        System.out.println(s); //heimaitcast


        System.out.println("---------------------");
        StringBuffer sb = new StringBuffer();
        sb.append("heima");
        System.out.println(sb);
        change(sb);
        System.out.println(sb);
    }

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

    public static String change(String s) {
        s += "itcast"; // heimaitcast
        return s;
    }




<div class="se-preview-section-delimiter"></div>

冒泡排序特点

两个相邻比较,如果前者比后者大,就做数据交换
两个数据交换

int a = 10;
int b = 20;
int temp = a;
a = b;
b = temp;




<div class="se-preview-section-delimiter"></div>

冒泡排序写法总结

• 1,两个for循环(Alt + /)
• 2,在里面的for循环做数据交换(要定义第三方变量)
• 3,在第一个for的判断语句 -1
• 4,在第二个for循环判断语句 -1 - i ;
  举例:

public static void main(String[] args) {
        // 定义数组
        int[] arr = { 1, 5, 2, 9, 10, 4 };
        bubbleSort(arr);
        //遍历
        for (int i = 0; i < arr.length; i++) { //i是索引
            System.out.print(arr[i] + " ");
        }
    }
    /*
     * 冒泡排序 1,确定 返回值类型 void 2,确定 参数列表 我要什么
     */
    public static void bubbleSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) { // 提高效率
            for (int j = 0; j < array.length - 1 - i; j++) { // -1防止越界 -i可以提高效率 
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }




<div class="se-preview-section-delimiter"></div>

选择排序特点

拿一个指定索引位置的元素去依次和其他位置上元素值比较,从小到大排序,如果前者比后者,就做数据交换

• 写法总结:
  第一步:写两个for循环出来
  第二步:做数据交换,注意 arr[i] 和arr[j]比较(需要定义临时变量交换)
  第三步:把第一个for循环判断条件 - 1
  第四步:把第二个for循环的初始化语句 j = i + 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++) {
                //从大到小  就改比较符号
                if(arr[i] < arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }




<div class="se-preview-section-delimiter"></div>

注意:如果从大到小排序就只需要改变比较的符号即可

二分查找的前提条件是什么？

必须有顺序

数组的工具类

Arrays
方法
toString():将数组元素转成字符串输出
sort():排序
binarySearch(传入指定元素):二分查找法

包装类

数据类型int，char对应的包装类分别是什么？
int –>Integer
char —> Character
Integer.toBinaryString(int i) :转二进制
Integer.toHexString(int i) : 转十六进制
其他都首字母小写转大写

String类型转int类型

Integer.parseInt(字符串):这个字符串必须是数字字符串
举例 String s = "100"; Integer.parseInt(s);

装箱和拆箱

• 自动装箱：把基本类型转换为包装类类型
• 自动拆箱：把包装类类型转换为基本类型

面试题

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);
            }
         */
    }

}