Java 之常用API（一）

常用API

•  1 API概述
•  2 Scanner類與String類
•  3 StringBuilder類

 

NO.one API概述

1.1 API概述

API(Application Programming Interface) : 應用程序編程接口

編寫一個機器人程序去控制機器人踢足球，程序就需要向機器人發出向前跑、向后跑、射門、搶球等各種命令，沒有編過程序的人很難想象這樣的程序如何編寫。但是對於有經驗的開發人員來說，知道機器人廠商一定會提供一些用於控制機器人的Java類，這些類中定義好了操作機器人各種動作的方法。其實，這些Java類就是機器人廠商提供給應用程序編程的接口，大家把這些類稱為API。本章涉及的Java API指的就是JDK中提供的各種功能的Java類

1.2 快速使用API步驟

A:打開幫助文檔

B:點擊顯示，找到索引，看到輸入框

C:你要學習什么內容，你就在框框里面輸入什么內容

    舉例：Random

D:看包

     java.lang包下的類在使用的時候是不需要導包的

E:看類的描述

    Random類是用於生成隨機數的類

F:看構造方法

     Random():無參構造方法

      Random r = new Random();

G:看成員方法

      public int nextInt(int n):產生的是一個[0,n)范圍內的隨機數

         調用方法：

                看返回值類型：人家返回什么類型，你就用什么類型接收

                看方法名：名字不要寫錯了

                看形式參數：人家要幾個參數，你就給幾個，人家要什么數據類型的，你就給什么數據類型的

                int number = r.nextInt(100);

NO.two Scanner類和String類

2.1 Scanner類

2.1.1 Scanner類的作用

用Scanner類的方法可以完成接收鍵盤錄入的數據

2.1.2 Scanner類接受鍵盤錄入的字符串

2.1.2.1 案例代碼：

package com.gao_01;
import java.util.Scanner;
/*
 * Scanner:用於獲取鍵盤錄入的數據。(基本數據類型，字符串數據)
 * public String nextLine():獲取鍵盤錄入的字符串數據
 */
public class ScannerDemo {
    public static void main(String[] args) {
        //創建鍵盤錄入對象
        Scanner sc = new Scanner(System.in);
        //接收數據
        System.out.println("請輸入一個字符串數據：");
        String s = sc.nextLine();
        
        //輸出結果
        System.out.println("s:"+s);
    }
}

2.2 String類

2.2.1 String類概述

通過JDK提供的API，查看String類的說明

A:"abc"是String類的一個實例,或者成為String類的一個對象

B:字符串字面值"abc"也可以看成是一個字符串對象

C:字符串是常量，一旦被賦值，就不能被改變

D:字符串本質是一個字符數組

2.2.2 String類的構造方法

 

String(String original):把字符串數據封裝成字符串對象

 

String(char[] value):把字符數組的數據封裝成字符串對象

 

String(char[] value, int index, int count):把字符數組中的一部分數據封裝成字符串對象

2.2.2.1 常用構造方法演示

2.2.2.1.1 案例代碼二：

package com.gao_02;
/*
 * String:字符串類
 *         由多個字符組成的一串數據
 *         字符串其本質是一個字符數組
 * 
 * 構造方法：
 *         String(String original):把字符串數據封裝成字符串對象
 *         String(char[] value):把字符數組的數據封裝成字符串對象
 *         String(char[] value, int index, int count):把字符數組中的一部分數據封裝成字符串對象
 * 
 * 注意：字符串是一種比較特殊的引用數據類型，直接輸出字符串對象輸出的是該對象中的數據。
 */
public class StringDemo {
    public static void main(String[] args) {
        //方式1
        //String(String original):把字符串數據封裝成字符串對象
        String s1 = new String("hello");
        System.out.println("s1:"+s1);
        System.out.println("---------");
        
        //方式2
        //String(char[] value):把字符數組的數據封裝成字符串對象
        char[] chs = {'h','e','l','l','o'};
        String s2 = new String(chs);
        System.out.println("s2:"+s2);
        System.out.println("---------");
        
        //方式3
        //String(char[] value, int index, int count):把字符數組中的一部分數據封裝成字符串對象
        //String s3 = new String(chs,0,chs.length);
        String s3 = new String(chs,1,3);
        System.out.println("s3:"+s3);
        System.out.println("---------");
        
        //方式4
        String s4 = "hello";
        System.out.println("s4:"+s4);
    }
}

