day10-API&Object&String

API概述

什么是API

API(Application Programming Interface)，应用程序编程接口。Java API是一本程序员的字典 ，是JDK中提供给 我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。所以我们可以通过查询API的方式，来学习Java提供的类，并得知如何使用它们。

API使用步骤

1. 打开帮助文档。 
2. 点击显示，找到索引，看到输入框。 
3. 你要找谁？在输入框里输入，然后回车。 
4. 看包。java.lang下的类不需要导包，其他需要。 
5. 看类的解释和说明。 
6. 学习构造方法及其他的成员。

Scanner类演示使用API

了解了API的使用方式，我们通过Scanner类，熟悉一下查询API，并使用类的步骤。

什么是Scanner类

一个可以解析基本类型和字符串的简单文本扫描器。 例如，以下代码使用户能够从 System.in 中读取一个数：

Scanner sc = new Scanner(System.in);
int i = sc.nextInt();

引用类型使用步骤

• 导包

  使用import关键字导包，在类的所有代码之前导包，引入要使用的类型，java.lang包下的所有类无需导入。 格

  式

  import 包名.类名;

• 创建对象

  使用该类的构造方法，创建一个该类的对象。 格式：

  类名 对象名 = new 类名(参数列表);

• 调用方法

  调用该类的成员方法，完成指定功能。 格式：

  对象名.方法名();

Scanner使用步骤

• 查看类

  java.util.Scanner ：该类需要import导入后使用。

• 查看构造方法

  public Scanner(InputStream source) : 构造一个新的 Scanner ，它生成的值是从指定的输入流扫描的。

• 查看成员方法

  public int nextInt() ：将输入信息的下一个标记扫描为一个 int 值。

  public String nextLine(): 此扫描器执行当前行，并返回跳过的输入信息。

Object类

Object类概述

java.lang.Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时 候，最终找的父类就是Object。如果一个类没有特别指定父类,那么默认则继承自Object类。例如：

public class MyClass  {     
}
public class MyClass extends Object{}

根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个。今天我们主要学习其中的2个：

方法名	说明
public String toString()	返回该对象的字符串表示。
public boolean equals(Object obj)	指示其他某个对象是否与此对象“相等”。

toString方法

• public String toString()：返回该对象的字符串表示。

  toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。

  由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

• 覆盖重写

  如果不希望使用toString方法的默认行为，则可以对它进行覆盖重写。例如自定义的Person类：

  public class Person {  
      private String name;
      private int age;
  ​
      @Override
      public String toString() {
          return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
      }
  ​
      // 省略构造器与Getter Setter
  }

  ==在IDEA中我们可以使用快捷键 atl + inset 快速生成toString方法==

equals方法

• public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

  调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否是相同的。这里的“相同”有默认和自定义两种方式。

• 默认比较方式

  如果没有覆盖重写equals方法，那么Object类中默认进行==运算符的对象地址比较，只要不是同一个对象，结果必然为false。

• 重写equals方法

  如果希望进行对象的内容比较，即所有指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写equals方法。例如：

  public class Student extends Object {
      private String name;
      private int age;
      public Student() {
      }
      public Student(String name, int age) {
          this.name = name;
          this.age = age;
      }
      public String getName() {
          return name;
      }
      public void setName(String name) {
          this.name = name;
      }
      public int getAge() {
          return age;
      }
      public void setAge(int age) {
          this.age = age;
      }    
      //直接自动生成即可 alt + insert 生成
      @Override
      public boolean equals(Object obj) {
          // 转换为当前类型
          Student s = (Student)obj;
          if(this.name.equals(s.name) && this.age == s.age) {
              return true;
          }else {
              return false;
          }
      }
  }

  public class StudentDemo {
      public static void main(String[] args) {
          Student s1 = new Student("yanqi",20);
          Student s2 = new Student();
  ​
          // ==：比较引用类型比较的是地址值是否相同
          System.out.println(s1 == s2 );//false
  ​
          // ==: 比较基本数据类型比较的是值是否相同
          int a = 3;
          int b = 4;
          System.out.println(a == b );//false
          System.out.println("====================");
  ​
          //equals： 比较两个对象比较的是地址值是否相同
          System.out.println(s1.equals(s2));//false
          System.out.println(s1.equals(s1));//true
          System.out.println("================");
  ​
          //我们重写equals，让比较两个对象的值
          Student s4 = new Student("yanqi",20);
          System.out.println(s1.equals(s4));
          
          System.out.println("基本数据类型不能使用equals，因为只有类才可以继承object");
      }
  }

  这段代码充分考虑了对象为空、类型一致等问题，但方法内容并不唯一。大多数IDE都可以自动生成equals方法的代码内容。在IntelliJ IDEA中，可以使用Code菜单中的Generate…选项，也可以使用快捷键alt+insert，并选择equals() and hashCode()进行自动代码生成。如下图

