Java Tutorial/Data Type/Convert from String

Convert a String to Date

   <source lang="java">

import java.text.SimpleDateFormat; import java.util.Date; public class Main {

 public static void main(String[] args) throws Exception {
   SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
   Date theDate = dateFormat.parse("01/01/2009");
   System.out.println(dateFormat.format(theDate));
 }

} //01/01/2009</source>

Convert base64 string to a byte array

   <source lang="java">

public class Main {

 public static void main(String[] argv) throws Exception {
   byte[] buf = new byte[] { 0x12, 0x23 };
   String s = new sun.misc.BASE64Encoder().encode(buf);
   buf = new sun.misc.BASE64Decoder().decodeBuffer(s);
 }

}</source>

Converting a String to a byte Number

   <source lang="java">

public class Main {

 public static void main(String[] argv) throws Exception {
   byte b = Byte.parseByte("123");
   System.out.println(b);
 }

}</source>

Converting a String to a int(integer) Number

   <source lang="java">

public class Main {

 public static void main(String[] argv) throws Exception {
   int i = Integer.parseInt("123");
   System.out.println(i);
 }

}</source>

Converting a String to a short Number

   <source lang="java">

public class Main {

 public static void main(String[] argv) throws Exception {
   short s = Short.parseShort("123");
   System.out.println(s);
 }

}</source>

Convert string of time to time object

   <source lang="java">

import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.Date; public class Main {

 public static void main(String[] args) throws Exception {
   String time = "15:30:18";
   DateFormat sdf = new SimpleDateFormat("hh:mm:ss");
   Date date = sdf.parse(time);
   System.out.println("Date and Time: " + date);
 }

}</source>

Convert String to character array

   <source lang="java">

public class Main {

 public static void main(String[] args) {
   String str = "Abcdefg";
   char[] cArray = str.toCharArray();
   for (char c : cArray)
     System.out.println(c);
 }

} /* A b c d e f g

• /</source>

Integer.parseInt(): Converting String to int

   <source lang="java">

public class MainClass {

 public static void main(String[] arg) {
   System.out.println(Integer.parseInt("100"));   
 }

}</source>

100

Integer.valueOf: Converting String to Integer

   <source lang="java">

public class MainClass {

 public static void main(String[] arg) {
   System.out.println(Integer.valueOf("00900"));   
 }

}</source>

900

Number Parsing

Parsing is to do with the conversion of a string into a number or a date.

The purpose of number parsing is to convert a string into a numeric primitive type. Byte, Short, Integer, Long, Float, and Double classes, provide static methods to parse strings. For example, the Integer class has the parseInteger method with the following signature.

   <source lang="java">

public static int parseInt (String s) throws NumberFormatException</source>

Parse basic types

   <source lang="java">

/*

* Copyright 2004, 2005, 2006 Odysseus Software GmbH
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/ 

import java.text.DateFormat; import java.text.Format; import java.text.ParseException; import java.text.ParsePosition; import java.util.Date; import java.util.Locale; import java.util.TimeZone; import java.math.BigDecimal; import java.math.BigInteger; /**

* Parse basic types.
*
* @author Christoph Beck
*/

public class ParseUtils {

