Ubuntu 24.04, codenamed “Noble Numbat”, is the latest LTS release and is available for download on Ubuntu’s official page. We can install Java on Ubuntu 24.04 and benefit from its latest features. For this purpose, we can use different package managers like apt, SDKMAN, etc.

How to Install Java on Ubuntu 24.04

To install Java on Ubuntu 24.04, we can use the “Apt” package manager, “Deb” package, or “SDKMAN”. Let’s start with the apt package manager.

Method 1: Installing Java on Ubuntu 24.04 Using Apt

apt is a well-known command-line tool that can be used to install the default or any specific Java version. This can be done by installing JDK or JRE. The JRE package installs only the components needed to run Java programs, while the JDK package enables both running and developing Java programs. Therefore, it is recommended to install JDK instead of JRE on Ubuntu. 

Follow the given stepwise instructions to install Java on Ubuntu 24.04 using Apt.

Step 1: Update and Upgrade System Repositories

Before installing Java, first, execute the provided command to update and upgrade the repository:

sudo apt update && sudo apt upgrade -y

Once the system repositories are updated and upgraded, we can proceed to the next step.

Step 2: Check Available Java Versions

To check all available Java versions, execute the following command:

javac --version

The output snippet shows that Java isn’t yet installed on our machine, but it shows several versions that we can install on Ubuntu 24.04:

You can pick the desired Java version and execute the corresponding command to install it on your system.

Step 3: Install Java Using Apt

From the available Java versions, select the desired one, and execute the below-given command to install it on Ubuntu 24.04:

sudo apt install default-jdk -y

On successful execution of this command, the default jdk will be installed on Ubuntu, as shown in the following screenshot. 

If you want to install any specific Java version, replace “default-jdk” with the specific version(that you want to install), like this:

sudo apt install java_version

Step 4: Verify Java Installation

To confirm Java’s installation on Ubuntu 24.04, run the following command that retrieves the currently installed Java version:

java --version

The output confirms the successful installation of “openjdk 21.0.3” on our Ubuntu 24.04 machine:

Method 2: Installing Java on Ubuntu 24.04 Using Deb

We can download the Java deb package using wget command and install it using the apt command. For better understanding, walk through the below-given stepwise instructions:

Step 1: Download Deb Package

The wget is a command line utility that lets us download files from the web. Execute the below-given “wget” command to download the Java deb package from Oracle’s official page:

sudo wget https://download.oracle.com/java/21/latest/jdk-21_linux-x64_bin.deb

Step 2: Install Java Using Deb

Now execute the following command to install Java from the deb package:

sudo apt install ./jdk-21_linux-x64_bin.deb

Step 3: Confirm Java Installation

Finally, we can run the given command to verify the Java’s installation on Ubuntu 24.04:

java --version

Method 3: Installing Java on Ubuntu 24.04 Using SDKMAN

SDKMAN is a command-line utility tool that allows us to install and manage multiple versions of software development kits (SDKs) on a system. We can use it to install different versions of Java JDK and switch between them.

To install Java on Ubuntu 24.04 using SDKMAN, follow the steps below:

Step 1: Install Dependencies for SDKMAN

First, execute the given command to install the essential dependencies for SDKMAN:

sudo apt install curl zip -y

Step 2: Run the SDKMAN Script

After installing the required dependencies, we can run the below-provided command to download and execute the SDKMAN script on our Ubuntu 24.04:

curl -s "https://get.sdkman.io" | bash

This command uses curl to download the SDKMAN script from the URL “get.sdkman.io”, and then pipes it to bash to execute it. On successful execution, the following output appears on the screen:

Now execute the given “source” command to save the changes:

source "/home/linuxuser/.sdkman/bin/sdkman-init.sh"

Step 3: Confirm the Installation of SDKMAN

You can confirm the SDKMAN installation using the following command:

sdk version

Step 4: Check Available Java Versions

Once SKD is successfully installed, use the given command to check the available Java versions (that can be installed using SDKMAN):

sdk list java

Choose the version that you want to install on your system and hit the q button to exit.

Step 5: Install Java Using SDKMAN

Now run the following sdk command to install Java on Ubuntu 24.04:

sdk install java identifier

Replace the “identifier” with a specific Java version like “17.0.11”, and run the command:

sdk install java 17.0.11-amzn

Step 6: Verify Java Installation 

Finally, we can check the installed Java version to confirm the installation:

java --version

Switching Default Java Version on Ubuntu 24.04

If we’ve multiple Java versions installed on our system, we can switch between them by executing the following command:

sudo update-alternatives --config java

Press the “Enter” key to keep the default Java version or select the preferred Java version by specifying the corresponding selection number:

Setting JAVA_HOME Environment Variable on Ubuntu 24.04

To set the JAVA_HOME environment variable on Ubuntu, open the “/etc/environment” file in the nano editor by executing the below-given command:

sudo nano /etc/environment

Now specify the path of the selected Java version in the “/etc/environment” file to set the JAVA_HOME environment variable:

JAVA_HOME="/usr/lib/jvm/java-21-openjdk-amd64/bin/java"

Hit the “CTRL+S” and “CTRL+X” to save the changes and exit the nano editor:

Now execute the given command to reload the “/etc/environment” file and apply changes to the current session: 

source /etc/environment

Now run the given command to ensure the JAVA_HOME is Set:

echo $JAVA_HOME

How to Uninstall Java From Ubuntu 24.04

If Java is no longer needed, we can uninstall/remove it to free up some space. However, uninstallation of Java depends on the installation method.

Method 1: Uninstalling Java From Ubuntu 24.04 Using Apt

If we install Java on our Ubuntu 24.04 using Apt, we can completely uninstall it using the following command: 

sudo apt autoremove java* -y

Method 2: Uninstalling Java From Ubuntu 24.04 Using Deb

If Java is installed on Ubuntu using the deb package, we can remove it from the system by executing the following command:

sudo apt autoremove jdk-21 -y

Method 3: Removing Java From Ubuntu Using SDKMAN

Execute the below-given command to uninstall Java installed via SDKMAN on Ubuntu: 

sdk uninstall --force java 17.0.11-amzn

This sums up the installation and uninstallation of Java on Ubuntu 24.04.

Final Thoughts

