String类用法总结

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/qq_38555490/article/details/89876011
    1. String类
      1. String特点

字符串是一个特殊的对象

字符串一旦初始化就不可以被改变

String str=”abc”;

String str1= new String(“abc”);

有什么区别?

 

方式一

代码示例:

package String类的特点;

 

public class StringDemo {

    public static void main(String[] args) {

       stringdemo1();

      

    }

 

    /**

     * 演示字符串的第一种方式,并明确字符串常量池的特点

     * 池中没有就建立,池中有,直接用

     */

    public static void stringdemo1() {

       /**

        * String类的特点

        * 字符串一旦初始化,就不能改变

        */

       String s="abc";//存储在字符串的常量池中

       //s="nba";

       String s1="abc";

       System.out.println(s==s1);//true

       /**

        * 为什么会是true

        * 我们字符串建立时,在内存中有个字符串缓冲区(字符串常量池)

        * 例如我们创建的abc字符串,会先去常量池看看有没有,有的给地址给变量s,

        * 没有我们就创建。

        *  当我们再创建abc的时候,会去常量池中看,有就直接给地址。

        *所以ss1比较地址会为true

        */

    }

}

 

 

为什么会是true

    • 我们字符串建立时,在内存中有个字符串缓冲区(字符串常量池)。
    • 例如我们创建的abc字符串,会先去常量池看看有没有,有的给地址给变量s,没有我们就创建这个abc,然后把地址给s
  • 当我们再创建abc的时候,会去常量池中看,有就直接给地址。

所以s和s1比较地址会为true

返回结果:

 

方式二

代码示例:

package String类的特点;

 

public class StringDemo {

    public static void main(String[] args) {

       stringdemo1();

       stringdemo2();

      

    }     

 

    public static void stringdemo2() {

      

       String s="abc";//这个是在字符串常量池中创建的字符

       String s1 = new String("abc");//创建两个对象,一个new,一个字符串对象在堆内存当中

       /*System.out.println("s:"+s);

       System.out.println("s1:"+s1);*/

       System.out.println(s==s1);//false  比较的是地址

       System.out.println(s.equals(s1));//true  比较内容,不比较地址

    }

}

 

返回结果:

 

      1. 构造函数

注意:

String string = new String();//恒等于String str="";  不等于String str=null;

字节数组转换为字符串

String(byte[] bytes)
          通过使用平台的默认字符集解码指定的 byte 数组,构造一个新的 String

 

代码示例:

 

public static void stringConstructorsDemo() {

      //将字节数组编程字符串

      byte [] arr= {67,68,69,70};

      String string2 = new String(arr);

      System.out.println(string2);

   }


返回结果:

 

字符数组转换为字符

String(char[] value)
          分配一个新的 String,使其表示字符数组参数中当前包含的字符序列。

代码示例:

/**

    * 字符数组转字符

    */

   @Test

   public void fun1() {

      char [] str= {'q','w','e','d'};

      String string = new String(str);

      System.out.println("str"+string);

   }

返回结果:

一部分字符数组转换为字符

String(char[] value, int offset, int count)

  • char[] value  字符数组
  • int offset    数组的下标
  • int count     取几个字符
              分配一个新的 String,它包含取自字符数组参数一个子数组的字符。

 

代码示例:

/**

     * 一部分字符数组转换为字符

     *    char[] value  字符数组

          int offset    数组的下标

          int count     取几个字符

     */

    @Test

    public void fun3() {

       char [] str= {'q','w','e','d'};

       String string = new String(str,1,3);//1下标开始取,取3个字符

       System.out.println("str"+string);

    }

返回结果:

 

      1. String常见的功能_获取
  • 获取字符的长度

 int

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

 

  • 根据字符获取第一次出现的位置

 int

indexOf(int ch)
          返回指定字符在此字符串中第一次出现处的索引。

 int

indexOf(int ch, int fromIndex)
          返回在此字符串中第一次出现指定字符处的索引,从指定的索引开始搜索。

 int

indexOf(String str)
          返回指定子字符串在此字符串中第一次出现处的索引。

 int

indexOf(String str, int fromIndex)
          返回指定子字符串在此字符串中第一次出现处的索引,从指定的索引开始。

 

  • 根据字符获取最后一次出现的位置

int

lastIndexOf(int ch)
          返回指定字符在此字符串中最后一次出现处的索引。

 int