String类

String类概述

String 类代表字符串。Java程序中所有的字符串文字（例如 "abc" ）都可以被看作是实现此类的实例。

String类 中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串以及创建具有翻译为大写或小写的所有字符的字符串的副本。

String类的特点

• 字符串不变：字符串的值在创建后不能被更改

  String s1 = "abc"; 
  s1 += "d"; 
  System.out.println(s1); // "abcd" 
  // 内存中有"abc"，"abcd"两个对象，s1从指向"abc"，改变指向，指向了"abcd"。

• 因为String对象是不可变的，所以它们可以被共享。

  String s1 = "abc";
  String s2 = "abc";
  // 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

• String的本质是

  • JDK8之前是char[] 数组

  • JDK8之后是byte[] 数组

String 类使用步骤

• 查看类

  java.lang.String：此类不需要导入。

• 查看构造方法

  方法名	说明
  public String()	初始化新创建的String对象，以使其表示空字符序列
  public String(char[] value)	通过当前参数中的字符数组来构造新的String。
  String(char[] value, int offset, int count)	通过当前参数中的字符数组的一部分来构造新的String。
  public String(byte[] bytes)	通过使用平台的默认字符集解码当前参数中的字节数组来构造新的
  String(byte[] bytes, int offset, int length)	通过使用平台的默认字符集解码当前参数中的字节数组的一部分来构造新的String

  基本代码演示

  // 无参构造
  String str = new String();
  // 通过字符数组构造
  char chars[] = {'a', 'b', 'c'};     
  String str2 = new String(chars);
  ​
  // 通过字节数组构造
  byte bytes[] = { 97, 98, 99 };     
  String str3 = new String(bytes);

String类常用的方法

判断功能的方法

String类的判断功能：
boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
boolean contains(String str):判断大字符串中是否包含小字符串
boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
boolean isEmpty():判断字符串是否为空。
注意：
字符串内容为空和字符串对象为空。
String s = "";内容为空
String s = null; 字符串对象为空

• 代码演示

  public class StringDemo {
      public static void main(String[] args) {
          // 创建字符串对象
          String s1 = "helloworld";
          String s2 = "helloworld";
          String s3 = "HelloWorld";
  ​
          // boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
          System.out.println("equals:" + s1.equals(s2));
          System.out.println("equals:" + s1.equals(s3));
          System.out.println("-----------------------");
  ​
          // boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
          System.out.println("equals:" + s1.equalsIgnoreCase(s2));
          System.out.println("equals:" + s1.equalsIgnoreCase(s3));
          System.out.println("-----------------------");
  ​
          // boolean contains(String str):判断大字符串中是否包含小字符串
          System.out.println("contains:" + s1.contains("hello"));
          System.out.println("contains:" + s1.contains("hw"));//false 一定是连在一起的
          System.out.println("-----------------------");
  ​
          // boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
          System.out.println("startsWith:" + s1.startsWith("h"));
          System.out.println("startsWith:" + s1.startsWith("hello"));
          System.out.println("startsWith:" + s1.startsWith("world"));
          System.out.println("-----------------------");
          // 练习：boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾这个自己玩
          // boolean isEmpty():判断字符串是否为空。
          System.out.println("isEmpty:" + s1.isEmpty());
          String s4 = "";
          String s5 = null;
          System.out.println("isEmpty:" + s4.isEmpty());
          // NullPointerException
          // s5对象都不存在，所以不能调用方法，空指针异常
          System.out.println("isEmpty:" + s5.isEmpty());
      }
  }

获取功能的方法

• public int length() ：返回此字符串的长度

• public String concat(String str): 将指定的字符串连接到该字符串的末尾。

• public char charAt(int index): 返回指定索引处的char值。

• public int indexOf(int ch)：返回指定子字符串第一次出现在该字符串内的索引。

• public String substring(int beginIndex)：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。

• public String substring(int beginIndex,int endIndex)：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。

• 代码演示

  /*
   * String类的获取功能
   * int length():获取字符串的长度。
   * char charAt(int index):获取指定索引位置的字符
   * int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
   *      为什么这里是int类型，而不是char类型?
   *      原因是：'a'和97其实都可以代表'a'
   * int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
   * int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
   * int indexOf(String str,int fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
   * String substring(int start):从指定位置开始截取字符串,默认到末尾。
   * String substring(int start,int end):从指定位置开始到指定位置结束截取字符串。
   */
  public class StringDemo {
      public static void main(String[] args) {
          // 定义一个字符串对象
          String s = "helloworld";
  ​
          // int length():获取字符串的长度。
          System.out.println("s.length:" + s.length());
          System.out.println("----------------------");
  ​
          // char charAt(int index):获取指定索引位置的字符
          System.out.println("charAt:" + s.charAt(7));
          System.out.println("----------------------");
  ​
          // int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
          System.out.println("indexOf:" + s.indexOf('l'));
          System.out.println("----------------------");
  ​
          // int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
          System.out.println("indexOf:" + s.indexOf("owo"));
          System.out.println("----------------------");
  ​
          // int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
          System.out.println("indexOf:" + s.indexOf('l', 4));//从第4个索引开始找l第一次出现的位置
          System.out.println("indexOf:" + s.indexOf('k', 4)); // -1
          System.out.println("indexOf:" + s.indexOf('l', 40)); // -1如果没有就返回-1
          System.out.println("----------------------");
  ​
          // 自己练习：int indexOf(String str,int
          // fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
  ​
          // String substring(int start):从指定位置开始截取字符串,默认到末尾。包含start这个索引
          System.out.println("substring:" + s.substring(5));
          System.out.println("substring:" + s.substring(0));
          System.out.println("----------------------");
  ​
          // String substring(int start,int
          // end):从指定位置开始到指定位置结束截取字符串。包括start索引但是不包end索引，包左不包
          System.out.println("substring:" + s.substring(3, 8));
          System.out.println("substring:" + s.substring(0, s.length()));
      }
  }
  ​

  字符串遍历

  /*
   * 需求：遍历获取字符串中的每一个字符  
   * 分析：
   *      A:如何能够拿到每一个字符呢?
   *          char charAt(int index)
   *      B:我怎么知道字符到底有多少个呢?
   *          int length()
   */
  public class StringTest {
      public static void main(String[] args) {
          // 定义字符串
          String s = "helloworld";
          // 原始版本
          // 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(s.charAt(5));
          // System.out.println(s.charAt(6));
          // System.out.println(s.charAt(7));
          // System.out.println(s.charAt(8));
          // System.out.println(s.charAt(9));
  ​
          // 只需要我们从0取到9
          // for (int x = 0; x < 10; x++) {
          // System.out.println(s.charAt(x));
          // }
          // 如果长度特别长，我不可能去数，所以我们要用长度功能
          for (int x = 0; x < s.length(); x++) {
              // char ch = s.charAt(x);
              // System.out.println(ch);
              // 仅仅是输出，我就直接输出了
              System.out.println(s.charAt(x));
          }
      }
  }

转换功能的方法

• public char[] toCharArray()：将此字符串转换为新的字符数组。

• public byte[] getBytes()：使用平台的默认字符集将该String编码转换为新的字节数组。

• public String replace(char oldChar, char newChar)：将oldChar匹配的字符串使用newChar字符串替换。

• public String replaceFirst(String regex,String replacement)用给定的 replacement 替换此字符串匹配给定的regex的第一个子字符串。

• public String toUpperCase() : 将字符中转换为大写

• public String toLowerCase(): 将字符中转换为小写