Java is a versatile programming language that can be installed on Ubuntu 24.04 using “apt”, “deb”, or “SDKMAN”. All the mentioned methods let us install the latest version of Java on Ubuntu 24.04. However, each method has its pros and cons, you can choose an installation method according to your requirements. For instance, Java installation using apt and deb is faster and easier while SDKMAN helps us install multiple Java versions and switch between them.

The “currentTimeMillis()” is a built-in method of the System class that retrieves the number of milliseconds passed since 1970. These retrieved milliseconds represent the current Timestamp in Java. Here is a simple example that demonstrates the practical implementation of the stated method in Java:

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class CurrentTS {
  public static void main(String[] args) {
//Getting the Current DateTime in Milliseconds
long currentTS = System.currentTimeMillis();
System.out.println("The Current Timestamp in Milliseconds == " + currentTS);

//Converting Milliseconds to Human-readable Date Format
DateFormat formatedTS = new SimpleDateFormat("dd MMM yyyy HH:mm:ss:SSS Z");
Date resultantTS = new Date(currentTS);
System.out.println("The Formated Current Timestamp == " + formatedTS.format(resultantTS));
}
}

Code Explanation

• First, we import the required classes like “DateFormat”, “SimpleDateFormat”, and “Date” from their respective packages.
• In the main() method, we invoke the “currentTimeMillis()” method of the System class to get the current timestamp in milliseconds. We store the retrieved milliseconds in a long-type variable named “currentTS”.
• In the next line, we use the println() method to print the current timestamp in milliseconds on the console.
• After this, we use the SimpleDateFormat class to convert the obtained current timestamp in milliseconds to a specific format.
• Next, we invoke the Date() constructor and pass the currentTS to it as an argument. This will convert the milliseconds (long type) to a date instance. 
• Finally, we invoke the format() method on the current timestamp to convert it into a specific pattern/format.

Method 2: Getting the Current Timestamp Using the Date Class

We can invoke the constructor of the Date class to get the current DateTime with millisecond precision, as shown in the following code:

import java.util.Date;

public class CurrentTS {
    public static void main(String[] args) {
//Getting the Current DateTime
Date currentTS = new Date();
System.out.println("The Current Timestamp == " + currentTS);

//Converting Current Timestamp in Milliseconds
System.out.println("The Current Timestamp in Milliseconds == " + currentTS.getTime());

}
}

Code Explanation

• First, we invoke the Date() constructor to get the current timestamp and println() method to print it on the console.
• In the next line, we invoke the getTime() method on the currentTS instance to convert the current timestamp into milliseconds.

Method 3: Getting the Current Timestamp in Java Using java.time.Instant

Java introduces a new DateTime API in the time package (Instant) that represents a specific instantaneous point on the timeline. This instantaneous point is independent of any specific timezone or calendar. Using the instant class we can store the DateTime values in UTC timezone as well. In the below code snippet, we use the Instant class to get the current timestamp:

import java.time.*;

public class CurrentTS {
    public static void main(String[] args) {
//Getting Current DateTime
Instant currentTS = Instant.now();
System.out.println("The Current Timestamp == " + currentTS);

//Converting Current DateTime into Milliseconds
System.out.println("The Current Timestamp in Milliseconds == " + currentTS.toEpochMilli());

}
}

Code Explanation

• First, we import the Instant class from the “time” package and then use it to invoke the now() method to get the current instant. We store the retrieved instant/timestamp in a variable named “currentTS”.
• Next, we invoke the toEpochMilli() method on the currentTS to convert the current instant into milliseconds:

Method 4: Getting the Current Timestamp in Java Using the Timestamp Class

Timestamp is an inbuilt Java class that belongs to the “java.sql” package. We can use the constructor of the stated class to get the current DateTime with millisecond precision, as demonstrated in the below example:

import java.sql.Timestamp;

public class CurrentTS {
    public static void main(String[] args) {
Timestamp currentTS = new Timestamp(System.currentTimeMillis());
System.out.println("The Current Timestamp in Milliseconds == " + currentTS.getTime());

//Formating the Current Timestamp
System.out.println("The Formatted Timestamp == " + currentTS.toString())
}
}

Code Explanation

• At the start of the program, we import the Timestamp class from the sql package.
• After this, we pass the “System.currentTimeMillis()” as an argument to the Timestamp() constructor and store the obtained result in the currentTS variable. Then we invoke the getTime() method on the currentTS to retrieve the current DateTime in milliseconds.
• Finally, we use the currentTS with the toString() method to get and print the formatted timestamp on the console:

Method 5: Getting the Current Timestamp in Java Using the LocalDateTime and DateTimeFormatter Classes

We can also get the current timestamp using the now() method of the LocalDateTime class. In addition to this, we can format the obtained current timestamp into a specific pattern using the DateTimeFormatter class. In the following example, first, we get the current timestamp and then we convert it into a specific pattern using the “DateTimeFormatter.ofPattern().format()” method:

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class CurrentTS {
public static void main(String[] args) {
LocalDateTime currTS = LocalDateTime.now();
System.out.println("The Current Timestamp == " + currTS);    

//Formatting Current TimeStamp
String formattedTS = DateTimeFormatter.ofPattern("yyyy/MM/dd - HH:mm:ss").format(currTS);
        System.out.println("The Formatted Timestamp == " + formattedTS);
}
}

Code Explanation

• We import the LocalDateTime and DateTimeFormatter classes from the respective packages.
• Next, we use the now() method to get the current/local DateTime.
• After this, we format the obtained DateTime into a specific format using the “ofPattern().format()” method.
• Finally, we print the obtained current timestamp and the formatted timestamp on the console. 

Method 6: Getting the Current Timestamp in Java Using the LocalDateTime and ZoneId Classes

The LocalDateTime and ZoneId are built-in classes of the “java.time” package. The LocalDateTime class retrieves the DateTime without timezone information while the ZoneId retrieves the timezone id. We use these classes combined to get the current DateTime with timezone information. Here is an example:

import java.time.*;
import java.time.format.DateTimeFormatter;

public class CurrentTS {
public static void main(String[] args) {
LocalDateTime currDateTime = LocalDateTime.now();
      ZoneId id = ZoneId.systemDefault();
      ZonedDateTime dateTimeZone = ZonedDateTime.of(currDateTime, id);
      //Getting Current Timestamp in Milliseconds
      long currentTS = dateTimeZone.toInstant().toEpochMilli();
      System.out.println("The Current Timestamp in Milliseconds == " + currentTS);
       
        //Formating the Current Timestamp
        DateTimeFormatter formatPattern = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formattedTS = currDateTime.format(formatPattern);
        System.out.println("The Formatted Timestamp == " + formattedTS);
}
}