2.2.2.2 創建字符串對象兩種方式的區別

2.2.2.2.1 案例代碼三：

package com.gao_02;
/*
 * 通過構造方法創建的字符串對象和直接賦值方式創建的字符串對象有什么區別呢?
 *         通過構造方法創建字符串對象是在堆內存。
 *         直接賦值方式創建對象是在方法區的常量池。
 *         
 * ==:
 *         基本數據類型：比較的是基本數據類型的值是否相同
 *         引用數據類型：比較的是引用數據類型的地址值是否相同
 */
public class StringDemo2 {
    public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = "hello";
        
        System.out.println("s1:"+s1);
        System.out.println("s2:"+s2);
        
        System.out.println("s1==s2:"+(s1==s2)); //false
        
        String s3 = "hello";
        System.out.println("s1==s3:"+(s1==s3)); //false
        System.out.println("s2==s3:"+(s2==s3)); //true
    }
}

2.2.3 String類的判斷功能

 

boolean equals(Object obj):比較字符串的內容是否相同

 

  boolean equalsIgnoreCase(String str):比較字符串的內容是否相同,忽略大小寫

 

  boolean startsWith(String str):判斷字符串對象是否以指定的str開頭

 

  boolean endsWith(String str):判斷字符串對象是否以指定的str結尾

2.2.3.1 判斷方法演示

2.2.3.1.1 案例代碼四：

package com.gao_03;
/*
 * Object:是類層次結構中的根類，所有的類都直接或者間接的繼承自該類。
 * 如果一個方法的形式參數是Object，那么這里我們就可以傳遞它的任意的子類對象。
 * 
 * String類的判斷功能：
 * boolean equals(Object obj):比較字符串的內容是否相同
 * boolean equalsIgnoreCase(String str):比較字符串的內容是否相同,忽略大小寫
 * boolean startsWith(String str):判斷字符串對象是否以指定的str開頭
 * boolean endsWith(String str):判斷字符串對象是否以指定的str結尾
 */
public class StringDemo {
    public static void main(String[] args) {
        //創建字符串對象
        String s1 = "hello";
        String s2 = "hello";
        String s3 = "Hello";
        
        //boolean equals(Object obj):比較字符串的內容是否相同
        System.out.println(s1.equals(s2));
        System.out.println(s1.equals(s3));
        System.out.println("-----------");
        
        //boolean equalsIgnoreCase(String str):比較字符串的內容是否相同,忽略大小寫
        System.out.println(s1.equalsIgnoreCase(s2));
        System.out.println(s1.equalsIgnoreCase(s3));
        System.out.println("-----------");
        
        //boolean startsWith(String str):判斷字符串對象是否以指定的str開頭
        System.out.println(s1.startsWith("he"));
        System.out.println(s1.startsWith("ll"));
    }
}

2.2.3.2  判斷功能案例

2.2.3.2.1 案例代碼五：

package com.gao_03;

import java.util.Scanner;

/*
 * 模擬登錄,給三次機會,並提示還有幾次。
 * 
 * 分析：
 *         A:定義兩個字符串對象，用於存儲已經存在的用戶名和密碼
 *         B:鍵盤錄入用戶名和密碼
 *         C:拿鍵盤錄入的用戶名和密碼和已經存在的用戶名和密碼進行比較
 *             如果內容相同，提示登錄成功
 *             如果內容不同，提示登錄失敗，並提示還有幾次機會
 */
public class StringTest {
    public static void main(String[] args) {
        //定義兩個字符串對象，用於存儲已經存在的用戶名和密碼
        String username = "admin";
        String password = "admin";
        
        //給三次機會，用for循環實現
        for(int x=0; x<3; x++) {
            //鍵盤錄入用戶名和密碼
            Scanner sc = new Scanner(System.in);
            System.out.println("請輸入用戶名：");
            String name = sc.nextLine();
            System.out.println("請輸入密碼：");
            String pwd = sc.nextLine();
            
            //拿鍵盤錄入的用戶名和密碼和已經存在的用戶名和密碼進行比較
            if(username.equals(name) && password.equals(pwd)) {
                System.out.println("登錄成功");
                break;
            }else {
                if((2-x) ==0) {
                    System.out.println("用戶名和密碼被鎖定,請與管理員聯系");
                }else {
                    System.out.println("登錄失敗,你還有"+(2-x)+"次機會"); //2,1,0
                }
            }
        }
    }
}

