Ufdjrw

The purpose of this method is replace all but the first and last letters of each word with "_". I'm a complete novice when it comes to coding, so I'm certain my code is fairly incorrect. I think where my code starts functioning improperly is with the while loop.

EDIT: How do I make this method without using arrays or extra methods, like the split method?

public static String blankWords(String s1) 

 StringBuilder sb = new StringBuilder();
 if(s1.length() > 2) 
 sb.append(s1.charAt(0));
 for(int x = 1; x < s1.length() - 1; x = x + 1) 
 char y = ' ';
 while(y != s1.charAt(x)) 
 sb.append("_");
 x = x + 1;
 
 
 sb.append(s1.charAt(s1.length() - 1));
 return sb.toString();
 
 return s1;
 

What my code is outputting:

HW2.blankWords("This is a Test.")
java.lang.StringIndexOutOfBoundsException: String index out of range: 15
at java.lang.String.charAt(Unknown Source)
at HW2.blankWords(HW2.java:73)

What my code should output:

HW2.blankWords("This is a Test.")
"T__s is a T__t."

Here is a pretty simple solution:

class Scratch 
 public static void main(String[] args) 
 System.out.println(blankWords("My name is sam orozco"));
 

 public static String delim = "_";

 public static String blankWords(String s1) 
 // this split arg on one or more space
 String[] words = s1.split("\s+");
 StringBuilder response = new StringBuilder();
 for (String val : words) 
 val = convertWord(val);
 response.append(val).append(" ");
 
 return response.toString().trim();
 


 public static String convertWord(String val) 
 int len = val.length();
 StringBuilder bldr = new StringBuilder();
 int index = 0;
 for (char ch : val.toCharArray()) index == len - 1) 
 bldr.append(ch);
 else 
 bldr.append(delim);
 
 index++;
 
 return bldr.toString();
 

You can do this using a StringTokenizer that will extract words based on a list of delimiters. Since you want to keep those delimiters in the output, you'll instruct the tokenizer to return them as tokens:

String blankWords(String s) 
 // build a tokenizer for your string, listing all special chars as delimiters. The last argument says that delimiters are going to be returned as tokens themselves (so we can include them in the output string)
 StringTokenizer tokenizer = new StringTokenizer(s, " .,;:?!()[]", true);
 // a helper class to build the output string; think of it as just a more efficient concat utility
 StringBuilder sb = new StringBuilder();
 while (tokenizer.hasMoreTokens()) 
 String blankWord = blank(tokenizer.nextToken());
 sb.append(blankWord);
 
 return sb.toString();


/**
 * Replaces all but the first and last characters in a string with '_'
 */
private String blank(String word) 
 // strings of up to two chars will be returned as such
 // delimiters will always fall into this category, as they are always single characters
 if (word.length() <= 2) 
 return word;
 
 // no need to iterate through all chars, we'll just get the array
 final char[] chars = word.toCharArray();
 // fill the array of chars with '_', starting with position 1 (the second char) up to the last char (exclusive, i.e. last-but-one)
 Arrays.fill(chars, 1, chars.length - 1, '_');
 // build the resulting word based on the modified array of chars
 return new String(chars);

Here is the contents of a test that validates this implementation, using TestNG:

@Test(dataProvider = "texts")
public void testBlankWords(String input, String expectedOutput) 
 assertEquals(blankWords(input), expectedOutput);


@DataProvider
public Object[][] texts() 
 return new Object[][] 
 "This is a test.", "T__s is a t__t.",
 "This one, again, is (yet another) test!", "T__s o_e, a___n, is (y_t a_____r) t__t!"
 ;

The main drawback of this implementation is that StringTokenizer requires you to list all the delimiters by hand. With a more advanced implementation, you can consider a delimiter any character that returns false for Character.isAlphabetic(c) or however you decide to define your non-word chars.

P.S.
This could be a "more advanced implementation", as I mentioned above:

static String blankWords(String text) 
 final char[] textChars = text.toCharArray();
 int wordStart = -1; // keep track of the current word start position, -1 means no current word
 for (int i = 0; i < textChars.length; i++) 
 if (!Character.isAlphabetic(textChars[i])) 
 if (wordStart >= 0) 
 for (int j = wordStart + 1; j < i - 1; j++) 
 textChars[j] = '_';
 
 
 wordStart = -1; // reset the current word to none
 else if (wordStart == -1) 
 wordStart = i; // alphabetic characters start a new word, when there's none started already
 else if (i == textChars.length - 1) // if the last character is aplhabetic
 for (int j = wordStart + 1; j < i; j++) 
 textChars[j] = '_';
 
 
 
 return new String(textChars);

No while loop necessary!

Look ahead by 1 character to see if it's a space, or if the current character is a space, in that case you append it. Otherwise you make sure to add the next character (skipNext false).

Always add the last character

public static String blankWords(String s1) 
 StringBuilder sb = new StringBuilder();
 if(s1.length() > 2) 
 Boolean skipNext = false;
 for(int x = 0; x < s1.length() - 1; x = x + 1) s1.charAt(x + 1) == ' ') 
 sb.append(s1.charAt(x));
 skipNext = false;
 
 else 
 if(skipNext) 
 sb.append('_');
 
 else 
 sb.append(s1.charAt(x));
 skipNext = true;
 
 

 
 sb.append(s1.charAt(s1.length() - 1));
 return sb.toString();
 
 return s1;

For the more advanced programmer, use regular expression.

public static String blankWords(String s1) 
 return s1.replaceAll("\B\w\B", "_");

This correctly keeps the final t, i.e. blankWords("This is a Test.") returns "T__s is a T__t.".