DEV Community: Pravanjan Amanta

🚀 Mastering JDBC: Bridging Java and Databases Seamlessly 📊

Pravanjan Amanta — Fri, 03 Jan 2025 18:32:53 +0000

JDBC IN JAVA

JDBC (Java Database Connectivity) is a key API in Advanced Java that allows Java applications to interact with databases. It provides a standard way to connect to a database, execute SQL queries, and retrieve results. Below is a comprehensive overview:

Key Components of JDBC

DriverManager:

Manages a list of database drivers and establishes a connection between the application and the database.
Connection:

Represents the session between the Java application and the database.
Statement:

Executes static SQL queries against the database.
PreparedStatement:

Used to execute parameterized SQL queries, improving security and performance.
CallableStatement:

Used for executing stored procedures in the database.
ResultSet:

Represents the results of a query, allowing navigation through rows of data.

Steps to Use JDBC

Load the Driver:

Class.forName("com.mysql.cj.jdbc.Driver"); // Load MySQL Driver

Establish a Connection:

Connection con = DriverManager.getConnection(
    "jdbc:mysql://localhost:3306/yourDatabaseName", "username", "password");

Create a Statement:

Statement stmt = con.createStatement();

Execute a Query:

ResultSet rs = stmt.executeQuery("SELECT * FROM yourTableName");
while (rs.next()) {
    System.out.println(rs.getString("columnName"));
}

Close the Connection:

rs.close();
stmt.close();
con.close();

Advantages of JDBC

Platform Independence: Works on any platform with a supported Java environment.
Supports Multiple Databases: Compatible with various databases like MySQL, Oracle, PostgreSQL, etc.
Dynamic SQL Execution: Provides flexibility to execute both static and dynamic SQL.
Database Metadata: Allows retrieval of database and table structure.

Types of JDBC Drivers

Type 1: JDBC-ODBC Bridge Driver (Deprecated)
Type 2: Native-API Driver
Type 3: Network Protocol Driver
Type 4: Thin Driver (Pure Java driver, widely used)

Common JDBC Operations

Insert Data:

String query = "INSERT INTO employees (id, name) VALUES (?, ?)";
PreparedStatement pstmt = con.prepareStatement(query);
pstmt.setInt(1, 101);
pstmt.setString(2, "John Doe");
pstmt.executeUpdate();

Update Data:

String query = "UPDATE employees SET name = ? WHERE id = ?";
PreparedStatement pstmt = con.prepareStatement(query);
pstmt.setString(1, "Jane Doe");
pstmt.setInt(2, 101);
pstmt.executeUpdate();

Delete Data:

String query = "DELETE FROM employees WHERE id = ?";
PreparedStatement pstmt = con.prepareStatement(query);
pstmt.setInt(1, 101);
pstmt.executeUpdate();

Example Program

import java.sql.*;

public class JdbcExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/yourDatabase";
        String user = "root";
        String password = "password";

        try (Connection con = DriverManager.getConnection(url, user, password);
             PreparedStatement pstmt = con.prepareStatement("SELECT * FROM yourTable")) {

            ResultSet rs = pstmt.executeQuery();
            while (rs.next()) {
                System.out.println("ID: " + rs.getInt("id") + ", Name: " + rs.getString("name"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

✨ More update to connect:

GitHub
Linkedin

🚀 Mastering Generics in Java: The Ultimate Guide to Type-Safe and Reusable Code 💻

Pravanjan Amanta — Thu, 02 Jan 2025 19:28:14 +0000

Generics in Java: A Comprehensive Guide

Generics in Java are a powerful feature introduced in Java 5 that allow developers to write reusable and type-safe code. While primarily used in collections, their applications extend far beyond. Generics enable you to specify types at compile-time, reducing runtime errors and enhancing code readability.

Key Concepts of Generics

Type Safety

Generics ensure that only the specified type of data can be added to a collection or used in a method, preventing runtime ClassCastException.
Code Reusability

A single generic class, method, or interface can work with various types of data, reducing redundancy and promoting code reuse.

How Generics Work

Generic Classes > Generic classes allow you to define a class that works with any data type. Here's an example:

class Box<T> {
    private T item;

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }
}

public class Main {
    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.setItem("Hello");
        System.out.println(stringBox.getItem());

        Box<Integer> intBox = new Box<>();
        intBox.setItem(123);
        System.out.println(intBox.getItem());
    }
}

Generic Methods > Generic methods allow type parameters to be used in method definitions.

class Util {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3};
        String[] strArray = {"A", "B", "C"};
        Util.printArray(intArray);
        Util.printArray(strArray);
    }
}

