Java Sequenced Collection

The Sequenced Collection feature was introduced in Java 9.

Purpose

The purpose of Sequenced Collection is to provide a way to create collections that maintain the order of elements based on the order in which they were added.

Real-time Use Case

Imagine a scenario where you need to maintain the order of tasks in a to-do list application. You want to display the tasks in the order they were added by the user.

In this case, you can use a Sequenced Collection to store the tasks, ensuring that they are displayed in the correct order.

Executable Code

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // Example using SequencedMap
        System.out.println("Example using SequencedMap:");
        Map<String, String> sequencedMap = new SequencedMap<>();
        sequencedMap.put("1", "One");
        sequencedMap.put("2", "Two");
        sequencedMap.put("3", "Three");

        System.out.println("Entries in the order they were added:");
        for (Map.Entry<String, String> entry : sequencedMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }

        // Example using SequencedSet
        System.out.println("\nExample using SequencedSet:");
        Set<String> sequencedSet = new SequencedSet<>();
        sequencedSet.add("Apple");
        sequencedSet.add("Banana");
        sequencedSet.add("Orange");

        System.out.println("Elements in the order they were added:");
        for (String element : sequencedSet) {
            System.out.println(element);
        }
    }
}
        

Java Virtual Threads

Java Virtual Threads, introduced in Java 21 (JDK 18), are lightweight threads managed by the Java Virtual Machine (JVM). Unlike traditional OS threads, virtual threads are managed entirely within the JVM, providing a more efficient and scalable concurrency model.

What are Java Virtual Threads?

Java Virtual Threads are threads that are managed by the JVM itself, rather than relying on the underlying operating system's threading mechanism. They are lightweight and consume significantly less memory compared to traditional OS threads.

When were Java Virtual Threads introduced?

Java Virtual Threads were introduced in Java 21, which is part of JDK 18. They are a major feature introduced to enhance the concurrency model of the Java platform.

Use Cases for Java Virtual Threads

• Highly Concurrent Applications: Virtual threads are suitable for applications that require high levels of concurrency, such as web servers and microservices.
• Asynchronous I/O Operations: They are well-suited for handling asynchronous I/O operations, such as network communication and file I/O.
• Task Parallelism: Virtual threads can be used to parallelize tasks across multiple CPU cores, improving performance on multi-core systems.
• Scalability: Applications that need to scale to a large number of concurrent users or connections can benefit from the lightweight nature of virtual threads.

Implementation Code

Here's an example of how to create and use virtual threads in Java:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class VirtualThreadExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newVirtualThreadExecutor();

        for (int i = 0; i < 10; i++) {
            executor.execute(() -> {
                System.out.println("Executing task on virtual thread: " + Thread.currentThread().getName());
            });
        }

        executor.shutdown();
    }
}

In this example, we create a virtual thread executor using Executors.newVirtualThreadExecutor() and submit tasks to it using the execute() method. Each task is executed on a separate virtual thread.

Java 21 Features

• Switch Expressions
• Pattern Matching for instanceof
• Records
• Text Blocks
• Sealed Classes
• Local Interfaces

---

Switch Expressions

Java 21 introduces a simplified syntax for switch statements, allowing them to be used as expressions. This enables more concise and readable code.

Example Code:

int day = 3;
String dayType = switch (day) {
    case 1, 2, 3, 4, 5 -> "Weekday";
    case 6, 7 -> "Weekend";
    default -> throw new IllegalArgumentException("Invalid day: " + day);
};
System.out.println("Day type: " + dayType);

---

Pattern Matching for instanceof

Java 21 introduces pattern matching for the instanceof operator, allowing for more concise and readable code when working with object types.

Example Code:

Object obj = "Hello";
if (obj instanceof String s) {
    System.out.println("Length of string: " + s.length());
} else {
    System.out.println("Not a string");
}

---

Records

Java 21 introduces record classes, which are a concise way to declare classes that are essentially data carriers, automatically generating constructors, accessors, and equals() and hashCode() methods.

Example Code:

public record Person(String name, int age) {
    // Record class automatically defines:
    // - Constructor
    // - Accessor methods
    // - equals() and hashCode() methods
}

---

Text Blocks

Java 21 introduces text blocks, which allow for multiline string literals without the need for escape characters. This improves readability and maintainability of code.

Example Code:

String html = """
              <html>
              <body>
              <p>Hello, world!</p>
              </body>
              </html>
              """;
System.out.println(html);

---

Sealed Classes

Java 21 introduces sealed classes, which restrict the subclasses that can extend or implement them, providing more control over class hierarchies.

Example Code:

public sealed interface Shape permits Circle, Rectangle, Triangle {
    // Interface definition
}

---

Local Interfaces

Java 21 allows the declaration of interfaces within methods, known as local interfaces. This can be useful for encapsulating functionality within a method.

Example Code:

public void process() {
    interface Callback {
        void onSuccess();
        void onFailure();
    }
    // Local interface usage
}

