String call by reference java

Passing String objects as arguments Java

A newbie question. Can someone explain why s1 is not getting updated to «this is a test» ?. I thought in Java, object arguments are passed as references and if that is the case, then I am passing String s1 object as reference in Line 1. And s1 should have been set to «this is a test» via display() method.. Right ?

5 Answers 5

Java is pass-by-value always. For reference types, it passes a copy of the value of the reference.

static String display(String s)

The String s reference is reassigned, its value is changed. The called code won’t see this change because the value was a copy.

With String s, it’s hard to show behavior because they are immutable but take for example

public class Foo < int foo; >public static void main(String[] args) < Foo f = new Foo(); f.foo = 3; doFoo(f); System.out.println(f.foo); // prints 19 >public static void doFoo(Foo some)

public static void doFoo(Foo some)

the original would still show 3 , because you aren’t accessing the object through the reference you passed, you are accessing it through the new reference.

Of course you can always return the new reference and assign it to some variable, perhaps even the same one you passed to the method.

String is a reference which is passed by value. You can change where the reference points but not the caller’s copy. If the object were mutable you could change it’s content.

In short, Java ALWAYS passed by VALUE, it never did anything else.

As others mentioned String s1 is a reference which is passed by value, and hence s1 reference in your method still points to the old string.

I believe you want to do this to assign the returned value back to string s1:

String s1 = "another"; s1 = display(s1); System.out.println(display(s1)) 

Actually in the program you are having two reference string variable s1 and s when you are calling display(s1). Both s1 and s will be referencing to String «another».

but inside the display method you are changing the reference of s to point another String «this is a test» and s1 will still point to «another»

now s and s1 are holding refence to two different stings

display(s1) —> which hold reference of s, will print «this is a test»

Only if you assign s= display(s1) both variable will refer to same string

Because String is immutable so changes will not occur if you will not assign the returned value of function to the string.so in your question assign value of display(s1) to s.

s=display(s1);then the value of string s will change.

I was also getting the unchanged value when i was writing the program to get some permutations string(Although it is not giving all the permutations but this is for example to answer your question)

