Thread: I wanted to output the string itself, but the output looks like it's been encrypted or something

Hi, I'm trying to fix a string from "hollo werld" to "hello world". To do this, I made another string of what we want, turned both of them into char arrays, and iterated through, changing elements as needed in a for loop. Here's what I have:

Here's the method definition:

package samsExperiments;
 
public class StaticMethodExample {	
 
	//fix "Hollo Werld" to "Hello World"
 
	public static String fixBadStr(char[] badStrToChars, char[] goodStrToChars) {
		for(int i = 0; i < badStrToChars.length; i++) {
			if(badStrToChars[i] != goodStrToChars[i]) {
				badStrToChars[i] = goodStrToChars[i];//badStrToChars[i].replace
			}
		}
		String backToStr = badStrToChars.toString();
		return backToStr;
	}
}

Here's where the method is called:

package samsExperiments;
 
import java.util.Scanner;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Vector;
import java.util.Hashtable;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Random;
 
import static samsExperiments.StaticMethodExample.*;
 
import java.lang.StringBuilder;
import java.text.DecimalFormat;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.Map;
 
import customExceptions.IntegerOutOfRangeException;
 
public class SamsExperimentsMain {
 
	public static void main(String[] args){
 
		String badStr = "Hollo Werld";
		String goodStr = "Hello World";
		char[] badStrToChars = badStr.toCharArray();
		char[] goodStrToChars = goodStr.toCharArray();
		String backToStr = StaticMethodExample.fixBadStr(badStrToChars, goodStrToChars);
		System.out.println(backToStr);
 
	}//end of main method	
 
}//end of class

The output is "[C@55f96302". What happened? Why isn't the output "Hello World"?

It works! Thanks Norm:

public static String fixBadStr(char[] badStrToChars, char[] goodStrToChars) {
		for(int i = 0; i < badStrToChars.length; i++) {
			if(badStrToChars[i] != goodStrToChars[i]) {
				badStrToChars[i] = goodStrToChars[i];//badStrToChars[i].replace
			}
		}
		String backToStr = String.valueOf(goodStrToChars);
		return backToStr;
	}

Norm, I am getting way closer! The IndexOutOfBoundsException problem is gone. Below is my updated code:

FixString.java

package samsExperiments;
import java.util.Scanner;
import java.util.ArrayList;
import java.lang.StringBuilder;
 
public class FixString {		
 
	public String fixBadStrWithArrayList(String badStr, String goodStr) {
		ArrayList<Character> badStrToChars = new ArrayList<>();
		for(int x = 0; x < badStr.length(); x++) {
			badStrToChars.add(badStr.charAt(x));
		}
		System.out.println(badStrToChars);
		int badSize = badStrToChars.size();
		ArrayList<Character> goodStrToChars = new ArrayList<>();
		for(int y = 0; y < goodStr.length(); y++) {
			goodStrToChars.add(goodStr.charAt(y));
		}
		System.out.println(goodStrToChars);
		int goodSize = goodStrToChars.size();
		if(badSize < goodSize) {
			System.out.println("badStr size before increase = " + badSize);
			badStrToChars.ensureCapacity(goodSize);
			System.out.println("badStr size after increase = " + badStrToChars.size() + ", " + badSize);
		}
		else if(goodSize < badSize) {
			System.out.println("goodStr size before increase = " + goodSize);
			goodStrToChars.ensureCapacity(badSize);
			System.out.println("goodStr size after increase = " + goodStrToChars.size() + ", " + goodSize);
		}
		for(int i = 0; i < badStrToChars.size()-1; i++) {
			if(badStrToChars.get(i) != goodStrToChars.get(i)) {//if the current badStr char is not what it's 
															   //supposed to be,
				badStrToChars.set(i, goodStrToChars.get(i));//then replace it with the correct goodStr char.
			}			
		}
		System.out.println("Bad char array size " + badSize);
		System.out.println("Good char array size " + goodSize);
		if(badStrToChars.size() > goodStrToChars.size()) {//if there are still extra chars that don't belong there,
			badStrToChars.subList(goodSize, badStrToChars.size()).clear();//then trim them off the fixed badStr.
		}
		StringBuilder str = new StringBuilder();
		for(char z : badStrToChars) {
			str.append(z);
		}
		String backToStr = String.valueOf(str);
		return backToStr;
	}
}

SamsExperimentsMain.java

package samsExperiments;
 
import java.util.Scanner;
import java.util.Arrays;
import SortingAlgorithms.*;
import customExceptions.BuiltInExceptions;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Vector;
import java.util.Hashtable;
import java.util.Map;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.ListIterator;
 
public class SamsExperimentsMain {
 
	public static void main(String[] args){	
		SamsDataStructures x = new SamsDataStructures();
 
		FixString z = new FixString();
 
		System.out.println("What is the bad string?");
		Scanner a = new Scanner(System.in);
		String badStr = a.nextLine();
		System.out.println("What do you want the string to be?");
		Scanner b = new Scanner(System.in);
		String goodStr = b.nextLine();
		String backToStr = z.fixBadStrWithArrayList(badStr, goodStr);
		System.out.println("Our bad string is now changed to: " + backToStr);		
 
	}//end of main method	
 
}//end of class