lastIndexOf(int ch, int fromIndex)
          返回指定字符在此字符串中最后一次出现处的索引,从指定的索引处开始进行反向搜索。

 int

lastIndexOf(String str)
          返回指定子字符串在此字符串中最右边出现处的索引。

 int

lastIndexOf(String str, int fromIndex)
          返回指定子字符串在此字符串中最后一次出现处的索引,从指定的索引开始反向搜索。

 

  •         1.5获取字符串中的一部分字符串

 String

substring(int beginIndex)
          返回一个新的字符串,它是此字符串的一个子字符串。

 String

substring(int beginIndex, int endIndex)
          返回一个新字符串,它是此字符串的一个子字符串。

注意:

      1. substring
public String substring(int beginIndex,
                        int endIndex)

返回一个新字符串,它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始,直到索引 endIndex - 1 处的字符。因此,该子字符串的长度为 endIndex-beginIndex

示例:

 "hamburger".substring(4, 8) returns "urge"
 "smiles".substring(1, 5) returns "mile"

 

参数:

beginIndex - 起始索引(包括)。

endIndex - 结束索引(不包括)。

 

 

 

1.获取

        *  1.1获取字符串中字符的个数(获取字符串的长度)

        *       int length();

        *  1.2根据位置获取字符

        *       char charAt(int index);

        *  1.3根据字符获取在字符串中的第一次出现的位置(从前往后找)

        *       int indexOf(int ch); 从0下标开始开查

        *       int indexOf(int ch,int formIndex);指定的的下标来查

        *       int indexOf(String str,int formIndex);

        *       int indexOf(String ch,int formIndex);

        * 

        *      1.4根据字符获取在字符串中的最后一次次出现的位置(从前往后找)

        *       int lastindexOf(int ch); 从0下标开始开查

        *       int lastindexOf(int ch,int formIndex);指定的的下标来查

        *       int lastindexOf(String str,int formIndex);

        *       int lastindexOf(String ch,int formIndex);

        1.5获取字符串中的一部分字符串

        *       String (int beginIndex);

        *       String (int beginIndex,int endIndex)

 

 

代码示例:

package string获取;

 

import org.junit.Test;

 

public class Demo2 {

    /**

     * 字符串的获取

     * 按照面向对象的思想来对字符串进行分类

     * abcd

     * 1.获取

     *  1.1获取字符串中字符的个数(获取字符串的长度)

     *     int length();

     *  1.2根据位置获取字符

     *     char charAt(int index);

     *  1.3根据字符获取在字符串中的第一次出现的位置(从前往后找)

     *     int indexOf(int ch); 0下标开始开查

     *     int indexOf(int ch,int formIndex);指定的的下标来查

     *     int indexOf(String str,int formIndex);

     *     int indexOf(String ch,int formIndex);

     * 

     *     根据字符获取在字符串中的最后一次次出现的位置(从前往后找)

     *     int lastindexOf(int ch); 0下标开始开查

     *     int lastindexOf(int ch,int formIndex);指定的的下标来查

     *     int lastindexOf(String str,int formIndex);

     *     int lastindexOf(String ch,int formIndex);

     *  1.4获取字符串中的一部分字符串

     *     String (int beginIndex);

     *     String (int beginIndex,int endIndex)

     */

    @Test

    public void fun() {

      

      

       String str="abcdeafg";

      

       System.out.println("字符串的长度:"+str.length());//8

       System.out.println("根据位置获取字符:"+str.charAt(1));//b

       System.out.println("获取字符第一次出现的位置:"+str.indexOf("a"));//0

       System.out.println("指定下标来查询:"+str.indexOf("a",2));//5 返回该指定下标出现的位置

       System.out.println("获取字符最后一次出现的位置:"+str.lastIndexOf("a"));//5

       System.out.println("获取字符串中的一部分字符串:"+str.substring(2));//cdeafg //截取到2下标之后的所有字符(包含2下标)

       System.out.println("获取字符串中的一部分字符串:"+str.substring(2, 5));//ab  2下标截取到5下包(包含2下标,不包含5下标)

 

      

    }

}

 

返回结果:

 

 

 

      1. String常见功能_转换

api:

