Showing posts with label ArrayList. Show all posts

Monday, 3 April 2023

How to read a range of documents using Java in MongoDB and add the docs into ArrayList or Consumer?

🚀 Love Java? Don't miss out!

Subscribe to Ram N Java for more beginner-friendly coding tutorials!

Mastering MongoDB with Java: Reading Document Ranges

In this tutorial, we dive into how to effectively filter and retrieve documents from a MongoDB collection using Java. This is a crucial skill for any developer working with NoSQL databases.

Step 1: Connecting to MongoDB

First, we create a MongoClient object by providing the host name and port number. This acts as our gateway to the database server.

Step 2: Selecting Your Collection

Once connected, we access our specific database (e.g., "order") and target the "product" collection. This is where our data resides.

Step 3: Filtering Data (Greater Than Logic)

The power of MongoDB lies in filtering. In this example, we use the find() method with a criteria to fetch products where the price is greater than 10,000.

Step 4: Storing Results in ArrayList or Consumer

After filtering, we can handle the data in two modern ways:

ArrayList: Store all matching documents in a list to iterate through later.
Consumer Interface: Use a functional approach to process each document as it is retrieved.

Check Out More Tutorials

If you found this helpful, explore these related videos from my channel:

Wednesday, 8 August 2018

How to create a concrete List collection (ArrayList and LinkedList) using ListFactoryBean in Spring

Enjoying This Tutorial?

Subscribe to Ram N Java for high-quality, practical Java and Spring tutorials!

SUBSCRIBE NOW

Introduction

In Spring Framework, when you inject collections using standard <list> tags, Spring creates an internal default List implementation. However, if your application explicitly requires a specific concrete implementation such as java.util.ArrayList or java.util.LinkedList, Spring provides the ListFactoryBean helper class.

Why Use ListFactoryBean?

Explicit Implementation: Set whether the resulting List bean is backed by ArrayList or LinkedList using the targetListClass property.
Standalone Reusable Bean: Define the list as its own first-class Spring bean and inject it into multiple collaborator beans across your context.
Fine-Grained Control: Easily swap implementations for performance optimization (e.g., fast random access vs. frequent additions/removals) directly in XML.

Step-by-Step Configuration

1. Configuring an ArrayList with ListFactoryBean

To configure a concrete ArrayList, set targetListClass to java.util.ArrayList:

<bean id="cityArrayList" class="org.springframework.beans.factory.config.ListFactoryBean">
    <property name="targetListClass" value="java.util.ArrayList" />
    <property name="sourceList">
        <list>
            <value>New York</value>
            <value>London</value>
            <value>Tokyo</value>
        </list>
    </property>
</bean>

2. Configuring a LinkedList with ListFactoryBean

To switch to a LinkedList, simply change the targetListClass value:

<bean id="cityLinkedList" class="org.springframework.beans.factory.config.ListFactoryBean">
    <property name="targetListClass" value="java.util.LinkedList" />
    <property name="sourceList">
        <list>
            <value>New York</value>
            <value>London</value>
            <value>Tokyo</value>
        </list>
    </property>
</bean>

Key Takeaway

ListFactoryBean provides an explicit, clean way in Spring XML to control concrete List collection types without changing your Java bean source code. Use ArrayList when fast index-based retrieval is needed and LinkedList when elements are frequently added or removed.

Recommended Related Tutorials from Ram N Java

Click here to watch on Youtube:
https://www.youtube.com/watch?v=0qcalr8iIpk&list=UUhwKlOVR041tngjerWxVccw

Click the below Image to Enlarge:

How to create a concrete List collection (ArrayList and LinkedList) using ListFactoryBean in Spring

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0%20http://maven.apache.org/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.ram.core</groupId>

    <artifactId>SpringDemo</artifactId>

    <packaging>jar</packaging>

    <version>1.0-SNAPSHOT</version>

    <name>SpringDemo</name>

    <url>http://maven.apache.org</url>

    <properties>

        <spring.version>5.0.2.RELEASE</spring.version>

    </properties>

    <dependencies>

        <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>3.8.1</version>

            <scope>test</scope>

        </dependency>

        <!-- Spring 5 dependencies -->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-core</artifactId>

            <version>${spring.version}</version>

        </dependency>

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-context</artifactId>

            <version>${spring.version}</version>

        </dependency>

    </dependencies>

</project>

FruitShop.java

package com.ram.core;

import java.util.List;

public class FruitShop

{

    private String shopName;

    private List<String> listOfAvailableFruits;

    public String getShopName()

    {

        return shopName;

    }

    public void setShopName(String shopName)

    {

        System.out.println("setShopName(String shopName) is "

                + "called by the Spring Container");

        this.shopName = shopName;

    }

