Data Type Conversions in Java
Tags: java, beginners, programming
Published: 2019-03-27 11:36:55

---
title: Data Type Conversions in Java
published: true
description: A brief guide to popular data type conversions in Java
canonical_url: https://attacomsian.com/blog/data-type-conversions-java
tags: java,beginners,programming
---

*This post was originally published on [attacomsian.com/blog](https://attacomsian.com/blog/data-type-conversions-java).*

---

Unlike PHP or JavaScript, Java is a strongly typed programming language. It essentially means that each variable must be declared with a pre-defined data type which can not be changed afterwards. There are two data types in Java:

* Primitive data types - int, double, float, byte, long, boolean etc.
* Reference data types - Integer, Double, Float, Date, String, Object etc.

In this tutorial, we will focus on type conversion for primitive data types.

## String to int

 There are two methods available for `String` to `int` conversion: `Integer.parseInt()` which returns a primitive `int` and `Integer.valueOf()` which return an `Integer` object.
 
```java
String str = "1050";

int inum = Integer.parseInt(str);   //return primitive
System.out.println(inum);

Integer onum = Integer.valueOf(str); //return object
System.out.println(onum);
 ```
 
## String to long
 
Similar to `int`, we can convert a `String` into a primitive `long` value using `Long.parseLong()`  or an object `Long` via `Long.valueOf()` method.
 
```java
String longStr = "1456755";

long ilong = Long.parseLong(longStr); //return primitive
System.out.println(ilong);

Long olong = Long.valueOf(longStr); //return object
System.out.println(olong);
```
 
## String to float
 
A `String` can be converted to primitive `float` value using `Float.parseFloat()` method. `Float.valueOf()` method can be used to convert a `String` into a `Float` object.
 
```java
String floatStr = "49.78";

float ifloat = Float.parseFloat(floatStr); //return primitive
System.out.println(ifloat);

Float ofloat = Float.valueOf(floatStr); //return object
System.out.println(ofloat);
```

## String to double

`double` and `float` data types may look same but are different in the way that they store the value. `float` is a single precision (32 bit or 4 bytes) floating point data type whereas `double` is a double precision (64 bit or 8 bytes) floating point data type.

A `String` value can be converted to `double` value using `Double.parseDouble()` method. Similarly, `Double.valueOf()` converts a `String` into a `Double` object.

```java
String doubleStr = "99.378";

double idouble = Double.parseDouble(doubleStr); //return primitive
System.out.println(idouble);

Double odouble = Double.valueOf(doubleStr); //return object
System.out.println(odouble);
```

## NumberFormatException

If the `String` does not contain a parsable value during `int`, `float`, or `double` conversion, a `NumberFormatException` is thrown. 

```java
try {
	String exeStr = "14c";
	int exeInt = Integer.parseInt(exeStr);
	System.out.println(exeInt);
} catch (NumberFormatException ex) {
	System.out.println(ex.getMessage());
}
```

## String to boolean

A `String` value can be converted to primitive `boolean` value using `Boolean.parseBoolean` method. For conversion to `Boolean` object, you can use `Boolean.valueOf()` method.

```java
String trueStr = "true";
String falseStr = "false";
String randomStr = "java";

System.out.println(Boolean.parseBoolean(trueStr)); //true
System.out.println(Boolean.valueOf(falseStr)); //false
System.out.println(Boolean.parseBoolean(randomStr)); //false
```

## String to Date

Java provides `SimpleDateFormat` class for formatting and parsing dates. It has the following two important method: 

* `parse()` - It converts a `String` value into a `Date` object
* `format()` - It converts the `Date` object into a `String` value

While creating an instance of the `SimpleDateFormat` classes, you need to pass date and time pattern that tells how the instance should parse or format the dates.

```java
String dateStr = "10/03/2019";

SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy");
Date dateObj = format.parse(dateStr);
System.out.println(dateObj);
```

In the example above, I used `dd/MM/yyyy` pattern to parse `10/03/2019` string. `dd` means two digits for the day, `MM` means two digit for the month and `yyyy` means 4 digits for the year. Below is a list of the most common date and time patterns used in `SimpleDateFormat`. For the complete list, please refer to official [JavaDoc](https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html).

| Letter | Description | Examples |
| -------- | -------- | -------- |
| y     | Year     | 2019, 19     |
| M     | Month in year     | March, Mar, 03, 3     |
| d     | Day in month     | 1-31     |
| E     | Date name in week     | Friday-Sunday     |
| a     | Am/pm marker     | AM, PM     |
| H     | Hour in day     | 0-23     |
| h     | Hour in am/pm     | 1-12     |
| m     | Minute in hour     | 0-59     |
| s     | Second in minute     | 0-59     |
| S     | Millisecond in second     | 0-999     |
| z     | General timezone     | Central European Time, PST, GMT +05:00     |


Following are some pattern examples, with examples of how each pattern would parse a date or vice versa:

```text
yyyy/MM/dd  <--> (2019/03/09)

dd-MM-YYYY  <-->  (10-03-2019)

dd-MMM-yy  <-->  (13-Feb-19)

EEE, MMMM dd, yyy  <--> (Fri, March 09, 2019)

yyyy-MM-dd HH:mm:ss <--> (2019-02-28 16:45:23)

hh:mm:ss a <--> (11:23:36 PM)

yyyy-MM-dd HH:mm:ss.SSS Z <--> (2019-01-31 21:05:46.555 +0500)
```

## Date to String

As we discussed above, `SimpleDateFormat` also supports formatting of dates into strings. Here is an example that formats the date into a string:

```java
Date date = Calendar.getInstance().getTime(); // OR new Date()

SimpleDateFormat dateFormat = new SimpleDateFormat("EEEE, MMMM dd, yyyy HH:mm:ss.SSS Z");

String formatStr = dateFormat.format(date);
System.out.println(formatStr);
```

The above code snippet will print the following depending on your location:

```text
Sunday, March 10, 2019 20:01:22.417 +0500
```

## Date to ISO 8601 String

[ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) is an international standard that covers the exchange of date- and time-related data. There ere several ways to express date and time in ISO format:

```text
2019-03-30T14:22:15+05:00
2019-03-30T09:22:15Z
20190330T092215Z
```

Here is an example to convert a date object into an ISO 8601 equivalent string in Java:

```java
TimeZone timeZone = TimeZone.getTimeZone("UTC");
SimpleDateFormat isoFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
isoFormat.setTimeZone(timeZone);
String isoFormatStr = isoFormat.format(new Date());
System.out.println(isoFormatStr);
```

Following are the date and time patterns for ISO format:

| Pattern | ISO Date Format |
| -------- | -------- |
| yyyy-MM-dd'T'HH:mm:ssXXX     | 2019-03-30T14:22:15+05:00     |
| yyyy-MM-dd'T'HH:mm:ss'Z'     | 2019-03-30T09:22:15Z     |
| yyyyMMdd'T'HHmmss'Z'     | 20190330T092215Z     |

> **Source code:** Download the complete source code from [GitHub](https://github.com/attacomsian/code-examples/tree/master/core-java/conversions) available under MIT license.

## Conclusion

Data type conversions are very common for a developer. Most of these conversions are trivial and are well-known to an experienced programmer. However, string to date conversion is a bit tricky especially for beginners. You may encounter errors if the pattern is not specified correctly. But if you spend some time to remember these patterns, it may save a lot of time while figuring out why a certain conversion is not compiling or executing.

Am I missing any important type conversion in this tutorial? Send me a [tweet](https://twitter.com/attacomsian) any time to let me know.


---

✌️ I write about **modern JavaScript, Node.js, Spring Boot**, and all things **web development**. [**Subscribe to my newsletter**](https://attacomsian.com/newsletter) to get web development tutorials & protips every week.