 private static Locale locale = Locale.US;
 private static Object nullValue(Class type) {
   if (type.isPrimitive()) {
     if (type == boolean.class)
       return Boolean.FALSE;
     if (type == byte.class)
       return new Byte((byte)0);
     if (type == char.class)
       return new Character((char)0);
     if (type == short.class)
       return new Short((short)0);
     if (type == int.class)
       return new Integer(0);
     if (type == long.class)
       return new Long(0);
     if (type == float.class)
       return new Float(0);
     if (type == double.class)
       return new Double(0);
   }
   return null;
 }
 private static Class objectType(Class type) {
   if (type.isPrimitive()) {
     if (type == boolean.class)
       return Boolean.class;
     if (type == byte.class)
       return Byte.class;
     if (type == char.class)
       return Character.class;
     if (type == short.class)
       return Short.class;
     if (type == int.class)
       return Integer.class;
     if (type == long.class)
       return Long.class;
     if (type == float.class)
       return Float.class;
     if (type == double.class)
       return Double.class;
   }
   return type;
 }
 private static Object parse(Format format, String value) throws ParseException {
   ParsePosition pos = new ParsePosition(0);
   Object result = format.parseObject(value, pos);
   if (pos.getIndex() < value.length())
     throw new ParseException("Cannot parse " + value + " (garbage suffix)!", pos.getIndex());
   return result;
 }
 private static Date parseDate(String value) throws ParseException {
   DateFormat format = DateFormat.getDateInstance(DateFormat.SHORT, locale);
   format.setTimeZone(TimeZone.getTimeZone("GMT"));
   return (Date)parse(format, value);
 }
 private static Boolean parseBoolean(String value) throws ParseException {
   if ("true".equals(value)) {
     return Boolean.TRUE;
   } else if ("false".equals(value)) {
     return Boolean.FALSE;
   } else {
     throw new ParseException("Cannot parse "" + value + "" as boolean", 0);
   }
 }
 private static Character parseCharacter(String value) throws ParseException {
   if (value.length() != 1) {
     throw new ParseException("Cannot parse "" + value + "" as character", value.length());
   }
   return new Character(value.charAt(0));
 }
 /**
  * Parse value of specified type. The string value has to be in
  * standard notation for the specified type.
  */
 public static Object parse(Class type, String value) throws Exception {
   if (value == null) {
     return nullValue(type);
   } else if (value.length() == 0) {
     return type == String.class ? value : nullValue(type);
   }
   type = objectType(type);
   if (type == BigDecimal.class) {
     return new BigDecimal(value);
   } else if (type == BigInteger.class) {
     return new BigInteger(value);
   } else if (type == Boolean.class) {
     return parseBoolean(value);
   } else if (type == Byte.class) {
     return Byte.valueOf(value);
   } else if (type == Character.class) {
     return parseCharacter(value);
   } else if (type == Date.class) {
     return parseDate(value);
   } else if (type == Double.class) {
     return Double.valueOf(value);
   } else if (type == Float.class) {
     return Float.valueOf(value);
   } else if (type == Integer.class) {
     return Integer.valueOf(value);
   } else if (type == Long.class) {
     return Long.valueOf(value);
   } else if (type == Short.class) {
     return Short.valueOf(value);
   } else if (type == String.class) {
     return value;
   }
   throw new ParseException("Cannot parse type " + type, 0);
 }

} /////////////////////// /*

* Copyright 2004, 2005, 2006 Odysseus Software GmbH
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/ 

package de.odysseus.calyxo.base.util; import java.math.BigDecimal; import java.math.BigInteger; import java.util.Date; import junit.framework.TestCase; /**

* ParseUtils test case.
*
* @author Christoph Beck
*/

public class ParseUtilsTest extends TestCase {

 /**
  * Constructor for ParseUtilsTest.
  * @param arg0
  */
 public ParseUtilsTest(String arg0) {
   super(arg0);
 }
 public void testNullPrimitive() throws Exception {
   assertEquals(Boolean.FALSE, ParseUtils.parse(boolean.class, null));
   assertEquals(new Character((char)0), ParseUtils.parse(char.class, null));
   assertEquals(new Byte((byte)0), ParseUtils.parse(byte.class, null));
   assertEquals(new Short((short)0), ParseUtils.parse(short.class, null));
   assertEquals(new Integer(0), ParseUtils.parse(int.class, null));
   assertEquals(new Long(0), ParseUtils.parse(long.class, null));
   assertEquals(new Float(0), ParseUtils.parse(float.class, null));
   assertEquals(new Double(0), ParseUtils.parse(double.class, null));
 }
 public void testPrimitive() throws Exception {
   assertEquals(Boolean.TRUE, ParseUtils.parse(boolean.class, "true"));
   assertEquals(Boolean.FALSE, ParseUtils.parse(boolean.class, "false"));
   assertEquals(new Character((char)10), ParseUtils.parse(char.class, "\n"));
   assertEquals(new Byte((byte)10), ParseUtils.parse(byte.class, "10"));
   assertEquals(new Short((short)10), ParseUtils.parse(short.class, "10"));
   assertEquals(new Integer(10), ParseUtils.parse(int.class, "10"));
   assertEquals(new Long(10), ParseUtils.parse(long.class, "10"));
   assertEquals(new Float(10), ParseUtils.parse(float.class, "10"));
   assertEquals(new Double(10), ParseUtils.parse(double.class, "10"));
 }
 public void testNullObject() throws Exception {
   assertNull(ParseUtils.parse(Boolean.class, null));
   assertNull(ParseUtils.parse(Byte.class, null));
   assertNull(ParseUtils.parse(Character.class, null));
   assertNull(ParseUtils.parse(Short.class, null));
   assertNull(ParseUtils.parse(Integer.class, null));
   assertNull(ParseUtils.parse(Long.class, null));
   assertNull(ParseUtils.parse(Float.class, null));
   assertNull(ParseUtils.parse(Double.class, null));
   assertNull(ParseUtils.parse(BigInteger.class, null));
   assertNull(ParseUtils.parse(BigDecimal.class, null));
   assertNull(ParseUtils.parse(Date.class, null));
   assertNull(ParseUtils.parse(String.class, null));
 }
 public void testObject() throws Exception {
   assertEquals(Boolean.TRUE, ParseUtils.parse(Boolean.class, "true"));
   assertEquals(Boolean.FALSE, ParseUtils.parse(Boolean.class, "false"));
   assertEquals(new Character((char)10), ParseUtils.parse(Character.class, "\n"));
   assertEquals(new Byte((byte)10), ParseUtils.parse(Byte.class, "10"));
   assertEquals(new Short((short)10), ParseUtils.parse(Short.class, "10"));
   assertEquals(new Integer(10), ParseUtils.parse(Integer.class, "10"));
   assertEquals(new Long(10), ParseUtils.parse(Long.class, "10"));
   assertEquals(new Float(10), ParseUtils.parse(Float.class, "10"));
   assertEquals(new Double(10), ParseUtils.parse(Double.class, "10"));
   assertEquals(new BigInteger("10"), ParseUtils.parse(BigInteger.class, "10"));
   assertEquals(new BigDecimal(10), ParseUtils.parse(BigDecimal.class, "10"));
   assertEquals(new Date(0), ParseUtils.parse(Date.class, "1/1/70"));
   assertEquals("foo", ParseUtils.parse(String.class, "foo"));
 }
 public void testBadValues() throws Exception {
   try {
     ParseUtils.parse(Boolean.class, "no");
     fail("Exception expected");
   } catch(Exception e) {}
   try {
     ParseUtils.parse(Character.class, "10");
     fail("Exception expected");
   } catch(Exception e) {}
   try {
     ParseUtils.parse(Byte.class, "abc");
     fail("Exception expected");
   } catch(Exception e) {}
   try {
     ParseUtils.parse(Short.class, "abc");
     fail("Exception expected");
   } catch(Exception e) {}
   try {
     ParseUtils.parse(Integer.class, "abc");
     fail("Exception expected");
   } catch(Exception e) {}
   try {
     ParseUtils.parse(Long.class, "abc");
     fail("Exception expected");
   } catch(Exception e) {}
   try {
     ParseUtils.parse(Float.class, "abc");
     fail("Exception expected");
   } catch(Exception e) {}
   try {
     ParseUtils.parse(Double.class, "abc");
     fail("Exception expected");
   } catch(Exception e) {}
   try {
     ParseUtils.parse(BigInteger.class, "abc");
     fail("Exception expected");
   } catch(Exception e) {}
   try {
     ParseUtils.parse(BigDecimal.class, "abc");
     fail("Exception expected");
   } catch(Exception e) {}
   try {
     ParseUtils.parse(Date.class, "1.1.70");
     fail("Exception expected");
   } catch(Exception e) {}
 }
 public void testBadType() throws Exception {
   try {
     ParseUtils.parse(Cloneable.class, "dolly");
     fail("Exception expected");
   } catch(Exception e) {}
 }
 public static void main(String[] args) {
   junit.textui.TestRunner.run(ParseUtilsTest.class);
 }

}</source>

String.ValueOf

   <source lang="java">

public class MainClass {

  public static void main( String args[] )
  {
     char charArray[] = { "a", "b", "c", "d", "e", "f" };
     boolean booleanValue = true;
     char characterValue = "Z";
     int integerValue = 7;
     long longValue = 10000000000L; // L suffix indicates long
     float floatValue = 2.5f; // f indicates that 2.5 is a float
     double doubleValue = 33.333; // no suffix, double is default
     Object objectRef = "hello"; // assign string to an Object reference
     System.out.printf("char array = %s\n", String.valueOf( charArray ) );
     System.out.printf("part of char array = %s\n",String.valueOf( charArray, 3, 3 ) );
     System.out.printf("boolean = %s\n", String.valueOf( booleanValue ) );
     System.out.printf("char = %s\n", String.valueOf( characterValue ) );
     System.out.printf("int = %s\n", String.valueOf( integerValue ) );
     System.out.printf("long = %s\n", String.valueOf( longValue ) ); 
     System.out.printf("float = %s\n", String.valueOf( floatValue ) ); 
     System.out.printf("double = %s\n", String.valueOf( doubleValue ) ); 
     System.out.printf("Object = %s\n", String.valueOf( objectRef ) );
  } // end main

}</source>

char array = abcdef
part of char array = def
boolean = true
char = Z
int = 7
long = 10000000000
float = 2.5
double = 33.333
Object = hello

sums a list of numbers entered by the user

   <source lang="java">

import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; class ParseDemo {

 public static void main(String args[]) throws IOException {
   BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
   String str;
   int i;
   int sum = 0;
   System.out.println("Enter numbers, 0 to quit.");
   do {
     str = br.readLine();
     try {
       i = Integer.parseInt(str);
     } catch (NumberFormatException e) {
       System.out.println("Invalid format");
       i = 0;
     }
     sum += i;
     System.out.println("Current sum is: " + sum);
   } while (i != 0);
 }

}</source>