一文带你初识java中的String类

什么是字符串

字符串或串(string)是由数字、字母、下划线组成的一串字符。一般记为 s=“a1a2···an”(n>=0)。它是编程语言中表示文本的数据类型。在程序设计中，字符串（string）为符号或数值的一个连续序列，如符号串（一串字符）或二进制数字串（一串二进制数字）。其在java语言中可以通过一定的方法提取字符串中的一个字符

字符串常见的赋值方法

直接赋值法

string 变量名=" 初始值"

这种赋值方法经常被我们使用

 public static void main(string[] args) {
        string str1="hello world";
        system.out.println(str1);
    }

构造方法进行创建

格式：

string 变量名=new string(初始值)

public static void main(string[] args) {
        string str2=new string("swpu yyds");
        system.out.println(str2);
    }

注意：初始值不只局限于常量字符串，也可以是数组

比如字符数组：

public static void main(string[] args) {
        char ch[]={'s','w','p','u'};
        string str3=new string(ch);
        system.out.println(str3);
    }

又如字节数组：

public static void main(string[] args) {
        byte a[]={94,95,94};
        string str3=new string(a);
        system.out.println(str3);
    }

此外也可以通过这种构造方式把字符数组或者字节数组部分元素转换为字符串

public static void main(string[] args) {
        char ch[]={'a','b','c','d','e','f'};
        string str4=new string(ch,1,3);//1这个位置是字符串的开始位置，3为字符串的长度
        system.out.println(str4);
    }

字符串的比较相等

在int变量中判断两个int变量被赋予的值是否相等使用“==”便可以判断

 public static void main(string[] args) {
        int a=520;
        int b=520;
        system.out.println("a==b:"+(a==b));
    }

那么有人就会认为字符串的比较也可以用“==”进行比较

如图：

public static void main(string[] args) {
        string str5="abcdef";
        string str6="abcdef";
        system.out.println("str5和str6是否相等"+(str5==str6));
    }

那么字符串是不是就依靠“==”进行判断的呢？其结果显然是

的

就如这个代码：

public static void main(string[] args) {
        string str8="abcdef";
        string str7=new string("abcdef");
        system.out.println("str7和str8是否相等"+(str7==str8));
    }

 public static void main(string[] args) {
        string str8=new string("abcdef");
        string str7=new string("abcdef");
        system.out.println("str7和str8是否相等"+(str7==str8));
    }

为什么使用"=="会出现这种情况呢？

实际上string 使用 == 比较并不是在比较字符串内容, 而是比较两个引用是否是指向同一个对象

就比如：这里有两个篮子分别为a,b;分别里面放相同的5个苹果，将这两个篮子看做两个不同的类a和类b,而这个比较的便是类是否相同，而不是比较类里面的内容是否相同。

为了比较字符串内容是否相等那么我们就得使用string类提供的equals方法

public static void main(string[] args) {
        string str8="abcdef";
        string str7=new string("abcdef");
        system.out.println("str7和str8是否相等"+(str7.equals(str8)));
    }

public static void main(string[] args) {
        string str8=new string("abcdef");
        string str7=new string("abcdef");
        system.out.println("str7和str8是否相等"+(str7.equals(str8)));
    }

字符串常量池

在上面所讲的字符串赋值操作中

直接赋值为什么使用“==”进行比较有的就是true而有的就是false呢？

实际上当我们采用了直接赋值的模式进行string类的对象实例化操作，那么该实例化对象（字符串内容）将自动保存到字符串常量池之中，并且如果下次继续使用直接赋值的模式声明string类对象，此时对象池之中如若有指定内容，将直接进行引用如若没有，则开辟新的字符串对象而后将其保存在对象池之中以供下次使用。

public static void main5(string[] args) {
        string str5="abcdef";
        string str6="abcdef";
        system.out.println("str5和str6是否相等"+(str5==str6));
    }

而我们使用构造方法时,首先string类的对象实例化操作时，先在字符常量池中寻找是否有字符串内容，如果有就不需要在放入字符串常量池中，其次在堆上开辟一个内存空间，该空间指向字符串常量池上的内容，而栈上的对象指向新开辟的内存空间

