意料之外程序员_JavaSE学习总计第13天_API常用对象

作者: 今晚开什么码  发布:2019-11-15

黑马程序员_JavaSE学习总结第13天_API常用对象3,_javase_api

------- android培训、java培训、期待与您交流! ---------- 

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加上字符串参数的长度

例:

1 StringBuffer sb1 = new StringBuffer();
2 System.out.println(sb1.capacity());//16
3 System.out.println(sb1.length());//0
4 
5 StringBuffer sb2 = new StringBuffer("hello");
6 System.out.println(sb2.capacity());//21
7 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 把数组拼接成指定格式的字符串案例

 1 public class Practice 
 2 {
 3     public static void main(String[] args) 
 4     {
 5         //定义数组
 6         int[] arr = {23,52,12,63,25};
 7         String s = arrToString(arr);
 8         System.out.println(s);
 9     }
10     public static String arrToString(int[] arr)
11     {
12         StringBuffer sb = new StringBuffer("[");
13         for (int i = 0; i < arr.length; i++) 
14         {
15             if(i == arr.length -1)
16             {
17                 sb.append(arr[i]);
18             }
19             else
20             {
21                 sb.append(arr[i]).append(", ");
22             }
23         }
24         sb.append("]");
25         return sb.toString();
26     }
27 }

13.10 字符串反转功能案例

 1 import java.util.Scanner;
 2 
 3 public class Practice 
 4 {
 5     public static void main(String[] args) 
 6     {
 7         Scanner sc = new Scanner(System.in);
 8         System.out.println("请输入数据:");
 9         String str = sc.nextLine();
10         String s = myReverse(str);
11         System.out.println(s);
12     }
13     public static String myReverse(String s)
14     {
15         return new StringBuffer(s).reverse().toString();
16     }
17 }

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

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

 1 public class Practice 
 2 {
 3     public static void main(String[] args) 
 4     {
 5         String s = "abcba";
 6         System.out.println(isSame2(s));
 7     }
 8     //方式1
 9     public static String isSame(String s) 
10     {
11          // 把字符串转成字符数组
12          char[] chs = s.toCharArray();
13          for (int start = 0, end = chs.length - 1; start <= end; start++, end--) 
14          {
15              if (chs[start] != chs[end]) 
16              {
17                  return "不对称";
18              }
19          }
20          return "对称";
21     }
22     //方式2
23     public static boolean isSame2(String s) 
24     {
25         return new StringBuffer(s).reverse().toString().equals(s);
26     }
27 }

13.12 StringBuffer的两个面试题

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

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

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

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

第2题:StringBuffer和数组的区别

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

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

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

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

例:

 1 public class Practice 
 2 {
 3     public static void main(String[] args) 
 4     {
 5         String s1 = "hello";
 6         String s2 = "world";
 7         System.out.println(s1 + "---" + s2);
 8         change(s1, s2);
 9         System.out.println(s1 + "---" + s2);
10 
11         StringBuffer sb1 = new StringBuffer("hello");
12         StringBuffer sb2 = new StringBuffer("world");
13         System.out.println(sb1 + "---" + sb2);
14         change(sb1, sb2);
15         System.out.println(sb1 + "---" + sb2);
16     }
17     public static void change(StringBuffer sb1, StringBuffer sb2) 
18     {
19         sb1 = sb2;
20         sb2.append(sb1);
21     }
22 
23     public static void change(String s1, String s2) 
24     {
25         s1 = s2;
26         s2 = s1 + s2;
27     }
28 }

运行结果:

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

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

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

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

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

 1 public class Practice 
 2 {
 3     /**
 4      * 冒泡排序
 5      * @param args
 6      */
 7     public static void main(String[] args) 
 8     {
 9         int[] arr = {2,1,55,-12,45,25,-64};
10         System.out.println("排序前:");
11         print(arr);
12         bubbleSort(arr);
13         System.out.println("排序后:");
14         print(arr);
15     }
16     public static void bubbleSort(int[] arr)
17     {
18         for (int i = 0; i < arr.length-1; i++) 
19         {
20             //-1是为了避免角标越界
21             //-i是为了让内循环参与比较的次数随着外循环的增加而递减
22             for (int j = 0; j < arr.length-1-i; j++) 
23             {
24                 if(arr[j]>arr[j+1])
25                 {
26                     int temp = arr[j];
27                     arr[j] = arr[j+1];
28                     arr[j+1] =  temp;
29                 }
30             }
31         }
32     }
33     //遍历数组
34     public static void print(int[] arr)
35     {
36         for (int i = 0; i < arr.length; i++) 
37         {
38             System.out.print(arr[i]+" ");
39         }
40         System.out.println();
41     }
42 }