Code Explanation

• Initially, we import the necessary classes like “DateTime”, “ZoneId”, and “ZonedDateTime” from the “java.time” package. Also, we import the DateTimeFormatter class from its respective package to format the current timestamp in a specific format.
• After this, we invoke the “now()” method of the LocalDateTime class to fetch the current DateTime. 
• Next, we use the “ZoneId.systemDefault()” method to get the system’s default zone id. 
• After this, we use the ZonedDateTime.of() method to represent the DateTime with timezone information.
• Next, we invoke the “toInstant().toEpochMilli()” method on the dateTimeZone instance to retrieve the current timestamp(in milliseconds).
• Then we use the DateTimeFormatter.ofPattern() method to specify a pattern according to which the current timestamp will be formatted.
• Finally, we invoke the format method on the currDateTime instance to format it according to the specified DateTime pattern:

That’s all about Getting a current timestamp in Java.

Final Thoughts

The current timestamp represents the DateTime at the current instance along with the timezone information. To get a current timestamp in Java, we can use methods like “currentTimeMillis()”, “now()”, and the “Date()” constructor. Also, we can use the “Timestamp” class, or “LocalDateTime and ZoneId” Classes to achieve the same purpose. This write-up presented six different methods to get the current timestamp in Java; each method has its pros and cons; you can use the one that best suits your needs.

We can download the Postgres JDBC driver from Postgres’ official website. Once downloaded, add its JAR file to your Java project. Follow the below instructions to add the Postgres JDBC JAR file to Eclipse IDE:

First, right-click on the project, hover over the “Build Path”, and select the “Configure Build Path…” option:

From the pop-up window, navigate to the “Libraries” tab, left-click on the “Classpath”, and select the “Add External JARs…” button:

Now select the downloaded Postgres JDBC JAR file and hit the “Open” button:

Finally, click the “Apply and Close” button to add the selected JAR file to your project:

• Using Maven Dependency

Alternatively, you can create a maven project and modify its “pom.xml” file. To do that, simply add the latest dependency of the Postgres JDBC driver into the pom file, as follows:

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.7.3</version>
</dependency>

Using this method, there is no need to download the JDBC driver manually. Instead, Maven will automatically download all the essential JAR files from the remote repositories.

Step 2: Establish a Connection Between Postgres and Java

Now type the following code in your Java file to establish a connection with the Postgres database:

import java.sql.*;

public class PostgresJavaConnection {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
String conn = "jdbc:postgresql://localhost:5432/postgres";
String username = "postgres";
String pass = "1212";
Class.forName("org.postgresql.Driver");
      try (Connection connect = DriverManager.getConnection(conn, username, pass)) {
System.out.println("Connection Established Successfully!");
} catch (SQLException excep) {
excep.printStackTrace();
}
}
}

Code Explanation

• First, we import the required classes like “Connection”, “DriverManager”, and “SQLException” from the “java.sql” package.
• In the main() method, we specify the URL to establish the Postgres-Java connection using JDBC. 
• Next, we specify the database username and respective password.
• The next line of code registers the Postgres driver.
• We invoke the getConnection() method to make a connection between PostgreSQL and Java.
• Finally, we use the catch() block to catch the potential exceptions.

Output

The above snippet confirms the Postgres-Java connection establishment. Now, we can run any SQL query to perform database operations, such as table creation, deletion, etc.

Step 3: Fetch Table Data

We have already created a table named “article_details” in the “postgres” database. Let’s run the following Java code to fetch the data of the “article_details” table:

Statement sqlStatement = connect.createStatement();
ResultSet tbl = sqlStatement.executeQuery("SELECT * FROM article_details");
while (tbl.next()) {
String tableColumns = tbl.getString("article_title");
System.out.println("The Article Title = " + tableColumns);
}

Code Explanation

• After establishing the connection, we use the “createStatement()” method to send SQL statements to the database.
• Next, we use the executeQuery() method to execute the SELECT query. This retrieves the data from the “article_details” table.
• In the next line, we use the while loop with the next() method to traverse each record of the selected table.
• Finally, we print the retrieved table records on the console using Java’s println() method.

Output

The output shows that table rows have been successfully retrieved.

Step 4: Create a New Table

In the following snippet, we create a new Postgres table named “studentInfo”:

Statement sqlStatement = connect.createStatement();
String createNewTable = "CREATE TABLE studentInfo ("
                + "std_id serial PRIMARY KEY,"
                + "std_name TEXT,"
                + "std_email VARCHAR(255))";

sqlStatement.execute(createNewTable);
System.out.println("Table Created Successfully!");

Code Explanation

• First, we use the CREATE TABLE statement to create a new ” studentInfo ” table.
• Next, we invoke the execute() method to execute the CREATE TABLE statement.

Output

The following output shows that a new table has been successfully created in the postgres database:

This way we can execute any SQL query from Java to perform database operations like data insertion, table deletion, etc.

Conclusion

We can connect PostgreSQL to Java using an open-source JDBC driver. We can use the JAR File or Maven dependency to integrate the Postgres JDBC driver into a Java project. Once Postgres is integrated with Java, we can use the getConnection() method to establish the Postgres-Java connection. After establishing a connection, we can execute any SQL query to perform a database operation, as illustrated in this post.

int number = 5;int number1 = -512;int number2 = 51214;

int number = 0123

int number = 0X6;
int number1 = 0Xb;

int number = 0b1010;
int number1 = 0B1110;

double number = 654.321;float number = 654.321f;

char gender = 'M';

char x = 65;

In Java, we can specify a char literal in Unicode representation by using the escape sequence “\u” followed by a four-digit hexadecimal number, as illustrated below:

char x = '\u0065';  //it represent lowercase letter e

Escape Sequence

Each escape character can be represented as a char literal, as shown in the following example:

char x = '\t';  //here horizontal tab is specified as a char literal

4) String Literals in Java

A string literal in Java represents a sequence of characters specified within double quotations. This sequence may include alphabets, special symbols, numbers, blank spaces, etc. Here are some examples of String literals in Java:

String str = "javabeat";
String str = "java@beat";
String str = "12java123beat12";

5) Boolean Literals in Java

The Boolean literals in Java let us specify only one of two values: “true” or “false”. Here is an example:

boolean isAvailable = true;  boolean isAvailable = false;

6) Null Literals in Java

The null keyword represents that a reference-type object isn’t available. It can be assigned to any variable except those of primitive types. Here is an example that demonstrates how to specify a null literal in Java:

String productDescription = null;

7) Backslash Literals in Java

A literal that is prefixed with a backslash is referred to as a backslash literal. These literals are illustrated in the following table:

8) Invalid Literals

Be careful while declaring and using literals in Java, otherwise, you may face unwanted results. Here are some examples of invalid declarations of Java Literals:

• Underscores are not allowed immediately before or after a decimal point. For example, “123_.456” and “123._456” are invalid literals.
• We can’t use underscores as the last character of a numeric literal like this “100_”.
• We can’t use an underscore immediately before or after the ‘0x’ or ‘0X’ prefix, like “0x_52” or “0X_44”.

All in all, Underscores have to be located within digits.

How Literals Work in Java

This practical example demonstrates how to use literals in Java:

public class Example {
public static void main(String[] args) {
//Integral Literals
int num = 172;  
int hexaNum = 0x5e3; 
int binaryNum = 0b1110;
int octalNum = 054; 

//Floating-point Literals
double doubleNum = 654.321;
float floatNum = 654.321f;

//Char Literals
char gender = 'M';
char x = 65;
char y = '\u0065';
char z = '\t';

//String Literals
String str = "javabeat";
String str1 = "java@beat";
String str2 = "12java123beat12";

//Boolean Literals
boolean isAvailable = true;

//Null Literals
String productDescription = null; 

System.out.println("Decimal Literals ==> " + num);
System.out.println("HexaDecimal Literals ==> " + hexaNum);
System.out.println("Binary Literals ==> " + binaryNum);
System.out.println("Octal Literals ==> " + octalNum);

System.out.println("Floating-point Literals ==> " + doubleNum);
System.out.println("Floating-point Literals ==> " + floatNum);

System.out.println("Char Literals ==> " + gender);
System.out.println("Integral Literal as Char Literal ==> " + x);
System.out.println("Char Literal Unicode Representation ==> " + y);
System.out.println("Char Literal Escape Sequence ==> " + z);

System.out.println("String Literal ==> " + str);
System.out.println("String Literal Containing Special Character ==> " + str1);
System.out.println("Alphanumeric String Literal ==> " + str2);

System.out.println("Boolean Literals ==> " + isAvailable);

System.out.println("Null Literals ==> " + productDescription);
}
}

The above code implements Integral, Floating-point, Char, String, Boolean, and Null Literals in Java:

That’s all about Literals in Java.

Final Thoughts

A literal in Java is a synthetic representation of a boolean, char, string, or numeric data. It is a way of expressing a specific value in a program, such as int age = 28; String name = “Joseph”. These values remain constant throughout the program.

Java supports several types of literals, such as “Integral”, “floating-point”, “boolean”, “char”, “string”, “backslash”, and “null” literals. This Java tutorial has demonstrated all these literal types with suitable examples.

The Date class in Java offers multiple constructors and built-in methods that let us work with the DateTime values efficiently. We can pass a timestamp to the Date() constructor to convert it into a date. Here is an example:

import java.sql.Timestamp;
import java.util.Date;

public class Example {
    public static void main(String[] args) {
Timestamp currTS = new Timestamp(System.currentTimeMillis());
System.out.println("The Current Timestamp == " + currTS);
System.out.println("The Type of Original DateTime == " + currTS.getClass().getName());

Date currDate = new Date(currTS.getTime());
System.out.println("The Current Date == " + currDate);
System.out.println("The Type of Converted DateTime == " + currDate.getClass().getName());
}
}

In this code, 

• First, we import the Timestamp and Date classes from the sql and util packages, respectively.
• In the main() method, we wrap the “currentTimeMillis()” method within the Timestamp() constructor to get the Current DateTime.
• Next, we print the current date, time, and its respective data type on the console.
• After this, we pass the current timestamp to the Date() constructor to convert it into a date. It is important to note that the Date() constructor accepts a long-type value, so we use the getTime() method with the Timestamp instance to convert it into a long-type value.
• Finally, we print the converted date and its respective data type on the console:

Method 2: Converting a Timestamp to a Date Using Calendar Class

Calendar is a built-in abstract class in Java that provides different methods to convert dates between a particular instant in time and calendar fields like, Day, Month, Year, etc. We can use this class to convert a timestamp to a date, as demonstrated in the following code:

import java.sql.*;
import java.util.*;

public class Example {
  public static void main(String[] args) {
Timestamp currTS = new Timestamp(System.currentTimeMillis());
System.out.println("The Current Timestamp == " + currTS);
System.out.println("The Type of Original DateTime == " + currTS.getClass().getName());

Calendar cal = Calendar.getInstance();
cal.setTimeInMillis(currTS.getTime());
System.out.println("The Current DateTime == " + cal.getTime());
System.out.println("The Type of Converted DateTime == " + cal.getClass().getName());
}
}

In this code, 

• We import the essential classes like Timestamp and Calendar from the respective packages.
• Next, we use the Timestamp() constructor to get a timestamp that we want to convert.
• We print the retrieved timestamp and its respective class on the console.
• After this, we create a Calendar class instance and set its time to the timestamp using the setTimeInMillis() method.
• Finally, we print the converted date and its corresponding class on the console:

Method 3: Converting a Timestamp to a Date Using a Date Reference

We can directly assign a timestamp object to a date instance to convert a timestamp to a date. Here is an example:

import java.sql.Timestamp;import java.util.Date;
public class Example {
public static void main(String[] args) {
Timestamp currTS = new Timestamp(System.currentTimeMillis());
System.out.println("The Current Timestamp == " + currTS);
Date currDate = currTS;
System.out.println("The Current Date == " + currDate);
}
}

In this code, first, we get the current DateTime using the Timestamp() constructor and print it on the console. After this, we assign the obtained current timestamp to the Date instance. Finally, we print the converted date on the console:

Important: We can easily convert a timestamp to a date using the Date reference, however, Java experts recommend not using this method due to the potential loss of milliseconds and nanoseconds.

How to Convert a Timestamp to a Specific Date Format

We can use the SimpleDateFormat() constructor to format the converted date into a specific date format, as shown in the following example: 

import java.sql.Timestamp;
import java.text.DateFormat;
import java.util.Date;
import java.text.SimpleDateFormat;

