关于Java的String类型,可能你会碰到这种情况,将String类型的变量传到一个函数,在这个函数中修改变量的值,但是,实参的值并没有发生改变。
Java中String的传值/传地址问题:
例子引入:
1 package com.cnblog.GDUTtiantian.String; 2 3 /** 4 * @author GDUTtiantian 5 */ 6 public class JavaString { 7 8 public static void change(String name){ 9 //修改name的值 10 name = "ChangedName"; 11 } 12 13 14 public static void main(String[] args) { 15 String name = "GDUTtiantian"; 16 17 change(name); 18 19 System.out.println(name); 20 21 } 22 23 }
运行结果:
1 GDUTtiantian
为什么结果不是"ChangedName"呢?
String类的底层实现是用一个字符数组去实现的,就像Integer类,底层也是对int进行封装[装箱和拆箱]。
看String类的修饰部分(源码):
1 public final class String 2 implements java.io.Serializable, Comparable<String>, CharSequence { 3 /** The value is used for character storage. */ 4 private final char value[];
注意,String类加了final关键字,所以不能被继承。
第4行是字符串底层的存储结构:字符数组。
String的内容不能被动态地修改,因为底层是字符数组实现的,数组的大小是在初始化时决定的;
如果可以修改,新的字符串长度比原来数组大,那么就会造成数组越界。
String和StringBuffer的比较:
1 package com.cnblog.GDUTtiantian.String; 2 3 /** 4 * @author GDUTtiantian 5 * 6 * String, StringBuffer 在传参过程中的哈希值比较 7 */ 8 public class JavaString4 { 9 10 11 public static void change(String str) { 12 System.out.println("形参的哈希值:" + str.hashCode()); 13 14 str = "newString";//修改了形参的值 15 System.out.println("修改后:" + str.hashCode()); 16 } 17 18 public static void change(StringBuffer sb) { 19 System.out.println("形参的哈希值:" + sb.hashCode()); 20 sb.append("newStringBuffer");//修改了形参的值 21 System.out.println("修改后:" + sb.hashCode()); 22 } 23 24 25 public static void main(String[] args) { 26 String str = new String("GDUTtiantian"); 27 StringBuffer sb = new StringBuffer("tiantian"); 28 29 System.out.println("修改前:" + str.hashCode()); 30 change(str); 31 32 System.out.println("\n----------------------------\n"); 33 34 System.out.println("修改前:" + sb.hashCode()); 35 change(sb); 36 } 37 38 }
运行结果:
1 修改前:-501451264 2 形参的哈希值:-501451264 3 修改后:-595706415 4 5 ---------------------------- 6 7 修改前:1036782095 8 形参的哈希值:1036782095 9 修改后:1036782095
实参String变量传给形参,是传一个地址过去,并没有重新创建一个对象,StringBuffer变量也是这么做;
但是,在修改形参的值后,String变量的哈希值发生了改变,StringBuffer变量的哈希没有发生改变,即String变量指向了一个新建的对象。
看看JDK中String类的一段源码(String类的一个构造方法):
1 /** 2 * Allocates a new {@code String} that contains characters from a subarray 3 * of the <a href="Character.html#unicode">Unicode code point</a> array 4 * argument. The {@code offset} argument is the index of the first code 5 * point of the subarray and the {@code count} argument specifies the 6 * length of the subarray. The contents of the subarray are converted to 7 * {@code char}s; subsequent modification of the {@code int} array does not 8 * affect the newly created string. 9 * 10 * @param codePoints 11 * Array that is the source of Unicode code points 12 * 13 * @param offset 14 * The initial offset 15 * 16 * @param count 17 * The length 18 * 19 * @throws IllegalArgumentException 20 * If any invalid Unicode code point is found in {@code 21 * codePoints} 22 * 23 * @throws IndexOutOfBoundsException 24 * If the {@code offset} and {@code count} arguments index 25 * characters outside the bounds of the {@code codePoints} array 26 * 27 * @since 1.5 28 */ 29 public String(int[] codePoints, int offset, int count) { 30 if (offset < 0) { 31 throw new StringIndexOutOfBoundsException(offset); 32 } 33 if (count < 0) { 34 throw new StringIndexOutOfBoundsException(count); 35 } 36 // Note: offset or count might be near -1>>>1. 37 if (offset > codePoints.length - count) { 38 throw new StringIndexOutOfBoundsException(offset + count); 39 } 40 41 final int end = offset + count; 42 43 // Pass 1: Compute precise size of char[] 44 int n = count; 45 for (int i = offset; i < end; i++) { 46 int c = codePoints[i]; 47 if (Character.isBmpCodePoint(c)) 48 continue; 49 else if (Character.isValidCodePoint(c)) 50 n++; 51 else throw new IllegalArgumentException(Integer.toString(c)); 52 } 53 54 // Pass 2: Allocate and fill in char[] 55 final char[] v = new char[n]; 56 57 for (int i = offset, j = 0; i < end; i++, j++) { 58 int c = codePoints[i]; 59 if (Character.isBmpCodePoint(c)) 60 v[j] = (char)c; 61 else 62 Character.toSurrogates(c, v, j++); 63 } 64 65 this.value = v; 66 }
代码57行开始,就是对字符数组进行复制。
这里,用C/C++中的字符串/数组/指针的引用做比较:
1 #include<stdio.h> 2 3 //形参中数组退化为指针了 4 //这里s是指向array数组的指针 5 void go(char * s){ 6 7 s = "JavaString";//指针指向另一个空间,"JavaString"字符串的首地址 8 printf("s:%s#\n", s); 9 } 10 11 //形参中数组退化为指针了 12 void change(char * s){ 13 14 s[0] = ‘c‘; 15 s[1] = ‘h‘; 16 s[2] = ‘a‘; 17 s[3] = ‘n‘; 18 s[4] = ‘g‘; 19 s[5] = ‘e‘; 20 s[6] = ‘\0‘; 21 } 22 23 int main(){ 24 char array[100] = "GDUTtiantian"; 25 26 go(array); 27 printf("array:%s#\n", array); 28 29 change(array); 30 printf("array:%s#\n", array); 31 32 return 0; 33 }
第7行 : s = "JavaString";
这一行比较重要,s是指向main()函数中array数组的首地址的指针,然后在第7行,s指向另外一个字符串的首地址;
这里和String变量在形参中的改变有相似之处。
第14行: s[0] = ‘c‘;
这里的s也是指向main()函数中array数组的首地址的指针,然后把array数组的第一个字符修改为‘c‘.
运行结果[在CodeBlock编译运行]:
1 s:JavaString# 2 array:GDUTtiantian# 3 array:change# 4 5 Process returned 0 (0x0) execution time : 0.140 s 6 Press any key to continue.
Java实现字符串的值修改可以有两种方式:
用数组实现
1 package com.cnblog.GDUTtiantian.String; 2 3 /** 4 * @author GDUTtiantian 5 */ 6 public class JavaString2 { 7 8 public static void change(String[] name){ 9 //修改name的值 10 name[0] = "ChangedName"; 11 } 12 13 14 public static void main(String[] args) { 15 String[] name = {"GDUTtiantian"}; 16 17 change(name); 18 19 System.out.println(name[0]); 20 21 } 22 23 }
运行结果:
1 ChangedName
将String设置为新建类型的一个成员变量
1 package com.cnblog.GDUTtiantian.String; 2 3 /** 4 * @author GDUTtiantian 5 */ 6 7 class NewString { 8 private String value; 9 10 public NewString(String str){ 11 value = str; 12 } 13 14 public String getValue() { 15 return value; 16 } 17 18 public void setValue(String value) { 19 this.value = value; 20 } 21 22 23 @Override 24 public String toString() { 25 return getValue(); 26 } 27 } 28 29 public class JavaString3 { 30 private static NewString newName = new NewString("ChangedName"); 31 32 public static void change(NewString name){ 33 //修改name的值 34 name.setValue(newName.getValue()); 35 } 36 37 38 public static void main(String[] args) { 39 NewString name = new NewString("GDUTtiantian"); 40 41 change(name); 42 43 System.out.println(name); 44 45 } 46 47 }
运行结果:
1 ChangedName
这两种方式中String变量的值都发生了改变,但是,其底层还是创建了一个新的String对象[忽略涉及字符串在缓冲池创建对象的部分],然后返回引用给当前句柄。
为什么通过这两种方式可以去改变String变量的值呢?
暂时还想不太清楚,欢迎大家补充;
可以对比python的列表和元组,元组是不可变的,即元组的对象不可以删除,不可以增加;
如果该元组的一个元素为列表类型,那么,可以修改这个列表的内容,当然,列表对象还是当前这个列表对象。
欢迎讨论交流, 我的主页:http://www.cnblogs.com/GDUT/
我的邮箱:zone.technology.ex[email protected]
JAVA的String的传值和传地址问题