Java string parameter return

Best way to return a String as a parameter in Java

I frequently encounter a situation where I want to return several values from a Java method, and it’s not worth creating a class/object just for that purpose. In my specific current case, I have a number of input-validation methods which compute intermediate results that I’d like to re-use in the callers.

One solution is to pass in a new list and have the method append my results, but that’s misleading when I know there will always be a single value for each parameter that I want to return.

The most common such situation is when I want to return a string. I can pass in a StringBuilder or StringBuffer, and have the method fill in the value. But for some strange reason these classes do not provide a set() method (other than the constructor, which is not helpful for this purpose). The closest I can come up with is myStringBuilder.replace(0, myStringBuilder.length(), myString) , but that’s really ugly and does not communicate my intent clearly. So I would like to extend these classes with a utility class of my own, which adds a set() method (and internally uses replace), but these classes are declared final for some bizarre reason, and I can’t do that either.

Am I missing something? Is there some preferred way of doing what I want — passing in some kind of writable string buffer into which the method can put a value? Is there a good reason these classes are declared final?

An example of such a method might be:

void foo(List arg1, List arg2, StringBuffer somethingInteresting, StringBuffer somethingElseInteresting) 

I don’t want to replace the last two parameters with List if the two strings are unrelated semantically, because I’m imposing some semantics on the list order which is not clearly communicated. I don’t want to pass in two separate List and expect each to return with size() of 1, because that again is not clear to the caller.

The problem is your resistance to creating another class. I’m not saying your question is invalid, but if you want to return a bunch of values and your function is aware of the Single Responsibility Principle, then those values are related. Since they are related, you will have other things that want to operate on them as a group. These operations belong in the class you return.

I’ve never regretted creating a class to return similar values.

I’ve never regretted splitting up a class that returned two unrelated values.

Java tries not to make it easy to do things you will regret.

By the way, to answer the question directly, You might return an array of strings. Return value of String[] and have it return something like «new String[] «, but as I said this is the wrong path to take in general.

You COULD create a mutable string as you say, but there is a very good reason they are immutable. Immutability is the key to thread safety—even if you don’t think you are using threads much, having values change underneath you is a problem. Languages that are highly threaded are shifting towards immutability (functional style)—I wouldn’t start building an infrastructure going away from it.

If you don’t like using myStringBuilder.replace(0, myStringBuilder.length(), myString) because its intent is unclear, you can use

 myStringBuilder.setLength(0); // clears the existing content myStringBuilder.append(myString); // sets the new string 

Java URL encoding of query string parameters, Note that spaces in query parameters are represented by +, not %20, which is legitimately valid.The %20 is usually to be used to represent spaces in URI itself (the part before the URI-query string separator character ?), not in query string (the part after ?. Also note that there are three encode() methods. One without …

How to get the string value of a parameter in Java?

I’m trying to save a parameter as a property, the parameter is : testSpeed ( = «20» ) , and I have a method :

saveProperty(String Parameter) 

which will save the value of Parameter to a file, something like this :

My property file looks like this :

testSpeed : 20 testHeight : 300 

My question is : In Java is it possible to get the name of the parameter, in this case the parameter passed to saveProperty() is testSpeed , and it’s name is «testSpeed» , how to get this string from inside of saveProperty() , so I don’t have to do the following to save it :

saveProperty(String Name,String Value); 

saveProperty("testSpeed",testSpeed) 

Also, when I need to get it out from the property file, I can call :

I know how to use a property file, I’m just using it as an example, maybe it caused some confusion when I mentioned property file.

The essence of the question is : how to get the name of a parameter passed into a method.

void someMethod(String Parameter_XYZ) < // In here if I call someMethod(testSpeed), how to get the string "testSpeed", // not it's value, but it's name, // exactly spelled as "testSpeed" ? >

First of all correct format of property file is this:

testSpeed=20 testHeight=300 

Now to pull any property from this you need to pass key name, which you’re already doing in saveProperty(String name, String value) method. However if I understood your question correctly then you want to avoid passing property name. You can have some custom methods like this:

void saveTestSpeed(String value) < saveProperty("testSpeed", value); >Strig getTestSpeed()

EDIT: Based on your edited question.

No it is not possible in Java.

Please remember that Java is strictly pass-by-value that makes it impossible to figure out the name of actual variable name at callee’s end. Inside the saveProperty method we can only get the value of the arguments since in Java Object references are passed by value not by name.

This is not practical also since there is nothing that stops method being called like:

In the case what should be the name of the property?

public class Util < private static final Properties prop = new Properties(); static < try < prop.load(new FileReader(new File("prop.txt"))); >catch(IOException e) < e.printStackTrace(); >> public static void setProperty(String key, String value) < prop.setProperty(key, value); persistCurrentProperites(); >public static String getProperty(String key) < return prop.getProperty(key); >private static void persistCurrentProperites() < try < prop.store(new FileWriter(new File("prop.txt")), null); >catch(IOException e) < e.printStackTrace(); >> > 

I suggest maintaining the key-value pairs to acheive a more generic solution. You can use Properties

void saveProperty(String key, String value)

use getProperty to retrieve

Java — How to parametrize a string and replace, I have an String that is entered by the end user, and this string should be of the format Showing <0>to of and I would like to replace the parameters in curly brackets with numbers that I compute from the backend. Exactly like it happens for the strings from the properties file. How can I do that? Sample input: …

How do I use optional parameters in Java?

There are several ways to simulate optional parameters in Java:

One of the limitations of this approach is that it doesn’t work if you have two optional parameters of the same type and any of them can be omitted.

a) All optional parameters are of the same type:

 void foo(String a, Integer. b) < Integer b1 = b.length >0 ? b[0] : 0; Integer b2 = b.length > 1 ? b[1] : 0; //. > foo("a"); foo("a", 1, 2); 

b) Types of optional parameters may be different:

 void foo(String a, Object. b) < Integer b1 = 0; String b2 = ""; if (b.length >0) < if (!(b[0] instanceof Integer)) < throw new IllegalArgumentException(". "); >b1 = (Integer)b[0]; > if (b.length > 1) < if (!(b[1] instanceof String)) < throw new IllegalArgumentException(". "); >b2 = (String)b[1]; //. > //. > foo("a"); foo("a", 1); foo("a", 1, "b2"); 

The main drawback of this approach is that if optional parameters are of different types you lose static type checking. Furthermore, if each parameter has the different meaning you need some way to distinguish them.

1. Nulls. To address the limitations of the previous approaches you can allow null values and then analyze each parameter in a method body: void foo(String a, Integer b, Integer c) < b = b != null ? b : 0; c = c != null ? c : 0; //. >foo(«a», null, 2);

Now all arguments values must be provided, but the default ones may be null.

1. Optional class. This approach is similar to nulls, but uses Java 8 Optional class for parameters that have a default value: void foo(String a, Optional bOpt) < Integer b = bOpt.isPresent() ? bOpt.get() : 0; //. >foo(«a», Optional.of(2)); foo(«a», Optional.absent()); Optional makes a method contract explicit for a caller, however, one may find such signature too verbose. Update: Java 8 includes the class java.util.Optional out-of-the-box, so there is no need to use guava for this particular reason in Java 8. The method name is a bit different though.
2. Builder pattern. The Builder pattern is used for constructors and is implemented by introducing a separate Builder class:

class Foo < private final String a; private final Integer b; Foo(String a, Integer b) < this.a = a; this.b = b; >//. > class FooBuilder < private String a = ""; private Integer b = 0; FooBuilder setA(String a) < this.a = a; return this; >FooBuilder setB(Integer b) < this.b = b; return this; >Foo build() < return new Foo(a, b); >> Foo foo = new FooBuilder().setA("a").build(); 

@SuppressWarnings("unchecked") static T getParm(Map map, String key, T defaultValue) < return (map.containsKey(key)) ? (T) map.get(key) : defaultValue; >void foo(Map parameters) < String a = getParm(parameters, "a", ""); int b = getParm(parameters, "b", 0); // d = . >foo(Map.of("a","a", "b",2, "d","value")); 

Please note that you can combine any of these approaches to achieve a desirable result.

varargs could do that (in a way). Other than that, all variables in the declaration of the method must be supplied. If you want a variable to be optional, you can overload the method using a signature which doesn’t require the parameter.

private boolean defaultOptionalFlagValue = true; public void doSomething(boolean optionalFlag) < . >public void doSomething()

There is optional parameters with Java 5.0. Just declare your function like this:

public void doSomething(boolean. optionalFlag) < //default to "false" //boolean flag = (optionalFlag.length >= 1) ? optionalFlag[0] : false; > 

you could call with doSomething(); or doSomething(true); now.

You can use something like this:

public void addError(String path, String key, Object. params)

The params variable is optional. It is treated as a nullable array of Objects.

Strangely, I couldn’t find anything about this in the documentation, but it works!

This is «new» in Java 1.5 and beyond (not supported in Java 1.4 or earlier).

I see user bhoot mentioned this too below.

Best way to return a String as a parameter in Java, Java tries not to make it easy to do things you will regret. By the way, to answer the question directly, You might return an array of strings. Return value of String [] and have it return something like «new String [] «, but as I said this is the wrong path to take in general.

Источник

How to Return a String in Java

A String is a group of characters used to store text data. In Java, methods are declared with their return types like int, double, String, and so on. More specifically, a string can be returned with or without a return statement, depending on your program requirements.

This post will illustrate how to return Java strings.

How to Return a String in Java?

There are two ways to return a String in Java:

We will now check out both of the mentioned methods one by one!

Method 1: Return a String in Java Without Using return Statement

The simplest way to return a string without the return statement is using the “System.out.println()” method. This Java method is utilized for printing the passed argument on the console.

Here, “s” represents the string that will be returned to the console.

See the examples below to have a better understanding of the concept.

Example 1: Return a String Using System.out.println() Method

First of all, create a string named “s” having the following value:

Then, we will return the created string using the “System.out.println()” method:

Example 2: Return a String Using Static Java Method

Here, first, we will create a static void function that utilizes the “System.out.println()” method:

static void sMethod ( ) {
System. out . println ( «The String is returned without Return Statement» ) ;
}

Now, we will call the “sMethod()” in main() to print the specified string on the screen:

The given output indicates that we have successfully returned a string using a static method:

Now, let’s head towards the second method!

Method 2: Return a String in Java Using return Statement

Another way to return a string is by using a “return” statement at the end of the method. When a programmer writes a program, the compiler examines the return type. If the return type is set as “String”, then the added string will be returned.

Here, the “return” keyword represents the added return statement that will return the String specified in the double quotes.

Example
In this example, we will create a String type static method that returns the following string:

Next, we will call our “sMethod()” in main() method, store the returned value in “s” variable, and print it on console using the “System.out.println()” method:

public static void main ( String [ ] args ) {
String s = sMethod ( ) ;
System. out . println ( s ) ;
}

We compiled all the simplest methods related to returning a String in Java.

Conclusion

There are two methods to return a String in Java: the “System.out.println()” method or the “return” statement. The System.out.println() method can be utilized simply in the main() method or in any user-defined static method. However, to use the return statement, you have to create a method with a “String” return type and specify the required string with the “return” keyword within the method definition. This post illustrated the methods to return a Java String.

About the author

Farah Batool

I completed my master’s degree in computer science. I am an academic researcher and love to learn and write about new technologies. I am passionate about writing and sharing my experience with the world.

Источник