JAVA中字符串知识详解

 

java中字符串和整型之间的转化

1）如何将字符串转化为整型；

   int i = Integer.parseInt(String str);

   int i = Integer.valueOf().intValue();

 
  注：Integer.parseIn 和 Integer.valueOf 不同，前者生成的是整型，而后者是一个对象，所以要通过intValue()来获得对象的值；

  字串转成 Double, Float, Long 的方法大同小异.

2) 整型转化为字符串

   String str = String.valueOf(int i);

   String str = Integer.toString(int i);

   String str = "" + i ;

  注： Double, Float, Long 的方法大同小异.
 

 

 

1. 首先String不属于8种基本数据类型，String是一个对象。

　　因为对象的默认值是null，所以String的默认值也是null；但它又是一种特殊的对象

，有其它对象没有的一些特性。

2. new String()和new String(“”)都是申明一个新的空字符串，是空串不是null；

 

3. String str=”kvill”；

String str=new String (“kvill”);的区别：

　　在这里，我们不谈堆，也不谈栈，只先简单引入常量池这个简单的概念。

　　常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的

一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。

　　看例1：

String s0=”kvill”;

String s1=”kvill”;

String s2=”kv” + “ill”;

System.out.println( s0==s1 );

System.out.println( s0==s2 );

　　结果为：

true

true

　　首先，我们要知道Java会确保一个字符串常量只有一个拷贝。

　　因为例子中的s0和s1中的”kvill”都是字符串常量，它们在编译期就被确定了，所以

s0==s1为true；而”kv”和”ill”也都是字符串常量，当一个字符串由多个字符串常量连

接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常

量，所以s2也是常量池中”kvill”的一个引用。

　　所以我们得出s0==s1==s2;

　　用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String()

创建的字符串不放入常量池中，它们有自己的地址空间。

　　看例2：

String s0=”kvill”;

String s1=new String(”kvill”);

String s2=”kv” + new String(“ill”);

System.out.println( s0==s1 );

System.out.println( s0==s2 );

System.out.println( s1==s2 );

　　结果为：

false

false

false

　　例2中s0还是常量池中”kvill”的应用，s1因为无法在编译期确定，所以是运行时创

建的新对象”kvill”的引用，s2因为有后半部分new String(“ill”)所以也无法在编译

期确定，所以也是一个新创建对象”kvill”的应用;明白了这些也就知道为何得出此结果

了。

　　4. String.intern()：

　　再补充介绍一点：存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充

。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern(

)方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用

，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用；看例3就清楚了

　　例3：

String s0= “kvill”;

String s1=new String(”kvill”);

String s2=new String(“kvill”);

System.out.println( s0==s1 );

System.out.println( “**********” );

s1.intern();

s2=s2.intern(); //把常量池中“kvill”的引用赋给s2

System.out.println( s0==s1);

System.out.println( s0==s1.intern() );

System.out.println( s0==s2 );

　　结果为：

false

**********

false //虽然执行了s1.intern(),但它的返回值没有赋给s1

true //说明s1.intern()返回的是常量池中”kvill”的引用

true

　　最后我再破除一个错误的理解：

　　有人说，“使用String.intern()方法则可以将一个String类的保存到一个全局Strin

g表中，如果具有相同值的Unicode字符串已经在这个表中，那么该方法返回表中已有字符

串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中“如果我把他说

的这个全局的String表理解为常量池的话，他的最后一句话，“如果在表中没有相同值的

字符串，则将自己的地址注册到表中”是错的：

　　看例4：

String s1=new String("kvill");

String s2=s1.intern();

System.out.println( s1==s1.intern() );

System.out.println( s1+" "+s2 );

System.out.println( s2==s1.intern() );

　　结果：

false

kvill kvill

true

　　在这个类中我们没有声名一个”kvill”常量，所以Ａ砍刂幸豢 际敲挥小眐vill”的

，当我们调用s1.intern()后就在常量池中新添加了一个”kvill”常量，原来的不在常量