public class Example {

public static void main(String[] args) {
Timestamp currTS = new Timestamp(System.currentTimeMillis());
System.out.println("The Current Timestamp == " + currTS);
System.out.println("The Type of Original DateTime == " + currTS.getClass().getName());

Date currDate = new Date(currTS.getTime());
DateFormat formattedDate = new SimpleDateFormat("yyyy/MM/dd");
String date = formattedDate.format(currDate);

System.out.println("The Formatted Date == " + date);
System.out.println("The Type of Converted DateTime == " + currDate.getClass().getName());
}
}

In this code, 

• First, we import the required classes like Timestamp, DateFormat, Date, and SimpleDateFormat from the corresponding packages.
• Next, we get the timestamp to be converted using the Timestamp() constructor and print it on the console. Also, we print the class name to which the current timestamp belongs on the console.
• After this, we pass the given timestamp to the Date() constructor to convert it into a date.
• Next, we use the SimpleDateFormat class to format the converted date into “yyyy/MM/dd” format.
• Finally, we print the formatted date along with its respective class on the console:

How to Convert a Date to a Timestamp in Java

We can also convert a date to a timestamp in Java using the Timestamp() constructor, as shown in the example below:

import java.sql.Timestamp;
import java.util.Date;

public class Example {
    public static void main(String[] args) {
      Date currDate = new Date();       System.out.println("The Current Date == " + currDate);       System.out.println("The Type of Original DateTime == " + currDate.getClass().getName());
      Timestamp currTS = new Timestamp(currDate.getTime());
      System.out.println("The Converted Timestamp == " + currTS);
      System.out.println("The Type of Converted DateTime == " + currTS.getClass().getName());
  }
}

In this code, 

• We get the current Date using the Date() constructor and print it on the console along with its respective class.
• Next, we invoke the “getTime()” method with the Date instance and pass it to the Timestamp() constructor to convert it into a timestamp.
• In the end, we print the converted timestamp and its data type on the console:

That’s all about converting a timestamp to a date(or vice versa) in Java.

Conclusion

We can use the Date() constructor, Calendar class, and date reference to convert a timestamp to a date in Java. To convert a timestamp to a date, simply invoke the getTime() method with the timestamp instance and pass it as an argument to the Date() constructor. In addition to this, we can convert a timestamp to a date and format it according to a specific format pattern using the SimpleDateFormat class. This post demonstrated different methods of converting a timestamp to a date in Java using suitable examples.

Java offers a built-in TimeZone class that belongs to the “java.util” package. This class provides several methods that help us get timezone information. Using these methods, we can get the current timezone, all available time zones, or a specific timezone. Also, we can set or modify a timezone. Don’t know how to get/set a timezone in Java? No worries, in this tutorial, we’ll provide stepwise instructions to get a time zone in Java. 

How to Get the Default Timezone in Java

The TimeZone class belongs to the “java.util” package and offers different methods to work with the timezones. One such method is getDefault() which retrieves the system’s default timezone, as demonstrated in the following example:

import java.util.TimeZone;
public class GetTimezoneJava {
  public static void main(String args[]) {
      TimeZone defaultTZ = TimeZone.getDefault();
      System.out.println("The Default Timezone is ==> " + defaultTZ);
  }
}

In the above code:

• First, we import the TimeZone class from the util package to work with the timezones.
• In the main() method, we invoke the getDefault() method of the TimeZone class to get the system’s default timezone. 
• Finally, we print the retrieved timezone on the console using the println() method:

How to Get All Timezone IDs in Java

We can use the getAvailableIDs() method of the TimeZone class to get all available timezone IDs. Here is an example that retrieves all timezone IDs on the console:

import java.util.TimeZone;
public class GetTimezoneJava {
    public static void main(String args[]) {
String[] getIDs = TimeZone.getAvailableIDs();
System.out.println("The Available Timezone IDs are ==>");
  for (int i = 0; i < getIDs.length; i++) {
System.out.println(getIDs[i]);
}
  }
}

In this code example,

• We invoke the getAvailableIDs() method and store its result in a string array “getIDs”.
• After this, we use a for loop to traverse the complete array, access each array element, and print it on the console:

This way, each available timezone is printed on the console, as shown below:

How to Get the IDs According to a Specific Timezone Offset in Java

We can also get a list of IDs according to a specific timezone offset. For this purpose, we need to pass the raw offset as an argument to the getAvailableIDs() method, as illustrated below:

import java.util.TimeZone;

public class GetTimezoneJava {
public static void main(String args[]) {
String[] givenID = TimeZone.getAvailableIDs(-21600000);
System.out.println("The Available Ids in the Given TimeZone are ==>");
for (int i = 0; i < givenID.length; i++) {
System.out.println(givenID[i]);
}
}
}

In this example, 

• We specify a raw offset of “-21600000” to the getAvailableIDs() method that represents -6 hours from GMT. 
• We assign the result of the getAvailableIDs() method to a string array “givenID”. 
• Finally, we use a for loop to iterate the array and print each timezone ID on the console: 

How to Get the Current Time in Another Timezone

We can also get the current time in any specific timezone (i.e., other than the default timezone). To do this, we need to pass the desired timezone in the getTimeZone() method. For example, the below code prints the current time in the system’s default timezone and a specific timezone, i.e., “America/Chicago”:

import java.util.*;

public class GetTimezoneJava {
public static void main(String args[]) {
Calendar currInstance = Calendar.getInstance();
System.out.println("Current Time in Default TimeZone is ==>");
System.out.println("Current Hour = " + currInstance.get(Calendar.HOUR_OF_DAY));
System.out.println("Current Minute = " + currInstance.get(Calendar.MINUTE));
System.out.println("Current Second = " + currInstance.get(Calendar.SECOND));
System.out.println("Current Millisecond = " + currInstance.get(Calendar.MILLISECOND));

System.out.println("Current Time in America/Chicago TimeZone is ==> ");
currInstance.setTimeZone(TimeZone.getTimeZone("America/Chicago"));
System.out.println("Current Hour = " + currInstance.get(Calendar.HOUR_OF_DAY));
System.out.println("Current Minute = " + currInstance.get(Calendar.MINUTE));
System.out.println("Current Second = " + currInstance.get(Calendar.SECOND));
System.out.println("Current Millisecond = " + currInstance.get(Calendar.MILLISECOND));

}
}

In this example,

