一脚踩进java之基础篇23——常用API（Object、String）

一、Java的API

1.1 Java 的API（API: Application(应用) Programming(程序) Interface(接口)）

1） Java API就是JDK中提供给我们使用的类，这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。

2） 在JDK安装目录下有个src.zip文件，这个文件解压缩后里面的内容是所有Java类的源文件。可以在其中查看相对应的类的源码。

3） 我们可以通过查帮助文档的方式，来了解Java提供的API如何使用。如下图操作：查找Object类

 1.2 Object类概述

1）Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。所有类在创建对象的时候，最终找的父类就是Object。

2）在Object类众多方法中，我们先学习equals方法与toString方法，其他方法后面课程中会陆续学到。

1.3 equals方法

1）equals方法，用于比较两个对象是否相同，它其实就是使用两个对象的内存地址在比较。Object类中的equals方法内部使用的就是==比较运算符。

2）在开发中要比较两个对象是否相同，经常会根据对象中的属性值进行比较，也就是在开发经常需要子类重写equals方法根据对象的属性值进行比较。

如下代码演示：

/*
     描述人这个类，并定义功能根据年龄判断是否是同龄人
     由于要根据指定类的属性进行比较，这时只要覆盖Object中的equals方法
     在方法体中根据类的属性值进行比较
 */
class Person extends Object{
    int age ;
    //复写父类的equals方法，实现自己的比较方式
    public boolean equals(Object obj) {
        //判断当前调用equals方法的对象和传递进来的对象是否是同一个
        if(this == obj){
            return true;
        }
        //判断传递进来的对象是否是Person类型
        if(!(obj instanceof Person)){
            return false;
        }
        //将obj向下转型为Perosn引用，访问其属性
        Person p = (Person)obj;
        return this.age == p.age;
    }
}

注意：在复写Object中的equals方法时，一定要注意public boolean equals(Object obj)的参数是Object类型，在调用对象的属性时，一定要进行类型转换，在转换之前必须进行类型判断。

1.4 toString方法

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

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

class Person extends Object{
    int age ;
    //根据Person类的属性重写toString方法
    public String toString() {
        return "Person [age=" + age + "]";
    }
}

二、String类

2.1 String类的概述

1）查阅API中的String类的描述，发现String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。

//演示字符串
String str  = "hello";
str = "你好";

2）继续查阅API发现说字符串是常量；它们的值在创建之后不能更改，这是什么意思呢？其实就是说一旦这个字符串确定了，那么就会在内存区域中就生成了这个字符串。字符串本身不能改变，但str变量中记录的地址值是可以改变的。

3）继续查API发现，字符串有大量的重载的构造方法。通过String类的构造方法可以完成字符串对象的创建，那么，通过使用双引号的方式创建对象与new的方式创建对象，有什么不同呢？看如下程序与图解：

String s3 = "abc";
String s4 = new String("abc");
System.out.println(s3==s4);//false
System.out.println(s3.equals(s4));//true,
//因为String重写了equals方法，建立了字符串自己的判断相同的依据（通过字符串对象中的字符来判断）

4）s3和s4的创建方式有什么不同呢？

　　①s3创建，在内存中只有一个对象。这个对象在字符串常量池中

　　②s4创建，在内存中有两个对象。一个new的对象在堆中，一个字符串本身对象，在字符串常量池中

2.2 String类的构造方法

1）构造方法是用来完成String对象的创建，下图中给出了一部分构造方法需要在API中找到，并能够使用下列构造方法创建对象。

String s1 = new String(); //创建String对象，字符串中没有内容
        
        byte[] bys = new byte[]{97,98,99,100};
        String s2 = new String(bys); // 创建String对象，把数组元素作为字符串的内容
        System.out.println(s2);
        String s3 = new String(bys, 1, 3); //创建String对象，把一部分数组元素作为字符串的内容，参数offset为数组元素的起始索引位置，参数length为要几个元素
        System.out.println(s3);
        char[] chs = new char[]{‘a‘,‘b‘,‘c‘,‘d‘,‘e‘};
        String s4 = new String(chs); //创建String对象，把数组元素作为字符串的内容
        System.out.println(s4);
        String s5 = new String(chs, 0, 3);//创建String对象，把一部分数组元素作为字符串的内容，参数offset为数组元素的起始索引位置，参数count为要几个元素
        System.out.println(s5);
        String s6 = new String("abc"); //创建String对象，字符串内容为abc
        System.out.println(s6);

输出结果：

String s1 = new String(); //创建String对象，字符串中没有内容

    byte[] bys = new byte[]{97,98,99,100};

    String s2 = new String(bys); // 创建String对象，把数组元素作为字符串的内容

    String s3 = new String(bys, 1, 3); //创建String对象，把一部分数组元素作为字符串的内容，参数offset为数组元素的起始索引位置，参数length为要几个元素

    char[] chs = new char[]{’a’,’b’,’c’,’d’,’e’};

    String s4 = new String(chs); //创建String对象，把数组元素作为字符串的内容

    String s5 = new String(chs, 0, 3);//创建String对象，把一部分数组元素作为字符串的内容，参数offset为数组元素的起始索引位置，参数count为要几个元素

    String s6 = new String(“abc”); //创建String对象，字符串内容为abc

2.3 String类的常用方法

　　1）字符串中有多少个字符?

String str = "abcde";
int len = str.length();
System.out.println("len="+len);

2）获取部分字符串

String str = "abcde";
String s1 = str.substring(1); //返回一个新字符串，内容为指定位置开始到字符串末尾的所有字符
String s2 = str.substring(2, 4);//返回一个新字符串，内容为指定位置开始到指定位置结束所有字符（索引位置左闭右开）
System.out.println("str="+str);
System.out.println("s1="+s1);//bcde
System.out.println("s2="+s2);//cd