2.2.4 String類的獲取功能

2.2.4.1 獲取方法演示

package com.gao_04;
/*
 * String類的獲取功能：
 * int length():獲取字符串的長度，其實也就是字符個數
 * char charAt(int index):獲取指定索引處的字符
 * int indexOf(String str):獲取str在字符串對象中第一次出現的索引
 * String substring(int start):從start開始截取字符串
 * String substring(int start,int end):從start開始，到end結束截取字符串。包括start，不包括end
 */
public class StringDemo {
    public static void main(String[] args) {
        //創建字符串對象
        String s = "helloworld";
        
        //int length():獲取字符串的長度，其實也就是字符個數
        System.out.println(s.length());
        System.out.println("--------");
        
        //char charAt(int index):獲取指定索引處的字符
        System.out.println(s.charAt(0));
        System.out.println(s.charAt(1));
        System.out.println("--------");
        
        //int indexOf(String str):獲取str在字符串對象中第一次出現的索引
        System.out.println(s.indexOf("l"));
        System.out.println(s.indexOf("owo"));
        System.out.println(s.indexOf("ak"));
        System.out.println("--------");
        
        //String substring(int start):從start開始截取字符串
        System.out.println(s.substring(0));
        System.out.println(s.substring(5));
        System.out.println("--------");
        
        //String substring(int start,int end):從start開始，到end結束截取字符串
        System.out.println(s.substring(0, s.length()));
        System.out.println(s.substring(3,8));
    }
}

2.2.4.2 獲取功能案例

2.2.4.2.1 案例代碼六：

package com.gao_04;
/*
 * 遍歷字符串(獲取字符串中的每一個字符)
 */
public class StringTest {
    public static void main(String[] args) {
        //創建一個字符串對象
        String s = "abcde";
        
        //原始做法
        System.out.println(s.charAt(0));
        System.out.println(s.charAt(1));
        System.out.println(s.charAt(2));
        System.out.println(s.charAt(3));
        System.out.println(s.charAt(4));
        System.out.println("---------");
        
        //用for循環改進
        for(int x=0; x<5; x++) {
            System.out.println(s.charAt(x));
        }
        System.out.println("---------");
        
        //用length()方法獲取字符串的長度
        for(int x=0; x<s.length(); x++) {
            System.out.println(s.charAt(x));
        }
    }
}

2.2.4.2.2 案例代碼七：

 

package com.gao_04;

import java.util.Scanner;

/*
 * 統計一個字符串中大寫字母字符，小寫字母字符，數字字符出現的次數。(不考慮其他字符)
 * 
 * 分析：
 *         A:鍵盤錄入一個字符串數據
 *         B:定義三個統計變量，初始化值都是0
 *         C:遍歷字符串，得到每一個字符
 *         D:拿字符進行判斷
 *             假如ch是一個字符。
 *             大寫：ch>='A' && ch<='Z'
 *             小寫：ch>='a' && ch<='z'
 *             數字：ch>='0' && ch<='9'
 *         E:輸出結果
 */
public class StringTest2 {
    public static void main(String[] args) {
        //鍵盤錄入一個字符串數據
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入一個字符串數據：");
        String s = sc.nextLine();
        
        //定義三個統計變量，初始化值都是0
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
        
        //遍歷字符串，得到每一個字符
        for(int x=0; x<s.length(); x++) {
            char ch = s.charAt(x);
            //拿字符進行判斷
            if(ch>='A' && ch<='Z') {
                bigCount++;
            }else if(ch>='a' && ch<='z') {
                smallCount++;
            }else if(ch>='0' && ch<='9') {
                numberCount++;
            }else {
                System.out.println("該字符"+ch+"非法");
            }
        }
        
        //輸出結果
        System.out.println("大寫字符："+bigCount+"個");
        System.out.println("小寫字符："+smallCount+"個");
        System.out.println("數字字符："+numberCount+"個");
    }
}

 

2.2.5 String類的轉換功能

2.2.5.1 轉換方法演示

char[] toCharArray():把字符串轉換為字符數組

String toLowerCase():把字符串轉換為小寫字符串

String toUpperCase():把字符串轉換為大寫字符串

2.2.5.1.1 案例代碼八：

 