Bounded Type Parameters > Type parameters can be constrained using extends or super.
Upper Bound (extends): Ensures the type is a subclass of the specified type.

class MathUtils {
    public static <T extends Number> double square(T number) {
        return number.doubleValue() * number.doubleValue();
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(MathUtils.square(5));    // Integer
        System.out.println(MathUtils.square(5.5)); // Double
    }
}

Lower Bound (super): Ensures the type is a superclass of the specified type.

Wildcards > Wildcards (?) represent an unknown type and offer flexibility when working with generics.
Unbounded Wildcard:

public static void printList(List<?> list) {
    for (Object item : list) {
        System.out.println(item);
    }
}

Upper Bounded Wildcard:

public static void printNumbers(List<? extends Number> list) {
    for (Number num : list) {
        System.out.println(num);
    }
}

Lower Bounded Wildcard:

public static void addNumbers(List<? super Integer> list) {
    list.add(10); // Only Integer or its subclass can be added
}

Generics and Collections

The Java Collections Framework heavily relies on generics to provide type safety.

Example: Using Generics with Lists

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");

        for (String name : names) {
            System.out.println(name);
        }
    }
}

Example: Using Generics with Maps

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "One");
        map.put(2, "Two");

        for (Integer key : map.keySet()) {
            System.out.println("Key: " + key + ", Value: " + map.get(key));
        }
    }
}

Advantages of Generics

Type Safety:

Prevents runtime errors by catching type mismatches at compile time.
Code Reusability:

Allows writing flexible, reusable code for any type.
Performance:

Reduces runtime overhead by eliminating the need for explicit typecasting.

Limitations of Generics

Type Erasure:

Generics are implemented using type erasure, so the type information is not available at runtime.
Primitive Types Not Allowed:

Generics work only with objects. Use wrapper classes like Integer for int.
No Static Members:

Generic classes cannot define static fields or methods using the type parameter.

Conclusion

Generics in Java are essential for writing robust, maintainable, and efficient code. By leveraging type safety and code reusability, developers can handle data more effectively. Whether you're working with collections or creating custom classes, mastering generics is crucial for advanced Java development.

Thread Concurrency In Java

Pravanjan Amanta — Thu, 31 Oct 2024 21:09:56 +0000

Thread Concurrency or Multithreading in advanced Java allows multiple threads to execute concurrently, enhancing performance and responsiveness in complex applications. Here’s a concise breakdown of its key concepts and utilities.

Key Features of Multithreading in Java:

Creating Threads.
Thread Management with Executors
Concurrency Utilities
Fork/Join Framework
Asynchronous Programming with Completable Future

1️⃣ Creating Threads.

Extending Thread: Create a new thread by overriding the run() method.
Implementing Runnable: Pass a Runnable instance to a Thread object.
Implementing Callable: Unlike Runnable, Callable allows threads to return a result and handle checked exceptions.

2️⃣ Thread Management with Executors.

Java’s Executor Framework (java.util.concurrent.ExecutorService) manages thread pools, allowing efficient handling of tasks.
Executors like FixedThreadPool and CachedThreadPool create a pool of reusable threads, managing them efficiently to reduce the overhead of creating new threads.

