Java核心API

最新推荐文章于 2024-07-12 15:51:39 发布

竹韵飞

最新推荐文章于 2024-07-12 15:51:39 发布

阅读量1k

点赞数 34

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_55850995/article/details/136919948

版权

Java API

Java API（Application Programming Interface）是指Java编程语言提供的一套软件组件集合，用于开发Java应用程序。API定义了各种类、接口、方法和常量的规范，开发人员可以使用这些规范来编写程序、调用功能以及实现特定的功能。

接下来分多期为大家介绍java中常用的API

String类

String类是Java中用于表示字符串的类。它是Java标准API中最常用的类之一，提供了许多用于字符串操作的方法，使得在Java中处理和操作字符串变得非常方便。

特点

1.不可变性（Immutable）：

String类的对象一旦创建，其值不可被改变，java.lang.String使用了final修饰，不能被继承。任何对字符串的修改操作都会创建一个新的字符串对象，原有的字符串对象保持不变。

2.字符串常量池（String Pool）：

Java中的字符串池是一个特殊的内存区域，用于存储字符串常量。当创建一个字符串对象时，首先会检查字符串池中是否已经存在相同值的字符串，如果存在，则返回池中的对象引用，否则创建一个新的字符串并放入池中。这种机制可以减少字符串对象的重复创建，节省内存空间。

代码演示：

public class StringLiteralExample {
    public static void main(String[] args) {
        String s1 = "Hello"; // 字符串"Hello"是一个字符串字面量
        String s2 = "Hello"; // 直接使用相同的字面量创建字符串
        String s3 = new String("Hello"); // 使用new关键字创建新的字符串对象

        System.out.println(s1 == s2); // true，s1和s2引用的是同一个字符串对象
        System.out.println(s1 == s3); // false，s1和s3引用的是不同的字符串对象
    }
}

特殊情况：

编译器的优化特性可以减少在运行时对字符串的拼接操作，提高性能并减少内存开销。然而，对于那些在运行时才能确定内容的字符串拼接，不会进行这种优化，仍需注意字符串的创建和比较方式。

public class CompilerFeatureExample {
    public static void main(String[] args) {
        String s1 = "123";
        String s2 = "abc";
        String s3 = "123" + "abc"; // 编译器优化，将结果计算为"123abc"
        String s4 = s1 + s2;

        System.out.println(s3 == "123abc"); // true，s3与字面量"123abc"引用同一个对象
        System.out.println(s4 == "123abc"); // false，s4的值是在运行时计算的
    }
}

3.字符串的比较与相等性判断：

String类通过equals()方法来比较字符串的内容是否相等，而不是比较引用。这意味着两个字符串对象使用相同的字符序列，则equals()方法返回true。可以使用==运算符来比较字符串的引用是否相等。同时，还有compareTo()和equalsIgnoreCase()等方法用于比较字符串的大小和忽略大小写的比较。
4.字符串连接与拼接：

String类提供了多种方法用于字符串连接和拼接操作。用concat()方法来连接两个字符串。此外，还可以使用StringBuilder或StringBuffer类进行更复杂的字符串拼接，它们提供了可变字符串对象，适用于大量的字符串操作。
5.字符串的操作效率：

由于String类的不可变性，每次对字符串进行拼接、替换、插入等操作时，都会生成一个新的字符串对象。在进行大量的字符串操作时，可能会产生大量的临时对象，导致内存消耗增加和性能下降。

常用方法

String类提供了许多常用方法，用于字符串的操作和处理。以下是一些常见的String方法：

1.长度和字符访问：

length()：返回字符串的长度。

注意：

使用length()方法获取长度：要获取字符串的长度，请使用length()方法而不是属性。即，使用str.length()而不是str.length。
空字符串长度为0：空字符串表示没有包含任何字符的字符串。对于空字符串，length()方法的返回值将为0，" "空格不是空串。

public class StringLengthExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        int length = str.length(); // 调用length()方法获取字符串的长度
        System.out.println("字符串的长度为: " + length);
    }
}

charAt(index)：返回指定索引位置的字符。

注意：

index - 要获取字符的索引位置，范围从0到字符串长度减1。
如果指定的索引超出字符串长度的范围（小于0或大于等于字符串长度），则会抛出IndexOutOfBoundsException（下标越界异常）

public class CharAtExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        
        // 获取字符 'o' 的索引为 4
        char charAtIndex4 = str.charAt(4);
        System.out.println("索引位置 4 的字符是: " + charAtIndex4);
        
        // 获取字符串的第一个字符 'H' 的索引为 0
        char firstChar = str.charAt(0);
        System.out.println("第一个字符是: " + firstChar);
        
        // 获取字符串的最后一个字符 '!' 的索引为 12
        char lastChar = str.charAt(str.length() - 1);
        System.out.println("最后一个字符是: " + lastChar);
    }
}

2.比较和相等性判断：

equals(str)：比较字符串与指定字符串是否相等。

注意：

equals()方法比较的是字符串的内容，而非引用。
该方法区分大小写，因此大小写敏感。例如，"hello"与"Hello"不相等。
如果传入的参数为null，该方法会抛出NullPointerException异常。因此，在使用equals()方法之前要确保字符串不为null。