package com.gao_05;
/*
 * String類的轉換功能：
 * char[] toCharArray():把字符串轉換為字符數組
 * String toLowerCase():把字符串轉換為小寫字符串
 * String toUpperCase():把字符串轉換為大寫字符串
 * 
 * 字符串的遍歷：
 *         A:length()加上charAt()
 *         B:把字符串轉換為字符數組，然后遍歷數組
 */
public class StringDemo {
    public static void main(String[] args) {
        //創建字符串對象
        String s = "abcde";
        
        //char[] toCharArray():把字符串轉換為字符數組
        char[] chs = s.toCharArray();
        for(int x=0; x<chs.length; x++) {
            System.out.println(chs[x]);
        }
        System.out.println("-----------");
        
        //String toLowerCase():把字符串轉換為小寫字符串
        System.out.println("HelloWorld".toLowerCase());
        //String toUpperCase():把字符串轉換為大寫字符串
        System.out.println("HelloWorld".toUpperCase());
    }
}

 

2.2.5.2 轉換功能案例

2.2.5.2.1 案例代碼九：

package com.gao_05;

import java.util.Scanner;

/*
 * 鍵盤錄入一個字符串，把該字符串的首字母轉成大寫，其余為小寫。(只考慮英文大小寫字母字符)
 * 
 * 分析：
 *         A:鍵盤錄入一個字符串
 *         B:截取首字母
 *         C:截取除了首字母以外的字符串
 *         D:B轉大寫+C轉小寫
 *         E:輸出即可
 */
public class StringTest {
    public static void main(String[] args) {
        //鍵盤錄入一個字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入一個字符串：");
        String s = sc.nextLine();
        
        //截取首字母
        String s1 = s.substring(0, 1);
        
        //截取除了首字母以外的字符串
        String s2 = s.substring(1);
        
        //B轉大寫+C轉小寫
        String s3 = s1.toUpperCase()+s2.toLowerCase();
        
        //輸出即可
        System.out.println("s3:"+s3);
    }
}

2.2.6 String類的其他功能

2.2.6.1 其他方法演示

2.2.6.1.1 案例代碼十：

package com.gao_06;
/*
 * 去除字符串兩端空格    
 *        String trim()
 * 按照指定符號分割字符串    
 *        String[] split(String str)
 */
public class StringDemo {
    public static void main(String[] args) {
        //創建字符串對象
        String s1 = "helloworld";
        String s2 = "  helloworld  ";
        String s3 = "  hello  world  ";
        System.out.println("---"+s1+"---");
        System.out.println("---"+s1.trim()+"---");
        System.out.println("---"+s2+"---");
        System.out.println("---"+s2.trim()+"---");
        System.out.println("---"+s3+"---");
        System.out.println("---"+s3.trim()+"---");
        System.out.println("-------------------");
                                                               
        //String[] split(String str)
        //創建字符串對象
        String s4 = "aa,bb,cc";
        String[] strArray = s4.split(",");
        for(int x=0; x<strArray.length; x++) {
            System.out.println(strArray[x]);
        }
    }
}

2.2.7 String類的其他案例

2.2.7.1 案例代碼十一：

package com.gao_07;
/*
 * 把數組中的數據按照指定個格式拼接成一個字符串
 * 舉例：int[] arr = {1,2,3};    
 * 輸出結果：[1, 2, 3]
 * 
 * 分析：
 *         A:定義一個int類型的數組
 *         B:寫方法實現把數組中的元素按照指定的格式拼接成一個字符串
 *         C:調用方法
 *         D:輸出結果
 */
public class StringTest {
    public static void main(String[] args) {
        //定義一個int類型的數組
        int[] arr = {1,2,3};
        
        //寫方法實現把數組中的元素按照指定的格式拼接成一個字符串
        
        //調用方法
        String s = arrayToString(arr);
        
        //輸出結果
        System.out.println("s:"+s);
    }
    
    /*
     * 兩個明確：
     *         返回值類型：String
     *         參數列表：int[] arr
     */
    public static String arrayToString(int[] arr) {
        String s = "";
        
        //[1, 2, 3]
        s += "[";
        for(int x=0; x<arr.length; x++) {
            if(x==arr.length-1) {
                s += arr[x];
            }else {
                s += arr[x];
                s += ", ";
            }
        }
        s += "]";
        return s;
    }
}

2.2.7.2 案例代碼十二：

package com.gao_07;

import java.util.Scanner;

