Replace a character at a specific index in a string?

I'm trying to replace a character at a specific index in a string.

What I'm doing is:

String myName = "domanokz";
myName.charAt(4) = 'x';

This gives an error. Is there any method to do this?

String are immutable in Java. You can't change them.

You need to create a new string with the character replaced.

String myName = "domanokz";
String newName = myName.substring(0,4)+'x'+myName.substring(5);

Or you can use a StringBuilder:

StringBuilder myName = new StringBuilder("domanokz");
myName.setCharAt(4, 'x');

System.out.println(myName);

Turn the String into a char[], replace the letter by index, then convert the array back into a String.

String myName = "domanokz";
char[] myNameChars = myName.toCharArray();
myNameChars[4] = 'x';
myName = String.valueOf(myNameChars);

String is an immutable class in java. Any method which seems to modify it always returns a new string object with modification.

If you want to manipulate a string, consider StringBuilder or StringBuffer in case you require thread safety.

I agree with Petar Ivanov but it is best if we implement in following way:

public String replace(String str, int index, char replace){		
	if(str==null){
		return str;
	}else if(index<0 || index>=str.length()){
		return str;
	}
	char[] chars = str.toCharArray();
	chars[index] = replace;
	return String.valueOf(chars);		
}

As previously answered here, String instances are immutable. StringBuffer and StringBuilder are mutable and suitable for such a purpose whether you need to be thread safe or not.

There is however a way to modify a String but I would never recommend it because it is unsafe, unreliable and it can can be considered as cheating : you can use reflection to modify the inner char array the String object contains. Reflection allows you to access fields and methods that are normally hidden in the current scope (private methods or fields from another class...).

public static void main(String[] args) {
	String text = "This is a test";
	try {
		//String.value is the array of char (char[])
		//that contains the text of the String
		Field valueField = String.class.getDeclaredField("value");
		//String.value is a private variable so it must be set as accessible 
		//to read and/or to modify its value
		valueField.setAccessible(true);
		//now we get the array the String instance is actually using
		char[] value = (char[])valueField.get(text);
		//The 13rd character is the "s" of the word "Test"
		value[12]='x';
        //We display the string which should be "This is a text"
		System.out.println(text);
	} catch (NoSuchFieldException | SecurityException e) {
		e.printStackTrace();
	} catch (IllegalArgumentException e) {
		e.printStackTrace();
	} catch (IllegalAccessException e) {
		e.printStackTrace();
	}
}

You can overwrite a string, as follows:

String myName = "halftime";
myName = myName.substring(0,4)+'x'+myName.substring(5);  

Note that the string myName occurs on both lines, and on both sides of the second line.

Therefore, even though strings may technically be immutable, in practice, you can treat them as editable by overwriting them.

First thing I should have noticed is that charAt is a method and assigning value to it using equal sign won't do anything. If a string is immutable, charAt method, to make change to the string object must receive an argument containing the new character. Unfortunately, string is immutable. To modify the string, I needed to use StringBuilder as suggested by Mr. Petar Ivanov.

You can overwrite on same string like this

String myName = "domanokz";
myName = myName.substring(0, index) + replacement + myName.substring(index+1); 

where index = the index of char to replacement. index+1 to add rest of your string

this will work

   String myName="domanokz";
   String p=myName.replace(myName.charAt(4),'x');
   System.out.println(p);

Output : domaxokz