• 代码演示

  /*
   * String的转换功能：
   * byte[] getBytes():把字符串转换为字节数组。
   * char[] toCharArray():把字符串转换为字符数组。
   * static String valueOf(char[] chs):把字符数组转成字符串。
   * static String valueOf(int i):把int类型的数据转成字符串。
   *      注意：String类的valueOf方法可以把任意类型的数据转成字符串。
   * String toLowerCase():把字符串转成小写。
   * String toUpperCase():把字符串转成大写。
   * String concat(String str):把字符串拼接。
   */
  public class StringDemo {
      public static void main(String[] args) {
          // 定义一个字符串对象
          String s = "JavaSE";
  ​
          // byte[] getBytes():把字符串转换为字节数组。
          byte[] bys = s.getBytes();
          for (int x = 0; x < bys.length; x++) {
              System.out.println(bys[x]);
          }
          System.out.println("----------------");
          // char[] toCharArray():把字符串转换为字符数组。
          char[] chs = s.toCharArray();
          for (int x = 0; x < chs.length; x++) {
              System.out.println(chs[x]);
          }
          System.out.println("----------------");
          
          // static String valueOf(char[] chs):把字符数组转成字符串。
          String ss = String.valueOf(chs);
          System.out.println(ss);
          System.out.println("----------------");
          // static String valueOf(int i):把int类型的数据转成字符串。
          int i = 100;
          String sss = String.valueOf(i);
          System.out.println(sss);
          System.out.println("----------------");
          // String toLowerCase():把字符串转成小写。
          System.out.println("toLowerCase:" + s.toLowerCase());
          System.out.println("s:" + s);
          // System.out.println("----------------");
          // String toUpperCase():把字符串转成大写。
          System.out.println("toUpperCase:" + s.toUpperCase());
          System.out.println("----------------");
          // String concat(String str):把字符串拼接。
          String s1 = "hello";
          String s2 = "world";
          String s3 = s1 + s2;
          String s4 = s1.concat(s2);
          System.out.println("s3:"+s3);
          System.out.println("s4:"+s4);
      }
  }

分割-替换-去空格-正则的功能方法

• public String[] split(String regex)：将此字符串按照给定的regex（规则）拆分为字符串数组。

• public String trim()：去除该字符串的两端空格

• 代码演示

  public class String_Demo03 {
      public static void main(String[] args) {
          //创建字符串对象
          String s = "aa|bb|cc";
          String[] strArray = s.split("\\|"); // ["aa","bb","cc"]   
          for(int x = 0; x < strArray.length; x++) {
              System.out.println(strArray[x]); // aa bb cc
          }        
          // 替换功能
          String s1 = "helloworld";
          String s2 = s1.replace('l', 'k');//字符
          String s3 = s1.replace("owo", "ak47");//字符串
          System.out.println("s1:" + s1);
          System.out.println("s2:" + s2);
          System.out.println("s3:" + s3);
          System.out.println("---------------");       
          System.out.println("替换功能:"+s1);
          System.out.println(s1.replaceAll("\\s","e"));//把空格替换成e
  ​
          // 去除字符串两空格
          String s4 = " hello world  ";
          String s5 = s4.trim();
          System.out.println("s4:" + s4 + "---");
          System.out.println("s5:" + s5 + "---");
          
          //正则表达式-校验用户写的内容是否满足当前规定  手机号：123 4000 8888
          String s5 ="13140008888";
          boolean matches = s5.matches("^1[356789]\\d{9}$");
          System.out.println(matches);
          
      }
  }

  字符串的使用方法有很多，如果后期有需要参照api

String类的练习

字符串首字母改为大写

• 需求

  需求：把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)

/*
 * 需求：把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)
 * 举例：
 *      helloWORLD
 * 结果：
 *      Helloworld 
 * 分析：
 *      A:先获取第一个字符
 *      B:获取除了第一个字符以外的字符
 *      C:把A转成大写
 *      D:把B转成小写
 *      E:C拼接D
 */
public class StringTest {
    public static void main(String[] args) {
        // 定义一个字符串
        String s = "helloWORLD";
​
        // 先获取第一个字符
        String s1 = s.substring(0, 1);
        // 获取除了第一个字符以外的字符
        String s2 = s.substring(1);
        // 把A转成大写
        String s3 = s1.toUpperCase();
        // 把B转成小写
        String s4 = s2.toLowerCase();
        // C拼接D
        String s5 = s3.concat(s4);
        System.out.println(s5);
        // 优化后的代码
        // 链式编程
        String result = s.substring(0, 1).toUpperCase()
                .concat(s.substring(1).toLowerCase());
        System.out.println(result);
    }
}