池中的”kvill”仍然存在，也就不是“将自己的地址注册到常量池中”了。

　　s1==s1.intern()为false说明原来的“kvill”仍然存在；

　　s2现在为常量池中“kvill”的地址，所以有s2==s1.intern()为true。

　　5. 关于equals()和==:

　　这个对于String简单来说就是比较两字符串的Unicode序列是否相当，如果相等返回t

rue;而==是比较两字符串的地址是否相同，也就是是否是同一个字符串的引用。

　　6. 关于String是不可变的

　　这一说又要说很多，大家只要知道String的实例一旦生成就不会再改变了，比如说：

String str=”kv”+”ill”+” “+”ans”;

就是有4个字符串常量，首先”kv”和”ill”生成了”kvill”存在内存中，然后”kvill

”又和” “ 生成 ”kvill “存在内存中，最后又和生成了”kvill ans”;并把这个字符

串的地址赋给了str,就是因为String的“不可变”产生了很多临时变量，这也就是为什么

建议用StringBuffer的原因了，因为StringBuffer是可改变的

 

 

1，String类（属于java.lang包）定长，不可变的字符序列

 （1）构造方法
       1用双引号将字符序列括起来，int n = "abcdef".length();
       2采用new方法，new String(构造方法的参数列表)；
               eg: String s0 = new String("string");
       3通过运算符“＋”或其他成员方法生成String实例对象。

               String s = "abc".toUpperCase();将生成字符串ABC。在java语言
               中，任何一种类型的数据都可以转化成String类型的数据：
               String.valueOf(基本数据类型数据)；
               Double d = 0.12; String s = String.valueOf(d);
         结果字符串实例对象的值为“0.12”
     补充：对于引用数据类型：引用数据类型数据.toString();因public String toString() 是类Object的一个方法，而java中其他类都是类Object的子类，所以所有的java类均会含有成员方法toString.在调用Syetem,out.println或者
       Syetem.out.print时，如果他们的参数是非字符串类型的数据，则一般将自动调用toString方法将其转换成字符串，然后输出。
  (2)对字符串内字符的访问。
       通过String成员方法：public char charAt(int index)；
       "abc".charAt(1),将返回字符“b”。
       字符串中字符的个数可以通过public int length()得到
  (3)字符串内容的比较：可通过以下成员方法：
       public int compareTo(String anotherString)(区分大小写)
       public int compareToIgnoreCase(String anotherString)（不区分大小写，在比较之前先将两个字符串列统一成大写或者小写再进行比较）
       另外还有：
       Boolean equals(object str)
       Boolean equalsIgnoreCase(String str)
  (4)字符串常量、成员方法intern和运算符“ ＝＝”
    字符串常量：是指向类Stirng实例（也称为字符串实例）的引用，它存储在字符串池中，而且相同内容的字符串只对应一个字符串实例对象。
    方法intern：调用类String成员方法intern后，类String所维护的字符串池也会含有与该字符串实例相同内容的字符串实例。如果 字符串池已经含有相同内容的字符串实例，则返回该字符串实例的引用；否则在字符串池中创建一个新的具有该内容的字符串实例，并返回该实例的应用。此方法可 以用来判断字符串实例引用是否相等。
       如:s1.inter() == s0.intern()可以用来判断所s0与s1（s0和s1为字符串类型的变量）所指向的字符串实例的内容是否相同，相同则返回true，否则返回false。
       "=="与public boolean equals(Object anObject)方法是不同的。
       String s0 = "hello";
       String s2 = new String("hello");
       System.out.println(s0 == s2);
       System.out.println(s0.equals(s2));
       结果为：false
              true
 (5)字符串的修改
       1.运算符“＋”
       当两边都是字符串实例的引用时，运算的结果是将生成一个新的字符串实例，内容为两自符串实例内容的合并的结果。
       "String "+"abc"  结果是“String abc”
      当两侧不一致时，先将不为字符串数据的数据转化成字符串数据，再进行字符串间的“＋”操作：“String ” ＋ 1 结果为“String 1”
       2.类String中提供的方法（属于java.lang包）
       String substring(int startIndex)   截取子串
       String substring(int startIndex,int endIndex)  截取子串
       String concat(String str)  连接两个字符串
       String replace(char oldstring,char newstring)  将前者替换为后者
       String replace(CharSequence target,CharSequence replacement) 替换指定目标序列 eg：将aaa中的aa用b替代后成为：ba
       String trim()  用来去除字符串前后多余的空格
 (6)字符串与基本数据类型的转换 （具体可见帮助手册中关于valueOf方法的介
绍：http://gceclub.sun.com.cn/Java_Docs/html/zh_CN/api/index.html）
       public static 类型名 valueOf(String s) 如：
       public static Boolean valueOf(String s),(其中Character没有成员方法 valueOf) 然后再将基本数据类型的包装类数据转换成基本数据类型数据类型数据
       Public boolean boooleanValue()
       eg：Boolean b = Boolean.valueOf("true").booleanValue();将字符串转换成布尔数据。
 
 (7)字符串的搜索
       Int indexOf();字符或者字符串首次出现的位置
       Int lastIndexOf()；字符或者字符串最后一次出现的位置
2．StringBuffer类  可变长，可写的字符序列
  String实例一旦创建完毕，就不能再修改其内容。而StringBuffer则可以修改实例所包含的字符序列。
 (1)两者之间的转换
       1.String 到 Stringbuffer：
       public StringBuffer(String str)
       String s0="abc";
       StringBuffer b = new StringBuffer(s0);
       2.Stringbuffer到String：public String(StringBuffer实例的引用)
       Public String toString();  设b为StringBuffer类型的变量，则
       String s = new String(b);与String s ＝ b.toString();有相同的效果。
 (2)修改StringBuffer实例内容
       可通过成员方法public int length()获取StringBuffer实例的字符序列的长度.通过成员方法StringBuffer的成员方法 public char charAt(int index)得到字符序列中指定下标的字符.
       1.pubic void setCharAt(int index,char ch)用来将StringBuffer实例的字符序列中指定下标的字符设置为指
       StringBuffer b = new StringBuffer("that");
       b.setCharAt(0,'c'); 将that变为chat
       2.成员方法append是在字符序列之后再添加新的内容
       StringBuffer b = new StringBuffer("Party");
       b.append("good!");  结果为Party good!
       3.成员方法delete用来删除字符序列中指定的子序列
       StringBuffer b = new StringBuffer("Those");
       b.delete(2,4);   结果为The 注意2－4中不包括4，且下标从0开始
       5.此外还有insert,replace,reverse等，可查看在线帮助来获得这些方法的用法。
 (3)StringBuffer实例的容量
       StringBuffer实例的字符序列是允许发生变化的，包括字符个数的变化。为了减少频繁的内存申请，StringBuffer实例占有的内存一般要比实际的字符序列所需的空间要大。
       1.可通过StringBuffer的成员方法 public int capacity()获得StringBuffer实例的容量。public int length()方法获得实例的长度。
       2.void ensureCapacity方法在默认的基础上改变容量的大小。
       void setLength(int len)来指定新字符的长度，这个值是非负的。
       构造方法               字符序列长度               内存容量
public  StringBuffer()            0                      16
Public  StringBuffer(int length)  0                     length
Public  StringBuffer(String str)str中的字符序列长度  str中的字符序列长度加16

 

两者死不一样的：
1、String s="java"; 这里产生得到一个字符串常量。系统首先会去“常量池”寻找，看是否有“java”常量存在，如果有那么就将这个常量“java”赋给s，如果没有则系统在常量池里创建“java”，并将其给s。

2、String s = new String("java"); 意思是根据常量“java”创建一个字符串的对象，如此他首先会执行1中的操作，然后根据常量“java”在堆中创建对象，并为其分配内存。