3）字符串是否以指定字符串开头。结尾同理。

String str = "StringDemo.java";
boolean b1 = str.startsWith("Demo");//判断是否以给定字符串开头
boolean b2 = str.startsWith("String");
boolean b3 = str.endsWith("java");//判断是否以给定字符串结尾

4）字符串中是否包含另一个字符串

String str = "abcde";
int index = str.indexOf(“bcd”); //判断是否包含指定字符串，包含则返回第一次出现该字符串的索引，不包含则返回-1
boolean b2 = str.contains("bcd");//判断是否包含指定字符串，包含返回true，不包含返回false

5）将字符串转成一个字符数组。或者字节数组。

String str = "abcde";
char[] chs = str.toCharArray();
byte[] bytes = str.getBytes();

6）判断两个字符串中的内容是否相同

String str = "abcde";
String str2 = "abcde";
String str3 = "hello";
boolean b1 = str.equals(str2);
boolean b2 = str.equals(str3);

7）获取该字符串对象中的内容

String str = new String("hello");
System.out.println( str.toString() );
System.out.pintln( str );

直接打印引用类型变量时，默认调用该类型进行重写后的toString方法

2.4 String类方法使用练习

题目一：获取指定字符串中，大写字母、小写字母、数字的个数。

思路：　1.为了统计大写字母、小写字母、数字的个数。创建3个计数的变量。

　　2.为了获取到字符串中的每个字符，进行字符串的遍历，得到每个字符。

　　3.对得到的字符进行判断，如果该字符为大写字母，则大写字母个数+1；如果该字符为小写字母，则小写字母个数+1；如果该字符为数字，则数字个数+1。

　　4.显示大写字母、小写字母、数字的个数

代码：

public static void method(String str){
    int bigCount = 0; //大写字母的个数
    int smallCount = 0; //小写字母的个数
    int numberCount = 0; //数字的个数
    for (int i=0; i < str.length(); i++) {
         char ch = str.charAt(i); //获取指定位置上的字符
        if (ch>=’A’ && ch<=’Z’) {
            bigCount++;
} else if (ch>=’a’ && ch<=’z’) {
smallCount++;
} else if (ch>=’0’ && ch<=’9’) {
        numberCount++;
}
}
System.out.println("大写字母个数："+bigCount);
System.out.println("小写字母个数："+smallCount);
System.out.println("数字个数："+numberCount);
}

题目二：将字符串中，第一个字母转换成大写，其他字母转换成小写，并打印改变后的字符串。

思路：　1.把字符串分为两个部分，第一部分为字符串中第一个字母，第二部分为剩下的字符串。

　　2.把第一部分字符串转换成大写字母，把第二部分字符串转换成小写字母

　　3.把两部分字符串连接在一起，得到一个完整的字符串

代码：

public static String convert(String str){
    //获取第一部分为字符串
    String start = str.substring(0,1);
    //获取第二部分为字符串
    String end = str.substring(1);
    //把第一部分字符串转换成大写字母，把第二部分字符串转换成小写字母
    String big = start.toUpperCase();
    String small = end.toLowerCase();
　　//把两部分字符串连接在一起，得到一个完整的字符串
    return big+small;
}

题目三：查询大字符串中，出现指定小字符串的次数。如“hellojava,nihaojava,javazhenbang”中查询出现“java”的次数。

思路：　1.在大串中，查找小串出现的位置，出现了就次数+1

　　2.在上次小串出现位置的后面继续查找，需要更改大串的内容为上次未查询到的字符串。

　　3.回到第一步，继续查找小串出现的位置，直到大串中查询不到小串为止

代码：

public static int getCount(String big, String small){
    int count = 0; //出现小串的次数
    int index = -1;//出现小串的位置
    /*
        while的循环条件三步骤：
        步骤一. big.indexOf(small) 获取小串在大串中出现的位置
        步骤二. 把小串出现的位置，赋值给变量index
        步骤三. 判断出现的位置是否为-1， 如果位置等于-1，说明大串中已经查询不到小串了；如果位置不等于-1，那么，进行循环，完成次数累加与修改大串的操作
*/
    while ((index = big.indexOf(small)) != -1 ){
        count++;//出现次数+1
        //更改大串内容
        big = big.substring(index+1);
}
return count;
}

三、字符串缓冲区

3.1StringBuffer的使用

1）代码演示：

创建一个字符串缓冲区对象。用于存储数据。
StringBuffer sb = new StringBuffer();
sb.append("haha"); //添加字符串
sb.insert(2, "it");//在指定位置插入
sb.delete(1, 4);//删除
sb.replace(1, 4, "cast");//替换指定范围内的内容
String str = sb.toString();

注意：append、delete、insert、replace、reverse方法调用后，返回值都是当前对象自己，所以说，StringBuffer它可以改变字符序列的长度和内容。

3.2 对象的方法链式调用

在我们开发中，会遇到调用一个方法后，返回一个对象的情况。然后使用返回的对象继续调用方法。这种时候，我们就可以把代码现在一起，如append方法一样，代码如下：

创建一个字符串缓冲区对象。用于存储数据。
StringBuffer sb = new StringBuffer();
添加数据。不断的添加数据后，要对缓冲区的最后的数据进行操作，必须转成字符串才可以。
String str = sb.append(true).append("hehe").toString();

3.3 StringBuilder

查阅API发现还有一个StringBuilder类，它也是字符串缓冲区，StringBuilder与它和StringBuffer的有什么不同呢？

我们阅读StringBuilder的API说明发现，它也是一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。

目前，我们还没有涉及到线程与同步，知道结论StringBuilder比StringBuffer快即可。为什么快，我们会在学习线程时讲解。