[TOC]

StringBuffer类

StringBuffer类概述及其构造方法

• StringBuffer类概述

  • 线程安全的可变字符序列。
  • 用字符串做拼接，比较耗时并且也耗内存，而这种拼接操作又是比较常见的，为了解决这个问题，Java就提供了一个字符串缓冲区类StringBuffer供我们使用。

• StringBuffer和String的区别?

  • 前者长度和内容可变，后者不可变。
  • 如果使用前者做字符串的拼接，不会浪费太多的资源。

• 构造方法

  • public StringBuffer()：无参构造方法。
  • public StringBuffer(int capacity)：指定容量的字符串缓冲器对象。
  • public StringBuffer(String str)：指定字符串内容的字符串缓冲器对象。

• StringBuffer的方法：

  • public int capacity()：返回当前容量。（初始值16个字符） 理论值
  • public int length():返回长度（字符数）。 实际值

public class StringBufferDemo {
    public static void main(String[] args) {
        // public StringBuffer():无参构造方法
        StringBuffer sb = new StringBuffer();
        System.out.println("sb:" + sb);
        System.out.println("sb.capacity():" + sb.capacity());
        System.out.println("sb.length():" + sb.length());
        System.out.println("--------------------------");

        // public StringBuffer(int capacity):指定容量的字符串缓冲区对象
        StringBuffer sb2 = new StringBuffer(50);
        System.out.println("sb2:" + sb2);
        System.out.println("sb2.capacity():" + sb2.capacity());
        System.out.println("sb2.length():" + sb2.length());
        System.out.println("--------------------------");

        // public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
        StringBuffer sb3 = new StringBuffer("hello");
        System.out.println("sb3:" + sb3);
        System.out.println("sb3.capacity():" + sb3.capacity());
        System.out.println("sb3.length():" + sb3.length());
    }
}

/*
运行结果：
sb:
sb.capacity():16
sb.length():0
--------------------------
sb2:
sb2.capacity():50
sb2.length():0
--------------------------
sb3:hello
sb3.capacity():21 // 16+5
sb3.length():5
*/

StringBuffer类的成员方法

• ** 添加**功能

  • public StringBuffer** append**(String str)

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

    // 创建字符串缓冲区对象
    StringBuffer sb = new StringBuffer();
    
    //public StringBuffer append(String str)
    StringBuffer sb2 = sb.append("hello");//将hello添加到StringBuffer缓冲器
    System.out.println("sb:" + sb);
    System.out.println("sb2:" + sb2);
    System.out.println(sb == sb2); // true
    

    StringBuffer sb = new StringBuffer();
    // 链式编程
    sb.append("hello").append(true).append(12).append(34.56);
    System.out.println("sb:" + sb);
    sb.insert(5, "world");
    System.out.println("sb:" + sb);
    

  • public StringBuffer insert(int offset,String str)

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

• 删除功能

  • public StringBuffer deleteCharAt(int index)
    • 删除指定位置的字符，并返回本身
  • public StringBuffer delete(int start,int end)
    • 删除从指定位置开始指定位置结束的内容，并返回本身（包左不包右）

    // public StringBuffer delete(int start,int
    // end):删除从指定位置开始指定位置结束的内容，并返回本身
    // 需求：我要删除world这个字符串
    // sb.delete(5, 10);
    
    // 需求:我要删除所有的数据
    sb.delete(0, sb.length());
    System.out.println("sb:" + sb);
    

• 替换功能

  • public StringBuffer replace(int start,int end,String str)
    • 从start开始到end用str替换

    // 需求：我要把world这个数据替换为"节日快乐"
    sb.replace(5, 10, "节日快乐");
    System.out.println("sb:" + sb);
    

• 反转功能

  • public StringBuffer reverse()

      // 添加数据
      sb.append("霞青林爱我");
      System.out.println("sb:" + sb);
  
      // public StringBuffer reverse()
      sb.reverse();
      System.out.println("sb:" + sb);
  