3️⃣ Concurrency Utilities

Locks: Advanced locking mechanisms like ReentrantLock provide more flexibility than synchronized methods, allowing timed and interruptible locks.
Atomic Variables: The java.util.concurrent.atomic package includes atomic classes (AtomicInteger, AtomicLong) that offer lock-free thread-
safe operations.
Synchronizers:include utilities like:
CountDownLatch: Allows a thread to wait until other threads complete
tasks.
CyclicBarrier: Synchronizes a fixed number of threads at a common
barrier point.
Semaphore: Controls access to resources by allowing a specific number
of concurrent threads.

4️⃣ Fork/Join Framework

1. For divide-and-conquer tasks, ForkJoinPool splits a task into smaller subtasks that are processed in parallel, particularly useful in recursive algorithms.

5️⃣ Asynchronous Programming with Completable Future

CompletableFuture enables asynchronous and non-blocking programming, allowing chaining and combining tasks for complex workflows.

Using Thread Example

Main class call 2 different thread

public class ThreadConcurrence {
    public static void main(String[] args) {
        // There is 2 type you have to call thread method
                //1- Extend Thread class
                //1- Implements Runnable class
        // why Implement concept is introduce here
                // because in java multiple thread dose not support that's so why implement class will introduce
                // ex- when u extend (inherit) base call, then at that time this call can not extend another Thread class.
        int n = 10;
        for (int i = 0; i < n; i++) {

            // in case of extend(inherit) Thread class
            Thread1 t1 = new Thread1();
            t1.start();

            // in case of implement Runnable class
            Thread t2 =new Thread(new Thread2());
            t2.start();
        }
    }
}

Thread1--(extends Thread)