    public List<String> getListOfAvailableFruits()

    {

        return listOfAvailableFruits;

    }

    public void setListOfAvailableFruits(List<String> listOfAvailableFruits)

    {

        System.out.println(

                "setListOfAvailableFruits(List<String> listOfAvailableFruits) is "

                        + "called by the Spring Container");

        this.listOfAvailableFruits = listOfAvailableFruits;

    }

    public void displayFruitShopInfo()

    {

        System.out.println("FruitShop [shopName=" + shopName

                + ", listOfAvailableFruits=" + listOfAvailableFruits + "]");

    }

}

applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 

    xmlns:util="http://www.springframework.org/schema/util"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd

    http://www.springframework.org/schema/util

    http://www.springframework.org/schema/util/spring-util-4.3.xsd">

    <bean id="fruitShop" class="com.ram.core.FruitShop">

        <property name="shopName" value="Fruit Mart"></property>

        <property name="listOfAvailableFruits">

            <bean class="org.springframework.beans.factory.config.ListFactoryBean">

                <property name="targetListClass">

                    <value>java.util.ArrayList</value>

                </property>

                <property name="sourceList">

                    <list>

                        <value>apple</value>

                        <value>pineapple</value>

                        <value>orange</value>

                    </list>

                </property>

            </bean>

        </property>

    </bean>

</beans>

App.java

package com.ram.core;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App

{

    public static void main(String[] args)

    {

        ApplicationContext context = new ClassPathXmlApplicationContext(

                "applicationContext.xml");

        System.out.println("---------------------------------------");

        FruitShop fruitShop = (FruitShop) context.getBean("fruitShop");

        System.out.println(

                "Got fruitShop object from the ApplicationContext(Spring Container)");

        fruitShop.displayFruitShopInfo();

    }

}

Output

Jul 28, 2018 12:08:50 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh

INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@5b37e0d2: startup date [Sat Jul 28 12:08:50 IST 2018]; root of context hierarchy

Jul 28, 2018 12:08:50 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions

INFO: Loading XML bean definitions from class path resource [applicationContext.xml]

setShopName(String shopName) is called by the Spring Container

setListOfAvailableFruits(List<String> listOfAvailableFruits) is called by the Spring Container

---------------------------------------

Got fruitShop object from the ApplicationContext(Spring Container)

FruitShop [shopName=Fruit Mart, listOfAvailableFruits=[apple, pineapple, orange]]

Click the below link to download the code:
https://sites.google.com/site/ramj2eev2/java_basics/SpringDemo_List_ListFactoryBean.zip?attredirects=0&d=1

Github Link:
https://github.com/ramram43210/javaee/tree/master/Spring_2018/SpringDemo_List_ListFactoryBean

Bitbucket Link:
https://bitbucket.org/ramram43210/spring/src/463ef0439e374e3884b06b8ead881ecf3ac4364f/Spring_2018/SpringDemo_List_ListFactoryBean/?at=master

See also:

All JavaEE Videos Playlist

All Design Patterns Links

JDBC Tutorial

Java Collection Framework Tutorial

JAVA Tutorial

Kids Tutorial

Cooking Tutorial

Tuesday, 7 August 2018

How to create a concrete List collection class (ArrayList and LinkedList) using util:list in Spring

Enjoying This Tutorial?

Subscribe to Ram N Java for high-quality, practical Java and Spring tutorials!

SUBSCRIBE NOW

Introduction

In the Spring Framework, defining collections directly using the util schema is concise, modern, and readable. Using the util:list element, you can easily instantiate and inject concrete List implementations such as java.util.ArrayList or java.util.LinkedList as first-class, standalone Spring beans.

Why Use util:list?

Explicit Concrete Implementation: Use the list-class attribute to specify whether your bean is an ArrayList or a LinkedList.
Clean and Concise XML: Eliminates verbose factory bean declarations while remaining fully declarative.
Standalone Reusability: Create standalone collection beans that can be referenced across multiple bean definitions via ref.

Step-by-Step Configuration

First, ensure the Spring util namespace is defined at the top of your XML context configuration:

xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="... http://www.springframework.org/schema/util 
http://www.springframework.org/schema/util/spring-util.xsd"

1. Defining an ArrayList with util:list

<util:list id="cityArrayList" list-class="java.util.ArrayList">
    <value>New York</value>
    <value>London</value>
    <value>Tokyo</value>
</util:list>

2. Defining a LinkedList with util:list

<util:list id="cityLinkedList" list-class="java.util.LinkedList">
    <value>New York</value>
    <value>London</value>
    <value>Tokyo</value>
</util:list>