Java Top

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:


1. Overview

In this quick article, we’ll explore some simple conversions of String objects to different data types supported in Java.

2. Converting String to int or Integer

If we need to convert a String to primitive int or Integer wrapper type, we can use either the parseInt() or valueOf() APIs to get the corresponding int or Integer return value:

public void whenConvertedToInt_thenCorrect() {
    String beforeConvStr = "1";
    int afterConvInt = 1;

    assertEquals(Integer.parseInt(beforeConvStr), afterConvInt);

public void whenConvertedToInteger_thenCorrect() {
    String beforeConvStr = "12";
    Integer afterConvInteger = 12;

    assertEquals(Integer.valueOf(beforeConvStr).equals(afterConvInteger), true);

3. Converting String to long or Long

If we need to convert a String to primitive long or Long wrapper type, we can use parseLong() or valueOf() respectively:

public void whenConvertedTolong_thenCorrect() {
    String beforeConvStr = "12345";
    long afterConvLongPrimitive = 12345;

    assertEquals(Long.parseLong(beforeConvStr), afterConvLongPrimitive);

public void whenConvertedToLong_thenCorrect() {
    String beforeConvStr = "14567";
    Long afterConvLong = 14567l;

    assertEquals(Long.valueOf(beforeConvStr).equals(afterConvLong), true);

4. Converting String to double or Double

If we need to convert a String to primitive double or Double wrapper type, we can use parseDouble() or valueOf() respectively:

public void whenConvertedTodouble_thenCorrect() {
    String beforeConvStr = "1.4";
    double afterConvDoublePrimitive = 1.4;

    assertEquals(Double.parseDouble(beforeConvStr), afterConvDoublePrimitive, 0.0);

public void whenConvertedToDouble_thenCorrect() {
    String beforeConvStr = "145.67";
    double afterConvDouble = 145.67d;

    assertEquals(Double.valueOf(beforeConvStr).equals(afterConvDouble), true);

5. Converting String to ByteArray

In order to convert a String to a byte array, getBytes() encodes the String into a sequence of bytes using the platform’s default charset, storing the result into a new byte array.

The behavior of getBytes() is unspecified when the passed String cannot be encoded using the default charset. As per the java documentation, the java.nio.charset.CharsetEncoder class should be used when more control over the encoding process is required:

public void whenConvertedToByteArr_thenCorrect() {
    String beforeConvStr = "abc";
    byte[] afterConvByteArr = new byte[] { 'a', 'b', 'c' };

    assertEquals(Arrays.equals(beforeConvStr.getBytes(), afterConvByteArr), true);

6. Converting String to CharArray

In order to convert a String to a CharArray instance, we can simply use toCharArray():

public void whenConvertedToCharArr_thenCorrect() {
    String beforeConvStr = "hello";
    char[] afterConvCharArr = { 'h', 'e', 'l', 'l', 'o' };

    assertEquals(Arrays.equals(beforeConvStr.toCharArray(), afterConvCharArr), true);

7. Converting String to boolean or Boolean

To convert a String instance to primitive boolean or Boolean wrapper type, we can use parseBoolean() or valueOf() APIs respectively:

public void whenConvertedToboolean_thenCorrect() {
    String beforeConvStr = "true";
    boolean afterConvBooleanPrimitive = true;

    assertEquals(Boolean.parseBoolean(beforeConvStr), afterConvBooleanPrimitive);

public void whenConvertedToBoolean_thenCorrect() {
    String beforeConvStr = "true";
    Boolean afterConvBoolean = true;

    assertEquals(Boolean.valueOf(beforeConvStr), afterConvBoolean);

8. Converting String to Date or LocalDateTime

Java 6 provides the java.util.Date datatype for representing dates. Java 8 introduced new APIs for Date and Time to address the shortcomings of the older java.util.Date and java.util.Calendar.

You can read this article for more details.

8.1. Converting String to java.util.Date

In order to convert String objects to Date objects, we need to first construct a SimpleDateFormat object by passing the pattern describing the date and time format.

For example, a possible value for pattern could be “MM-dd-yyyy” or “yyyy-MM-dd”. Next, we need to invoke parse method passing the String.

The String passed as an argument should be in the same format as the pattern. Otherwise, a ParseException will be thrown at runtime:

public void whenConvertedToDate_thenCorrect() throws ParseException {
    String beforeConvStr = "15/10/2013";
    int afterConvCalendarDay = 15;
    int afterConvCalendarMonth = 9;
    int afterConvCalendarYear = 2013;
    SimpleDateFormat formatter = new SimpleDateFormat("dd/M/yyyy");
    Date afterConvDate = formatter.parse(beforeConvStr);
    Calendar calendar = new GregorianCalendar();

    assertEquals(calendar.get(Calendar.DAY_OF_MONTH), afterConvCalendarDay);
    assertEquals(calendar.get(Calendar.MONTH), afterConvCalendarMonth);
    assertEquals(calendar.get(Calendar.YEAR), afterConvCalendarYear);

8.2. Converting String to java.time.LocalDateTime

LocalDateTime is an immutable date-time object that represents a time, often viewed as year-month-day-hour-minute-second.

In order to convert String objects to LocalDateTime objects, we can simply use the parse API:

public void whenConvertedToLocalDateTime_thenCorrect() {
    String str = "2007-12-03T10:15:30";
    int afterConvCalendarDay = 03;
    Month afterConvCalendarMonth = Month.DECEMBER;
    int afterConvCalendarYear = 2007;
    LocalDateTime afterConvDate 
      = new UseLocalDateTime().getLocalDateTimeUsingParseMethod(str);

    assertEquals(afterConvDate.getDayOfMonth(), afterConvCalendarDay);
    assertEquals(afterConvDate.getMonth(), afterConvCalendarMonth);
    assertEquals(afterConvDate.getYear(), afterConvCalendarYear);

The String must represent a valid time according to java.time.format.DateTimeFormatter.ISO_LOCAL_DATE_TIME. Otherwise, a ParseException will be thrown at runtime.

For example ‘2011-12-03‘ represents a valid string format having 4 digits for the year, 2 digits for the month for a year and 2 digits for the day of the month.

9. Conclusion

In this quick tutorial, we have covered different utility methods for converting String objects to different data types supported in java.

The complete source code and all code snippets for this article are available over on GitHub.

Java bottom

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2: