The JavaScript Object Notation (JSON) is a standard text-based format for representing structured data based on JavaScript object syntax. It is lightweight, flexible, and faster than XML, which is the reason that it is used widely for data interchange between server and client. If you ever work on Java Enterprise Applications then you will come across tasks where you might need to generate and parse JSON data for your application. For instance, RESTful web services use JSON extensively as the format for the data inside requests and responses.
The following examples show a JSON object with name-value pairs:
{
"firstName": "Duke",
"lastName": "Java",
"age": 18,
"streetAddress": "100 Internet Dr",
"city": "JavaTown",
"state": "JA",
"postalCode": "12345",
"phoneNumbers": [
{ "Mobile": "111-111-1111" },
{ "Home": "222-222-2222" }
]
}
Java provides an API to parse, transform, and query JSON data using either the object model or the streaming model.
The object model works by creating a tree that represents the JSON data in memory. The object model generates JSON output by navigating the entire tree at once and hence, allows for processing that requires access to the entire contents of the tree at once. The tree can be navigated, analyzed, or modified. This approach is considered flexible but it is slower than the streaming model and requires more memory.
Java API provides the javax.json package, it contains a reader interface, a writer interface, and a model builder interface for the object model. The package also contains other utility classes and Java types for JSON elements.
In the object model, a JSON-object reference is created which represents the root of the tree and can be used to navigate the tree or to write it to a stream as JSON data. This JSON-object reference created can either be of type JsonObject or JsonArray, and both of them are the subtypes of JsonStructure. Which one it will depend on the format/content of the file.
Let's describe each of them to be precise and clear.
Let us go through some traits of JsonObject
- Written in key-value pairs.
- Keys must be strings and values must be valid JSON type.
- JsonObject starts and ends with curly braces { }.
- Order is not important.
Sample code for JSON object is as follows in below illustration
{
"name" : "GeeksforGeeks",
"description" : "An educational website"
}
Let us go through some traits of JsonArray
- Used to organize a collection of related items.
- Values can be of type string, number, object, array, boolean, or null.
- JsonArray starts and ends with square brackets [ ].
- Order is important.
Illustration:
[1, 2, 3, 4]
JsonObject and JsonArray can also be used in a nested manner to represent some special kind of data. You can either use the object inside the array or the array inside the object.
{
"employees":[
{"firstName":"John", "lastName":"Doe"},
{"firstName":"Anna", "lastName":"Smith"},
{"firstName":"Peter", "lastName":"Jones"}
],
"positions" : [
{"department" : "Testing", "role" : "Junior"},
{"department" : "Testing", "role" : "Senior"},
{"department" : "Design", "role" : "Junior"}
]
}
Now that we are clear with the basics, we can learn how to code.
Now let us come onto installing javax.json API. So, If you are using a Maven project then add this dependency to your pom.xml file:
<dependency>
<groupId>javax.json</groupId>
<artifactId>javax.json-api</artifactId>
<version>1.1.4</version>
</dependency>
Otherwise, in case you are creating a normal project then add the javax.json jar to your Libraries else download the jar file from here and follow the below steps
Step 1: Creating Object model from given JSON data
if we assume that we already have some data in the JSON format, and thus want to convert that into a java JsonObject, then we can make use of the javax.json.JsonStructure.
Let us assume we have a sample.txt that stores JSON data as follows:
{
"firstName": "John",
"lastName": "Smith",
"age": 25,
"address": {
"streetAddress": "21 2nd Street",
"city": "New York",
"state": "NY",
"postalCode": "10021"
},
"phoneNumber":
[
{
"type":"home",
"number":"212 555-1234"
},
{
"type": "fax",
"number": "646 555-4567"
}
]
}
Apart from just creating an object of the data, we need to have a way to read that data as well!
Step 2: Navigate it.
For navigating the data we will create a function navigateTree() that will take the JSON object/model that we created, as an input, and for every object or array that it encounters nested inside the JSON model, it will call the navigating function again, and if the element is a value, then it will print the standard output.
Now we can proceed to code for creating a JsonStructure out of this sample.txt file which is as shown below
Example
Java
// Java Program to create a JsonStructure of an already
// existing data in the JSON format
// Importing required classes
import java.io.FileNotFoundException;
import java.io.FileReader;
import javax.json.Json;
import javax.json.JsonArray;
import javax.json.JsonNumber;
import javax.json.JsonObject;
import javax.json.JsonReader;
import javax.json.JsonString;
import javax.json.JsonStructure;
import javax.json.JsonValue;
// Main class
public class CreateObjectModelFromJSONData {
// Main driver method
public static void main(String args[])
throws FileNotFoundException
{
// JsonReader: an interface that reads a JSON object
// or an array structure from an input source.
JsonReader reader = Json.createReader(
new FileReader("sample.txt"));
// JsonStructure: an interface that is a super type
// for the two structured types in JSON
// (objects and arrays)
JsonStructure jsonst = reader.read();
// navigateTree method takes two arguments: a JSON
// element and a key. The key is used only to help
// print the key-value pairs inside objects.
// Elements in a tree are represented by the
// JsonValue type.
navigateTree(jsonst, null);
}
// A JsonValue is one of the following: an object
// (JsonObject), an array (JsonArray), a number
// (JsonNumber), a string (JsonString), true
// (JsonValue.TRUE), false (JsonValue.FALSE), or null
// (JsonValue.NULL).
// Method 2
// To navigate through the model
// and print the key-value pairs
public static void navigateTree(JsonValue tree,
String key)
{
if (key != null)
System.out.print("Key " + key + ": ");
// Switch case
// Method 3
// getValueType() returns the value type of
// this JSON value.
switch (tree.getValueType()) {
// Case 1
case OBJECT:
System.out.println("OBJECT");
JsonObject object = (JsonObject)tree;
for (String name : object.keySet())
navigateTree(object.get(name), name);
break;
// Case 2
case ARRAY:
System.out.println("ARRAY");
JsonArray array = (JsonArray)tree;
for (JsonValue val : array)
navigateTree(val, null);
break;
// Case 3
case STRING:
JsonString st = (JsonString)tree;
System.out.println("STRING " + st.getString());
break;
// Case 4
case NUMBER:
JsonNumber num = (JsonNumber)tree;
System.out.println("NUMBER " + num.toString());
break;
// Case 5
case TRUE:
// Case 6
case FALSE:
// Case 7
case NULL:
// Print statement
System.out.println(
tree.getValueType().toString());
break;
}
}
}
Output
OBJECT
Key firstName: STRING John
Key lastName: STRING Smith
Key age: NUMBER 25
Key address: OBJECT
Key streetAddress: STRING 21 2nd Street
Key city: STRING New York
Key state: STRING NY
Key postalCode: STRING 10021
Key phoneNumber: ARRAY
OBJECT
Key type: STRING home
Key number: STRING 212 555-1234
OBJECT
Key type: STRING fax
Key number: STRING 646 555-4567
2. Creating an object model from code
In order to create an object model of our own from scratch we will make use of the JSON class that provides a method createObjectBuilder() that creates a JSON object builder. The JsonObjectBuilder interface acts as a builder for creating JsonObject models from scratch. This interface initializes an empty JSON object model and provides methods to add name/value pairs to the object model and to return the resulting object. The methods in this class can be chained to add multiple name/value pairs to the object.
Example
Java
// Java Program to create a Json object from scratch using
// JsonObjectBuilder and navigate it.
// Importing required classes
import javax.json.Json;
import javax.json.JsonArray;
import javax.json.JsonNumber;
import javax.json.JsonObject;
import javax.json.JsonString;
import javax.json.JsonValue;
// Main class
// CreateObjectModelFromCode
public class GFG {
// Method 1
// Main driver method
public static void main(String args[])
{
// add() method adds a name/value pair to the JSON
// object associated with this object builder.
// build() method returns the JSON object associated
// with this object builder.
JsonObject model
= Json.createObjectBuilder()
.add("firstName", "Duke")
.add("lastName", "Java")
.add("age", 18)
.add("streetAddress", "100 Internet Dr")
.add("city", "JavaTown")
.add("state", "JA")
.add("postalCode", "12345")
.add("phoneNumbers",
Json.createArrayBuilder()
.add(Json.createObjectBuilder()
.add("type", "mobile")
.add("number",
"111-111-1111"))
.add(Json.createObjectBuilder()
.add("type", "home")
.add("number",
"222-222-2222")))
.build();
// The same navigateTree() method can be used to
// navigate this model.
navigateTree(model, null);
}
// Method 2
public static void navigateTree(JsonValue tree,
String key)
{
if (key != null)
System.out.print("Key " + key + ": ");
// Method 3- getValueType()
// To get the value types
// Switch case
switch (tree.getValueType()) {
// Case 1
case OBJECT:
System.out.println("OBJECT");
JsonObject object = (JsonObject)tree;
for (String name : object.keySet())
navigateTree(object.get(name), name);
break;
// Case 2
case ARRAY:
System.out.println("ARRAY");
JsonArray array = (JsonArray)tree;
for (JsonValue val : array)
navigateTree(val, null);
break;
// Case 3
case STRING:
JsonString st = (JsonString)tree;
System.out.println("STRING " + st.getString());
break;
// Case 4
case NUMBER:
JsonNumber num = (JsonNumber)tree;
System.out.println("NUMBER " + num.toString());
break;
// Case 5
case TRUE:
// Case 6
case FALSE:
// Case 7
case NULL:
System.out.println(
tree.getValueType().toString());
break;
}
}
}
Output
OBJECT
Key firstName: STRING Duke
Key lastName: STRING Java
Key age: NUMBER 18
Key streetAddress: STRING 100 Internet Dr
Key city: STRING JavaTown
Key state: STRING JA
Key postalCode: STRING 12345
Key phoneNumbers: ARRAY
OBJECT
Key type: STRING mobile
Key number: STRING 111-111-1111
OBJECT
Key type: STRING home
Key number: STRING 222-222-2222
3. Writing Object model to a Stream
The object models that we created in the above examples can be written to a stream using the JsonWriter class. JsonWriter writes a JSON object or array structure to an output source. This time we will write the contents of the sample.txt to an output stream after we have converted it to a JsonStructure.
Example
Java
// Java Program to Write the Object Model to an Output Stream
// Importing required classes
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.StringWriter;
import javax.json.Json;
import javax.json.JsonObject;
import javax.json.JsonReader;
import javax.json.JsonStructure;
import javax.json.JsonWriter;
// Main class
// WritingObjectModelToAStream
public class GFG {
// Main driver method
public static void main(String args[])
throws FileNotFoundException
{
JsonReader reader = Json.createReader(
new FileReader("sample.txt"));
JsonStructure jsonst = reader.read();
StringWriter stWriter = new StringWriter();
// We use try-with-resources to close the JSON
// writer automatically
// Json.createWriter() method takes an output stream
// as a parameter. JsonWriter.writeObject() method
// writes the object to the stream.
// Try block to check for exceptions
try (JsonWriter jsonWriter
= Json.createWriter(stWriter)) {
jsonWriter.writeObject((JsonObject)jsonst);
}
// Creating variable jsonData to store the object
// written to the stream in the form of a String
String jsonData = stWriter.toString();
// Print the data string
System.out.println(jsonData);
}
}
Output: On the console, the following will be printed in a single line
{
"firstName":"John","lastName":"Smith","age":25,
"address":{"streetAddress":"21 2nd Street","city":"New York","state":"NY","postalCode":"10021"},
"phoneNumber":[{"type":"home","number":"212 555-1234"},{"type":"fax","number":"646 555-4567"}]
}
Now dwelling onto next model,
The streaming model uses an event-based parser that reads JSON data one element at a time. The streaming model generates JSON output to a given stream by making a function call with one element at a time. This approach is adequate for local processing, in which the processing of an element does not require information from the rest of the data. The way it works is that the parser generates events and stops for processing whenever it either finds a key, or finds a value, or reaches the beginning or end of an object or array. The element found can be processed or discarded based on the code and then the parser moves to the next event.
The Java API provides the javax.json.stream package, it contains a parser interface, JsonParser, and a generator interface, JsonGenerator for the streaming model. The interface JsonParser contains methods to parse JSON in a streaming way. The interface JsonGenerator contains methods to write JSON to an output source in a streaming way.
In the upcoming code, we will make use of the same sample.txt file to parse it.
1. Reading JSON data using a Parser: We will use the JsonParser that provides forward, read-only access to JSON data in a streaming way. JsonParser parses JSON using the pull parsing programming model. In this model, the client code controls the thread and calls the method next() to advance the parser to the next state after processing each element. The parser can generate the following events:
START_OBJECT, END_OBJECT, START_ARRAY, END_ARRAY, KEY_NAME, VALUE_STRING, VALUE_NUMBER, VALUE_TRUE, VALUE_FALSE, and VALUE_NULL.
In the following code we will perform the following steps:
- Get the JSON data in the form of a String, so that it can be passed to the parser object.
- Obtain a parser instance by calling the JSON.createParser static method and pass the string to it.
- Iterate over the parser events with the JsonParser.hasNext and the JsonParser.next methods.
- Perform local processing for each element.
Implementation:
Example
Java
// Java program to Read JSON data using a JsonParser
// Importing required classes
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.StringReader;
import java.io.StringWriter;
import javax.json.Json;
import javax.json.JsonObject;
import javax.json.JsonReader;
import javax.json.JsonStructure;
import javax.json.JsonWriter;
import javax.json.stream.JsonParser;
// Main class
// ReadingJSONDataUsingAParser
public class GFG {
// Main driver method
public static void main(String args[])
throws FileNotFoundException
{
// Creating object of JsonReader class
// Creating object of JsonStructure class
JsonReader reader = Json.createReader(
new FileReader("sample.txt"));
JsonStructure jsonst = reader.read();
StringWriter stWriter = new StringWriter();
// Try block to check for exceptions
try (JsonWriter jsonWriter
= Json.createWriter(stWriter)) {
jsonWriter.writeObject((JsonObject)jsonst);
}
// Step 1
String jsonData = stWriter.toString();
// Step 2
// Json.createParser(): Creates a JSON parser from a
// character stream.
JsonParser parser
= Json.createParser(new StringReader(jsonData));
// Step 3
// haNext(): Returns true if there are more parsing
// states. This method returns false if the parser
// reaches the end of the JSON text
while (parser.hasNext()) {
// JsonParser.Event: An event from JsonParser.
// next(): Returns the event for the next
// parsing state.
JsonParser.Event event = parser.next();
// Step 4
// Switch case
switch (event) {
// Case 1
// Start of a JSON array.
case START_ARRAY:
// Case 2
// End of a JSON array.
case END_ARRAY:
// Case 3
// Start of a JSON object.
case START_OBJECT:
// Case 4
// End of a JSON object.
case END_OBJECT:
// Case 5
// False value in a JSON array or object.
case VALUE_FALSE:
// Case 6
// Null value in a JSON array or object.
case VALUE_NULL:
// Case 7
// True value in a JSON array or object.
case VALUE_TRUE:
System.out.println(event.toString());
break;
// Case 8
// Name in a name/value pair of a JSON object.
case KEY_NAME:
System.out.print(event.toString() + " "
+ parser.getString()
+ " - ");
break;
// Case 9
// String value in a JSON array or object.
case VALUE_STRING:
// Case 10
// Number value in a JSON array or object.
case VALUE_NUMBER:
System.out.println(event.toString() + " "
+ parser.getString());
break;
}
}
}
}
Output:
START_OBJECT
KEY_NAME firstName - VALUE_STRING John
KEY_NAME lastName - VALUE_STRING Smith
KEY_NAME age - VALUE_NUMBER 25
KEY_NAME address - START_OBJECT
KEY_NAME streetAddress - VALUE_STRING 21 2nd Street
KEY_NAME city - VALUE_STRING New York
KEY_NAME state - VALUE_STRING NY
KEY_NAME postalCode - VALUE_STRING 10021
END_OBJECT
KEY_NAME phoneNumber - START_ARRAY
START_OBJECT
KEY_NAME type - VALUE_STRING home
KEY_NAME number - VALUE_STRING 212 555-1234
END_OBJECT
START_OBJECT
KEY_NAME type - VALUE_STRING fax
KEY_NAME number - VALUE_STRING 646 555-4567
END_OBJECT
END_ARRAY
END_OBJECT
2. Writing JSON Data using Generator
Using the JsonGenerator we can write JSON data to an output source in a streaming way. Obtain a JSON generator by calling the Json.createGenerator static method, which takes a writer or an output stream as a parameter. We will write the JSON data to a details.txt file.
Example
Java
// Java Program to Generate JSON data and Store it into a
// file.
// Importing required classes
import java.io.FileWriter;
import java.io.IOException;
import javax.json.Json;
import javax.json.stream.JsonGenerator;
// Main class
// WriteJSONDataUsingGenerator
public class GFG {
// Main driver method
public static void main(String args[])
{
FileWriter writer = null;
// Try block to check for exceptions
try {
writer = new FileWriter("details.txt");
}
// Catch block to handle i/o exceptions
catch (IOException e) {
// Print the exceptions along with line number
// using printStackTrace() method
e.printStackTrace();
}
// Json.createGenerator(): Creates a JSON generator
// for writing JSON to a character stream.
JsonGenerator generator
= Json.createGenerator(writer);
// writeStartObject(): Writes the JSON name/start
// object character pair in the current object
// context. write(): Writes a JSON name/string value
// pair in the current object context. writeEnd():
// Writes the end of the current context.
// writeStartArray(): Writes the JSON name/start
// array character pair with in the current object
// context.
generator.writeStartObject()
.write("firstName", "John")
.write("lastName", "Smith")
.write("age", 25)
.writeStartObject("address")
.write("streetAddress", "21 2nd Street")
.write("city", "New York")
.write("state", "NY")
.write("postalCode", "10021")
.writeEnd()
.writeStartArray("phoneNumber")
.writeStartObject()
.write("type", "home")
.write("number", "212 555-1234")
.writeEnd()
.writeStartObject()
.write("type", "fax")
.write("number", "646 555-4567")
.writeEnd()
.writeEnd()
.writeEnd();
// Closes this generator and frees any resources
// associated with it using close() method
generator.close();
}
}
Output: In the details.txt file the following data will be written in a single line:
{
"firstName":"John","lastName":"Smith","age":25,
"address":{"streetAddress":"21 2nd Street","city":"New York","state":"NY","postalCode":"10021"},
"phoneNumber":[{"type":"home","number":"212 555-1234"},{"type":"fax","number":"646 555-4567"}]
}
Similar Reads
Java Tutorial Java is a high-level, object-oriented programming language used to build web apps, mobile applications, and enterprise software systems. Known for its Write Once, Run Anywhere capability, which means code written in Java can run on any device that supports the Java Virtual Machine (JVM).Syntax and s
10 min read
Basics
Introduction to JavaJava is a high-level, object-oriented programming language developed by Sun Microsystems in 1995. It is platform-independent, which means we can write code once and run it anywhere using the Java Virtual Machine (JVM). Java is mostly used for building desktop applications, web applications, Android
4 min read
Java Programming BasicsJava is one of the most popular and widely used programming language and platform. A platform is an environment that helps to develop and run programs written in any programming language. Java is fast, reliable and secure. From desktop to web applications, scientific supercomputers to gaming console
4 min read
Java MethodsJava Methods are blocks of code that perform a specific task. A method allows us to reuse code, improving both efficiency and organization. All methods in Java must belong to a class. Methods are similar to functions and expose the behavior of objects.Example: Java program to demonstrate how to crea
7 min read
Access Modifiers in JavaIn Java, access modifiers are essential tools that define how the members of a class, like variables, methods, and even the class itself, can be accessed from other parts of our program. They are an important part of building secure and modular code when designing large applications. In this article
6 min read
Arrays in JavaIn Java, an array is an important linear data structure that allows us to store multiple values of the same type. Arrays in Java are objects, like all other objects in Java, arrays implicitly inherit from the java.lang.Object class. This allows you to invoke methods defined in Object (such as toStri
9 min read
Java StringsIn Java, a String is the type of object that can store a sequence of characters enclosed by double quotes and every character is stored in 16 bits, i.e., using UTF 16-bit encoding. A string acts the same as an array of characters. Java provides a robust and flexible API for handling strings, allowin
8 min read
Regular Expressions in JavaIn Java, Regular Expressions or Regex (in short) in Java is an API for defining String patterns that can be used for searching, manipulating, and editing a string in Java. Email validation and passwords are a few areas of strings where Regex is widely used to define the constraints. Regular Expressi
7 min read
OOPs & Interfaces
Classes and Objects in JavaIn Java, classes and objects are basic concepts of Object Oriented Programming (OOPs) that are used to represent real-world concepts and entities. A class is a template to create objects having similar properties and behavior, or in other words, we can say that a class is a blueprint for objects.An
10 min read
Java ConstructorsIn Java, constructors play an important role in object creation. A constructor is a special block of code that is called when an object is created. Its main job is to initialize the object, to set up its internal state, or to assign default values to its attributes. This process happens automaticall
10 min read
Java OOP(Object Oriented Programming) ConceptsBefore Object-Oriented Programming (OOPs), most programs used a procedural approach, where the focus was on writing step-by-step functions. This made it harder to manage and reuse code in large applications.To overcome these limitations, Object-Oriented Programming was introduced. Java is built arou
10 min read
Java PackagesPackages in Java are a mechanism that encapsulates a group of classes, sub-packages and interfaces. Packages are used for: Prevent naming conflicts by allowing classes with the same name to exist in different packages, like college.staff.cse.Employee and college.staff.ee.Employee.They make it easier
8 min read
Java InterfaceAn Interface in Java programming language is defined as an abstract type used to specify the behaviour of a class. An interface in Java is a blueprint of a behaviour. A Java interface contains static constants and abstract methods. Key Properties of Interface:The interface in Java is a mechanism to
11 min read
Collections
Exception Handling
Java Exception HandlingException handling in Java is an effective mechanism for managing runtime errors to ensure the application's regular flow is maintained. Some Common examples of exceptions include ClassNotFoundException, IOException, SQLException, RemoteException, etc. By handling these exceptions, Java enables deve
8 min read
Java Try Catch BlockA try-catch block in Java is a mechanism to handle exceptions. This make sure that the application continues to run even if an error occurs. The code inside the try block is executed, and if any exception occurs, it is then caught by the catch block.Example: Here, we are going to handle the Arithmet
4 min read
Java final, finally and finalizeIn Java, the keywords "final", "finally" and "finalize" have distinct roles. final enforces immutability and prevents changes to variables, methods, or classes. finally ensures a block of code runs after a try-catch, regardless of exceptions. finalize is a method used for cleanup before an object is
4 min read
Chained Exceptions in JavaChained Exceptions in Java allow associating one exception with another, i.e. one exception describes the cause of another exception. For example, consider a situation in which a method throws an ArithmeticException because of an attempt to divide by zero.But the root cause of the error was an I/O f
3 min read
Null Pointer Exception in JavaA NullPointerException in Java is a RuntimeException. It occurs when a program attempts to use an object reference that has the null value. In Java, "null" is a special value that can be assigned to object references to indicate the absence of a value.Reasons for Null Pointer ExceptionA NullPointerE
5 min read
Exception Handling with Method Overriding in JavaException handling with method overriding in Java refers to the rules and behavior that apply when a subclass overrides a method from its superclass and both methods involve exceptions. It ensures that the overridden method in the subclass does not declare broader or new checked exceptions than thos
4 min read
Java Advanced
Java Multithreading TutorialThreads are the backbone of multithreading. We are living in the real world which in itself is caught on the web surrounded by lots of applications. With the advancement in technologies, we cannot achieve the speed required to run them simultaneously unless we introduce the concept of multi-tasking
15+ min read
Synchronization in JavaIn multithreading, synchronization is important to make sure multiple threads safely work on shared resources. Without synchronization, data can become inconsistent or corrupted if multiple threads access and modify shared variables at the same time. In Java, it is a mechanism that ensures that only
10 min read
File Handling in JavaIn Java, with the help of File Class, we can work with files. This File Class is inside the java.io package. The File class can be used to create an object of the class and then specifying the name of the file.Why File Handling is Required?File Handling is an integral part of any programming languag
6 min read
Java Method ReferencesIn Java, a method is a collection of statements that perform some specific task and return the result to the caller. A method reference is the shorthand syntax for a lambda expression that contains just one method call. In general, one does not have to pass arguments to method references.Why Use Met
9 min read
Java 8 Stream TutorialJava 8 introduces Stream, which is a new abstract layer, and some new additional packages in Java 8 called java.util.stream. A Stream is a sequence of components that can be processed sequentially. These packages include classes, interfaces, and enum to allow functional-style operations on the eleme
15+ min read
Java NetworkingWhen computing devices such as laptops, desktops, servers, smartphones, and tablets and an eternally-expanding arrangement of IoT gadgets such as cameras, door locks, doorbells, refrigerators, audio/visual systems, thermostats, and various sensors are sharing information and data with each other is
15+ min read
JDBC TutorialJDBC stands for Java Database Connectivity. JDBC is a Java API or tool used in Java applications to interact with the database. It is a specification from Sun Microsystems that provides APIs for Java applications to communicate with different databases. Interfaces and Classes for JDBC API comes unde
12 min read
Java Memory ManagementJava memory management is the process by which the Java Virtual Machine (JVM) automatically handles the allocation and deallocation of memory. It uses a garbage collector to reclaim memory by removing unused objects, eliminating the need for manual memory managementJVM Memory StructureJVM defines va
4 min read
Garbage Collection in JavaGarbage collection in Java is an automatic memory management process that helps Java programs run efficiently. Java programs compile to bytecode that can be run on a Java Virtual Machine (JVM). When Java programs run on the JVM, objects in the heap are created, which is a portion of memory dedicated
7 min read
Memory Leaks in JavaIn programming, a memory leak happens when a program keeps using memory but does not give it back when it's done. It simply means the program slowly uses more and more memory, which can make things slow and even stop working. Working of Memory Management in JavaJava has automatic garbage collection,
3 min read
Practice Java
Java Interview Questions and AnswersJava is one of the most popular programming languages in the world, known for its versatility, portability, and wide range of applications. Java is the most used language in top companies such as Uber, Airbnb, Google, Netflix, Instagram, Spotify, Amazon, and many more because of its features and per
15+ min read
Java Programs - Java Programming ExamplesIn this article, we will learn and prepare for Interviews using Java Programming Examples. From basic Java programs like the Fibonacci series, Prime numbers, Factorial numbers, and Palindrome numbers to advanced Java programs.Java is one of the most popular programming languages today because of its
8 min read
Java Exercises - Basic to Advanced Java Practice Programs with SolutionsLooking for Java exercises to test your Java skills, then explore our topic-wise Java practice exercises? Here you will get 25 plus practice problems that help to upscale your Java skills. As we know Java is one of the most popular languages because of its robust and secure nature. But, programmers
7 min read
Java Quiz | Level Up Your Java SkillsThe best way to scale up your coding skills is by practicing the exercise. And if you are a Java programmer looking to test your Java skills and knowledge? Then, this Java quiz is designed to challenge your understanding of Java programming concepts and assess your excellence in the language. In thi
1 min read
Top 50 Java Project Ideas For Beginners and Advanced [Update 2025]Java is one of the most popular and versatile programming languages, known for its reliability, security, and platform independence. Developed by James Gosling in 1982, Java is widely used across industries like big data, mobile development, finance, and e-commerce.Building Java projects is an excel
15+ min read