API、String类和StringBuilder类

一.什么是API

API (Application Programming Interface) ：应用程序编程接口

其实就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。

通常我们可以借助jdk帮助文档来查询到我们所需的类。

比如，我们可以在搜索栏输入Math关键词来查询到Math类的作用，以及它包含的方法。

往下翻就能找到Math包含的方法，比如abs。

通过帮助文档，我们就可以轻松的找到需要的封装类，更便于我们进行java的学习。

二.String类

String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的对象（实例）。所以我们创建一个字符串，相当于创建了一个String类的对象。

1.字符串的构造方法及特性

常用的String类的构造方法有如下几种：

public String();

eg:

String s=new String();//创建一个空的字符串对象

public String(字符数组);

eg：

char[] c={'a','b','c'};

String s=new String（c）;//创建了一个"abc"的字符串

public String（"字符串"）;

eg:

String s=new String("abc");//同样创建了一个"abc"字符串

我们常用的直接赋值的方式相当于最后一种的简化版：String s="abcd";

值得注意的是，当我们直接选择用字符串给字符变量赋值和new一个对象赋值在内存上有一些区别。

通过new创建字符串对象时，不管内存（方法区中的字符串常量池）中有没有相同的字符串常量，系统都会自动在内存（堆空间）中新建一个对象指向字符串常量所在的地址。但如果采用直接赋值字符串的方式新建字符串，而字符串常量池已经存在相同的字符串时，系统就不会新建对象，而是直接指向字符串常量池中的字符串了。

字符串不可变，它们的值在创建后不能被更改。意思是，创建一个字符串后，该字符串就会在字符串常量池中进行维护，你=改变对象的值，其实是创建了一个新的字符串，而开始的字符串依旧存在。

2.String类常用的方法

public boolean equals(String s) 比较两个字符串内容是否相同、区分大小写

下面我们用了equals方法做了个判断字符串的小案例（登录信息的比对）：

import java.util.Scanner;
public class lodingImitate {
    public static void main(String[] args) {
        String realName ="ying";//设置正确的用户名
        String realPassword="12345678";//设置正确的的登录密码
        String name;//定义name和password两个变量用于接收录入的姓名和登录密码
        String password;
        Scanner sc = new Scanner(System.in);//创建一个Scanner对象，用于录入信息
        for(int i=1;;i++){
            System.out.println("请输入正确的用户名：");
            name= sc.nextLine();//用name接收录入的姓名信息
            System.out.println("请输入正确的密码：");
            password= sc.nextLine();//接收登录密码
            if(realName.equalsIgnoreCase(name)&&realPassword.equals(password)){
                System.out.println("恭喜你登录成功！");//equals判断真实的姓名和密码是否和录入的相等
                break;
            }else{
                if(i==3){//设置循环次数，如果输入次数满足三则打破循环
                    System.out.println("登录失败，您今日的"+i+"次机会已用完，请明天再来");
                    break;
                }else {
                    System.out.println("很遗憾，您输入的密码或用户名不正确，请重新输入！");
                }
                }
        }
    }
}

上述案例我们使用了equals方法来比较字符串是否相等：realPassword.equals(password)

之所以不用“==”，是因为String是引用类型的数据，用“==”只能比较两个字符串的地址，而不能比较实际的内容。

同时我们也使用了另一个和equals相似的方法：equalsIgnoreCase（参数），这个方法同样是比较字符串是否相等，不同的是，equalsIgnoreCase不区分大小写。

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

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

我们同样用一个遍历字符串的案例来体现这两个方法:

import java.util.Scanner;
//遍历
public class StringErgodic {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);//创建Scanner对象来录入字符串
        System.out.println("请输入所需遍历的字符串：");
        String se=sc.nextLine();//用se来接收录入的字符串
        for (int i=0;i<se.length();i++){//通过length()方法来计算字符串的长度
          if(i==se.length()-1){//此处用了if来判断索引是否为最后一个，如果是，则在字符后不加逗号
              System.out.print(se.charAt(i));//通过charAt来返回索引i处的字符
          }
        else{
              System.out.print(se.charAt(i)+",");
          }
        }
    }
}

public char[] toCharArray( )：将当前字符串拆分为字符数组并返回

如果需要将字符串转成单个字符为单位的字符数组，我们可以使用toCharArray，例如当我们要统计字符串中有多少数字或字母时，可以将字符串转换为字符数组，再通过遍历来统计。

import java.util.Scanner;
public class ToCharArrayTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要统计的字符串:");
        String st=sc.nextLine();
        char[] ch=st.toCharArray();//通过字符串对象st调用toCharArray将字符串st转换成字符数组，再将数组传给ch数组
        int lowercase=0;
        int capital=0;
        int num=0;
        for(int i=0;i< ch.length;i++){//遍历
            if(ch[i]>='a'&&ch[i]<='z'){//由于字母、数字的ASCll码都是连续的，所以可以直接对字母进行判断
                lowercase++;
            }
            else if(ch[i]>='A'&&ch[i]<='Z'){
                capital++;
            }
            else if(ch[i]>='0'&&ch[i]<='9'){
                num++;
            }
        }
        System.out.println("小写字母的个数有:"+lowercase+"大写字母的个数有："+capital+"数字的个数有："+num);

    }
}

String类还有不少方法，例如：

​    public String substring(int beginIndex, int endIndex)  根据开始和结束索引进行截取，得到新的字符串（包含头，不包含尾）

​    public String substring(int beginIndex)  从传入的索引处截取，截取到末尾，得到新的字符串

​    public String replace(CharSequence target, CharSequence replacement)  使用新值，将字符串中的旧值替换，得到新的字符串

//屏蔽字符串和替换字符串
import java.util.Scanner;
//手机号屏蔽
//通过subString来截取字符串
public class TelShield {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要屏蔽的手机号(11位)：");
        String tel=sc.nextLine();
      String telAfter=  tel.substring(0,3)+"****"+tel.substring(7,11);
        System.out.println("原号码" +tel);//substring截取的字符串会创建一个新的字符串对象，所以不会对原来的字符串进行更改
        System.out.println("截取后"+telAfter);
        System.out.println("=====以下是替换方法replace的应用====");
        System.out.println("请输入包含屏蔽词的话：");
        String mingan=sc.nextLine();
        String minAfter=mingan.replace("死","暴富");//replace来替换内容
        System.out.println("原："+mingan);
        System.out.println("后："+minAfter);
    }
}

​    public String[] split(String regex)  根据传入的规则切割字符串，得到字符串数组

import com.bean.Student;//导入自建的学生类
import java.util.Scanner;
public class StringSplit {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生的姓名和年龄和性别，并用中文格式的’，‘将其分隔开: ");
        String infor = sc.nextLine();
        char c = infor.charAt(1);//charAt(index i);返回指定字符串索引的字符
        System.out.println(c);
        String[] split = infor.split("，");//通过“，”来对字符串进行分割，使其生成所需的字符串数组
       // System.out.println(split.length);
        String name = split[0];
        String agestr = split[1];
        int age = Integer.parseInt(agestr);//Integer.parseInt(String s);可以将字符串转为int型,和valueOf用法一样
        String gender = split[2];
        Student student = new Student(name, age, gender);
        student.show();
    }
}

三.StringBuilder类

上面说到String类是不可变的字符串类，每次修改字符串其实都是新建字符串对象，这样就会造成内存空间浪费，所以我们需要学习可变字符类。

StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是 StringBuilder 对象中的内容是可变的。

StringBuilder类的构造方法和String相似：

public StringBuilder()	创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str)	根据字符串的内容，来创建可变字符串对象

public class StringbuilderExer {
    public static void main(String[] args) {
        StringBuilder bui = new StringBuilder();//创建一个空白可变字符串对象，不含有任何内容
        StringBuilder builder = new StringBuilder("你好");//StringBuilder可变字符串
        System.out.println(builder);
       // System.out.println(builder.length());
        builder.append("手机号");//append（参数）可对原有的StringBuilder字符串进行手动拼接，结果为：你好手机号
        System.out.println(builder);
        StringBuilder sb=builder;
        System.out.println(sb == builder);//结果为true，因为地址一样
        System.out.println(builder.reverse());//reverse()反转字符串，结果为：号机手好你
    }
}

上述案例中我们还使用了StringBuilder类中的两个常用成员方法：

 public StringBuilder   append(任意类型)        添加数据，并返回对象本身 

 public StringBuilder   reverse()        返回相反的字符序列     

String类和StringBuilder可以相互转换，如下例所示：

public class StringBuider_String {
    public static void main(String[] args) {
        String str = new String("我愿成为一棵树");//创建一个String对象str，并将其赋值为"我愿成为一棵树"
        StringBuilder sb = new StringBuilder(str);//通过创建StringBuilder对象，将String对象str传入，实现String转换为StringBuilder
        System.out.println(str);
        System.out.println(sb);
        sb.append("一半在风里飞扬，一半在土里安详");//append对生成的StringBuilder对象sb进行拼接
        System.out.println(sb);
        String s = sb.toString();//通过toString可以将StringBUilder转化为String
        System.out.println(s);
    }
}