统计字符个数

• 需求

  键盘录入一个字符串，统计字符串中大小写字母及数字字符个数 "abcABC123"

• 代码演示

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

统计大串中小串出现的次数

 需f：在字符串"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun"
 结果：java出现了5次

package cn.yanqi_04;
public class StringTest3 {
    public static void main(String[] args) {
        // 定义大串
        String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagunjavajava";
        // 定义小串
        String minString = "java";
        //循环  while
        //找java在大串中第一次出现的位置
        int count =0;
        int index;
        while ( (index = maxString.indexOf(minString)) != -1){
            count++;
            //重新计算新的大串开始位置， index + minSring.length()  4+4
            maxString = maxString.substring(index+minString.length());
        }
        System.out.println("java出现的次数为："+count);
    }
}

代码优化

package cn.yanqi_04;
public class GetCount {
    /**
     * 方法-写功能   大串中统计小串出现的次数
     * @param maxString
     * @param minString
     * @return
     */
    public int getStr(String maxString , String minString){
        int count =0;
        int index;
        while ( (index = maxString.indexOf(minString)) != -1 ){
            count++;
            //重新计算新的大串开始位置， index + minSring.length()  4+4
            maxString = maxString.substring(index+minString.length());
        }
        return count;
    }
}

package cn.yanqi_04;
public class Demo {
    public static void main(String[] args) {
        GetCount gc = new GetCount();
        // 定义大串
        String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagunjava";
        // 定义小串
        String minString = "java";
        //调方法看参数列表  看返回类型
        int str = gc.getStr(maxString, minString);
        System.out.println(str);
    }
}

/**
1、概述：
 String类：字符串类，final class:是最终类,不能有子类
    字符串不变：字符串的值在创建后不能被更改
            重新赋值时：重新开辟内存，变量指向新内存
    因为String对象是不可变的，所以它们可以被共享
 注：字符串数据是保存到常量池中的，所以可以共享数据
2.String的本质是
 - JDK8之前是char[] 数组
 - JDK8之后是byte[] 数组
3.常见的构造方法：
    方法名                                 说明
 public String()                    初始化新创建的String对象，以使其表示空字符序列
 public String(char[] value)        通过当前参数中的字符数组来构造新的String。
 String(char[] value, int offset, int count)    通过当前参数中的字符数组的一部分来构造新的String。
 public String(byte[] bytes)        通过使用平台的默认字符集解码当前参数中的字节数组来构造新的
 String(byte[] bytes, int offset, int length)    通过使用平台的默认字符集解码当前参数中的字节数组的一部分来构造新的String
 */

/**
 String类的判断功能：
     boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
     boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
     boolean contains(String str):判断大字符串中是否包含小字符串
     boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
     boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾
     boolean isEmpty():判断字符串是否为空。
     注意：
     字符串内容为空和字符串对象为空。
     String s = "";内容为空
     String s = null; 字符串对象为空
 */

/** 字符串中获取的功能：
 - public int length() ：返回此字符串的长度
 - public String concat(String str): 将指定的字符串连接到该字符串的末尾。
 - public char charAt(int index): 返回指定索引处的char值。
 - public int indexOf(int ch)：返回指定子字符串第一次出现在该字符串内的索引。
 - public String substring(int beginIndex)：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
 - public String substring(int beginIndex,int endIndex)：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。
 */

/**
 * String 转换的方法：
 - public char[] toCharArray()：将此字符串转换为新的字符数组。
 - public byte[] getBytes()：使用平台的默认字符集将该String编码转换为新的字节数组。
 - public String replace(char oldChar, char newChar)：将oldChar匹配的字符串使用newChar字符串替换。
 - public String replaceFirst(String regex,String replacement)用给定的 replacement 替换此字符串匹配给定的regex的第一个子字符串。
 - public String toUpperCase() :  将字符中转换为大写
 - public String toLowerCase():  将字符中转换为小写
 分割-替换-去空格-正则的功能方法
 - public String[] split(String regex)：将此字符串按照给定的regex（规则）拆分为字符串数组。
 - public String trim()：去除该字符串的两端空格
 */