JavaSE学习总结第13天_API常用对象3

 

13.01 StringBuffer的概述

StringBuffer类概述:线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。

StringBuffer和String的区别:StringBuffer长度和内容可变，String不可变。使用StringBuffer做字符串的拼接不会浪费太多资源

13.02 StringBuffer类的构造方法

1.  public StringBuffer():

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

2.  public StringBuffer(int capacity):

构造一个不带字符，但具有指定初始容量的字符串缓冲区

3.  public StringBuffer(String str):

构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16加上字符串参数的长度

例:

StringBuffer sb1 = new StringBuffer();
System.out.println(sb1.capacity());//16
System.out.println(sb1.length());//0

StringBuffer sb2 = new StringBuffer("hello");
System.out.println(sb2.capacity());//21
System.out.println(sb2.length());//5

13.03 StringBuffer的添加功能

1.  public StringBuffer append(String str):

将指定的字符串追加到此字符序列

2.  public StringBuffer insert(int offset,String str):

将字符串插入此字符序列中

13.04 StringBuffer的删除功能

1.  public StringBuffer deleteCharAt(int index):

移除此序列指定位置的 char。此序列将缩短一个 char

2.  public StringBuffer delete(int start,int end):

移除此序列的子字符串中的字符。该子字符串从指定的 start 处开始，一直到索引 end - 1 处的字符，如果不存在这种字符，则一直到序列尾部。如果 start 等于 end，则不发生任何更改

13.05 StringBuffer的替换功能

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

使用给定 String 中的字符替换此序列的子字符串中的字符

13.06 StringBuffer的反转功能

public StringBuffer reverse():将此字符序列用其反转形式取代

13.07 StringBuffer的截取功能

1.  public String substring(int start)

返回一个新的 String，它包含此字符序列当前所包含的字符子序列

2.  public String substring(int start,int end)

返回一个新的 String，它包含此序列当前所包含的字符子序列。该子字符串从指定的 start 处开始，一直到索引 end - 1 处的字符

13.08 StringBuffer和String的相互转换

String和StringBuffer的相互转换

• String →StringBuffer

Stirng s;

1.StringBuffer sb = new StringBuffer (s);

2.StringBuffer sb = new StringBuffer (); sb.append(s);

• StringBuffer →String

1.String s = new String(sb);

2.String s = sb.toString();

13.09 把数组拼接成指定格式的字符串案例

public class Practice 
{
    public static void main(String[] args) 
    {
        //定义数组
        int[] arr = {23,52,12,63,25};
        String s = arrToString(arr);
        System.out.println(s);
    }
    public static String arrToString(int[] arr)
    {
        StringBuffer sb = new StringBuffer("[");
        for (int i = 0; i < arr.length; i++) 
        {
            if(i == arr.length -1)
            {
                sb.append(arr[i]);
            }
            else
            {
                sb.append(arr[i]).append(", ");
            }
        }
        sb.append("]");
        return sb.toString();
    }
}

13.10 字符串反转功能案例

import java.util.Scanner;

public class Practice 
{
    public static void main(String[] args) 
    {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数据:");
        String str = sc.nextLine();
        String s = myReverse(str);
        System.out.println(s);
    }
    public static String myReverse(String s)
    {
        return new StringBuffer(s).reverse().toString();
    }
}

13.11 判断一个字符串是否对称案例

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

public class Practice 
{
    public static void main(String[] args) 
    {
        String s = "abcba";
        System.out.println(isSame2(s));
    }
    //方式1
    public static String isSame(String s) 
    {
         // 把字符串转成字符数组
         char[] chs = s.toCharArray();
         for (int start = 0, end = chs.length - 1; start <= end; start++, end--) 
         {
             if (chs[start] != chs[end]) 
             {
                 return "不对称";
             }
         }
         return "对称";
    }
    //方式2
    public static boolean isSame2(String s) 
    {
        return new StringBuffer(s).reverse().toString().equals(s);
    }
}

13.12 StringBuffer的两个面试题

第1题:String,StringBuffer,StringBuilder的区别

1.String是内容不可变的，而StringBuffer和StringBuilder都是内容可变的

2.StringBuffer是同步的，数据安全，效率低

  StringBuilder是不同步的，数据不安全，效率高

第2题:StringBuffer和数组的区别

StringBuffer和数组都是可以装数据的容器

StringBuffer可以存储任意类型的数据，但最终是一个字符串数据

数组只能存储同一种数据类型的数据

13.13 String和StringBuffer分别作为参数传递

例:

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

        StringBuffer sb1 = new StringBuffer("hello");
        StringBuffer sb2 = new StringBuffer("world");
        System.out.println(sb1 + "---" + sb2);
        change(sb1, sb2);
        System.out.println(sb1 + "---" + sb2);
    }
    public static void change(StringBuffer sb1, StringBuffer sb2) 
    {
        sb1 = sb2;
        sb2.append(sb1);
    }

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

运行结果:

hello---world
hello---world
hello---world
hello---worldworld