FastAPI throws an error (Error loading ASGI app. Could not import module "main")

Make sure the main fastapi code is in the same directory where you are running the code.

graphql spring boot error java.lang.IllegalArgumentException:

Error: java.lang.IllegalArgumentException: Name for argument of type [java.lang.String] not specified, and parameter name information not found in class file either.

Fix: Change @Argument decorator by adding the required input String.

Mysql - java.sql.SQLNonTransientConnectionException: Public Key Retrieval is not allowed

Add allowPublicKeyRetrieval=true to the JDBC URL.

jdbc:mysql://localhost:3306/db?allowPublicKeyRetrieval=true&useSSL=false

Vector Database Explained

A vector database, also known as a vector database management system (VDBMS), is a type of database system optimized for storing and querying vector data. Vector data represents spatial information, such as points, lines, and polygons, often used in geographic information systems (GIS), mapping applications, and spatial analytics. Unlike traditional relational databases, which store data in tabular form, vector databases store geometric shapes and their attributes.

Vector databases are designed to efficiently handle complex spatial queries, spatial indexing, and geometric operations, making them suitable for applications that require spatial analysis, visualization, and location-based services. These databases typically provide specialized data types, indexing structures, and query capabilities tailored to vector data.

Key Features of Vector Databases:

Spatial Data Types: Vector databases support geometric data types, such as points, lines, polygons, and multi-geometries, allowing users to store and manipulate spatial information accurately.

Spatial Indexing: Efficient spatial indexing techniques, such as R-tree or Quadtree, are employed to accelerate spatial queries and improve query performance, especially for large datasets.

Geometric Operations: Vector databases offer built-in functions and operators for performing geometric operations, including intersection, union, buffer, distance calculation, and spatial relationships (e.g., containment, adjacency).

Topology Support: Some vector databases provide topological relationships between geometric features, enabling advanced spatial analysis and network analysis.

Concurrency and Scalability: Scalability and concurrency support are essential for handling large volumes of spatial data and concurrent access from multiple users or applications.

Integration with GIS Tools: Vector databases often integrate with GIS software and libraries, allowing seamless data exchange and interoperability with popular GIS tools and applications.

Transaction Support: Transaction management ensures data consistency and integrity, allowing users to perform atomic updates and maintain data integrity in multi-user environments.

Use Cases of Vector Databases:

Geographic Information Systems (GIS): Vector databases are widely used in GIS applications for storing and analyzing geographic data, such as maps, satellite imagery, terrain models, and environmental data. They support spatial queries, spatial analysis, and map visualization.

Location-Based Services (LBS): LBS applications, including mapping services, navigation systems, and location-based marketing, rely on vector databases to store and retrieve spatial data, such as points of interest (POIs), routes, and geofences.

Urban Planning and Infrastructure Management: Vector databases are used in urban planning, infrastructure management, and city modeling to store and analyze spatial data related to land use, transportation networks, utilities, and facilities.

Environmental Monitoring and Natural Resource Management: Vector databases play a vital role in environmental monitoring, natural resource management, and conservation efforts by storing and analyzing spatial data, such as habitat maps, ecological zones, and species distributions.

Retail and Marketing Analytics: Retailers and marketers use vector databases to analyze spatial data, such as customer demographics, market areas, and sales territories, to optimize store locations, target marketing campaigns, and analyze customer behavior.

Popular Vector Databases:

PostGIS: An open-source spatial database extension for PostgreSQL, providing robust support for vector data types, spatial indexing, and spatial functions. It is widely used in GIS applications and supports advanced spatial analysis capabilities.

Oracle Spatial and Graph: Oracle's spatial database option provides comprehensive support for managing and analyzing spatial data within the Oracle Database. It offers spatial indexing, spatial operators, and integration with Oracle's SQL and PL/SQL.

Microsoft SQL Server Spatial: Microsoft SQL Server includes built-in support for spatial data types and spatial indexing, allowing users to store and query vector data efficiently. It provides spatial functions and integration with SQL Server Management Studio (SSMS).

GeoMesa: An open-source, distributed database built on top of Apache Accumulo, Apache HBase, or Apache Cassandra, designed for storing and querying large-scale spatial data, such as geospatial-temporal data and spatiotemporal trajectories.

MongoDB with GeoJSON: MongoDB, a NoSQL database, supports the storage and indexing of GeoJSON documents, allowing users to store and query spatial data in JSON format. It provides geospatial indexes and spatial query operators.

GeoServer and GeoNode: GeoServer is an open-source server for sharing and publishing geospatial data, while GeoNode is a web-based platform for creating and sharing geospatial content. Both platforms support vector data storage and management.

In conclusion, vector databases are specialized database systems tailored for storing, querying, and analyzing spatial data. They find applications across various domains, including GIS, LBS, urban planning, retail analytics, and environmental monitoring. With a range of available options, users can choose the vector database that best fits their requirements, whether open-source or commercial, relational or NoSQL, depending on factors such as scalability, performance, and integration capabilities.