/**

    * 转换

    * 1.将字符串变成字符串数组(字符串的切割)

    *    String [] split(String regex);//参数是正则表达式

    *  2.将字符串变成字符数组

    *     char tocharArray();

    *  3.将字符串变成字节数组

    *     byte getByte();

    *  4.将字符串中的字母转换成大小写

    *     String toLowerCase()

    *  5.将字符串中的内容进行替换

    *     Srring replace(char oldch,char newch)

    *  6.去除字符串两端的空格

    *     String trim();

    *  7.将字符串进行连接

    *     String concat(String str);

    *

 

 

代码示例:

package string转换;

 

import org.junit.Test;

 

public class StringDemo {

   

 

    /**

     * 转换

     * 1.将字符串变成字符串数组(字符串的切割)

     *     String [] split(String regex);//参数是正则表达式

     *  2.将字符串变成字符数组

     *     char tocharArray();

     *  3.将字符串变成字节数组

     *     byte getByte();

     *  4.将字符串中的字母转换成大小写

     *     String toLowerCase()

     *  5.将字符串中的内容进行替换

     *     Srring replace(char oldch,char newch)

     *  6.去除字符串两端的空格

     *     String trim();

     *  7.将字符串进行连接

     *     String concat(String str);

     */

   

   

    @Test

    public void fun() {

      

       /**

        *

        * 1.将字符串变成字符串数组(字符串的切割)

        * String [] split(String regex);

        * 返回:

        *  张三

           李四

           王五

        */

       String name="张三,李四,王五";

       String [] arr =name.split("");

       for (int i = 0; i < arr.length; i++) {

           System.out.println(arr[i]);

       }

    }

    /**

     * 2.将字符串变成字符串数组

     *

      

       a

       a

      

       q

       A

       A

      

       1

       1

      

     */

    @Test

    public void fun1() {

       String s="将字aaqAA11";

       char [] str=s.toCharArray();

       for (int i = 0; i < str.length; i++) {

           System.out.println(str[i]);

       }

    }

   

    /**

     * byte 3.将字符串转换为字节数据

     *  字节:97

       字节:-28

       字节:-67

       字节:-96

       字节:-27

       字节:-91

       字节:-67

     */

    @Test

    public void fun3() {

       String s="a你好";

       byte [] tytes=s.getBytes();

       for (int i = 0; i < tytes.length; i++) {

              System.out.println("字节:"+tytes[i]);

          

       }

    }

   

    /**

     * 4.将字符串中的字母转换成大小写

     *     String toLowerCase()

     *  返回结果:

     *  转换为大写字母:ABCDEFG

       转换为小写字符:hijklmn

     */

    @Test

    public void fun4() {

       String s="abcdefg";

       String s2="HIJKLMN";

       System.out.println("转换为大写字母:"+s.toUpperCase());

       System.out.println("转换为小写字符:"+s2.toLowerCase());

      

    }

    /**

     * 5.将字符串中的内容进行替换

     *     Srring replace(char oldch,char newch)

     *  返回jovo

     */

    @Test

    public void fun5() {

       String s="java";

       System.out.println(s.replace("a", "o"));

    }

   

    /**

     * 6.去除字符串两端的空格

     *  String trim()

     *  返回结果:

     *  之前:     abcdefg  

       之后:abcdefg

     */

    @Test

    public void fun6() {

       String s="     abcdefg   ";

       System.out.println("之前:"+s);

       System.out.println("之后:"+s.trim());

    }

   

    /**

     * 7.字符串的连接

     * String concat(String str);

     */

    @Test

    public void fun7() {

       /*

        * 这两个的效果都是一样

        * 区别:使用concat感觉更牛逼,专业

        * 建议:那个简单用哪个

        * 返回结果:

        * aabb

           aabb

        */

       System.out.println("aa"+"bb");

       System.out.println("aa".concat("bb"));

    }

   

}

 

 

基本数据类型转换为字符串

static String

valueOf(char c)
          返回 char 参数的字符串表示形式。

static String

valueOf(char[] data)
          返回 char 数组参数的字符串表示形式。

static String

valueOf(char[] data, int offset, int count)
          返回 char 数组参数的特定子数组的字符串表示形式。

static String

valueOf(double d)
          返回 double 参数的字符串表示形式。

static String

valueOf(float f)
          返回 float 参数的字符串表示形式。

static String

valueOf(int i)
          返回 int 参数的字符串表示形式。

static String

valueOf(long l)
          返回 long 参数的字符串表示形式。