import java.io.*; public class MyString < public static void main(String []args)throws IOException< BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); String s=br.readLine().trim(); int n=0;int k=0; while(n!=s.length())< while(kn++; > > public static void swap(String s,int n1,int n2) < char temp; temp=s.charAt(n1); StringBuilder sb=new StringBuilder(s); sb.setCharAt(n1,s.charAt(n2)); sb.setCharAt(n2,temp); s=sb.toString(); >> 

but i was not getting the permuted values of the string from above code.So I assigned the returned value of the swap function to the string and got changed values of string. after assigning the returned value i got the permuted values of string.

//import java.util.*; import java.io.*; public class MyString < public static void main(String []args)throws IOException< BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); String s=br.readLine().trim(); int n=0;int k=0; while(n!=s.length())< while(kn++; > > public static String swap(String s,int n1,int n2) < char temp; temp=s.charAt(n1); StringBuilder sb=new StringBuilder(s); sb.setCharAt(n1,s.charAt(n2)); sb.setCharAt(n2,temp); s=sb.toString(); return s; >> 

Источник

Need to pass String by reference in java [closed]

Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.

Questions must demonstrate a minimal understanding of the problem being solved. Tell us what you’ve tried to do, why it didn’t work, and how it should work. See also: Stack Overflow question checklist

Good Day, My program requires a function as such: I need to check for a string on the server, and if it was successful, it will return a boolean true, and modify data, and if not place an error message in data and return false. This is the C++ way of doing things.

boolean getStringFromServer(String& data) 

However, I need to do this in Java. Take not, I am working in a highly multi threaded environment. I heard you can use StringBuffer to pass in data and modify it. Can I actually get an example code?

you have a high negative because you show nothing that you tried and use an irrelevant example. String is immutable in java. you can not change it. There is no ‘direct’ pass by reference in java.

3 Answers 3

boolean getStringFromServer(StringBuilder sb) < if(sb.indexOf("some magic string")!=-1) < //string found return true; >//not found //modify sb return false; > 

How you modify sb is up to you. Take a look at the java doc.

By the way, you cannot modify a String in Java because it is immutable.

Yeah, the inability to modify a String parameter has nothing to do with the reference/value parm thing — it’s simply because Strings are immutable. StringBuffers and several other String-like objects are not immutable.

Okay, lets say the above function exists in a static class/method in java. I acccess it via a thread call, i can have multiple threads calling the above method yes? this means different Strinbuilder objects will be passe din

does stringbuilder get destroyed at the end of a function? Sorry I come from a C background this whole java thing is new to me

In response to what some say, Java is entirely pass by value. Even when people say arrays and objects pass by reference, what they really mean is that arrays’ and objects’ references are passed by value. For example,

 public static void main(String[] args) < int[] numbers = new int[]; change(numbers); System.out.println(Arrays.toString(numbers)); //prints [1,2,3] > public static void change(int[] ra) < ra = new int[]; > 

Nonetheless, that’s not the issue here. Strings are immutable. This is because you have no way to access their indices to change change them (you can use charAt() to see what char is at a specific index, but have no way to change the char ), since the char[] that the String class uses hold the characters is private and there are no setter methods. Additionally, that private char[] is also final so it can never be assigned an additional reference.

As another user suggested, you can use a StringBuilder to accomplish what you want.

Источник

String reference in java

in this code,ob is a reference of test class and st is a reference of string class. while printing ob it shows the reference but st prints the value i.e.»it is a string».. why?

9 Answers 9

Because you haven’t overridden toString() in your test class so it uses the one from Object (the parent class of all objects in java) which is simply going to output the class name and hashcode.

Josh Bloch outlines this in «Effective Java»:

(See: «Item 9: Always override toString»)

because string class overrides a method toString of Object class which is supposed to print whats passed to the constructor. But the test class doesnt do that.

If you run println on an arbitrary object, it will print its string representation as produced by its toString() method (defined in the Object class), which your class does not override. The default implementation prints the reference (or something to that effect).

Your test class does not override toString but String does. The Object implementation of test constructs a string from the class name and the hashCode .

Calling print on Java object merely calls the toString() method which is default inherited form the object class . Since String class has a overridden behavior of toString() to print the string value and your test class don’t have such an implementation ,hence the difference.

This happens because Java provides support for the representation of strings as literals, with compiler support for the automatic conversion of string literals into String objects; and the automatic conversion from any reference type (i.e. any subclass of class Object) into a printable string by using Object.toString method.

In your example, Here the Java compiler notes the signature of the method calls to the print statement is System.out.toString(String arg). Hence it knows that the arguments must be converted to a String.

Every Java class extends Object class automatically even if you don’t explicitly declare it and the Object class contains a toStrong() method which is used to get a String representing the instance of the Object class. The toString() method of the Object class is implemented to show the reference of object but that is not the actual reference (it is just a text containing information about reference).

However, this method may be overriden by its subclass and this is what what happens to a String class. The toString() method of the String class is overriden to represent the content that the String object holds.

Now, when you use print or println methods on an object, it calls the toString() method of the object and print those values.

In your case, test class has not overriden the toString() method so it prints out whatever value the Object.toString() gives.

Источник

Passing Strings By Reference in Java

In Java, variables of primitive data types, such as int, char, float, etc., are passed by value, meaning that a copy of the variable’s value is passed to a method or function. However, when it comes to passing objects, including Strings, the concept of passing by reference versus passing by value can be confusing. In this blog post, we will explore the concept of passing Strings by reference in Java, and provide a clear understanding of how it works.

Passing by Reference vs Passing by Value

Before diving into the details of passing Strings by reference in Java, let’s first understand the basic concepts of passing by reference and passing by value.

Passing by Value

When a variable of a primitive data type is passed as an argument to a method or function, a copy of the variable’s value is passed. Any changes made to the parameter within the method or function have no effect on the original variable outside the method or function.

Passing by Reference

When an object, including Strings, is passed as an argument to a method or function, the reference to the memory location of the object is passed, rather than a copy of the object itself. This means that any changes made to the object within the method or function are reflected in the original object outside the method or function.

Understanding String as an Object in Java

In Java, unlike primitive data types, String is not a primitive data type but rather an object. String objects are instances of the String class, which is a part of the Java standard library. This means that when you create a String variable, you are actually creating an object that represents a sequence of characters.

Now, let’s see how passing Strings by reference works in Java:

Example

Consider the following example:

Java

Before calling modifyString() method: Hello Inside modifyString() method: Hello World! After calling modifyString() method: Hello

Explanation

In the above example, we have a main() method that creates a String variable str with the value “Hello”. We then pass this String variable to the modifyString() method. Inside the modifyString() method, we concatenate ” World!” to the original String using the += operator, and print the modified String. However, when we print the value of str again in the main() method after calling the modifyString() method, we see that the original String “Hello” remains unchanged.

This is because, in Java, Strings are immutable, meaning that their values cannot be changed after they are created. When we pass a String to a method or function, a new String object is created with the same value, and any changes made to the parameter within the method or function have no effect on the original String object outside the method or function. In other words, although we passed the String by reference, the reference itself is passed by value, and the original String object remains unchanged.

Workaround to Pass String by “Reference” in Java

If you really need to modify the original String object inside a method or function, there is a workaround you can use. Instead of using the += operator, which creates a new String object, you can use the StringBuilder or StringBuffer class, which are mutable classes in Java, to modify the original String object. Here’s an example:

Источник