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(索引) 0length() :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);            }         */    }}