/*
result:
sb:霞青林爱我
sb:我爱林青霞
*/
```

• 截取功能 : 注意返回值类型不再是StringBuffer本身,而是String类型
  • public String substring(int start)
  • public String substring(int start,int end)
    • 截取功能和前面几个功能的不同：返回值类型是String类型，本身没有发生改变

    public class StringBufferDemo {
    public static void main(String[] args) {
        // 创建字符串缓冲区对象
        StringBuffer sb = new StringBuffer();

        // 添加元素
        sb.append("hello").append("world").append("java");
        System.out.println("sb:" + sb);

        // 截取功能
        // public String substring(int start)
        String s = sb.substring(5);
        System.out.println("s:" + s);
        System.out.println("sb:" + sb);

        // public String substring(int start,int end)
        String ss = sb.substring(5, 10);
        System.out.println("ss:" + ss);
        System.out.println("sb:" + sb);
    }
}

StringBuffer类练习

• String和StringBuffer的相互转换
  • 注意：不能把字符串的值直接赋值给StringBuffer,可通过以下两种方式进行赋值：
• String转StringBuffer方法：
  • 方式1:通过构造方法
    • StringBuffer sb = new StringBuffer(s);
  • 方式2：通过append()方法
    • StringBuffer sb2 = new StringBuffer();
    • sb2.append(s);
• StringBuffer转String方法：
  • 注：任何引用类型调用toString方法都可以转为String类型。
  • 方式1:通过构造方法
    • String str = new String(buffer);
  • 方式2：通过toString()方法
    • String str2 = buffer.toString();

public class StringBufferTest {
    public static void main(String[] args) {
        // String -- StringBuffer
        String s = "hello";
        StringBuffer sb2 = new StringBuffer();
        sb2.append(s);
        System.out.println("sb:" + sb);
        System.out.println("sb2:" + sb2);
        System.out.println("---------------");

        // StringBuffer -- String
        StringBuffer buffer = new StringBuffer("java");
        // String(StringBuffer buffer)
        // 方式1:通过构造方法
        String str = new String(buffer);
        // 方式2：通过toString()方法
        String str2 = buffer.toString();
        System.out.println("str:" + str);
        System.out.println("str2:" + str2);
    }
}

• 把数组拼接成一个字符串

public class StringBufferTest2 {
    public static void main(String[] args) {
        // 定义一个数组
        int[] arr = { 44, 33, 55, 11, 22 };

        //用StringBuffer做拼接的方式
        String s2 = arrayToString2(arr);
        System.out.println("s2:" + s2);
    }

    // 用StringBuffer做拼接的方式
    public static String arrayToString2(int[] arr) {
        StringBuffer sb = new StringBuffer();
        sb.append("[");
        for (int x = 0; x < arr.length; x++) {
            if (x == arr.length - 1) {
                sb.append(arr[x]);
            } else {
                sb.append(arr[x]).append(", ");
            }
        }
        sb.append("]");

        return sb.toString();
    }
}

• 把字符串反转

public class StringBufferTest3 {
    public static void main(String[] args) {
        // 键盘录入数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数据：");
        String s = sc.nextLine();

        // 方式1：用String做拼接
        String s1 = myReverse(s);
        System.out.println("s1:" + s1);
        // 方式2：用StringBuffer的reverse()功能
        String s2 = myReverse2(s);
        System.out.println("s2:" + s2);
    }

    // 用StringBuffer的reverse()功能
    public static String myReverse2(String s) {
        // StringBuffer sb = new StringBuffer();
        // sb.append(s);

        // StringBuffer sb = new StringBuffer(s);
        // sb.reverse();
        // return sb.toString();

        // 简易版
        return new StringBuffer(s).reverse().toString();
    }

    // 用String做拼接
    public static String myReverse(String s) {
        String result = "";

        char[] chs = s.toCharArray();
        for (int x = chs.length - 1; x >= 0; x--) {
            // char ch = chs[x];
            // result += ch;
            result += chs[x];
        }

        return result;
    }
}

• 判断一个字符串是否是对称字符串
  • 例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串

public class StringBufferTest4 {
    public static void main(String[] args) {
        // 创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s = sc.nextLine();

        // 一个一个的比较
        boolean b = isSame(s);
        System.out.println("b:" + b);
        
        //用字符串缓冲区的反转功能
        boolean b2 = isSame2(s);
        System.out.println("b2:"+b2);
    }
    
    public static boolean isSame2(String s) {
        return new StringBuffer(s).reverse().toString().equals(s);
    }

    public static boolean isSame(String s) {
        boolean flag = true;

        // 把字符串转成字符数组
        char[] chs = s.toCharArray();

        for (int start = 0, end = chs.length - 1; start <= end; start++, end--) {
            if (chs[start] != chs[end]) {
                flag = false;
                break;
            }
        }
        return flag;
    }
}

StringBuffer类面试题

• 通过查看API了解一下StringBuilder类

  • 此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。

• String , StringBuffer , StringBuilder的区别

  • A:String是内容不可变的，而StringBuffer,StringBuilder都是内容可变的。
  • B:StringBuffer是同步的，数据安全,效率低;
  • C:StringBuilder是不同步的,数据不安全,效率高

• StringBuffer和数组的区别?

  • 二者都可以看出是一个容器，装其他的数据。
  • StringBuffer的数据最终是一个字符串数据。
  • 数组可以放置多种数据，但必须是同一种数据类型的。

• 看程序写结果：
  • String作为参数传递
  • StringBuffer作为参数传递
• 注意：
  • String作为参数传递，效果和基本类型作为参数传递是一样的。
  • StringBuffer类型调用append方法时内存值会改变

public class StringBufferDemo {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "world";
        System.out.println(s1 + "---" + s2);// hello---world
        change(s1, s2);
        System.out.println(s1 + "---" + s2);// hello---world

        StringBuffer sb1 = new StringBuffer("hello");
        StringBuffer sb2 = new StringBuffer("world");
        System.out.println(sb1 + "---" + sb2);// hello---world
        change(sb1, sb2);
        System.out.println(sb1 + "---" + sb2);// hello---worldworld

    }

    public static void change(StringBuffer sb1, StringBuffer sb2) {
        sb1 = sb2;//StringBuffer类型用`=`赋值的特殊点。
        sb2.append(sb1);
    }

    public static void change(String s1, String s2) {
        s1 = s2;
        s2 = s1 + s2;
    }
}

数组高级(排序和查找)

排序

• 冒泡排序(必须掌握)
  • 相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处
    

public class ArrayDemo {
    public static void main(String[] args) {
        // 定义一个数组
        int[] arr = { 24, 69, 80, 57, 13 };
        System.out.println("排序前：");
        printArray(arr);

        //由于我可能有多个数组要排序，所以我要写成方法
        bubbleSort(arr);
        System.out.println("排序后：");
        printArray(arr);
    }
    
    //冒泡排序代码
    public static void bubbleSort(int[] arr){
        for (int x = 0; x < arr.length - 1; x++) {
            for (int y = 0; y < arr.length - 1 - x; y++) {
                if (arr[y] > arr[y + 1]) {
                    int temp = arr[y];
                    arr[y] = arr[y + 1];
                    arr[y + 1] = temp;
                }
            }
        }
    }

    // 遍历功能
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int x = 0; x < arr.length; x++) {
            if (x == arr.length - 1) {
                System.out.print(arr[x]);
            } else {
                System.out.print(arr[x] + ", ");
            }
        }
        System.out.println("]");
    }
}

• 选择排序

  • 从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

    
    

public class ArrayDemo {
    public static void main(String[] args) {
        // 定义一个数组
        int[] arr = { 24, 69, 80, 57, 13 };
        System.out.println("排序前：");
        printArray(arr);

        //用方法改进
        selectSort(arr);
        System.out.println("排序后：");
        printArray(arr);

    }
    
    public static void selectSort(int[] arr){
        for(int x=0; x<arr.length-1; x++){
            for(int y=x+1; y<arr.length; y++){
                if(arr[y] <arr[x]){
                    int temp = arr[x];
                    arr[x] = arr[y];
                     arr[y] = temp;
                }
            }
        }
    }

    // 遍历功能
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int x = 0; x < arr.length; x++) {
            if (x == arr.length - 1) {
                System.out.print(arr[x]);
            } else {
                System.out.print(arr[x] + ", ");
            }
        }
        System.out.println("]");
    }
}

练习题：字符串排序

public class ArrayTest {
    public static void main(String[] args) {
        // 定义一个字符串
        String s = "dacgebf";

        // 把字符串转换为字符数组
        char[] chs = s.toCharArray();

        // 把字符数组进行排序
        bubbleSort(chs);

        //把排序后的字符数组转成字符串
        String result = String.valueOf(chs);
        
        //输出最后的字符串
        System.out.println("result:"+result);
    }

    // 冒泡排序
    public static void bubbleSort(char[] chs) {
        for (int x = 0; x < chs.length - 1; x++) {
            for (int y = 0; y < chs.length - 1 - x; y++) {
                if (chs[y] > chs[y + 1]) {
                    char temp = chs[y];
                    chs[y] = chs[y + 1];
                    chs[y + 1] = temp;
                }
            }
        }
    }
}

查找

基本查找: 数组元素无序

public static int getIndex(int[] arr,int value) {
    int index = -1;
    for(int x=0; x<arr.length; x++) {
        if(arr[x] == value) {
            index = x;
            break;
        }
    }
    return index;
}

二分查找(折半查找) : 数组元素有序

public class ArrayDemo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {11,22,33,44,55,66,77};
        
        //写功能实现
        int index = getIndex(arr, 33);
        System.out.println("index:"+index);
        
        //假如这个元素不存在后有什么现象呢?
        index = getIndex(arr, 333);
        System.out.println("index:"+index);
    }
    
    /*
     * 两个明确：
     * 返回值类型：int
     * 参数列表：int[] arr,int value
     */
    public static int getIndex(int[] arr,int value){
        //定义最大索引，最小索引
        int max = arr.length -1;
        int min = 0;
        
        //计算出中间索引
        int mid = (max +min)/2;
        
        //拿中间索引的值和要查找的值进行比较
        while(arr[mid] != value){
            if(arr[mid]>value){
                max = mid - 1;
            }else if(arr[mid]<value){
                min = mid + 1;
            }
            //加入判断
            if(min > max){
                return -1;
            }
            mid = (max +min)/2;
        }
        return mid;
    }
}

数组高级练习题

• 把字符串中的字符进行排序。
• 举例：”dacgebf”
• 结果：”abcdefg”

Arrays类

Arrays类概述

• 针对数组进行操作的工具类。提供了排序，查找等功能。

Arrays类常用方法

• public static String toString(int[] a):把数组转为字符串
• public static void sort(int[] a)：对数组进行排序
• public static int binarySearch(int[] a,int key)：二分查找

常用方法源码详细解释

• public static String toString(int[] a)
• public static int binarySearch(int[] a,int key)

基本类型包装类

基本类型包装类概述

• 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
• 常用的操作之一：用于基本数据类型与字符串之间的转换。
• 基本类型和包装类的对应
  • byte <---> Byte
  • short <---> Short
  • int <---> Integer
  • long <---> Long
  • float <---> Float
  • double <---> Double
  • char <---> Character
  • boolean <---> Boolean

Integer类

Integer类概述

• Integer类概述
  • Integer 类在对象中包装了一个基本类型 int 的值
  • 该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。

Integer类构造方法

• public Integer(int value)
• public Integer(String s)
  • 注：这个字符串必须是由数字字符串组成。

Integer类成员方法

• int类型和String类型的相互转换：String.valueOf

  • int –-> String

      int number = 100;
      // 方式1
      String s1 = "" + number;
      System.out.println("s1:" + s1);
  
      // 方式2(最优)
      String s2 = String.valueOf(number);
      System.out.println("s2:" + s2);
  
      // 方式3
      // int -- Integer -- String
      Integer i = new Integer(number);
      String s3 = i.toString();
      System.out.println("s3:" + s3);
  
      // 方式4
      // public static String toString(int i)
      String s4 = Integer.toString(number);
      System.out.println("s4:" + s4);
      System.out.println("-----------------");
  

  • String –-> int: Integer.parseInt

      // String -- int
      String s = "100";
      // 方式1
      // String --> Integer --> int
      Integer ii = new Integer(s);
      // public int intValue()
      int x = ii.intValue();
      System.out.println("x:" + x);
      //方式2(非常重要)
      //public static int parseInt(String s)
      int y = Integer.parseInt(s);
      System.out.println("y:"+y);
  

• public int intValue()
• public static int parseInt(String s)
• public static String toString(int i)
• public static Integer valueOf(int i)
• public static Integer valueOf(String s)
• 常用的基本进制转换
  • public static String toBinaryString(int i)
  • public static String toOctalString(int i)
  • public static String toHexString(int i)
• 十进制到其他进制
  • public static String toString(int i,int radix)
• 其他进制到十进制
  • public static int parseInt(String s,int radix)

JDK5的新特性

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

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

• JDK1.5以后，简化了定义方式。

  • Integer x = new Integer(4);可以直接写成
  • Integer x = 4;//自动装箱。
  • x = x + 5;//自动拆箱。通过intValue方法。

• 需要注意：

  • 在使用时，Integer x = null;上面的代码就会出现NullPointerException。

public class IntegerDemo {
    public static void main(String[] args) {
        // 定义了一个int类型的包装类类型变量i
        // Integer i = new Integer(100);
        Integer ii = 100;
        ii += 200;
        System.out.println("ii:" + ii);

        // 通过反编译后的代码
        // Integer ii = Integer.valueOf(100); //自动装箱
        // ii = Integer.valueOf(ii.intValue() + 200); //自动拆箱，再自动装箱
        // System.out.println((new StringBuilder("ii:")).append(ii).toString());

        Integer iii = null;
        // NullPointerException
        if (iii != null) {
            iii += 1000;
            System.out.println(iii);
        }
    }
}

Integer的面试题

• Integer i = 1; i += 1;做了哪些事情
• 缓冲池(看程序写结果)
  • 注意：Integer的数据直接赋值，如果在-128到127之间，会直接从缓冲池里获取数据

public class IntegerDemo {
    public static void main(String[] args) {
        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1 == i2);
        System.out.println(i1.equals(i2));
        System.out.println("-----------");

        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3 == i4);
        System.out.println(i3.equals(i4));
        System.out.println("-----------");

        Integer i5 = 128;
        Integer i6 = 128;
        System.out.println(i5 == i6);
        System.out.println(i5.equals(i6));
        System.out.println("-----------");

        Integer i7 = 127;
        Integer i8 = 127;
        System.out.println(i7 == i8);
        System.out.println(i7.equals(i8));

        // 通过查看源码，我们就知道了，针对-128到127之间的数据，做了一个数据缓冲池，如果数据是该范围内的，每次并不创建新的空间
        // Integer ii = Integer.valueOf(127);
    }
}

Character类

Character类概述

• Character类概述
  • Character 类在对象中包装一个基本类型 char 的值,此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然

Character类构造方法

• 构造方法
  • public Character(char value)

Character类成员方法

• public static boolean isUpperCase(char ch)
• public static boolean isLowerCase(char ch)
• public static boolean isDigit(char ch)
• public static char toUpperCase(char ch)
• public static char toLowerCase(char ch)

练习题：

• 统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)

    public static void main(String[] args) {
        // 定义三个统计变量。
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;

        // 键盘录入一个字符串。
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();

        // 把字符串转换为字符数组。
        char[] chs = line.toCharArray();

        // 历字符数组获取到每一个字符
        for (int x = 0; x < chs.length; x++) {
            char ch = chs[x];

            // 判断该字符
            if (Character.isUpperCase(ch)) {
                bigCount++;
            } else if (Character.isLowerCase(ch)) {
                smallCount++;
            } else if (Character.isDigit(ch)) {
                numberCount++;
            }
        }

        // 输出结果即可
        System.out.println("大写字母：" + bigCount + "个");
        System.out.println("小写字母：" + smallCount + "个");
        System.out.println("数字字符：" + numberCount + "个");
    }
}