public class Thread1 extends Thread{
    //If you are extend Thread class then you  most be used run()
    // Because when you start a thread then run() automatically call and run
    public void run(){
        try {
            System.out.println("Thread1 is running now....");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

Thread2--(implements Runnable)

public class Thread2 implements Runnable {
    //IF you are implement thread Then run() will be executed.
    // Because when you start a thread then run() automatically call and run
    public void run(){
        try {
            System.out.println("Thread2 is running.......");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

Conclusion :

By leveraging these tools and frameworks, advanced Java multithreading enables building scalable, high-performance applications that can handle concurrent tasks seamlessly.

For more insights, feel free to mention your Linkedin and GitHub for in-depth examples and code samples! Let me know if you'd like any specific adjustments.

Linkedin : https://www.linkedin.com/in/pravanjan-17p/

GitHub : https://github.com/Prabhanjan-17p

Serialization and Deserialization In Java

Pravanjan Amanta — Mon, 28 Oct 2024 15:45:21 +0000

In advanced Java, serialization and deserialization are processes to save and restore the state of an object, making it possible to store objects in files or databases, or transfer them over a network. Here’s a breakdown of these concepts and their application

1️⃣ Serialization

Serialization is the process of converting an object into a stream of bytes. This byte stream can be saved to a file, sent over a network, or stored in a database. In Java, the Serializable interface is used to indicate that a class can be serialized.

✍ Steps to serialize an object:

▶️ Implement the Serializable interface.

▶️ Use ObjectOutputStream and FileOutputStream to write the object to a file or output stream.

▶️ Call the writeObject() method on ObjectOutputStream.

👉Code Example:

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class Employee implements Serializable {
    private static final long serialVersionUID = 1L;
    String name;
    int id;

    public Employee(String name, int id) {
        this.name = name;
        this.id = id;
    }
}

public class SerializeDemo {
    public static void main(String[] args) {
        Employee emp = new Employee("John Doe", 101);

        try (FileOutputStream fileOut = new FileOutputStream("employee.ser");
             ObjectOutputStream out = new ObjectOutputStream(fileOut)) {
            out.writeObject(emp);
            System.out.println("Serialized data is saved in employee.ser");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Here, employee.ser is a serialized file that stores the object’s byte stream.

2️⃣ Deserialization
Deserialization is the reverse process, where the byte stream is converted back into a copy of the original object. This enables you to recreate the object’s state after it’s been stored or transferred.

✍ Steps to deserialize an object:

▶️ Use ObjectInputStream and FileInputStream to read the object from the file or input stream.

▶️ Call the readObject() method on ObjectInputStrea

👉Code Example:

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class DeserializeDemo {
    public static void main(String[] args) {
        Employee emp = null;

        try (FileInputStream fileIn = new FileInputStream("employee.ser");
             ObjectInputStream in = new ObjectInputStream(fileIn)) {
            emp = (Employee) in.readObject();
            System.out.println("Deserialized Employee...");
            System.out.println("Name: " + emp.name);
            System.out.println("ID: " + emp.id);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

This will retrieve the object’s original state, allowing access to its fields as they were before serialization.

3️⃣ Advanced Serialization Topics

▶️ Custom Serialization: Override writeObject() and readObject() for customized serialization.

▶️ Externalizable Interface: Provides full control over serialization, requiring the implementation of writeExternal() and readExternal() methods.

▶️ Transient Fields: Use the transient keyword to avoid serializing specific fields (e.g., sensitive data like passwords).

✍ Advantages of Serialization:

▶️ Allows saving the state of an object for future use.

▶️ Facilitates the transfer of complex data objects over networks.

📝 Briefly Explain Code Example

import java.io.*;

class Student implements Serializable {
    private  static   final long serialVersionUId = 1l;
    private String name ;
    private int  age;
    private String Address;

    public Student(String name,int age,String Address){
        this.name = name;
        this.age = age;
        this.Address = Address;
    }
    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public void setAddress(String Address){
        this.Address = Address;
    }

    public String getName(){
        return name;
    }
    public String getAddress(){
        return Address;
    }
    public int getAge(){
        return age;
    }


    public String toString(){
        return ("Student name is "+this.getName()+", age is "+this.getAge()+", and address is "+this.getAddress());
    }
}

public class  JAVA3_Serialization {
    // when you implement Serializable then you must be write a serialVersionUId because when it serialise and deserialize it uniquely identify in the network
    // when u update ur object or anything then you have to update the serialVersionUId increment .
    // private  static   final long serialVersionUId = 1l;

    // transient  int x ;
    // If you do not want a particular value to serialise and Deserialize.
    // the value x, when you don't serialise and Deserialize Then transient you used.

    public static void main(String[] args) {

        Student student = new Student("kanha",21,"angul odisha");

        String filename = "D:\\Advance JAVA\\CLS3 JAVA\\Test.txt"; // store the data in this location
        FileOutputStream fileOut = null; // write file
        ObjectOutputStream objOut = null; // create object
        //Serialization
        try {
            fileOut = new FileOutputStream(filename);
            objOut = new ObjectOutputStream(fileOut);
            objOut.writeObject(student);

            objOut.close();
            fileOut.close();

            System.out.println("Object has been serialise =\n"+student);
        } catch (IOException ex){
            System.out.println("error will occure");
        }

        //Deserialization
        FileInputStream fileIn = null;
        ObjectInputStream objIn = null;
        try {
            fileIn = new FileInputStream(filename);
            objIn = new ObjectInputStream(fileIn);
            Student object =(Student) objIn.readObject();
            System.out.println("object has been Deserialization =\n"+object);

            objIn.close();
            fileIn.close();

        } catch (IOException e) {
            throw new RuntimeException(e);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}

✍ Key Notes:

▶️ Only non-static and non-transient data members are serialized by default.

▶️ Serializable objects must ensure compatibility between versions if the class is modified after serialization.

For more insights, feel free to mention your GitHub for in-depth examples and code samples! Let me know if you'd like any specific adjustments.

GitHub - https://github.com/Prabhanjan-17p