JavaSE 成长之路zijava学习

JavaSE基础(十三) - StringBuffer &

2016-12-21  本文已影响259人  SawyerZh
Day13-常见对象

1.String 高级

1.1 - StringBuffer 概述

读读 API 📖
A thread-safe, mutable sequence of characters. A string buffer is like a String, but can be modified. At any point in time it contains some particular sequence of characters, but the length and content of the sequence can be changed through certain method calls.
String buffers are safe for use by multiple threads. The methods are synchronized where necessary so that all the operations on any particular instance behave as if they occur in some serial order that is consistent with the order of the method calls made by each of the individual threads involved.

1.2 - StringBuffer 构造方法

构造一个不带字符的字符串缓冲区，初始容量为 16 个字节。

Constructs a string buffer with no characters in it and an initial capacity of 16 characters.

每个字符串缓冲区都有一定的容量。只要字符串缓冲区所包含的字符序列的长度没有超出此容量，就无需分配新的内部缓冲区数组。如果内部缓冲区溢出，则此容量自动增大。从 JDK5 开始，为该类补充了一个单线程使用的等价类 StringBuilder 。与该类相比，通常应该优先使用 StringBuilder ，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。

As of release JDK 5, this class has been supplemented with an equivalent class designed for use by a single thread, StringBuilder. The StringBuilder class should generally be used in preference to this one, as it supports all of the same operations but it is faster, as it performs no synchronization.

1.3 - StringBuffer 基本方法
1.4 - StringBuffer 添加功能

StringBuffer 是字符串缓冲区，当 new 的时候在堆内存创建了一个对象，底层是一个长度为 16 的字符数组，当调用添加方法时，不会再重新创建对象，而是在不断的向原缓冲区添加字符。

插入到 insert 这个索引位置，其他字符串向后移。

1.5 - StringBuffer 删除功能

当缓冲区中这个索引上没有元素时 👇
StringIndexOutOfBoundsException

1.6 - StingBuffer 替换、反转功能
1.7 - StringBuffer 截取功能

原字符串缓冲区不被改变

1.8 - StringBuffer 与 String 相互转换
1.9 - Test 👨‍💻 输出数组
private static String arrayToString(int[] arr) {
    StringBuffer sb = new StringBuffer();
    for (int I = 0; I < arr.length; I++) {
        if (I == 0) {
            // “+” 是通过创建 StringBuffer 对象 append 后 toString() 实现的。
            sb.insert(0, “[“ + arr[i] + “, “);
        } else if (I == arr.length - 1) {
            sb.append(arr[i]).append(‘]’);
        } else {
            sb.append(arr[i]).append(“, “);
        }
    }
    return sb.toString();
}

好处：只有一个 StringBuffer 对象，不会产生过多内存垃圾。

1.10 - Test 👨‍💻 字符串反转
public class Test2 {
    public static void test() {
        Scanner sc = new Scanner(System.in);
        System.out.print(“Please enter a line: “);
        String line = sc.nextLine();
        String reverseLine = reverseString(line);
        System.out.println(reverseLine);
    }

    private static String reverseString(String str) {
        StringBuffer sb = new StringBuffer(str);   // String -> StringBuffer
        sb.reverse();   // 将缓冲区中内容反转
        return sb.toString();
    }
}
1.11 - StringBuffer 与 StringBuilder 区别
  1. StringBuffer 是 JDK1.0版本的，线程安全，效率低；StringBuilder 是 JDK1.5版本的，线程不安全，效率高。
  2. String 是一个不可变的字符序列。
1.12 - StringBuffer 与 StringBuilder 作为参数传递

2.数组高级