static String

valueOf(Object obj)
          返回 Object 参数的字符串表示形式。

 

示例:

   /**

    * 基本数据类型转换为字符串

    * 返回:33

    */

   @Test

   public void fun8() {

      System.out.println(String.valueOf(3)+3);

     

   }

注意,其他的几个也是这么用的。

      1. Stirng常见功能_判断

/**

        * 字符的判断

        * 1.两个字符内容是否相同

        *               boolean equals(Object obj);

        * 2.忽略大小写对字符串进行判断

        *               boolean equalsIgnoreCase(String str);

        * 3.判断是否包含该字符串

        *               boolean contains(String str);

        * 4.字符串是否指定字符串开头,是否指定字符串结尾

        *         通俗的讲:就是找包含该字符串的

        *               boolean startsWith(String str);

        *               boolean endWith(String str);

        */

 

 

代码示列:

package string判断;

 

import org.junit.Test;

 

public class StringDemo {

    /**

     * 字符的判断

     * 1.两个字符内容是否相同

     *     boolean equals(Object obj);

     * 2.忽略大小写对字符串进行判断

     *     boolean equalsIgnoreCase(String str);

     * 3.判断是否包含该字符串

     *     boolean contains(String str);

     * 4.字符串是否指定字符串开头,是否指定字符串结尾

     *  通俗的讲:就是找包含该字符串的

     *     boolean startsWith(String str);

     *     boolean endWith(String str);

     */

   

    /**

     * 1.两个字符内容是否相同

     *     boolean equals(Object obj);

     * 返回:true

     */

    @Test

    public void fun() {

       String s="abc";

       String s2="ABC";

       System.out.println(s.equals(s2));

    }

   

   

    /**

     * 2.忽略大小写对字符串进行判断

     *     boolean equalsIgnoreCase(String str);

     * 返回:true

     */

    @Test

    public void fun2() {

       /*

        * 需求:我们用户注册的时候输入字符不区分大小写

        * 大写的ABC和小写的abc都是同一个用户

        */

       String s="abc";

       String s2="ABC";

       System.out.println(s.equalsIgnoreCase(s2));

       System.out.println(s.equals(s2.toLowerCase()));//这个结果和上面的方法是一样的,建议用上面的。

    }

   

    /**

     * 3.判断是否包含该字符串

     *     boolean contains(String str);

     * 返回:true

     */

    @Test

    public void fun3() {

       String aa="abcdefg";

       System.out.println(aa.contains("abc"));

    }

   

   

    /**

     * 4.字符串是否指定字符串开头,是否指定字符串结尾

     *  通俗的讲:就是找包含该字符串的

     *     boolean startsWith(String str);

     *     boolean endWith(String str);

     *

     * 返回结果:

     *  true

       true

     */

    @Test

    public void fun4() {

       String aa="ArrayDemo.java";

       System.out.println(aa.startsWith("Array"));

       System.out.println(aa.endsWith(".java"));

    }

   

   

}

 

      1. String常见功能_比较

这个要重点掌握:

 int

compareTo(String anotherString)
          按字典顺序比较两个字符串。

但是返回值是int,这就有点奇怪了。看api详解

返回:

  • 如果参数字符串等于此字符串,则返回值 0
  • 如果此字符串按字典顺序小于字符串参数,则返回一个小于 0 的值
  • 如果此字符串按字典顺序大于字符串参数,则返回一个大于 0 的值

代码示例:

package string比较;

 

import org.junit.Test;

 

public class StringDemo {

   /**

    * 比较

    * 1.字符串按照字典排序来比较

    * 返回

    *    值相等返回0

    *    值小于返回小于0

    *    值大于返回大于0

    *    String compareTo(String str);

    *

    */

  

  

   /**

    * 1.字符串按照字典排序来比较

    *    String compareTo(String str);

    *

    * 返回:ab按照字典的顺序比较,a小于c

    *  -1

    */

   @Test

   public void fun() {

      System.out.println("a".compareTo("b"));

   }

}

 

      1. 练习

需求:

一个子串在整串中出现的次数。

         "nbaernbatynbauinbaopnba"

代码示例:

package string练习;

 

import org.junit.Test;

 

public class StringTest2 {

 

 

