JAVA的String的传值和传地址问题

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

关于Java的String类型，可能你会碰到这种情况，将String类型的变量传到一个函数，在这个函数中修改变量的值，但是，实参的值并没有发生改变。

Java中String的传值/传地址问题：

例子引入：

package com.cnblog.GDUTtiantian.String; /** * @author GDUTtiantian */ public class JavaString { public static void change(String name){ //修改name的值 name = "ChangedName"; } public static void main(String[] args) { String name = "GDUTtiantian"; change(name); System.out.println(name); } }

运行结果:

1 GDUTtiantian

为什么结果不是"ChangedName"呢？

String类的底层实现是用一个字符数组去实现的，就像Integer类，底层也是对int进行封装[装箱和拆箱]。

看String类的修饰部分(源码)：

public final class String implements java.io.Serializable, Comparable<String>, CharSequence { /** The value is used for character storage. */ private final char value[];

注意，String类加了final关键字，所以不能被继承。

第4行是字符串底层的存储结构：字符数组。

String的内容不能被动态地修改，因为底层是字符数组实现的，数组的大小是在初始化时决定的；

如果可以修改，新的字符串长度比原来数组大，那么就会造成数组越界。

String和StringBuffer的比较：

package com.cnblog.GDUTtiantian.String; /** * @author GDUTtiantian * * String, StringBuffer 在传参过程中的哈希值比较 */ public class JavaString4 { public static void change(String str) { System.out.println("形参的哈希值：" + str.hashCode()); str = "newString";//修改了形参的值 System.out.println("修改后：" + str.hashCode()); } public static void change(StringBuffer sb) { System.out.println("形参的哈希值：" + sb.hashCode()); sb.append("newStringBuffer");//修改了形参的值 System.out.println("修改后：" + sb.hashCode()); } public static void main(String[] args) { String str = new String("GDUTtiantian"); StringBuffer sb = new StringBuffer("tiantian"); System.out.println("修改前：" + str.hashCode()); change(str); System.out.println("\n----------------------------\n"); System.out.println("修改前：" + sb.hashCode()); change(sb); } }

运行结果：

修改前：-501451264 形参的哈希值：-501451264 修改后：-595706415 ---------------------------- 修改前：1036782095 形参的哈希值：1036782095 修改后：1036782095

实参String变量传给形参，是传一个地址过去，并没有重新创建一个对象，StringBuffer变量也是这么做；

但是，在修改形参的值后，String变量的哈希值发生了改变，StringBuffer变量的哈希没有发生改变，即String变量指向了一个新建的对象。

看看JDK中String类的一段源码(String类的一个构造方法)：

/** * Allocates a new {@code String} that contains characters from a subarray * of the <a href="Character.html#unicode">Unicode code point</a> array * argument. The {@code offset} argument is the index of the first code * point of the subarray and the {@code count} argument specifies the * length of the subarray. The contents of the subarray are converted to * {@code char}s; subsequent modification of the {@code int} array does not * affect the newly created string. * * @param codePoints * Array that is the source of Unicode code points * * @param offset * The initial offset * * @param count * The length * * @throws IllegalArgumentException * If any invalid Unicode code point is found in {@code * codePoints} * * @throws IndexOutOfBoundsException * If the {@code offset} and {@code count} arguments index * characters outside the bounds of the {@code codePoints} array * * @since 1.5 */ public String(int[] codePoints, int offset, int count) { if (offset < 0) { throw new StringIndexOutOfBoundsException(offset); } if (count < 0) { throw new StringIndexOutOfBoundsException(count); } // Note: offset or count might be near -1>>>1. if (offset > codePoints.length - count) { throw new StringIndexOutOfBoundsException(offset + count); } final int end = offset + count; // Pass 1: Compute precise size of char[] int n = count; for (int i = offset; i < end; i++) { int c = codePoints[i]; if (Character.isBmpCodePoint(c)) continue; else if (Character.isValidCodePoint(c)) n++; else throw new IllegalArgumentException(Integer.toString(c)); } // Pass 2: Allocate and fill in char[] final char[] v = new char[n]; for (int i = offset, j = 0; i < end; i++, j++) { int c = codePoints[i]; if (Character.isBmpCodePoint(c)) v[j] = (char)c; else Character.toSurrogates(c, v, j++); } this.value = v; }

代码57行开始，就是对字符数组进行复制。

这里，用C/C++中的字符串/数组/指针的引用做比较：

#include<stdio.h> //形参中数组退化为指针了 //这里s是指向array数组的指针 void go(char * s){ s = "JavaString";//指针指向另一个空间，"JavaString"字符串的首地址 printf("s:%s#\n", s); } //形参中数组退化为指针了 void change(char * s){ s[] = 'c'; s[] = 'h'; s[] = 'a'; s[] = 'n'; s[] = 'g'; s[] = 'e'; s[] = '\0'; } int main(){ ] = "GDUTtiantian"; go(array); printf("array:%s#\n", array); change(array); printf("array:%s#\n", array); ; }

第7行： s = "JavaString";

这一行比较重要，s是指向main()函数中array数组的首地址的指针，然后在第7行，s指向另外一个字符串的首地址；

这里和String变量在形参中的改变有相似之处。

第14行： s[0] = 'c';

这里的s也是指向main()函数中array数组的首地址的指针，然后把array数组的第一个字符修改为'c'.

运行结果[在CodeBlock编译运行]：

s:JavaString# array:GDUTtiantian# array:change# Process returned (0x0) execution time : 0.140 s Press any key to continue.

Java实现字符串的值修改可以有两种方式：

用数组实现

package com.cnblog.GDUTtiantian.String; /** * @author GDUTtiantian */ public class JavaString2 { public static void change(String[] name){ //修改name的值 name[0] = "ChangedName"; } public static void main(String[] args) { String[] name = {"GDUTtiantian"}; change(name); System.out.println(name[0]); } }

运行结果：

1 ChangedName

将String设置为新建类型的一个成员变量

package com.cnblog.GDUTtiantian.String; /** * @author GDUTtiantian */ class NewString { private String value; public NewString(String str){ value = str; } public String getValue() { return value; } public void setValue(String value) { this.value = value; } @Override public String toString() { return getValue(); } } public class JavaString3 { private static NewString newName = new NewString("ChangedName"); public static void change(NewString name){ //修改name的值 name.setValue(newName.getValue()); } public static void main(String[] args) { NewString name = new NewString("GDUTtiantian"); change(name); System.out.println(name); } }

运行结果：

1 ChangedName

这两种方式中String变量的值都发生了改变，但是，其底层还是创建了一个新的String对象[忽略涉及字符串在缓冲池创建对象的部分]，然后返回引用给当前句柄。

为什么通过这两种方式可以去改变String变量的值呢？