2019-05-22 Java学习日记之StringBuffer&数组排序

StringBuffer

StringBuffer的添加功能:

public StringBuffer append(String str)

　　可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身

public StringBuffer insert(int offset,String str)

　　在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身

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

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

    private static void demo2() {
        StringBuffer sb1 = new StringBuffer("hello");
        sb1.insert(5, "kugou");        //在指定位置添加元素,如果没有指定位置的索引就会报索引越界异常
        
        System.out.println(sb1);
    }

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

StringBuffer的删除功能:

public StringBuffer deleteCharAt(int index);

　　删除指定位置的字符,并返回本身

public StringBuffer delete(int start,int end)

　　删除从指定位置开始指定位置结束的内容,并返回本身

public class Demo3 {
    public static void main(String[] args) {
        StringBuffer sb1 = new StringBuffer();
//        sb1.deleteCharAt(5);        //当缓冲区中的这个索引上没有元素的时候就会报StringIndexOutOfBoundsException
        
        sb1.append("hello");
//        sb1.deleteCharAt(4);        //根据索引删除掉索引位置上对应的字符
//        sb1.delete(0, 2);            //删除的时候是包含头,不包含尾
//        System.out.println(sb1);
        
        sb1.delete(0, sb1.length());//清空缓冲区    
        System.out.println(sb1);
        
        
    }
}

StringBuffer的替换功能:

public StringBuffer replace(int start,int end, String str);

　　从start开始到end用str替换

    private static void demo2() {
        StringBuffer sb1 = new StringBuffer("我爱学习");
        sb1.reverse();
        System.out.println(sb1);
    }

StringBuffer的反转功能:

public StringBuffer reverse();

　　字符串反转

    private static void demo1() {
        StringBuffer sb1 = new StringBuffer("我爱学习");
        sb1.replace(1, 2, "非常爱");
        System.out.println(sb1);
    }

StringBuffer的截取功能:

public String substring(int start)

　　从指定位置截取到末尾

public String substring(int start,int end)

　　截取从指定位置开始到结束位置,包括开始位置,不包括结束位置

注意:返回值类型不再是StringBuffer本身

    private static void demo1() {
        StringBuffer sb1 = new StringBuffer("woaixuexi");
        String str = sb1.substring(4);
        System.out.println(str);
        System.out.println(sb1);
        
        String str2= sb1.substring(4,7);
        System.out.println(str2);
    }

StringBuffer与String的相互转换:

A:String -- StringBuffer

a:通过构造方法

b:通过append()方法

B:StringBuffer -- String

a:通过构造方法

b:通过toString()方法

c:通过subString(0,length);

    private static void demo2() {
        StringBuffer sb1 = new StringBuffer("hello");
        
        String s1 = new String(sb1);                //通过构造将StringBuffer转换为String
        System.out.println(s1);
        
        String s2 = sb1.toString();                    //通过toString方法将StringBuffer转换为String
        System.out.println(s2);
        
        String s3 = sb1.substring(0,sb1.length());    //通过截取字符串将StringBuffer转换为String
        System.out.println(s3);
    }

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

 把数组转换成字符串:

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

输出结果:"[1,2,3]";

public class Test1 {
    public static void main(String[] args) {
        int[] arr = { 1, 2, 3 };

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

    }

    /**
     * 将数组转换成字符串: 
     * 1、返回值类型String 
     * 2、参数列表int[]
     * 
     * arrayToString 将数组转换成字符串
     */
    public static String arrayToString(int[] arr) {
        StringBuffer sb1 = new StringBuffer(); // 创建字符串缓冲区对象
        sb1.append("["); // 将[添加到缓冲区

        for (int i = 0; i < arr.length; i++) { // 遍历数组
            if (i == arr.length - 1) {
                sb1.append(arr[i]).append("]");
            } else {
                sb1.append(arr[i] + ", ");
            }

        }

        return sb1.toString();
    }
}

字符串反转:

需求:把字符串反转

import java.util.Scanner;

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));
        
    }
    /**
     * 将字符串反转:
     * 1、返回值类型String
     * 2、参数列表String line
     */
    public static String revString(String line){
        StringBuffer sb = new StringBuffer(line);    //将字符串转换成StringBuffer对象
        sb.reverse();                                //将缓冲区的内容反转
        
        return sb.toString();
    }

}

形式参数问题:

String作为参数传递

StringBuffer作为参数传递

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

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

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

public class Demo7 {
    public static void main(String[] args) {
        String s = "hello";
        System.out.println(s);
        change(s);
        System.out.println(s);

        StringBuffer sb = new StringBuffer();
        sb.append("hello ");
        System.out.println(sb);
        change(sb);
        System.out.println(sb);

    }

    private static void change(StringBuffer sb) {
        sb.append("kugou");
    }

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

}

 数组排序

 冒泡排序:

package com.array;

public class Demo1 {

    public static void main(String[] args) {
        int[] arr = {24,32,69,80,13,57};
        bubbleSort(arr);
//        selectSort(arr);
        print(arr);
    }
    /**
     * 冒泡排序
     * 1、返回值类型，void
     * 2、参数列表，int[] arr
     */
    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++) {    //-1s为了防止索引越界
                if (arr[j] > arr[j+1]) {
                    /*int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;*/
                    swap(arr, i, j);
                }
            }
        }
    }
    /**
     * 打印数组
     * 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.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;
    }
}

选择排序:

概述:

用一个索引位置上的元素,依次与其他索引位置上的元素比较,

小的在前面大的在后面.

package com.array;

public class Demo1 {

    public static void main(String[] args) {
        int[] arr = {24,32,69,80,13,57};
        bubbleSort(arr);
//        selectSort(arr);
        print(arr);
    }
    /**
     * 选择排序
     * 1、返回值类型void
     * 2、参数列表int[] arr
     */
    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
     */
    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
    /**
     * 换位操作
     * 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;
    }
}

二分查找:

注意:

如果数组无序,就不能使用二分查找

　　因为如果你排序了,但是你排序的时候已经改变了最原始的元素索引

package com.array;

public class Demo2 {

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

}

Arrays类:

概述:

针对数组进行操作的工具类

提供了排序,查找等功能

package com.array;

import java.util.Arrays;

public class Demo3 {

    public static void main(String[] args) {
        int[] arr = {33,66,44,55,11,22};
        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, 88));    //-插入点-1
        
    }

}

基本类型包装类:

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

常用的操作之一:用于基本数据类型与字符串之间的转换

String和int类型的相互转换:

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

char的包装类Character中没有parseXxx的方法

字符串到字符的转换通过toCharArray()就可以吧字符串转换成字符数组

    private static void demo2() {
        // 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
        System.out.println(i5);
    }

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

 JDK5的新特性:

自动装箱:把基本类型转换成包装类

自动拆箱:把包装类类型转换成基本类型

注意事项:

在使用时,Integer x = null;代码就会出现NullPointerException

建议先判断是否为null, 然后再使用

public class Demo5 {
    public static void main(String[] args) {
        int x = 100;
        Integer i1 = new Integer(x);    //将基本数据类型包装成对象,装箱
        
        int y = i1.intValue();            //将对象转换成基本数据类型,拆箱
        
        Integer i2 = 100;                //自动装箱,将基本数据类型转换成对象
        int z = i2 + 100;                //自动拆箱,把对象转换成基本数据类型
        System.out.println(z);
    
        Integer i3 = null;
        int a = i3 + 100;                //底层i3调用intValue,但是i3是null,null调用就会出现
        System.out.println(a);            //空指针异常java.lang.NullPointerException
    }