    /**

     * 2,一个子串在整串中出现的次数。

     * "nbaernbatynbauinbaopnba"

     * 思路:

     * 1,要找的子串是否存在,如果存在获取其出现的位置。这个可以使用indexOf完成。

     * 2,如果找到了,那么就记录出现的位置并在剩余的字符串中继续查找该子串,

     * 而剩余字符串的起始位是出现位置+子串的长度.

     * 3,以此类推,通过循环完成查找,如果找不到就是-1,并对 每次找到用计数器记录。

     */

    /**

     * @param args

     */

    public static void main(String[] args) {

 

       String str = "nbaernbatnbaynbauinbaopnba";

       String key = "nba";

      

       int count = getKeyStringCount_2(str,key);

       //int count = getKeyStringCount(str,key);

       System.out.println("count="+count);

             

    }

 

   

    /**

     * 方法二:

     * 获取子串在整串中出现的次数。

     * @param str

     * @param key

     * @return

     */

    public static int getKeyStringCount_2(String str, String key) {

       //1,定义计数器。

       int count = 0;

       //2,定义变量记录key出现的位置。

       int index = 0;

      

       while((index = str.indexOf(key,index))!=-1){

          

           index = index + key.length();

           count++;

          

       }

       return count;

    }

   

   

 

    /**

     * 方法一:

     * 获取子串在整串中出现的次数。

     * @param str

     * @param key

     * @return

     */

    public static int getKeyStringCount(String str, String key) {

      

       //1,定义计数器。

       int count = 0;

      

       //2,定义变量记录key出现的位置。

       int index = 0;

      

       while((index = str.indexOf(key))!=-1){

          

           str = str.substring(index+key.length());//0+3,截取后面的字符  nba --ernbatnbaynbauinbaopnba

           count++;

       }

       return count;

    }

 

}

 

返回conunt:6

      1. Stringbuffer

 

  • 字符串的组成原理就是通过该类实现的
  • StringBuffer可以对字符串尽心增删
  • StringBuffer是一个容器
  • 很多方法与String相同
  • StringBuffer是可变长度的

* * StringBuffer字符串缓冲区

 

特点

    * 作用:用于存储数据的一个容器

    *

    * 特点:

    * 1.长度是可变的

    * 2.可以存储不同类型的数据

    * 3.最终需要转成字符串来使用

功能

/**

    

    * 功能:

    *    1.添加:可以添加 int long boolean很多,具体看api

    *    StringBuffer append(data);

    *

    *    2.插入:可以在指定的位置添加数据,位置是下标。这个方法有很多,可以重载,具体看api

    *    StringBuffer insert(int content,int index);

    *    content:插入的内容

    *    index:插入的位置

    *

    *    3.删除:

    *    StirngBuffer delete(int start,int end)//包含头,不包含尾

    *    StringBuffer deleteCharAt(int index);//删除指定位置的元素

    *

    *    4.查找:和我们的String类的那些方法都差不多

    *    char charAt(int index);

    *    int indexOf(String str);

    *    int lastIndexOf(String str);

    *

    *    5.修改

    *    StringBuffer replace(int start,int end,String str);

    *    void setCharAt(int index,char ch);

    *

    * 6.倒置:将添加进去的字符倒置

    *     StringBuffer reverse();

    *

    * 增删改查:CRUD

    * C:create

    * R:read

    * U:update

    * D:delete

    */

 

代码示列:

package stringbuffer;

 

import org.junit.Test;

 

 

public class StringDemo {

   

    /**

     * * StringBuffer字符串缓冲区

     * 作用:用于存储数据的一个容器

     *

     * 特点:

     * 1.长度是可变的

     * 2.可以存储不同类型的数据

     * 3.最终需要转成字符串来使用

     *

     * 功能:

     * 1.添加:可以添加 int long boolean很多,具体看api

     *     StringBuffer append(data);

     *

     * 2.插入:可以在指定的位置添加数据,位置是下标。这个方法有很多,可以重载,具体看api

     *     StringBuffer insert(int content,int index);

     *     content:插入的内容

     *     index:插入的位置

     *

     * 3.删除:

     *     StirngBuffer delete(int start,int end)//包含头,不包含尾

     *     StringBuffer deleteCharAt(int index);//删除指定位置的元素

     *

     * 4.查找:和我们的String类的那些方法都差不多

     *     char charAt(int index);

     *     int indexOf(String str);

     *     int lastIndexOf(String str);

     *

     * 5.修改

     *     StringBuffer replace(int start,int end,String str);

     *     void setCharAt(int index,char ch);

     *

     * 6.倒置:将添加进去的字符倒置

     *      StringBuffer reverse();

     *

     * 增删改查:CRUD

     * C:create

     * R:read

     * U:update

     * D:delete

     */

   

   

   

   