public static void main6(string[] args) {
        string str8="abcdef";
        string str7=new string("abcdef");
        system.out.println("str7和str8是否相等"+(str7==str8));
    }

注意：在采用直接赋值时，只会开辟一块堆内存空间，并且该字符串对象可以自动保存在对象池中以供下次使用。在采用构造方法时会开辟两块堆内存空间，不会自动保存在对象池中，可以使用intern()方法手工池。

字符串常量池的实例

为了更好了解字符串常量池这里有几个实例可以加以练习

实例一

public static void main(string[] args) {
        string str1="abcdef";
        string str2="abc"+"def";
        system.out.println(str1==str2);
    }

2. 实例二

 public static void main(string[] args) {
        string str1="abcdef";
        string str2="abc";
        string str3=str2+"def";
        system.out.println(str1==str3);
    }

注意str2是变量，在编译的时候无法知道里面的值是什么，只有运行到时才知道

3. 实例三

public static void main(string[] args) {
        string str1="abcdef";
        string str2="abc"+new string("def");
        system.out.println(str1==str2);
    }

4. 实例四

public static void main(string[] args) {
        string str1="abcdef";
        string str2=new string("abc")+new string("def");
        system.out.println(str1==str2);
    }

5. 实例五

public static void main(string[] args) {
        string str1="abc";
        string str2=str1;
        str1="def";
        system.out.println(str1==str2);
    }

字符串的不可变

字符串是一种不可变对象. 它的内容不可改变.

string 类的内部实现也是基于 char[] 来实现的, 但是 string 类并没有提供 set 方法之类的来修改内部的字符数组.

如代码：

public static void main(string[] args) {
        string str = "hello" ;
        str = str + " world" ;
        str += "!!!" ;
        system.out.println(str);
    }

结果看似简单其实底层进行了许多操作

第一步：

第二步：

第三步：

那么如果我们需要修改字符串, 例如, 现有字符串 str = “hello” , 想改成 str = “hello” , 该怎么办？

最简单的方法是：借助原字符串，创建新的字符串

public static void main(string[] args) {
        string str = "hello";
        str = "h" + str.substring(1);
        system.out.println(str);
    }

为什么string为不可变？

1. 方便实现字符串对象池. 如果 string 可变, 那么对象池就需要考虑何时深拷贝字符串的问题了。
2. 不可变对象是线程安全的。
3. 不可变对象更方便缓存 hash code, 作为 key 时可以更高效的保存到 hashmap 中。

字符串的常见操作

字符串的比较

equals方法

该方法比较字符串的内容并区分字符的大小关系

public static void main(string[] args) {
        string str="hello";
        string str1="hello";
        system.out.println(str.equals(str1));
    }

equalsignorecase方法

该方法比较字符串的内容但不区分字符的大小关系

public static void main(string[] args) {
        string str="hello";
        string str1="hello";
        system.out.println(str.equalsignorecase(str1));
    }

compareto方法

在string类中compareto()方法是一个非常重要的方法，该方法返回一个整型，该数据会根据大小关系返回三类内容：如果相等则返回0；如果小于比较的字符串则返回小于0；相反则返回大于0的值；

 public static void main(string[] args) {
        string str1="hello";
        string str2="hello";
        system.out.println(str1.compareto(str2));
    }

public static void main(string[] args) {
        string str2="hello";
        string str1="hello";
        system.out.println(str1.compareto(str2));
    }

 public static void main(string[] args) {
        string str2="hello";
        string str1="hello";
        system.out.println(str1.compareto(str2));
    }

字符串的查找

contains()方法

该方法可以判断该字符串是否有子串有则返回true;没有就返回false;

public static void main(string[] args) {
        string str1="acbaskjcbaskd";
        string str2="xass";
        system.out.println(str1.contains(str2));
    }

public static void main(string[] args) {
        string str1="acbaskjcbaskd";
        string str2="acbaskj";
        system.out.println(str1.contains(str2));
    }

indexof()方法

该方法使字符串从头开始查找需要查找字符串的位置，查到了就返回位置的开始索引，如果没有检查到则返回-1。

public static void main(string[] args) {
        string str1="acbaskjcbaskd";
        string str2="askj";
        system.out.println(str1.indexof(str2));
    }

 public static void main(string[] args) {
        string str1="acbaskjcbaskd";
        string str2="askjsass";
        system.out.println(str1.indexof(str2));
    }

lastindexof(string str)方法

由后向前查找子字符串

public static void main(string[] args) {
        string str1="acbaskjcbaskd";
        string str2="askj";
        system.out.println(str1.lastindexof(str2));
    }

lastindexof(string str,int fromindex)方法

从指定位置由后向前查找。

public static void main(string[] args) {
        string str1="acbaskjcbaskd";
        string str2="askj";
        system.out.println(str1.lastindexof(str2,1));
    }

public static void main(string[] args) {
        string str1="acbaskjcbaskd";
        string str2="askj";
        system.out.println(str1.lastindexof(str2,13));
    }

startswith(string prefix)

判断是否以指定的字符串开头是则返回true不是则返回false

public static void main(string[] args) {
        string str1="acbaskjcbaskd";
        string str2="askj";
        system.out.println(str1.startswith(str2));
    }

public static void main(string[] args) {
        string str1="acbaskjcbaskd";
        string str2="ac";
        system.out.println(str1.startswith(str2));
    }

startswith(string prefix,int toffset)

从指定位置开始判断是否以指定字符串开头

public static void main(string[] args) {
        string str1="acbaskjcbaskd";
        string str2="bask";
        system.out.println(str1.startswith(str2,2));
    }

endswith(string suffix)

判断是否以指定字符串结尾

public static void main(string[] args) {
        string str1="acbaskjcbaskd";
        string str2="bask";
        system.out.println(str1.endswith(str2));
    }

public static void main(string[] args) {
        string str1="acbaskjcbaskd";
        string str2="skd";
        system.out.println(str1.endswith(str2));
    }

字符串替换

replaceall(string regx,string replacement)

替换字符串中所有指定的内容

public static void main(string[] args) {
        string str = "helloworld" ;
        system.out.println(str.replaceall("l", "_"));
    }

replacefirst(string regx,string replacement)

替换字符串中第一个指定的内容

 public static void main(string[] args) {
        string str = "helloworld" ;
        system.out.println(str.replacefirst("l", "_"));
    }

注意: 由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串.

字符串拆分

split（string regex）

将字符串全部拆分

public static void main(string[] args) {
        string str = "hello world hello swpu" ;
        string[] result = str.split(" ") ;
        for(string s: result) {
            system.out.println(s);
        }
    }

注意：有些特别的字符作为分隔符可能无法正确切分需要加上转义

如：

public static void main(string[] args) {
        string str = "192.168.1.1" ;
        string[] result = str.split("\\.") ;
        for(string s: result) {
            system.out.println(s);
        }
    }

注意：

字符"|","*","+“都得加上转义字符，前面加上”\".而如果是"."，那么就得写成"\".如果一个字符串中有多个分隔符，可以用"|"作为连字符 split(string regex,int limit)

将字符串部分拆分，该数组长度就是limit极限

public static void main(string[] args) {
        string str = "hello world hello swpu" ;
        string[] result = str.split(" ",3) ;
        for(string s: result) {
            system.out.println(s);
        }
    }

字符串截取

substring(int bedinindex)

从指定索引截止到结尾

public static void main(string[] args) {
        string str="helloworld";
        system.out.println(str.substring(3));
    }

substring(int beginindex,int endindex)

截取字符串的部分内容

public static void main(string[] args) {
        string str="helloworld";
        system.out.println(str.substring(3,5));
    }

注意：该区间为左闭右开则：[3,5)不包含5下标

总结

到此这篇关于java中string类的文章就介绍到这了,更多相关java的string类内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！