/*
 * 字符串反轉
 * 舉例：鍵盤錄入”abc”        
 * 輸出結果：”cba”
 * 
 * 分析：
 *         A:鍵盤錄入一個字符串
 *         B:寫方法實現字符串的反轉
 *             a:把字符串倒着遍歷，得到的每一個字符拼接成字符串。
 *             b:把字符串轉換為字符數組，然后對字符數組進行反轉，最后在把字符數組轉換為字符串
 *         C:調用方法
 *         D:輸出結果
 */
public class StringTest2 {
    public static void main(String[] args) {
        //鍵盤錄入一個字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入一個字符串：");
        String s = sc.nextLine();
        
        //寫方法實現字符串的反轉
        
        //調用方法
        String result = reverse(s);
        
        //輸出結果
        System.out.println("result:"+result);
    }
    
    
    
    /*
     * 把字符串倒着遍歷，得到的每一個字符拼接成字符串。
     * 
     * 兩個明確：
     *         返回值類型：String
     *         參數列表：String s
     */
    
    /*
    public static String reverse(String s) {
        String ss = "";
        
        for(int x=s.length()-1; x>=0; x--) {
            ss += s.charAt(x);
        }
        
        return ss;
    }
    */
    
    //把字符串轉換為字符數組，然后對字符數組進行反轉，最后在把字符數組轉換為字符串
    public static String reverse(String s) {
        //把字符串轉換為字符數組
        char[] chs = s.toCharArray();
        
        //對字符數組進行反轉
        for(int start=0,end=chs.length-1; start<=end; start++,end--) {
            char temp = chs[start];
            chs[start] = chs[end];
            chs[end] = temp;
        }
        
        //最后在把字符數組轉換為字符串
        String ss = new String(chs);
        return ss;
    }
}

NO.three StringBuilder類

3.1 StringBuilder類概述

StringBuilder:是一個可變的字符串。字符串緩沖區類。 

String和StringBuilder的區別：

String的內容是固定的

StringBuilder的內容是可變的

3.1.1 +=拼接字符串耗費內存原因：

 

每次拼接都會產生新的字符串對象,而利用StringBuilder來拼接字符串自始至終用的都是同一個StringBuilder容器

3.2 StringBuilder類的常用方法

 

A:構造方法:

 

     StringBuilder()

 

  B:成員方法:

 

     public int capacity():返回當前容量 (理論值)

 

     public int length():返回長度(已經存儲的字符個數)

 

     public StringBuilder append(任意類型):添加數據，並返回自身對象

 

     public StringBuilder reverse():反轉功能

3.2.1 案例代碼十三：

package com.gao_01;
/*
 * StringBuilder:是一個可變的字符串。字符串緩沖區類。
 * 
 * String和StringBuilder的區別：
 *         String的內容是固定的。
 *         StringBuilder的內容是可變的。
 * 
 * 構造方法：
 *         StringBuilder()
 * 
 * 成員方法：
 *         public int capacity():返回當前容量
 *         public int length():返回長度（字符數）
 * 
 *         容量：理論值
 *         長度：實際值
 */
public class StringBuilderDemo {
    public static void main(String[] args) {
        //創建對象
        StringBuilder sb = new StringBuilder();
        System.out.println("sb:"+sb);
        System.out.println("sb.capacity():"+sb.capacity());
        System.out.println("sb.length():"+sb.length());
    }
}

3.2.2 案例代碼十四：

 

package com.gao_02;
/*
 * 添加功能
 *        public StringBuilder append(任意類型):添加數據，並返回自身對象
 * 反轉功能
 *        public StringBuilder reverse()
 */
public class StringBuilderDemo {
    public static void main(String[] args) {
        //創建對象
        StringBuilder sb = new StringBuilder();
        
        //public StringBuilder append(任意類型)
        //StringBuilder sb2 = sb.append("hello");
        
        /*
        System.out.println("sb:"+sb);
        System.out.println("sb2:"+sb2);
        System.out.println(sb == sb2); //true
        */
        
        /*
        sb.append("hello");
        sb.append("world");
        sb.append(true);
        sb.append(100);
        */
        
        //鏈式編程
        sb.append("hello").append("world").append(true).append(100);
        
        System.out.println("sb:"+sb);
        
        //public StringBuilder reverse()
        sb.reverse();
        System.out.println("sb:"+sb);
        
    }
}

 

3.3 StringBuilder 案例

3.3.1 案例一需求

StringBuilder和String通過方法完成相互轉換