运行结果:

排序前:
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 数组高级选择排序代码实现

 1 public class Practice 
 2 {
 3     /**
 4      * 选择排序
 5      * @param args
 6      */
 7     public static void main(String[] args) 
 8     {
 9         int[] arr = {2,15,23,12,76,73,18,29};
10         System.out.println("排序前:");
11         print(arr);
12         selectSort(arr);
13         System.out.println("排序后:");
14         print(arr);
15     }
16     public static void selectSort(int[] arr)
17     {
18         for (int i = 0; i < arr.length-1; i++) 
19         {
20             for (int j = i+1; j < arr.length; j++) 
21             {
22                 if(arr[i]>arr[j])
23                 {
24                     int temp = arr[i];
25                     arr[i] = arr[j];
26                     arr[j] = temp;
27                 }
28             }
29         }
30     }
31     //遍历数组
32     public static void print(int[] arr)
33     {
34         for (int i = 0; i < arr.length; i++) 
35         {
36             System.out.print(arr[i]+" ");
37         }
38         System.out.println();
39     }
40 }

运行结果:

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

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

 1 public class Practice 
 2 {
 3     /**
 4      * @param args
 5      */
 6     public static void main(String[] args) 
 7     {
 8         String s = "dacgebf";
 9         char[] ch = s.toCharArray();
10         selectSort(ch);
11         System.out.println(new String(ch));
12     }
13     public static void selectSort(char[] ch)
14     {
15         for (int i = 0; i < ch.length-1; i++) 
16         {
17             for (int j = i+1; j < ch.length; j++) 
18             {
19                 if(ch[i] > ch[j])
20                 {
21                     char temp = ch[i];
22                     ch[i] = ch[j];
23                     ch[j] = temp;
24                 }
25             }
26         }
27     }
28 }

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

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

  

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

 1 public class Practice 
 2 {
 3     /**
 4      * 二分查找
 5      * @param args
 6      */
 7     public static void main(String[] args) 
 8     {
 9         int[] arr = {11,15,23,28,35,39,48,49,58};
10         int index = binarySearch(arr, 28);
11         System.out.println(index);
12     }
13     public static int binarySearch(int[] arr,int key)
14     {
15         int min = 0;
16         int max = arr.length-1;
17         int mid = (min+max)/2;
18         while(arr[mid]!=key)
19         {
20             if(arr[mid]>key)
21                 max = mid-1;
22             if(arr[mid]<key)
23                 min = mid+1;
24             if(min>max)
25                 return -1;
26             mid = (min+max)/2;
27         }
28         return mid;
29     }
30 }

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 型数组,以获得指定的值。

例:

1 //定义一个数组
2 int[] arr = {23,25,65,85,34,82};
3 //数组转字符串
4 System.out.println(Arrays.toString(arr));
5 //数组排序
6 Arrays.sort(arr);
7 System.out.println(Arrays.toString(arr));
8 //二分查找
9 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 值。

例:

1 int i = 100;
2 Integer i1 = new Integer(i);
3 System.out.println("Integer:"+i1);
4 
5 String s = "100";
6 Integer i2 = new Integer(s);
7 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+"个");
    }
}

 

------- android培训、java培训、期待与您交流! ---------- 13.01 StringBuffer的概述 StringBu...

文档版本 开发工具 测试平台 工程名字 日期 作者 备注
V1.0 2016.03.07 lutianfei none

[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,可通过以下两种方式进行赋值:
  • StringStringBuffer方法:
    • 方式1:通过构造方法
      • StringBuffer sb = new StringBuffer(s);
    • 方式2:通过append()方法
      • StringBuffer sb2 = new StringBuffer();
      • sb2.append(s);
  • StringBufferString方法:
    • 注:任何引用类型调用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;
    }
}

-

数组高级(排序和查找)

排序

  • 冒泡排序(必须掌握)

    • 相邻元素两两比较,大的往后放,第一次完毕,最大值出现在了最大索引处

      图片 1

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索引开始,依次和后面元素比较,小的往前放,第一次完毕,最小值出现在了最小索引处
    ![](https://upload-images.jianshu.io/upload_images/1688304-95f9dc52d1dac255.jpg)
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;
}
二分查找(折半查找) : 数组元素有序

图片 2

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 + "个");
    }
}

本文由今晚开什么码发布于今晚开什么码,转载请注明出处:意料之外程序员_JavaSE学习总计第13天_API常用对象

关键词:

上一篇:leetcode 200 : Number of Islands
下一篇:没有了