When the goodStr is longer than the badStr, the output is mostly as expected, except I don't understand why the goodStrToChars arraylist size stays at 11 instead of increasing to 12 like it's supposed to:
Output:
What is the bad string?
holllo werld
What do you want the string to be?
hello world
[h, o, l, l, l, o, , w, e, r, l, d]
[h, e, l, l, o, , w, o, r, l, d]
goodStr size before increase = 11
goodStr size after increase = 11, 11
Bad char array size 12
Good char array size 11
Our bad string is now changed to: hello world

When the badStr is longer than the goodStr, notice that the returned backToStr prints out as "holllo werd" instead of "holllo werld":
Output:
What is the bad string?
hello world
What do you want the string to be?
holllo werld
[h, e, l, l, o, , w, o, r, l, d]
[h, o, l, l, l, o, , w, e, r, l, d]
badStr size before increase = 11
badStr size after increase = 11, 11
Bad char array size 11
Good char array size 12
Our bad string is now changed to: holllo werd

What is up with that? Any idea as to why the l is the char that is left out?

Originally Posted by Norm

What is the code supposed to do?
Can you add some comments to the code saying what it is trying to do?
Describe what the program will do when the Strings are the same length and what it is supposed to do when one String is longer than the other.

The overall goal of this entire program is to overwrite the old badStr with the goodStr, regardless of what length the strings are. The overwritten badStr is the fixed version that of the badStr, and it's only fixed if it's exactly the same as the goodStr. Here you go:

FixString.java

package samsExperiments;
import java.util.Scanner;
import java.util.ArrayList;
import java.lang.StringBuilder;
 
public class FixString {		
 
	public String fixBadStrWithArrayList(String badStr, String goodStr) {
		ArrayList<Character> badStrToChars = new ArrayList<>();
		for(int x = 0; x < badStr.length(); x++) {
			badStrToChars.add(badStr.charAt(x));
		}
		System.out.println(badStrToChars);
		int badSize = badStrToChars.size();
		ArrayList<Character> goodStrToChars = new ArrayList<>();
		for(int y = 0; y < goodStr.length(); y++) {
			goodStrToChars.add(goodStr.charAt(y));
		}
		System.out.println(goodStrToChars);
		int goodSize = goodStrToChars.size();
		if(badSize < goodSize) {
			System.out.println("badStr size before increase = " + badSize);
			badStrToChars.ensureCapacity(goodSize);
			System.out.println("badStr size after increase = " + badStrToChars.size() + ", " + badSize);
		}
		else if(goodSize < badSize) {
			System.out.println("goodStr size before increase = " + goodSize);
			goodStrToChars.ensureCapacity(badSize);
			System.out.println("goodStr size after increase = " + goodStrToChars.size() + ", " + goodSize);
		}
		for(int i = 0; i < badStrToChars.size()-1; i++) {
			if(badStrToChars.get(i) != goodStrToChars.get(i)) {//if the current badStr char is not what it's 
															   //supposed to be (if the char in the current 
															   //badStrToChars index position is not the same  
															   //as the char in the same index position of the
															   //goodStrToChars),
				badStrToChars.set(i, goodStrToChars.get(i));//then replace the badStrToChars char with the
															//goodStrToChars char.
			}			
		}
		System.out.println("Bad char array size " + badSize);
		System.out.println("Good char array size " + goodSize);
		if(badStrToChars.size() > goodStrToChars.size()) {//if there are still extra chars that don't belong there
														  //(which will happen if the badStr is longer than the 
														  //goodStr),
			badStrToChars.subList(goodSize, badStrToChars.size()).clear();//then trim them off the fixed badStr.
		}
		//Allow the now overwritten badStrToChars arraylist to become an official String,
		//so that we can return as a String, as the user originally entered it in as:
		StringBuilder str = new StringBuilder();
		for(char z : badStrToChars) {
			str.append(z);
		}
		String backToStr = String.valueOf(str);
		return backToStr;//return the overwritten and converted version of the badStr
	}
}

SamsExperimentsMain.java

package samsExperiments;
 
import java.util.Scanner;
import java.util.Arrays;
import SortingAlgorithms.*;
import customExceptions.BuiltInExceptions;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Vector;
import java.util.Hashtable;
import java.util.Map;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.ListIterator;
 
public class SamsExperimentsMain {
 
	public static void main(String[] args){	
		SamsDataStructures x = new SamsDataStructures();
 
		FixString z = new FixString();
 
		System.out.println("What is the bad string?");
		Scanner a = new Scanner(System.in);
		String badStr = a.nextLine();
		System.out.println("What do you want the string to be?");
		Scanner b = new Scanner(System.in);
		String goodStr = b.nextLine();
		String backToStr = z.fixBadStrWithArrayList(badStr, goodStr);
		System.out.println("Our bad string is now changed to: " + backToStr);		
 
	}//end of main method	
 
}//end of class

The only thing that doesn't work yet is when the goodStr is longer than the badStr. The effect of that situation is as follows:
Output:
What is the bad string?
hello world
What do you want the string to be?
holllo werld
[h, e, l, l, o, , w, o, r, l, d]
[h, o, l, l, l, o, , w, e, r, l, d]
badStr size before increase = 11
badStr size after increase = 11, 11
Bad char array size 11
Good char array size 12
Our bad string is now changed to: holllo werd

So any idea to what happened to the l in werld?