3.3.1.1 案例代碼十五：

 

package com.gao_03;
/*
 * StringBuilder和String的相互轉換
 * 
 * StringBuilder -- String
 *         public String toString():通過toString()就可以實現把StringBuilder轉成String
 * 
 * String -- StringBuilder
 *         StringBuilder(String str):通過構造方法就可以實現把String轉成StringBuilder
 */
public class StringBuilderTest {
    public static void main(String[] args) {
        //StringBuilder -- String
        /*
        StringBuilder sb = new StringBuilder();
        sb.append("hello").append("world");
        
        String s = sb.toString();
        System.out.println(s);
        */
        
        //String -- StringBuilder
        String s = "helloworld";
        StringBuilder sb = new StringBuilder(s);
        System.out.println(sb);
    }
}

 

3.3.2 案例二需求

 

利用StringBuilder把數組拼接成一個字符串

 

   舉例：

 

              int[] arr = {1,2,3};

 

   結果：

 

             [1, 2, 3]

3.3.2.1 案例代碼十六：

 

package com.gao_03;
/*
 * 把數組拼接成一個字符串
 * 舉例：
 *         int[] arr = {1,2,3};
 * 結果：
 *         [1, 2, 3]
 */
public class StringBuilderTest2 {
    public static void main(String[] args) {
        //定義一個數組
        int[] arr = {1,2,3};
        
        //寫方法實現拼接
        
        //調用方法
        String s = arrayToString(arr);
        
        //輸出結果
        System.out.println("s:"+s);
    }
    
    /*
     * 兩個明確：
     *         返回值類型：String
     *         參數列表：int[] arr
     */
    public static String arrayToString(int[] arr) {
        StringBuilder sb = new StringBuilder();
        //[1, 2, 3]
        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("]");
        
        String result = sb.toString();
        
        return result;
    }
}

 

3.3.3 案例三需求

3.3.3.1 案例代碼十七：

package com.gao_03;

import java.util.Scanner;

/*
 * 把字符串反轉
 * 
 * 分析：
 *         A:鍵盤錄入一個字符串
 *         B:寫方法實現反轉
 *             String -- StringBuilder -- reverse() -- String
 *         C:調用方法
 *         D:輸出結果
 */
public class StringBuilderTest3 {
    public static void main(String[] args) {
        //鍵盤錄入一個字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入一個字符串：");
        String s = sc.nextLine();
        
        //寫方法實現反轉
        
        //調用方法
        String result = myReverse(s);
        
        //輸出結果
        System.out.println("result:"+result);
    }
    
    /*
     * 兩個明確：
     *         返回值類型：String
     *         參數列表：String
     */
    public static String myReverse(String s) {
        //String -- StringBuilder -- reverse() -- String
        StringBuilder sb = new StringBuilder(s);
        sb.reverse();
        String result = sb.toString();
        return result;
    }
}

3.3.4 案例四需求

 

判斷一個字符串是否是對稱字符串

 例如"abc"不是對稱字符串，"aba"、"abba"、"aaa"、"mnanm"是對稱字符串

3.3.4.1 案例代碼十八：

package com.gao_03;
import java.util.Scanner;

/*
 * 判斷一個字符串是否是對稱字符串
 * 例如"abc"不是對稱字符串，"aba"、"abba"、"aaa"、"mnanm"是對稱字符串
 * 
 * 分析：
 *         A:鍵盤錄入一個字符串
 *         B:寫方法實現判斷一個字符串是否是對稱字符串
 *             把字符串反轉，和反轉前的字符串進行比較，如果內容相同，就說明是對稱字符串
 *         C:調用方法
 *         D:輸出結果
 */
public class StringBuilderTest4 {
    public static void main(String[] args) {
        //鍵盤錄入一個字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入一個字符串：");
        String s = sc.nextLine();
        
        //寫方法實現判斷一個字符串是否是對稱字符串
        
        //調用方法
        boolean b = isSymmetry(s);
        
        //輸出結果
        System.out.println("b:"+b);
    }
    
    /*
     * 兩個明確：
     *         返回值類型：boolean
     *         參數列表：String s
     */
    public static boolean isSymmetry(String s) {
        //把字符串反轉，和反轉前的字符串進行比較，如果內容相同，就說明是對稱字符串
        StringBuilder sb = new StringBuilder(s);
        sb.reverse();
        String result = sb.toString();
        
        return result.equals(s);
    }
}