Extracting characters from a String

[Adrian Burke]

Hi,

I would like to enhance this piece of code to do the following:
- add the characters to a single element in an array.
- add the digits to the next element in the same array.

public class ConvertStringToAscii {
    public static void main(String args[]) {
	
        String test = "ABC123DEF";

        for ( int i = 0; i < test.length(); ++i ) {
            char c = test.charAt( i );
            int charCode = c;
            System.out.println("ASCII value of " + c +" is: " + charCode);
        }
    }
}

Result required is : [ABC, 123, DEF]

Can anyone help?

Thank you in advance

[Matthew Brown]

Hi Adrian. Welcome to The Ranch!

Your code is easier to read if you UseCodeTags. I've added them for you this time.

[Adrian Burke]

Thanks Matthew.

[Nico Van Brandt]

You could do something with Character.IsDigit() or Character.isLetter()?
I think you are smart enough to add some logic around it

[Adrian Burke]

Thanks Nico for the advice.

public class ConvertStringToAscii {
	
	public static void main(String args[]) {
	String test = "ABC123DEF";
	
	String myArr [] = new String[9];
	
	for ( int i = 0; i < test.length(); i++ ) {
	     char c = test.charAt( i );
	    	     
	     if (Character.isLetter(c)){
	    	 myArr[0] += c; 	
	     }
	     if( Character.isDigit(c)) {
	                 myArr[1] += c; 		
	     }
	     if( Character.isLetter(c) ) {
		 myArr[2] += c; 		
	    }
	}
	System.out.println("1st element: " + myArr[0]);
	System.out.println("2nd element: " + myArr[1]);
	System.out.println("3rd element: " + myArr[2]);
	
	}
	
}

Result:
1st element: nullABCDEF
2nd element: null123
3rd element: nullABCDEF

Now, I am having a different problem. All Letter characters are been added to the first element in the array?

Regards,
Adrian.

[Wouter Oet]

I would do something like this (pseudocode):

List<String> strings ... String temp while(hasNextCharacter) { if((previousCharacter.isDigit() && currentCharacter.isLetter()) || (previousCharacter.isLetter() && currentCharacter.isDigit()) { addTempToStrings clearTemp } addCharacterToTemp } addTempToStrings

[Adrian Burke]

Appreciate the pseudocode. Thank you.

public class ExtractString {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String symbol = "ABC123";
		
		List list = new ArrayList();
		for ( int i = 0; i < symbol.length(); i++ ) {
		     char c = symbol.charAt( i );
		     list.add(c);
		}   
		
		ExtractString character = new ExtractString();
		
		Iterator iter = list.iterator();
		while (iter.hasNext()){
			System.out.println(iter.next());
			character.addCharacter((Character)iter.next());
		}
	
	} 
	
	public void addCharacter (char s){
		
		String myArr [] = new String[5];
		if (Character.isLetter(s)){
			myArr[0] += s; 
 		    }
		if( Character.isDigit(s)) {
			myArr[1] += s; 		
		}
		if( Character.isLetter(s) ) {
			myArr[2] += s; 		
		}

	} 
	
	
} 

How can I get the previous index and compare it to the current index going through the iterator? If I could determine the previous character and current character, I could then pass them as arguments to the addCharacter()
Eg : addCharacter(char previousCharacter char currentCharacter)

[Adrian Burke]

Here is a solution offered by my collegue Ed Burke

import java.util.ArrayList;
import java.util.List;

public class ExtractString {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String symbol = "ABC123";
		
		for(String str : extractContinousLettersAndDigits(symbol)) {
			System.out.println(str);
		}
		
	}
	
	
	/**
	 * break the input string into a list of continous letters and/or digits and return this list
	 * @param stringToExtract
	 * @return
	 */
	private static List<String> extractContinousLettersAndDigits(String stringToExtract) {
		
		//list of strings to return
		List<String> strings = new ArrayList<String>();
		
		//The next string to add to the list
		String nextStringToInsert= "" + stringToExtract.charAt(0);
		
		//true if the first char is a digit
		boolean isPreviousCharADigit= Character.isDigit(stringToExtract.charAt(0)) ? true : false;
		
		for(int i=1; i<stringToExtract.length(); i++){
			
			if(isPreviousCharADigit) {
				if(Character.isDigit(stringToExtract.charAt(i))) { //another digit - add to the string to insert
					nextStringToInsert += stringToExtract.charAt(i);
				} else { //a letter, add the string to insert to the list
					isPreviousCharADigit = false;
					if(nextStringToInsert.length() > 0) {
						strings.add(nextStringToInsert);
						nextStringToInsert=""+stringToExtract.charAt(i); //start the next string to insert
					}
				}
			} else { //last char was a letter
				if(Character.isLetter(stringToExtract.charAt(i))) { //another letter - add to the string to insert
					nextStringToInsert += stringToExtract.charAt(i);
				} else { //a digit - add the string to insert to the list
					isPreviousCharADigit = true;
					if(nextStringToInsert.length() > 0) {
						strings.add(nextStringToInsert);
						nextStringToInsert=""+stringToExtract.charAt(i); //start the next string to insert
					}
				}
			}
		}
		if(nextStringToInsert.length()>0) { //add the last string of digit / letters
			strings.add(nextStringToInsert);
		}
		
		return strings;
		
	}

} 

Thanks Ed for your help..

[Rob Spoor]

I see two issues with that:
1) if the String is empty it will throw an exception (StringIndexOutOfBoundsException if I recall correctly)
2) the String concatenation is not that efficient. Switching to StringBuilder would be better.

import java.util.ArrayList;
import java.util.List;

public class ExtractString {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String symbol = "ABC123";
		
		for(String str : extractContinousLettersAndDigits(symbol)) {
			System.out.println(str);
		}
		
	}
	
	
	/**
	 * break the input string into a list of continous letters and/or digits and return this list
	 * @param stringToExtract
	 * @return
	 */
	private static List<String> extractContinousLettersAndDigits(String stringToExtract) {
		
		//list of strings to return
		List<String> strings = new ArrayList<String>();

		if (stringToExtract.length() == 0) {
			// nothing to extract
			return strings;
		}
		
		//The next string to add to the list, as a StringBuilder
		StringBuilder nextStringToInsert = new StringBuilder(stringToExtract.length()); // maximum length any element will ever have
		nextStringToInsert.append(stringToExtract.charAt(0));
		
		//true if the first char is a digit
		boolean isPreviousCharADigit= Character.isDigit(stringToExtract.charAt(0)) ? true : false;
		
		for(int i=1; i<stringToExtract.length(); i++){
			
			if(isPreviousCharADigit) {
				if(Character.isDigit(stringToExtract.charAt(i))) { //another digit - add to the string to insert
					nextStringToInsert.append(stringToExtract.charAt(i));
				} else { //a letter, add the string to insert to the list
					isPreviousCharADigit = false;
					if(nextStringToInsert.length() > 0) {
						strings.add(nextStringToInsert.toString());
						nextStringToInsert.delete(0, nextStringToInsert.length()); // clear the contents
						nextStringToInsert.append(stringToExtract.charAt(i)); //start the next string to insert
					}
				}
			} else { //last char was a letter
				if(Character.isLetter(stringToExtract.charAt(i))) { //another letter - add to the string to insert
					nextStringToInsert.append(stringToExtract.charAt(i));
				} else { //a digit - add the string to insert to the list
					isPreviousCharADigit = true;
					if(nextStringToInsert.length() > 0) {
						strings.add(nextStringToInsert.toString());
						nextStringToInsert.delete(0, nextStringToInsert.length()); // clear the contents
						nextStringToInsert.append(stringToExtract.charAt(i)); //start the next string to insert
					}
				}
			}
		}
		if(nextStringToInsert.length()>0) { //add the last string of digit / letters
			strings.add(nextStringToInsert.toString());
		}
		
		return strings;
		
	}

} 

The only differences are:
- return strings without doing anything if the String is empty.
- nextStringToInsert becomes a StringBuilder, with the String size as capacity, and initial contents the first character.
- don't add nextStringToInsert to the List but nextStringToInsert converted into a String (toString()).
- appending is done by using the append method instead of +=
- re-initializing is done by removing the current contents (delete(...)), then adding the next character.