Java 字符串

1、字符串

  • 字符串操作是程序编写中经常用到的一种操作。Java 提供了两种字符串类:String 类和 StringBuffer 类,它们都提供了相应的方法实现字符串的操作,但二者略有不同。

    • String 类:该类一旦产生一个字符串,其对象就不可变。String 的内容和长度是固定的。如果程序需要获得字符串的信息,需要调用系统提供的各种字符串操作方法来实现。虽然通过各种系统方法可以对字符串施加操作,但这并不改变对象实例本身,而是生成了一个新的实例。系统为 String 类对象分配内存,是按照对象包含的实际字符数分配的。

    • StringBuffer 类:该类从名字就可以看出具有缓冲功能。StringBuffer 类用来处理可变字符串。如果要修改一个 StringBuffer 类的字符串,不需要再创建新的字符串对象,而是直接操作原来的字符串。该类的各种字符串操作方法与 String 类提供的方法不相同。系统为 StringBuffer 类对象分配内存时,除去当前字符所占空间外,还提供另外 16 个字符大小的缓冲区。注意使用 StringBuffer 类对象时,使用 length() 方法获得实际包含字符串的长度,capacity() 方法返回当前数据容量和缓冲区的容量之和。

    • StringBuilder 类:在 Java 程序里,如果需要大量拼接字符串的话,应该使用 StringBuffer 和 StringBuilder 类,它们可以避免不必要的 String 对象的产生,以提高程序的性能。它们两者的作用类似,只不过 StringBuilder 是线程安全的。

1.1 声明字符串

  • 字符串的声明格式有两种:常量声明方式和对象声明方式。

  • 常量声明方式用双引号括住一个字符串

    1
    String stringhello = "hello";
  • 对象声明方式

    1
    字符串类 字符串名 = new 字符串类(参数);
    1
    String stringhello = new String("hello");

1.2 创建字符串

  • 在声明了字符串后,就需要创建字符串实例,使字符串操作有实际的对象。

1.2.1 String 类字符串的创建

  • 初始化一个新创建的 String 对象,该对象表示一个空(null)的字符串。

    1
    String s = new String();
  • 初始化一个新创建的 String 对象,该对象初始化为参数 String 表示的字符串。

    1
    String s = new String(String);
  • 初始化一个新创建的 String 对象,该对象表示字符数组顺序组成的字符串。

    1
    String s = new String(char chars[]);
  • 初始化一个新创建的 String 对象,该对象表示由字符数组的部分组成的字符串,第 2 个参数表示部分字符数组的起始位置,第 3 个参数表示从起始位置开始的字符数量。

    1
    String s = new String(char chars[], int startindex, int numchars);
  • 初始化一个新创建的 String 对象,该对象表示由 Unicode code point 数组的一个子数组组成的字符串。Unicode 编码是单字节,即一个字符用一个字节表示,目前所有的键盘标识字符都可以用 Unicode 字符表示。

    1
    String s = new String(int[], int begin, int end);
  • 初始化一个新创建的 String 对象,该对象的内容是 StringBuffer 类所包含的字符数组。

    1
    String s = new String(StringBuffer);

1.2.2 StringBuffer 类字符串的创建

  • 初始化一个新创建的 StringBuffer 对象,该对象不包含任何字符,初始化容量为 16 个字符。

    1
    StringBuffer s = new StringBuffer();
  • 初始化一个新创建的 StringBuffer 对象,该对象不包含任何字符,初始化容量为 length 个字符,即初始化时确定了对象的容量。

    1
    StringBuffer s = new StringBuffer(int length);
  • 初始化一个新创建的 StringBuffer 对象,该对象初始化为参数 String 的内容。

    1
    StringBuffer s = new StringBuffer(String);
  • 初始化一个新创建的 StringBuffer 对象,该对象初始化为参数 CharSequence 的内容。

    1
    StringBuffer s = new StringBuffer(CharSequence);

2、字符串操作

2.1 字符串连接

  • 字符串连接实现两个或多个字符串连接为一个字符串,同时生成一个新串。

  • Java 调用 String 类的 concat() 函数实现字符串连接,该函数的参数是一个 String 对象,返回值是 String 对象(连接后的新字符串)。

    1
    2
    // 连接字符串
    String concat(String);
  • concat() 函数是 String 类独有的。

    1
    2
    3
    4
    5
    String s1 = new String("hello");    // 创建一个字符串,内容为 "hello",字符串名为 s1
    String s2 = new String("world"); // 创建一个字符串,内容为 "world",字符串名为 s2
    String s3; // 声明一个字符串 s3 但没初始化

    s3 = s1.concat(s2); // 调用 String 类的 concat 函数实现字符串的连接

2.2 字符串比较

  • 比较字符串实现返回两个字符串内容是否相同的比较结果,如果相同则返回 true,如果不同则返回 false。

  • Java 调用 String 类的 equals() 函数实现,该函数的参数是一个 String 对象,返回值是 boolean 值(比较后的结果)。

    1
    2
    // 比较字符串
    boolean equals(String);
  • equals() 函数是 String 类独有的。

    1
    2
    3
    4
    5
    6
    7
    String s1 = new String("hello");    // 创建一个字符串,内容为 "hello",字符串名为 s1
    String s2 = new String("world"); // 创建一个字符串,内容为 "world",字符串名为 s2
    String s3 = s1.concat(s2); // 调用 String 类的 concat 函数实现字符串的连接
    String s4 = "helloworld"; // 创建一个字符串,内容为 "helloworld",字符串名为 s4

    boolean result1 = s1.equals(s2); // 输入比较结果,结果为 false
    boolean result2 = s3.equals(s4); // 输入比较结果,结果为 true

2.3 字符长度获取

  • 在字符串创建后,往往需要获得字符串的长度值。

  • String 类对象的字符串的长度值是固定的,一旦字符串对象创建后长度就不再变化,而 StringBuffer 类有缓冲空间,默认是 16 个字符的长度。在操作 String 类对象时是生成一个新的字符串,而操作 StringBuffer 类的对象时,不用生成新的字符串而是在原串的基础上实现操作。二者都提供了获得字符串长度的函数 length() 来获得当前对象中的字符数量,但 StringBuffer 类还提供了 capacity() 函数说明字符容量,因为有缓冲区,所以容量大小肯定大于当前对象中的字符数量。

    1
    2
    3
    4
    5
    // 获得字符串长度
    int length();

    // 获得字符容量
    int capacity();
  • length() 函数是 String 类和 StringBuffer 类共有的。

  • capacity() 函数是 StringBuffer 类独有的。

    1
    2
    3
    4
    5
    6
    7
    String s = new String("hello");                 // 创建一个字符串,内容为 "hello",字符串名为 s1
    StringBuffer sf = new StringBuffer("world"); // 创建一个 StringBuffer 类

    int result1 = s.length(); // 输出 String 类对象的长度,结果为 5

    int result2 = sf.length(); // 输出 StringBuffer 类对象的长度,结果为 5
    int result3 = sf.capacity(); // 输出 StringBuffer 类对象的容量,结果为 5 + 16 = 21

2.4 字符串复制

  • 字符串的复制实现字符串的部分复制和全部复制。

  • Java 提供了 copyValueOf() 方法实现字符串的复制,但该方法只提供两种参数,返回值都是 String 对象。

    1
    2
    3
    4
    5
    // 复制部分字符数组的内容为一个新字符串
    String copyValueOf(char[], int offset, int count);

    // 复制整个字符数组为一个新的字符串
    String copyValueOf(char[]);
  • copyValueOf() 函数是 String 类独有的。

    1
    2
    3
    4
    5
    6
    7
    8
    char[] s_chars = {'h', 'e', 'l', 'l', 'o'};

    // 复制整个字符数组为一个新数组,完成字符串 s_chars 的复制,s1 的内容是 "hello"
    String s1 = String.copyValueOf(s_chars);

    // 复制整个字符数组的部分为一个新数组,完成字符串 s_chars 的部分复制,参数 0 表示起始位置,
    // 而参数 3 表示从开始位置起共有几个需要复制的字符,s2 的内容是 "hel"
    String s2 = String.copyValueOf(s_chars, 0, 3);

2.5 字符串子串获取

  • 获得子串实现获得字符串中的部分字符串。

  • Java 提供了 substring() 方法以获得子串,但该方法只提供两种参数,返回值都是 String 对象。

    1
    2
    3
    4
    5
    // 获得从 start 到 end(不包含 end 位置)的字符串
    String substring(int start ,int end )

    // 获得字符串中从 count(包含 count 位置)开始到字符串结束的子串
    String substring(int count)
  • 如果参数 index 的长度超过了字符串的长度范围,编译系统会抛出异常:“java.lang.StringIndexOutOfBoundsException: String index out of range: -2”。从异常中 “String index out of range:-2” 可以看出,该函数首先会判断参数是否越界,实现的方式是用参数值减去字符串长度,如果小于 0 就抛出异常,且输出差值;如果参数本身就是负数(如输入错误等),则抛出异常且直接输出该负数值。

  • substring() 函数是 String 类独有的。

    1
    2
    3
    4
    String s1 = new String("hello");       // 创建一个字符串,内容为 "hello",字符串名为 s1

    String subs1 = s1.substring(0, 2); // 获得从第一个字符到第二个字符的子串,结果是 "he"
    String subs2 = s1.substring(2); // 获得从第三个字符到最后一个字符的子串,结果是 "llo"

2.6 字符串字符获取

  • 在字符串操作中获取指定位置的字符提供了字符操作的灵活性,通过该操作可以直接获取字符串中一个特定位置的字符,前提是首先知道字符串的长度值,在长度范围内获得一个指定的字符。

    1
    2
    // 获得字符串中指定位置的字符(char 类型),参数 index 是 int 数据类型,用以指定字符位置
    String charAt(int index);
  • 如果参数 index 的长度超过了字符串的长度范围,编译系统会抛出下面的异常:“java.lang. StringIndexOutOfBoundsException。”

  • charAt() 函数是 String 类和 StringBuffer 类共有的。

    1
    2
    3
    String s1 = new String("hello");       // 创建一个字符串,内容为 "hello",字符串名为 s1

    Char resultchar = s1.charAt(0); // 获得字符串 s1 中第一个位置的字符

2.7 字符串大小写转换

  • Java 提供了更改字符串中字符大小写的方法,如把大写字母 “A” 转换成小写字母 “a”,把小写字符串 “hello” 转换成大写字符串 “HELLO”。

    1
    2
    3
    4
    5
    // 方法把小写字符串转换成大写字符串
    String toUpperCase();

    // 把大写字符串转换成小写字符串
    String toLowerCase();

  • 以上两个方法是 String 类独有的。

    1
    2
    3
    4
    5
    String s1 = new String("hello");       // 创建一个字符串,内容为 "hello",字符串名为 s1
    String s2 = new String("HELLO"); // 创建一个字符串,内容为 "HELLO",字符串名为 s2

    String uppers1 = s1.toUpperCase(); // 把字符串 s1 的字符转换成大写
    String lowers2 = s2.toLowerCase(); // 把字符串 s2 的字符转换成小写

2.8 字符串分割

  • 分割字符串指按照指定的划界表达式把字符串分割成几部分,每部分都是一个字符串,方法返回值是字符串数组(String[])。

    1
    2
    3
    // 指定划界表达式,通过该表达式来分割字符串
    // 如字符串 “hello:moto”,如果划界表达式是 “:”,则分割结果是 {"hello", "moto"};如果划界表达式是 “o”,则分割结果是 {"hell", ":m", "t"}
    split(String)
  • split() 函数是 String 类独有的。

    1
    2
    String s1 = new String("hello");       // 创建一个字符串,内容为 "hello",字符串名为 s1
    String[] splitresult = s1.split("l"); // 划界表达式是 "l";分割结果是 {"he", " ", "o"}

2.9 字符串字符替换

  • Java 提供了更改字符串中字符的方法,即替换方法。

    1
    2
    3
    4
    5
    6
    7
    8
    // 把字符串中与方法的第一个参数相同的字符,统一替换为方法中的第二个参数
    replace(char, char);

    // 把字符串中与方法中第一个参数字符串相同的字符串统一替换为方法中第二个参数字符串
    replaceAll(String, String);

    // 把字符串中与方法中第一个参数字符串相同的第一个字符串替换为方法中第二个参数字符串
    replaceFirst(String, String);
  • 以上三个方法都是 String 类独有的。

    1
    2
    3
    4
    5
    String s = new String("hello");                      // 创建一个字符串,内容为 "hello",字符串名为 s

    String replaceresult1 = s.replace('l', 'o'); // 结果为 "heooo"
    String replaceresult2 = s.replaceAll("ll", "LL"); // 结果为 "heLLo"
    String replaceresult3 = s.replaceAll("l", "LL"); // 结果为 "heLLlo"

3、字符串格式化

3.1 一般类型格式化

  • 一般类型格式化创建格式化的字符串,同时连接多个字符串对象。

  • 使用指定的语言环境,字符串格式和一系列参数生成一个格式化的新字符串

    1
    public static String format(Locale l, String format, Object args);
    • Locale:指定的语言环境,可以通过 Locale.setDefault(Locale newlocale) 方法设置,Java 虚拟机可以依本机环境在启动期间设置默认的本地环境。
    • format:字符串格式。
    • args:字符串格式中由格式说明符引用的参数,该参数可以没有。
  • 使用指定的语言环境,字符串格式和一系列参数生成一个格式化的新字符串,该方法使用默认的本地环境。

    1
    public static String format(String format, Object args);
    • format:字符串格式。
    • args:字符串格式中由格式说明符引用的参数,该参数可以没有。

3.2 日期和时间类型格式化

  • 日期格式化实现日期格式的显示方式,如日期可以是 2010-5-21,也可以是 2010 年 5 月 21 日或 2010/05/21。在格式化日期时,需要事先导入 java.text.* 包,该包中包含格式化日期的类函数。

  • 类 SimpleDateFormat 实现了日期的格式化,参数可以自己设置,如设置成为 yyyy/MM/dd、yyyy_MM_dd 或 yy/MM/dd,只要是符合自己的习惯就可以了。

    1
    2
    3
    4
    5
    6
    import java.text.*;

    SimpleDateFormat formatter = new SimpleDateFormat("yyyy年MM月dd日");
    Date date = new Date();

    String dateString = formatter.format(date);
  • 时间格式化实现时、分、秒的显示格式,同样需要事先导入 java.text.* 包。

    1
    2
    3
    4
    5
    6
    7
    8
    TimeZone gmtZone = TimeZone.getTimeZone("GMT");
    SimpleDateFormat format = new SimpleDateFormat("yyyy/MM/dd hh:mm:ss");
    format.setTimeZone(gmtZone);

    Date datetime = new Date();

    // 这里 date 是个日期、时间对象,把该对象统一为日期、时间格式为 "yyyy/MM/dd hh:mm:ss"
    String dateString = format.format(datetime);
文章目录
  1. 1. 1、字符串
    1. 1.1. 1.1 声明字符串
    2. 1.2. 1.2 创建字符串
      1. 1.2.1. 1.2.1 String 类字符串的创建
      2. 1.2.2. 1.2.2 StringBuffer 类字符串的创建
  2. 2. 2、字符串操作
    1. 2.1. 2.1 字符串连接
    2. 2.2. 2.2 字符串比较
    3. 2.3. 2.3 字符长度获取
    4. 2.4. 2.4 字符串复制
    5. 2.5. 2.5 字符串子串获取
    6. 2.6. 2.6 字符串字符获取
    7. 2.7. 2.7 字符串大小写转换
    8. 2.8. 2.8 字符串分割
    9. 2.9. 2.9 字符串字符替换
  3. 3. 3、字符串格式化
    1. 3.1. 3.1 一般类型格式化
    2. 3.2. 3.2 日期和时间类型格式化
隐藏目录