• First, we import the necessary classes like “Calendar” and “TimeZone” from the Java util package.
• In the main() method, we invoke the getInstance() method to get the current date and time (according to the system’s default timezone).
• Next, we use the get() method with the “HOUR_OF_DAY”, “MINUTE”, “SECOND”, and “MILLISECONDS” fields to get the current hour, minutes, seconds, and milliseconds, respectively.
• Next, we use the getTimeZone() with the “America/Chicago” as its argument to get the current time according to the “America/Chicago” timezone.
• Finally, we use the get() method to retrieve the current hour, minutes, seconds, and milliseconds according to the “America/Chicago” timezone:

How to Set the Base Timezone Offset to GMT in Java

We can use the setRawOffset() method to set the base timezone offset to any specific value relative to GMT. In the following example, we set the raw offset to 8 minutes:

import java.util.TimeZone;

public class GetTimezoneJava {
    public static void main(String args[]) {
TimeZone givenTZ = TimeZone.getTimeZone("America/Chicago");
System.out.println("Getting RawOffset of Given Timezone ==>" + givenTZ.getRawOffset());

givenTZ.setRawOffset(800000);
System.out.println("The Current RawOffset Value is ==>" + givenTZ.getRawOffset());

}
}

In this code,

• First, we use the getTimeZone() method with the ID “America/Chicago”.
• Next, we get and print the raw offset of the “America/Chicago” timezone using the getRawOffset() and println() methods, respectively.
• After this, we invoke the setRawOffset() method to set the raw offset of the “givenTZ” time zone to 8 minutes. 
• Finally, we print the updated raw offset value of the “America/Chicago” time zone on the console:

How to Get a Formatted Timezone in Java

We use the SimpleDateFormat class to format a date, time, or timezone. For instance, in the following code, we get different DateTime fields in a formatted manner:

import java.util.*;
import java.text.*;

public class GetTimezoneJava {
public static void main(String args[]){
Calendar currInstance = Calendar.getInstance();
SimpleDateFormat simpleformat = new SimpleDateFormat("yyyy-MM-dd hh:mm:s z");

System.out.println("The Current Instance is ==> " + simpleformat.format(currInstance.getTime()));

Format formatter = new SimpleDateFormat("YYYY");
String getYear = formatter.format(new Date());
System.out.println("The Current Year is ==> " + getYear);

formatter = new SimpleDateFormat("MM");
String getMonth = formatter.format(new Date());
System.out.println("The Current Month is ==> " + getMonth);

formatter = new SimpleDateFormat("dd");
String getDay = formatter.format(new Date());
System.out.println("The Current Day is ==> " + getDay);

formatter = new SimpleDateFormat("H");
String getHour = formatter.format(new Date());
System.out.println("The Current Hour is ==> " + getHour);

formatter = new SimpleDateFormat("mm");
String getMinute = formatter.format(new Date());
System.out.println("Current Minutes ==> " + getMinute);

formatter = new SimpleDateFormat("ss");
String getSeconds = formatter.format(new Date());
System.out.println("Current Seconds ==> " + getSeconds);

formatter = new SimpleDateFormat("a");
String getMarker = formatter.format(new Date());
System.out.println("AM or PM ? " + getMarker);

formatter = new SimpleDateFormat("z");
String getTimeZone = formatter.format(new Date());
System.out.println("The Current TimeZone is ==> " + getTimeZone);
}
}

In this code, 

• We use the format() method to get the current DateTime and timezone in a specific format.
• Next, we invoke the SimpleDateFormat() constructor multiple times with the “YYYY”, “MM”, “dd”, “H”, “mm”, “ss”, “a”, and “z” parameters, respectively. 
• As a result, we get the current year, month, day, hour minutes, seconds, AM or PM marker, and “timezone”, respectively: 

That’s all about getting a Timezone in Java.

Conclusion

To get a timezone in Java, we can invoke the getDefault() method of the Timezone class. This method retrieves the default timezone based on the system’s timezone setting. To get a specific timezone, we must specify the timezone ID in the getDefault() method. Also, we can get all available timezones by invoking the getAvailableIDs() method of the TimeZone class. In this Java guide, we covered different aspects of timezones, such as getting a timezone, setting a timezone, formatting a timezone, etc. 

A timestamp is a date-time object in Java that is used to represent date-time information with precision. Java users often go through a situation where they need to convert a string representation of a date into a timestamp object.

In this tutorial, we’ll use different built-in Java classes to convert a string date to a timestamp. 

How to Convert a String to a Timestamp in Java

To convert a date string into a timestamp in Java, we can use built-in methods like “SimpleDateFormat.parse()” and “Timestamp.valueOf()”. 

1. Converting a String to a Timestamp Using SimpleDateFormat.parse()

The SimpleDateFormat class provides a method named parse() that takes a string and parses it into a date. This method can parse a string(date) into a timestamp. For instance, in the following code snippet, we invoke the parse() method on the given date string to parse into a timestamp according to a specific date format:

import java.sql.Timestamp;
import java.text.*;

public class ExampleClass {
  public static void main(String[] args) {
String givenDate = "2020/11/14 10:11:12";
SimpleDateFormat formatDate = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
try {
java.util.Date parseDate = formatDate.parse(givenDate);
Timestamp convertedTimestamp = new Timestamp(parseDate.getTime());
System.out.println("The Given Date String is ==> " + givenDate);
System.out.println("The Data Type of Given Date is ==> " + givenDate.getClass().getName());
System.out.println("The Converted Timestamp is ==> " + convertedTimestamp);
System.out.println("The Data Type of the Converted Timestamp is ==> " + convertedTimestamp.getClass().getName());
} catch (ParseException excep) {
excep.printStackTrace();
}
}
}

Code Explanation 

• First, we import the required classes from the “sql” and “text” packages.
• After this, we initialize a date string to a variable “givenDate”. 
• Next, we use the SimpleDateFormat() constructor to specify a valid date format (according to which the provided date will be parsed). 
• In the next line, we invoke the parse() method on the given string to convert it into a date.
• Up next, we use the Timestamp() constructor to convert the parsed date into a timestamp.
• Finally, we print the given string and the converted timestamp on the console. Also, we printed the data type of the given date string and the converted timestamp to make things clear:

The output confirms the conversion of the given string into a timestamp using the parse() method. 

2. Converting a String to a Timestamp Using Timestamp.valueOf()

The valueOf() is an easy-to-use built-in method of the Timestamp class. This method can be used to convert a date string to a timestamp, as shown in the following code snippet:

import java.sql.Timestamp;public class ExampleClass {
  public static void main(String[] args) {
  String givenDate = "2021-04-11 01:12:12";
  try {
Timestamp convertedDate = Timestamp.valueOf(givenDate);
System.out.println("The Given Date String is ==> " + givenDate);
System.out.println("The Data Type of Given Date is ==> " + givenDate.getClass().getName());
System.out.println("The Converted Timestamp is ==> " + convertedDate);
System.out.println("The Data Type of the Converted Timestamp is ==> " + convertedDate.getClass().getName());
} catch (Exception excep) {
excep.printStackTrace();
}
  }
}

In the above code snippet, 

• At the program’s start, we import the Timestamp class from the “java.sql” package.
• In the main() method, we create a string-type variable and assign it a date value.
• Up next, we invoke the valueOf() method on the given date string to convert it into a timestamp.
• Finally, we print the given date and the converted timestamp (along with their corresponding data types) on the console:

The output confirms that the valueOf() method successfully converted the given string to a timestamp.

How to Format/Convert a Timestamp to a String in Java?

The “Timestamp” class of the “java.sql” package offers a “toString()” method that retrieves a string representation of the timestamp in JDBC timestamp escape format. This method lets us convert a timestamp object into a string in Java:

import java.sql.Timestamp;
public class ExampleClass {
  public static void main(String[] args) {
    try {
Timestamp givenTimestamp = Timestamp.valueOf("2021-04-11 01:12:12");
System.out.println("The Given Timestamp is ==> " + givenTimestamp);
System.out.println("The Data Type of Given Timestamp is ==> " + givenTimestamp.getClass().getName());

String convertedTimestamp = givenTimestamp.toString();
System.out.println("The Converted Timestamp is ==> " + convertedTimestamp);
System.out.println("The Data Type of the Converted Timestamp is ==> " + convertedTimestamp.getClass().getName());
} catch (Exception excep) {
excep.printStackTrace();
}
  }
}

In this example,

• We declare a timestamp using the valueOf() method and initialize it to a variable named “givenTimestamp”.
• Also, we print the initialized timestamp and its data type on the console.
• After this, we use the toString() method on the given timestamp to convert it into a string.
• For verification purposes, we print the converted timestamp along with its data type on the console, as shown in the following screenshot: 

That’s all from converting a string to a timestamp in Java.

Conclusion

To convert a string to a timestamp in Java, use the “parse()” or the “valueOf()” methods of the SimpleDateFormat and Timestamp classes, respectively. On the other hand, if you need to format/convert a timestamp object to a String, you can use the toString() method of the Timestamp class. In this tutorial, all these methods are explained with appropriate examples.

The Java FileWriter class belongs to the “java.io” package that lets us write character data to a file. Using this class we can easily write data to a CSV file, as shown in the following code:

import java.io.*;

public class WriteDataCSV {
public static void main(String[] args) {
                    try {
FileWriter obj = new FileWriter("C:\\Users\\HP\\Desktop\\sampleFile.txt");
obj.write("empName, empDesig, empAge\n");
obj.write("Ambrose, Author, 25\n");
obj.write("Joseph, Designer, 27\n");
obj.write("Alexa, Tutor, 30\n");
obj.close();
} catch (IOException excep) {
excep.printStackTrace();
}
}
}

Code Explanation

• First, we import the required classes like FileWriter and IOException to write data to a CSV file by avoiding any potential exceptions.
• We use the FIleWriter() constructor to specify the file’s path to which we want to write data.
• After this, we invoke the write() method of the FileWriter class to write the data into the selected CSV class.

Output (sampleFile.txt)

2) Writing Data to a CSV File Using Java BufferedWriter Class

The BufferedWriter is a built-in Java class that belongs to the same “io” package. This class lets us write text to a character-output stream with buffering. Using this class, you can write data to any CSV file:

import java.io.*;

public class WriteDataCSV {
public static void main(String[] args) {
try {
BufferedWriter obj = new BufferedWriter(new FileWriter("C:\\Users\\HP\\Desktop\\sampleFile.txt"));
obj.write("empName, empDesig, empSal\n");
obj.write("Ambrose, Author, 25000\n");
obj.write("Joseph, Designer, 25000\n");
obj.write("Alexa, Tutor, 30000\n");
obj.close();
} catch (IOException excep) {
excep.printStackTrace();
}
}
}

Code Explanation:

• In this example, we wrap the FileWriter() constructor within the BufferedWriter() constructor. While the FileWriter() constructor is initialized with the file path (to which the data will be written).
• After this, we use the object of the BufferedWriter class to invoke the write() method to write the data to the CSV file

Output (sampleFile.txt)

3) Writing Data to a CSV File Using Java PrintWriter Class

The PrintWriter is an in-built class of Java’s io package that helps us print the formatted representation of objects to a text-output stream. You can use this class to write data to a CSV file, as demonstrated in the following code:

import java.io.*;

public class WriteDataCSV {
public static void main(String[] args) {
      try {
PrintWriter obj = new PrintWriter(new File("C:\\Users\\HP\\Desktop\\sampleFile.txt"));
StringBuffer fileHeader = new StringBuffer("");
StringBuffer fileData = new StringBuffer("");

fileHeader.append( "empName, empDesig, empSal\n");
obj.write(fileHeader.toString());

fileData.append("Ambrose");
fileData.append(',');
fileData.append("Tutor");
fileData.append(',');
fileData.append("25000");
fileData.append('\n');

fileData.append("Joseph");
fileData.append(',');
fileData.append("Designer");
fileData.append(',');
fileData.append("30000");
fileData.append('\n');

obj.write(fileData.toString());
obj.close();

} catch (FileNotFoundException excep) {
excep.printStackTrace();
}
    }
}

Code Explanation

• We use the PrintWriter() constructor along with the File() constructor to specify the file path to which we want to write the data.
• Next, we create two objects of the StringBuffer class to store the file header and file’s data, respectively.
• Next, we use the append() method to append the header line and the content of the file to the respective StringBuffer object.
• Finally, the write() method is used to write the file header and the file content to the selected CSV file.

Output (sampleFile.txt)

4) Writing Data to a CSV File in Java Using OpenCSV

It is a third-party library that can also be used to write data to a CSV file. To do that, first, add the given dependency to the xml file of your Maven project:

<dependency>
    <groupId>com.opencsv</groupId>
    <artifactId>opencsv</artifactId>
    <version>5.9</version>
</dependency>

Once added, you can write data to a CSV file line-by-line or all data at once.

Example 1: Writing Data to a CSV File Line-by-line Using OpenCSV

In the following example, first, we import the CSVWrite class from the OpenCSV:

import java.io.*;
import com.opencsv.CSVWriter;

public class WriteDataCSV {
public static void main(String[] args) {
    File fileObj = new File("C:\\Users\\HP\\Desktop\\sampleFile.txt");
    try {
FileWriter resultFile = new FileWriter(fileObj);
CSVWriter csvWriterObj = new CSVWriter(resultFile);
String[] fileHeader = { "empName", "empDesig", "empSal" };
csvWriterObj.writeNext(fileHeader);
String[] emp1 = { "John", "Tutor", "35000" };
csvWriterObj.writeNext(emp1);
String[] emp2 = { "Joseph", "Instructor", "35000" };
csvWriterObj.writeNext(emp2);
String[] emp3 = { "Alex", "Software Engineer", "40000" };
csvWriterObj.writeNext(emp3);
String[] emp4 = { "Seth", "Designer", "30000" };
csvWriterObj.writeNext(emp4);
String[] emp5 = { "Ambrose", "Instructor", "35000" };
csvWriterObj.writeNext(emp5);
System.out.println("Data Written to the CSV File Successfully");             csvWriterObj.close();
}
catch (IOException excep) {
              excep.printStackTrace();
}
}
}

Code Explanation

• First, we create an object of the FilerWriter class to write data to the selected CSV file. 
• Also, we create an object of the CSVWriter class to write the CSV formatted data to the selected CSV file. 
• Next, we define a string array to specify the column names(file header). We use the WriteNext() method to write the specified column names as the first row of the selected CSV file.
• After this, we create multiple arrays to specify the data of different employees and invoke the writeNext() method on each array to write it to the CSV file.

Output (sampleFile.txt)

Example 2: Writing All Data at Once to a CSV File Using OpenCSV

The following code demonstrates how to write all data at once to a CSV file using the OpenCSV library:

import com.opencsv.CSVWriter;import java.io.*;
import java.util.*;

public class WriteDataCSV {
public static void main(String[] args) {
  File fileObj = new File("C:\\Users\\HP\\Desktop\\sampleFile.txt");
try {
        FileWriter resultFile = new FileWriter(fileObj);
        CSVWriter csvWriterObj = new CSVWriter(resultFile);
  List<String[]> writeData = new ArrayList<String[]>();
  writeData.add(new String[] {"empName", "empDesig", "empSal"});
        writeData.add(new String[] {"John", "Tutor", "35000"});
  writeData.add(new String[] {"Alex", "Software Engineer", "40000"});
  writeData.add(new String[] {"Seth", "Designer", "30000"});
  csvWriterObj.writeAll(writeData);
  csvWriterObj.close();
}
catch (IOException excep) {
  excep.printStackTrace();
}
}
}

Output (sampleFile.txt)

• In this example, we create a list of string arrays, and add them to a list named “writeData”.
• After this, we invoke the writeAll() method to write all the data to the selected CSV file in one go (instead of writing it line-by-line).

5) Writing Data to a CSV File in Java Using Apache Commons CSV

Apache Commons is another well-known third-party library that allows us to write data to a CSV file. However, to use Apache Commons, first, you must add the latest version of this library into the “pom.xml” file of your Maven project:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-csv</artifactId>
    <version>1.10.0</version>
</dependency>

Once the library is added, import the CSVFormat and CSVPrinter classes to your Java program, as shown below:

import org.apache.commons.csv.CSVFormat;
import org.apache.commons.csv.CSVPrinter;

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;

public class WriteDataCSV {
    public static void main(String[] args){
try {
BufferedWriter resultFile = Files.newBufferedWriter(Paths.get("C:\\Users\\HP\\Desktop\\sampleFile.txt"));
CSVPrinter csvPrinterObj = new CSVPrinter(resultFile,
CSVFormat.DEFAULT.withHeader("empName", "empDesig", "empSal"));

csvPrinterObj.printRecord("John", "Tutor", "35000");
csvPrinterObj.printRecord("Alex", "Software Engineer", "40000");
csvPrinterObj.printRecord("Seth", "Designer", "30000");
csvPrinterObj.printRecord(Arrays.asList("Alexa", "Jr. Software Engineer", "30000"));
csvPrinterObj.flush();
csvPrinterObj.close();
}
catch (IOException excep) {
excep.printStackTrace();
}
}
}

Code Explanation:

• After importing the required classes, we create a BufferedWriter to specify the file path.
• Next, we create an object of the CSVPrint class to set the header line and content of the CSV file.
• To set the header line we invoke the withHeader() method and specify the file’s content we use the printRecord() method.
• Finally, we flush the buffer before closing the writer.

Output (sampleFile.txt)

How to Write/Append Data into an Existing CSV File in Java?

To write data into an existing CSV file in Java, you must use a method that lets you append data into a file without overwriting the original content. For instance, you can use the FileWriter instance and specify the append mode as its second argument, as follows:

import java.io.*;

public class WriteDataCSV {
public static void main(String[] args) {
try {
FileWriter obj = new FileWriter("C:\\Users\\HP\\Desktop\\sampleFile.txt", true);
obj.write("Ambrose, Author, 25\n");
obj.close();
} catch (IOException excep) {
excep.printStackTrace();
}
}
}

Code Explanation:

• We create a FileWriter object and initialize it with the targeted CSV file’s path.
• We specify “true” as a second parameter to the FileWrite() method; this means the targeted CSV file will be open in “append” mode.
• Finally, we use the write() method to append a new line to an already-existing file.

The output demonstrates that this time a new line is appended(instead of overwriting) at the end of the selected file:

That’s all about writing data to a CSV file in Java.

Final Thoughts

You can use different built-in classes like FileWriter, PrintWriter, or BufferedWriter to write data to a CSV file in Java. Besides these built-in classes, you can also use some third-party libraries like Apache Commons and OpenCSV to write data to a CSV file. Using OpenCSV, you can write data line-by-line or all data at once. All these methods allow you to write data to a CSV file conveniently and efficiently. To write data into an existing CSV file in Java, you must use a method that lets you append data into a file without overwriting the original content.