[Java 基础]字符串

String类

实例化String对象

String 对象初始化方式有多种。

如下代码中,各种初始化方式的效果是一样的,初始化后,String 对象的内容为 "hello" 。

public static void main(String[] args) {
 // 直接赋值
    String str1 = "hello";
 
 // 构造函数方式,参数为 String
    String str2 = new String("hello");
 
 // 构造函数方式,参数为 StringBuilder
    String str3 = new String(new StringBuilder("hello"));
 
 // 构造函数方式,参数为 StringBuffer
    String str4 = new String(new StringBuffer("hello"));
 
 // 构造函数方式,参数为 char 数组
 char[] cz = {'h', 'e', 'l', 'l', 'o'};
    String str5 = new String(cz);
 
 // 构造函数方式,参数为 byte 数组
 byte[] bz = {'h', 'e', 'l', 'l', 'o'};
    String str6 = new String(bz);
 
 // 先使用默认构造函数,再赋值
    String str7 = new String();
    str7 = "hello";
}

以上方式可归纳为两类:

(1) 赋值方式

(2) 构造函数方式

当前的Java SE8中,String类有15种构造函数,详细看参见Java API。

传入的参数可以是String、StringBuilder、StringBuffer、char 数组、byte 数组等等。

两种实例化方式比较

一个字符串就是一个 String 类的匿名对象

匿名对象

匿名对象就是开辟了内存空间的并且可以直接使用的对象。

对于这样的代码:

String name = "Jack";               // 赋值方式初始化 String 对象

实际上就是在堆中开辟一个内存空间,这个空间的中存储的值为 "Jack"。然后这个空间被 name 变量所引用。

注:在JAVA中,如果一个字符串已经被一个名称所引用,则以后再有相同的字符串声明时,不会重新开辟空间,而是复用之前的空间。这样减少了不必要的空间开销。

String str1 = "hello";
String str2 = "hello";
String str3 = "hello";

以上三个String类变量本身是存放在栈内存中,但是它们指向同一块堆内存空间。

而如果使用构造函数方式初始化String类对象,和所有普通类一样,只要new一次,就会新开辟一块堆空间。

综上所述,可以看出赋值方式要优于构造函数方式

String的内容比较

1、使用 "=="

public static void main(String[] args) {
     String str1 = "hello";
     String str2 = new String("hello");
     String str3 = str2;
 
     System.out.println("str1 == str2 --> " + (str1 == str2));
     System.out.println("str1 == str3 --> " + (str1 == str3));
     System.out.println("str2 == str3 --> " + (str2 == str3));
 }

运行结果

str1 == str2 --> false
str1 == str3 --> false
str2 == str3 --> true

从以上代码可以看出,虽然三个字符串内容完全一致,但是使用 "==" 去比较却发现并不完全相等。

这是因为每个String对象的内容实际上是保存在堆内存中的。所以,即使堆中的内容一致,并不代表它们的地址空间也一致。

"==" 是用来进行数值比较的,所以 str1str2 并不相等。

2、使用equals方法

如果要比较两个字符串的内容是否相等,可以使用 equals 方法。

public static void main(String[] args) {
     String str1 = "hello";
     String str2 = new String("hello");
     String str3 = str2;
 
     System.out.println("str1 == str2 --> " + (str1.equals(str2)));
     System.out.println("str1 == str3 --> " + (str1.equals(str3)));
     System.out.println("str2 == str3 --> " + (str2.equals(str3)));
 }

运行结果

str1 == str2 --> true
str1 == str3 --> true
str2 == str3 --> true

String对象不可变

//: StringDemo03.java
public class StringDemo03 {
 public static String upcase(String s) {
 return s.toUpperCase();
    }
 public static void main(String[] args) {
        String a = "hello";
        System.out.println(a);    // hello
        String b = upcase(a);
        System.out.println(b);    // HELLO
        System.out.println(a);    // hello
    }
} /* Output:
hello
HELLO
hello
*///:~

当把a传给 upcase() 方法时,实际传递的是引用的一个拷贝。其实,每当把 String 对象作为方法的参数时,都会复制一份引用,而该引用所指的对象其实一直待在单一的物理位置上,从未动过。

所以指向 String 的任何引用都不可能改变它的值

不可变性会带来一定的效率问题。例如String类的重载操作符 "+"。

注:JAVA不同于C++,并不允许程序员自定义任何重载操作符。用于String的 "+" 和 "+=" 是JAVA中仅有的两个重载操作符。

操作符"+"可以用来拼接String。方式如下:

String s = "How " + "are " + "you?";
System.out.println(s);
/* Output:
How are you?
*///:~

这种方式的问题在于,会产生一大堆需要垃圾回收的中间对象。

那么,如何避免这种问题呢?

JAVA中提供了两个类:StringBuilderStringBuffer ,它们都有 append() 方法,效率高于 String 的 "+"。

这两个类的差别在于 StringBuffer线程安全的,因此开销也更大一些。

String类的常用方法

以下代码是String类的一些常用方法。

public class StringDemo {
 public static void main(String[] args) {
 // 获取字符串字符个数
        System.out.println(" Goodbye ".length());

 // 获取 String 中该索引位置上的 char
        System.out.println("Computer".charAt(4));

 // 复制 byte 到一个目标数组
 byte bytes[] = "Winter".getBytes();                // 将字符串转为 byte 数组
        System.out.println(new String(bytes));            // 将完整 byte 数组转为字符串
        System.out.println(new String(bytes, 1, 3));    // 将部分 byte 数组转为字符串

 // 复制 char 到一个目标数组
 char chars[] = new char[10];
        "Summer".getChars(0, 6, chars, 2);                // 将字符串0~6位置的内容拷贝到 char 数组中,从数组位置2开始
        System.out.println(new String(chars));            // 将完整 char 数组转为字符串
        System.out.println(new String(chars, 1, 3));    // 将部分 char 数组转为字符串

 // 字符串转char数组
 char[] data1 = "Baby".toCharArray();
 for (char c : data1) {
            System.out.print(c + " ");
        }
        System.out.println();

 // 如果String不包含此参数,返回-1,否则返回此参数在String中的起始索引。lastIndexOf是从后向前查找
        System.out.println("How are you".indexOf("o"));            // 查找返回位置
        System.out.println("How are you".indexOf("o", 5));        // 查找返回位置, 从位置5开始
        System.out.println("How are you".indexOf("z"));            // 没有查到返回-1
        System.out.println("How are you".lastIndexOf("o"));        // 查找返回位置
        System.out.println("How are you".lastIndexOf("o", 5));    // 查找返回位置, 从位置5开始
        System.out.println("How are you".lastIndexOf("z"));        // 没有查到返回-1

 // 根据参数截取字符串
        System.out.println("Hello World".substring(6));            // 从位置6开始截取
        System.out.println("Hello World".substring(0, 5));        // 截取0~5个位置的内容

 // 按照指定字符拆分字符串
        String[] s = "sample@sina.com".split("@");
 for (int i = 0; i < s.length; i++) {
            System.out.println(s[i]);
        }
 
 // 去除左右空格
        System.out.println("    Night       ".trim());            // 去除左右空格输出

 // 转换大小写
        System.out.println("China".toLowerCase());
        System.out.println("China".toUpperCase());

 // 判断是否以指定的字符串开头或结尾
 if ("**NAME".startsWith("**")) {
            System.out.println("**NAME 以**开头");
        }
 if ("NAME**".endsWith("**")) {
            System.out.println("NAME** 以**结尾");
        }

 // 替换源子字符串为目标子字符串
        System.out.println("good".replaceAll("o", "x"));
    }
}

StringBuilder类

注意

String类是不可改变的,所以你一旦创建了String对象,那它的值就无法改变了。 如果需要对字符串做很多修改,那么应该选择使用StringBuffer & StringBuilder 类。

StringBuilder 类的用法大部分与 String 类相似。

StringBuilder 类的字符串连接操作 append() 效率高于 String 类。而且此方法返回一个 StringBuilder 类的实例,这样就可以采用链式方式一直调用 append() 方法。

示例代码如下:

StringBuilder str = new StringBuilder();
str.append("How ").append("are ").append("you?");
System.out.println(str);
/* Output:
How are you?
*///:~

StringBuffer类

StringBuffer 类和 StringBuilder 类大致相同。

但是 StringBuffer线程安全的,因此开销也更大一些。

参考资料

JAVA 编程思想

JAVA 开发实战经典

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏技术博客

编写高质量代码改善C#程序的157个建议[动态数组、循环遍历、对象集合初始化]

    软件开发过程中,不可避免会用到集合,C#中的集合表现为数组和若干集合类。不管是数组还是集合类,它们都有各自的优缺点。如何使用好集合是我们在开发过程中必须...

1004
来自专栏Albert陈凯

函数–函数字面量的一些简化写法及报错解析

scala 下划线解析报错: missing parameter type for expanded function 本文首先介绍下eta-expansion...

3065
来自专栏别先生

Scala学习教程笔记三之函数式编程、集合操作、模式匹配、类型参数、隐式转换、Actor、

1:Scala和Java的对比: 1.1:Scala中的函数是Java中完全没有的概念。因为Java是完全面向对象的编程语言,没有任何面向过程编程语言的特性,因...

3235
来自专栏ShaoYL

OC内存管理

3569
来自专栏抠抠空间

函数 (一) 基础

一、函数的作用 函数可以让我们代码结构更清晰,而且避免了代码的重复,冗余,使一段代码或者功能可以反复的被调用,大大提高了开发效率 二、函数的定义 def 函数名...

2776
来自专栏从流域到海域

C++区别于其他语言的知识点总结

C++是博主的一门限选课,所使用的课本为谭浩强老师的《C++面向对象程序设计》(第二版),这本书内容全面,简单易懂,也强烈推荐给大家(尤其是初学者)。但对...

18410
来自专栏技术之路

c++ this *this

在一个类里每个成员函数都有一个this指针。this指针指向调用对象。如果方法需要引用整个调用 对象可以使用*this。this是对象的地址,而不是对象本身。 ...

1849
来自专栏每日一篇技术文章

Swift3.0 - 类和结构体的区别

结论: 在数据量比较大的排序中,结构体排序的速度比较慢,因为结构体是值类型,排序的时候,需要大量的赋值运算。而对象只需要交换地址即可。

581
来自专栏Phoenix的Android之旅

重构 - 你为什么要对参数赋值?

对于学过多门语言的开发者来说,应该都明白在不同语言中对参数赋值有着不同的意义, 总的来说参数有值传递和引用传递两种, 而在Java中只有值传递的概念。

702
来自专栏技术博客

C# try catch finally

 catch 和 finally 一起使用的常见方式是:在 try 块中获取并使用资源,在 catch 块中处理异常情况,并在 finally 块中释放资源。

1182

扫码关注云+社区