public class StringEqualsExample {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        String str3 = "World";

        // 比较 str1 和 str2 是否相等
        boolean isEqual1 = str1.equals(str2);
        System.out.println("str1 与 str2 是否相等: " + isEqual1);

        // 比较 str1 和 str3 是否相等
        boolean isEqual2 = str1.equals(str3);
        System.out.println("str1 与 str3 是否相等: " + isEqual2);
    }
}

equalsIgnoreCase(str)：忽略大小写比较字符串与指定字符串是否相等。

注意：

equalsIgnoreCase()方法比较的是字符串的内容，而非引用。
该方法忽略大小写，因此不会区分大小写。例如，"hello"和"Hello"会被视为相等。
如果传入的参数为null，该方法会抛出NullPointerException异常。因此，在使用equalsIgnoreCase()方法之前要确保字符串不为null。

public class StringEqualsIgnoreCaseExample {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "hello";
        String str3 = "HELLO";

        // 忽略大小写比较 str1 和 str2 是否相等
        boolean isEqual1 = str1.equalsIgnoreCase(str2);
        System.out.println("str1 忽略大小写与 str2 是否相等: " + isEqual1);

        // 忽略大小写比较 str1 和 str3 是否相等
        boolean isEqual2 = str1.equalsIgnoreCase(str3);
        System.out.println("str1 忽略大小写与 str3 是否相等: " + isEqual2);
    }
}

startsWith(prefix)：检查字符串是否以指定的前缀开始。
endsWith(suffix)：检查字符串是否以指定的后缀结束。

注意：

这两个方法都比较的是字符串的内容，而非引用。
方法的比较是区分大小写的。如果需要忽略大小写进行比较，可以使用startsWithIgnoreCase()和endsWithIgnoreCase()方法。
如果传入的参数为null，这两个方法会抛出NullPointerException异常。因此，在使用这两个方法之前要确保字符串和参数都不为null。

public class StringStartEndExample {
    public static void main(String[] args) {
        String str = "Hello, World!";

        // 检查字符串是否以指定前缀 "Hello" 开始
        boolean startsWithHello = str.startsWith("Hello");
        System.out.println("字符串是否以 \"Hello\" 开始: " + startsWithHello);

        // 检查字符串是否以指定后缀 "World!" 结束
        boolean endsWithWorld = str.endsWith("World!");
        System.out.println("字符串是否以 \"World!\" 结束: " + endsWithWorld);
    }
}

3.搜索和替换：

indexOf(str)：返回指定字符串第一次出现的索引位置。
lastIndexOf(str)：返回指定字符串最后一次出现的索引位置。

注意：

索引位置是从 0 开始的，即第一个字符的索引位置为 0。
如果指定的字符串在调用方法的字符串中不存在，则 indexOf() 方法和 lastIndexOf() 方法都会返回 -1。
这两个方法都可以接受一个字符或一个字符串作为参数。
indexOf() 方法从字符串的开头开始搜索指定字符串 str 的出现位置，而 lastIndexOf() 方法从字符串的末尾开始向前搜索指定字符串 str 的出现位置。

public class IndexOfLastIndexOfExample {
    public static void main(String[] args) {
        String str = "Hello World, Hello Java";

        int firstIndex = str.indexOf("Hello");
        System.out.println("First occurrence of 'Hello' at index: " + firstIndex);

        int lastIndex = str.lastIndexOf("Hello");
        System.out.println("Last occurrence of 'Hello' at index: " + lastIndex);
    }
}

当 indexOf(str) 和 lastIndexOf(str) 方法接受两个参数时，第二个参数表示搜索的起始位置。这样可以限制搜索的范围。

public class IndexOfLastIndexOfExample {
    public static void main(String[] args) {
        String str = "Hello World, Hello Java";

        int firstIndex = str.indexOf("Hello", 6);
        System.out.println("First occurrence of 'Hello' after index 6 at index: " + firstIndex);

        int lastIndex = str.lastIndexOf("Hello", 15);
        System.out.println("Last occurrence of 'Hello' before index 15 at index: " + lastIndex);
    }
}

replace(oldChar, newChar)：替换字符串中的所有旧字符为新字符。

注意：

replace(oldChar, newChar) 方法是区分大小写的，意味着它只会替换与 oldChar 参数完全匹配的字符。

public class ReplaceExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        String replacedStr = str.replace('o', 'e');
        System.out.println("Original string: " + str);
        System.out.println("Replaced string: " + replacedStr);
    }
}

replaceAll(regex, replacement)：使用给定的正则表达式替换字符串中所有匹配的部分。

replaceAll(regex, replacement) 方法中的 regex 参数是一个正则表达式，用于指定匹配的模式。

public class ReplaceAllExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        String replacedStr = str.replaceAll("[aeiou]", "*");
        System.out.println("Original string: " + str);
        System.out.println("Replaced string: " + replacedStr);
    }
}

4.截取和提取：

substring(beginIndex)：从指定索引位置开始截取字符串。
substring(beginIndex, endIndex)：截取字符串的指定范围。