    /**

     * 添加:

     *     StringBuffer append(data);

     *

     * 返回:

     * aaatrue12

     */

    @Test

    public void fun() {

       //创建缓冲区对象

       StringBuffer sb = new StringBuffer();

       sb.append("aaa").append(true).append(12);

       System.out.println(sb.toString());

      

    }

   

    /**

     *2.插入:在指定的位置插入数据

     *返回:

     *  a我在1角标插入了字符aa12345true

     */

    @Test

    public void fun2() {

       StringBuffer sb = new StringBuffer();

       sb.append("aaa").append(12345).append(true);

       sb.insert(1, "我在1角标插入了字符");

       System.out.println(sb);

      

    }

   

   

    /**

     * 3.删除:

     *     StirngBuffer delete(start,end)//包含头,不包含尾

     *     StringBuffer deleteCharAt(int index);//删除指定位置的元素

     */

    @Test

    public void fun3() {

       StringBuffer sb = new StringBuffer("abcdefg");

       sb.delete(1, 3);//从下标1开始删除到下标3,但是不包含3,所有说是删除1-2  删除bc--adefg

       //System.out.println(sb.toString());

      

       //清空缓冲区

       sb.delete(0, sb.length());

       System.out.println(sb.toString());

    }

   

   

    /**

     * 5.修改

     *     StringBuffer replace(int start,int end,String str);

     * 返回值:

     * cbadefg

     *

     *     void setCharAt(int index,char ch);

     * 返回值:

     * cbadefw

     */

    @Test

    public void fun5() {

      

       StringBuffer sb = new StringBuffer("abcdefg");

       sb.replace(0, 3, "cba");//意思是把"abcdefg" 下标0-3的替换为cba

       System.out.println(sb.toString());

      

      

       sb.setCharAt(6, 'w');

       System.out.println(sb.toString());

      

    }

   

    /**

     *6.倒置  StringBuffer reverse()

     *返回值:

     *  gfedcba

     */

    @Test

    public void fun6() {

       StringBuffer sb = new StringBuffer("abcdefg");

       sb.reverse();

       System.out.println(sb);

    }

}

展开阅读全文

关于String总结

05-03

最近系统的学习了一下String类,就String的创建等问题,总结出一下内容:rn[b]String创建的原理:[/b]rn1、以任何方式创建String字符串对象时,运行时会在字符串池中找是否存在这个字符串,如果不存在则创建一个rn2、使用new创建对象,则一定会在堆栈中创建一个新对象rn3、使用指定字符串或纯字符串串联,仅仅会检查字符串池中维护的对象rn4、使用包含变量的表达式来创建string对象,会检查字符串池,也会在堆栈区创建一个string对象rn例如:rnString s = new String("abc");会创建两个对象rn 1、首先根据abc在字符串池中查找,如果没有则新创建一个字符串对象rn 2、根据new在堆栈中创建一个内容为abc的对象,并由变量s指向它rnString s1 = s +"aa"; 会将s对象和aa合成一个字符串,并在堆栈中创建一个新的对象rnrn[b]字符串的比较:[/b]rn1、==:比较的是两个字符串对象的引用是否相等rn 例如:String s2 = "abc";rn String s3 = "abc";rn System.out.println(s2==s3);//结果为true,s2和s3均引用了字符串池中abc的地址rn System.out.println(s2==s);//结果为false,s指向堆中对象地址rn2、equals:先比较引用,如果引用相等,返回值为true,如果引用不相等,再比较值,如果值相等,返回值也是true,只有当引用和值都不相等的情况下,返回的才是false。rn3、当调用 intern 方法时,如果池已经包含一个等于此 String 对象的字符串(用 equals(Object) 方法确定),则返回池中的字符串。否则,将此 String 对象添加到池中,并返回此 String 对象的引用。 它遵循以下规则:对于任意两个字符串 s 和 t,当且仅当 s.equals(t) 为 true 时,s.intern() == t.intern() 才为 true。rn 论坛

没有更多推荐了,返回首页