2.1 - 冒泡排序
// 外层循环控制趟数，不参与运算，共比较 length - 1 趟。
for (int I = 0; I < arr.length - 1; I++) {
    for (int j = 0; j < arr.length - 1 - I; j++) {
        if (arr[j] > arr[j + 1]) {
            arr[j] = arr[j] ^ arr[j + 1];
            arr[j + 1] = arr[j] ^ arr[j + 1];
            arr[j] = arr[j] ^ arr[j + 1];
        }
    }
}
2.2 - 选择排序
 for (int I = 0; I < arr.length - 1; I++) {
    for (int j = I + 1; j < arr.length; j++) {
        if (arr[I] > arr[j]) {
            arr[i] = arr[i] ^ arr[j];
            arr[j] = arr[i] ^ arr[j];
            arr[i] = arr[i] ^ arr[j];
        }
    }
}
2.3 - 二分查找
public static int search_binary(int[] arr, int target) {
    int min = 0;
    int max = arr.length - 1;
    int mid;
    while (true) {
        if (min > max) {
            return -1;
        }
        mid = (min + max) / 2;
        if (arr[mid] > target) {
            max = mid - 1;
        }
        if (arr[mid] < target) {
            min = mid + 1;
        }
        if (arr[mid] == target) {
            return mid;
        }
    }
}
2.4 - Arrays 概述

读读原码 💡

public static String toString(int[] a) {
    if (a == null)
        // 如果传入数组是 null 返回 “null”
        return “null”;
    // 最大索引
    int iMax = a.length - 1;
    // 如果数组中没有元素，返回[]
    if (iMax == -1)
        return “[]”;
    // 线程不安全，效率高
    StringBuilder b = new StringBuilder();
    // 将 ‘[‘ 添加到字符串缓冲区
    b.append(‘[‘);
    for (int I = 0; ; I++) {
        // 将元素拼接到到字符串缓冲区
        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) {
    // 最小索引 0
    int low = fromIndex;
    // 最大索引 length - 1
    int high = toIndex - 1;

    // 最小索引 <= 最大索引 作为循环判断
    while (low <= high) {
        // >>> 求出中间索引值
        int mid = (low + high) >>> 1;
        // 通过中间索引获取中间值
        int midVal = a[mid];
        // 查找值在中间值右侧
        if (midVal < key)
            // 最小索引变化
            low = mid + 1;
        // 查找值在中间值左侧
        else if (midVal > key)
            high = mid - 1;
        else
            // 中间值 == 查找值
            return mid; // key found
    }
    // 如果跳出循环，说明符合 low <= high 条件，没有找到返回 -(low + 1)
    return -(low + 1);  // key not found.
}

3.Integer 基本数据类型包装类

3.1 - Integer 概述

byte -> Byte
short -> Short
int -> Integer
long -> Long
float -> Float
double -> Double
char -> Character
boolean -> Boolean

3.2 - 进制转换
3.3 - 常量及构造方法

Integer i = new Integer("abc");
NumberFormatException：数字格式异常

3.4 - int 与 String 互相转换
int i1 = 100;
Integer i2 = new Integer(i1);
// 第一种
String s1 = i1 + "";
// 第二种
String s2 = String.valueOf(i1);
// 第三种
String s3 = i2.toString();
// 第四种
String s4 = Integer.toString(i1);

String s = "200";
// 第一种
int i1 = new Integer(s).intValue;
// 第二种
int i2 = Integer.parseInt(s);
3.5 - 拆装箱

注意事项：Integer i = null; ，底层用 i 调用 intValue()
NullPointerException

3.6 - 面试题
{
    Integer i1 = 97;
    Integer i2 = 97;
    System.out.println(i1 == i2);       // true
    System.out.println(i1.equals(i2));  // true
}

{
    Integer i1 = 128;
    Integer i2 = 128;
    System.out.println(i1 == i2);       // false
    System.out.println(i1.equals(i2));  // true
}

通过自动装箱创建 Integer，如果没有超过 byte 取值范围，就不会自动创建对象。而是从常量池中取，如果超过了 byte 取值范围，则会重新创建对象。

悄悄话 🌈

彩蛋 🐣

Project NotePDF
上一篇下一篇

猜你喜欢

热点阅读