注意:String作为参数传递，效果与基本类型作为参数传递一样

13.14 数组高级冒泡排序原理图解

冒泡排序原理:将数组0下标的数与1下标的数比较，如果1下标的数小于0下标的数则交换位置，然后将1下标的数与2下标的数比较，如果1下标的数大于2下标的数则交换位置，反之就不交换位置，直到比较结束最后一个下标存放的就是数组中最大的数，第一轮比较结束。然后再从0下标与1下标的数比较，此时最后一个数不需要参与比较，重复以上步骤直到结束。(从小到大排序)

13.15 数组高级冒泡排序代码实现

public class Practice 
{
    /**
     * 冒泡排序
     * @param args
     */
    public static void main(String[] args) 
    {
        int[] arr = {2,1,55,-12,45,25,-64};
        System.out.println("排序前:");
        print(arr);
        bubbleSort(arr);
        System.out.println("排序后:");
        print(arr);
    }
    public static void bubbleSort(int[] arr)
    {
        for (int i = 0; i < arr.length-1; i++) 
        {
            //-1是为了避免角标越界
            //-i是为了让内循环参与比较的次数随着外循环的增加而递减
            for (int j = 0; j < arr.length-1-i; j++) 
            {
                if(arr[j]>arr[j+1])
                {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] =  temp;
                }
            }
        }
    }
    //遍历数组
    public static void print(int[] arr)
    {
        for (int i = 0; i < arr.length; i++) 
        {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
}

运行结果:

排序前:
2 1 55 -12 45 25 -64 
排序后:
-64 -12 1 2 25 45 55 

13.16 数组高级选择排序原理图解

选择排序原理:将数组内0下标的元素依次与后面的元素比较，如果1下标之后的元素小于0下标的元素就将该元素与0下标的元素交换位置，比较完成后0下标的元素存放的就是最小值，第一轮比较结束。然后从1下标开始依次与后面的元素比较，比较完成后1下标存放的就是第二小的数，依次类推直到排序结束。(由小到大排序)

 

13.17 数组高级选择排序代码实现

public class Practice 
{
    /**
     * 选择排序
     * @param args
     */
    public static void main(String[] args) 
    {
        int[] arr = {2,15,23,12,76,73,18,29};
        System.out.println("排序前:");
        print(arr);
        selectSort(arr);
        System.out.println("排序后:");
        print(arr);
    }
    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;
                }
            }
        }
    }
    //遍历数组
    public static void print(int[] arr)
    {
        for (int i = 0; i < arr.length; i++) 
        {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
}

运行结果:

排序前:
2 15 23 12 76 73 18 29 
排序后:
2 12 15 18 23 29 73 76

13.18 把字符串中的字符进行排序案例

public class Practice 
{
    /**
     * @param args
     */
    public static void main(String[] args) 
    {
        String s = "dacgebf";
        char[] ch = s.toCharArray();
        selectSort(ch);
        System.out.println(new String(ch));
    }
    public static void selectSort(char[] ch)
    {
        for (int i = 0; i < ch.length-1; i++) 
        {
            for (int j = i+1; j < ch.length; j++) 
            {
                if(ch[i] > ch[j])
                {
                    char temp = ch[i];
                    ch[i] = ch[j];
                    ch[j] = temp;
                }
            }
        }
    }
}

13.19 数组高级二分查找原理图解

二分查找的前提数组元素必须有序

 

 

13.20 数组高级二分查找代码实现

public class Practice 
{
    /**
     * 二分查找
     * @param args
     */
    public static void main(String[] args) 
    {
        int[] arr = {11,15,23,28,35,39,48,49,58};
        int index = binarySearch(arr, 28);
        System.out.println(index);
    }
    public static int binarySearch(int[] arr,int key)
    {
        int min = 0;
        int max = arr.length-1;
        int mid = (min+max)/2;
        while(arr[mid]!=key)
        {
            if(arr[mid]>key)
                max = mid-1;
            if(arr[mid]<key)
                min = mid+1;
            if(min>max)
                return -1;
            mid = (min+max)/2;
        }
        return mid;
    }
}

13.21 二分查找使用的注意事项

如果数组元素是无序的，这种情况下的查找不能使用二分查找，因为使用二分查找元素必须有序，如果先排序再使用二分查找，排序的时候已经改变了最原始的元素索引。

13.22 Arrays工具类的概述和使用

此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

成员方法:

1.  public static String toString(int[] a):

返回指定数组内容的字符串表示形式。

2.  public static void sort(int[] a):

对指定的 int 型数组按数字升序进行排序。

3.  public static int binarySearch(int[] a,int key):

使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。

例:

//定义一个数组
int[] arr = {23,25,65,85,34,82};
//数组转字符串
System.out.println(Arrays.toString(arr));
//数组排序
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
//二分查找
System.out.println(Arrays.binarySearch(arr, 65));

运行结果:

[23, 25, 65, 85, 34, 82]
[23, 25, 34, 65, 82, 85]
3

binarySearch方法如果要查找的数在数组中存在，则返回的是该数在数组中的位置

如果不存在则返回的是该数在数组中插入的位置，该数是一个负数，表示要查找的数在数组中不存在

插入位置的计算方法为:例如返回的是-7，则在数组中应该插入的位置是7-1=6

13.23 Arrays工具类的源码解析

13.24 基本类型包装类的引入

为了方便操作基本数据类型值，将基本数据类型封装成对象，在对象中定义了属性和行为，用于描述该对象的类就称为基本数据类型对象包装类，好处在于可以在对象中定义更多的功能方法操作该数据。常用的操作之一:用于基本数据类型与字符串之间的转换。

 

13.25 Integer的构造方法

Integer类概述:Integer 类在对象中包装了一个基本类型 int 的值

该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法

构造方法:

public Integer(int value):

构造一个新分配的 Integer 对象，它表示指定的 int 值。

public Integer(String s)throws NumberFormatException:

构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。

例:

int i = 100;
Integer i1 = new Integer(i);
System.out.println("Integer:"+i1);

String s = "100";
Integer i2 = new Integer(s);
System.out.println("Integer:"+i2);

13.26 String和int类型的相互转换

int→String

1.使用字符串的拼接 " "+number

2.使用方法 String.valueOf(int number)(推荐使用)

3.使用Integer做桥梁，int→Integer→String

Integer i = new Integer(number);

String s = i.toString();

4.使用方法 Integer.toString(int number)

String→int

1.使用Integer做桥梁，String→Integer→int

Integer i = new Integer(s);

int ii = i.intValue();

2.使用方法 Integer.parseInt(String s)(推荐使用)

13.27 Integer中进制转换的操作

1.  常用的基本进制转换

a.  public static String toBinaryString(int i):

以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。

b.  public static String toOctalString(int i):

以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。

c.  public static String toHexString(int i):

以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。

2.  十进制到其他进制

public static String toString(int i,int radix):

返回用第二个参数指定基数表示的第一个参数的字符串表示形式。radix范围从2~36

3.  其他进制到十进制

public static int parseInt(String s,int radix)throws NumberFormatException

使用第二个参数指定的基数，将字符串参数解析为有符号的整数。

13.28 JDK5的新特性自动装箱和拆箱

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

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

 

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

Integer x = new Integer(4);可以直接写成

Integer x = 4;//相当于Integer x = Integer.valueOf(4);自动装箱

x  = x + 5;//相当于x = Integer.valueOf(x.intValue() + 5);先自动拆箱，再自动装箱

需要注意:在使用时，Integer  x = null;上面的代码就会出现NullPointerException。

13.29 Integer直接赋值的面试题

1.Integer i = 1;i += 1;做了哪些事情

编译时:

Integer i = 1;相当于Integer i = Integer.valueOf(1);

i += 1;相当于i = Integer.valueOf(i.intValue() + 1);

2.看程序写结果

Integer i1 = new Integer(127);

Integer i2 = new Integer(127);

System.out.println(i1 == i2);//false

System.out.println(i1.equals(i2));//true

 

Integer i3 = new Integer(128);

Integer i4 = new Integer(128);

System.out.println(i3 == i4);//false

System.out.println(i3.equals(i4));//true

 

Integer i5 = 127;

Integer i6 = 127;

System.out.println(i5 == i6);//true

System.out.println(i5.equals(i6));//true

 

Integer i7 = 128;

Integer i8 = 128;

System.out.println(i7 == i8);//false

System.out.println(i7.equals(i8));//true

注意:Integer的数据直接赋值，如果在-128到127之间，会直接从缓冲池里获取数据

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

13.30 Character的概述

Character 类在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段。

此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然。

构造方法:

public Character(char value):

构造一个新分配的 Character 对象，用以表示指定的 char 值。

13.31 Character的常见方法讲解

1.  public static boolean isUpperCase(char ch):

确定指定字符是否为大写字母。

2.  public static boolean isLowerCase(char ch):

确定指定字符是否为小写字母。

3.  public static boolean isDigit(char ch):

确定指定字符是否为数字。

4.  public static char toUpperCase(char ch):

使用取自 UnicodeData 文件的大小写映射信息将字符参数转换为大写。

5.  public static char toLowerCase(char ch):

使用取自 UnicodeData 文件的大小写映射信息将字符参数转换为小写。

13.32 统计字符串中大写小写以及数字出现的次数案例

public class Practice 
{
    /**
     * @param args
     */
    public static void main(String[] args) 
    {
        String s = "SdfgD32sdF65hfg3Sf s3EDf  S";
        int big = 0,samll = 0,number = 0;
        char[] chs = s.toCharArray();
        for (int i = 0; i < chs.length; i++) 
        {
            if(Character.isUpperCase(chs[i]))
                big++;
            else if(Character.isLowerCase(chs[i]))
                samll++;
            else if(Character.isDigit(chs[i]))
                number++;
        }
        System.out.println("大写字符"+big+"个");
        System.out.println("小写字符"+samll+"个");
        System.out.println("数字字符"+number+"个");
    }
}