注意：

substring(beginIndex) 方法从指定的 beginIndex 索引位置开始截取字符串，包括 beginIndex 所指向的字符及其后面的字符。
substring(beginIndex, endIndex) 方法截取字符串的指定范围，包括 beginIndex 所指向的字符但不包括 endIndex 所指向的字符。

public class SubstringExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        String substring1 = str.substring(7);
        String substring2 = str.substring(7, 12);

        System.out.println("Original string: " + str);
        System.out.println("Substring from index 7 onwards: " + substring1);
        System.out.println("Substring from index 7 to 12: " + substring2);
    }
}

trim()：去除字符串开头和结尾的空格。

注意：

trim() 方法不会改变原始字符串的值，而是返回一个新的字符串，该字符串去除了开头和结尾的空格。
trim() 方法只去除开头和结尾的空格，中间的空格不会被去除。

public class TrimExample {
    public static void main(String[] args) {
        String str = "   Hello, World!    ";
        String trimmedStr = str.trim();

        System.out.println("Original string: [" + str + "]");
        System.out.println("Trimmed string: [" + trimmedStr + "]");
    }
}

5.大小写转换：

toLowerCase()：将字符串转换为小写。
toUpperCase()：将字符串转换为大写。

public class CaseConversionExample {
    public static void main(String[] args) {
        String str = "Hello, World!";
        String lowerCaseStr = str.toLowerCase();
        String upperCaseStr = str.toUpperCase();

        System.out.println("Original string: " + str);
        System.out.println("Lowercase string: " + lowerCaseStr);
        System.out.println("Uppercase string: " + upperCaseStr);
    }
}

6.切割和分割：

split(delimiter)：将字符串按指定的分隔符拆分成字符串数组。

注意

split(delimiter) 方法接受一个参数 delimiter，表示要使用的分隔符。
分隔符可以是一个字符串，也可以是一个正则表达式。
split(delimiter) 方法将字符串根据分隔符进行拆分，并返回一个字符串数组，数组中的每个元素是拆分后的子字符串。

public class SplitExample {
    public static void main(String[] args) {
        String str = "Hello,World,Java";
        String[] splitArray = str.split(",");

        System.out.println("Original string: " + str);
        System.out.println("Split array length: " + splitArray.length);
        System.out.println("Split array elements: ");
        for (String element : splitArray) {
            System.out.println(element);
        }
    }
}

特殊情况：

在使用 split(delimiter) 方法时，如果在字符串的开头、结尾或中间出现连续的分隔符，会有一些特殊情况需要注意：

如果连续分隔符在字符串的开头或结尾，split() 方法会生成一个空字符串作为结果数组的元素。
如果连续分隔符在字符串的中间，split() 方法会将连续的分隔符视为一个分隔符，并且生成空字符串元素。

public class SplitExample {
    public static void main(String[] args) {
        String str1 = ",Hello,World,Java,";
        String str2 = "Hello,,World";
        String str3 = "Hello,,,World";

        String[] splitArray1 = str1.split(",");
        String[] splitArray2 = str2.split(",");
        String[] splitArray3 = str3.split(",");

        System.out.println("Original string 1: " + str1);
        System.out.println("Split array 1 length: " + splitArray1.length);
        System.out.println("Split array 1 elements: ");
        for (String element : splitArray1) {
            System.out.println("[" + element + "]");
        }

        System.out.println("Original string 2: " + str2);
        System.out.println("Split array 2 length: " + splitArray2.length);
        System.out.println("Split array 2 elements: ");
        for (String element : splitArray2) {
            System.out.println("[" + element + "]");
        }

        System.out.println("Original string 3: " + str3);
        System.out.println("Split array 3 length: " + splitArray3.length);
        System.out.println("Split array 3 elements: ");
        for (String element : splitArray3) {
            System.out.println("[" + element + "]");
        }
    }
}

7.转换：

valueOf(value)：将提供的值转换为字符串。

注意：

valueOf(value) 方法接受一个值作为参数，并返回该值的字符串表示形式。
参数 value 可以是基本类型的值、对象实例或字符串等。
不同的包装类有着不同的 valueOf(value) 方法，例如 Integer.valueOf(value)、Double.valueOf(value) 等。

public class ValueOfExample {
    public static void main(String[] args) {
        int intValue = 42;
        double doubleValue = 3.14;
        String stringValue = "Hello";

        String intString = String.valueOf(intValue);
        String doubleString = String.valueOf(doubleValue);
        String stringString = String.valueOf(stringValue);

        System.out.println("intString: " + intString);
        System.out.println("doubleString: " + doubleString);
        System.out.println("stringString: " + stringString);
    }
}

竹韵飞

关注

34
点赞
踩
27

收藏

觉得还不错? 一键收藏
1
评论
Java核心API

Java API（Application Programming Interface）是指Java编程语言提供的一套软件组件集合，用于开发Java应用程序。API定义了各种类、接口、方法和常量的规范，开发人员可以使用这些规范来编写程序、调用功能以及实现特定的功能。接下来分多期为大家介绍java中常用的API。
复制链接

扫一扫