Скачать или смотреть Creating a Generic Number of Objects in Java

Learn how to effectively create a generic number of objects in Java and understand the handling of references and memory. Perfect for beginners and experienced Java developers alike!
---
This video is based on the question https://stackoverflow.com/q/62387686/ asked by the user '1stNox' ( https://stackoverflow.com/u/12541446/ ) and on the answer https://stackoverflow.com/a/62388974/ provided by the user 'Kevin Anderson' ( https://stackoverflow.com/u/6304094/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: How to create a generic number of objects?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Introduction

As programmers, we often encounter scenarios where we need to create multiple objects of a certain type based on dynamic conditions, such as database entries. For instance, you might be tasked with mapping the entries from a specific database table into Java objects. This raises an important question: How do we create a generic number of objects in Java?

In this guide, we will explore various strategies to create multiple objects efficiently while addressing common concerns about Java's memory management and object references.

The Problem

You want to create n objects of a specific type, let’s say MyObject, dynamically based on the number of entries returned from a database. A naive approach might involve using nested loops and managing lists for every table column, which can become quite inefficient, not to mention complicated!

Here’s what you might initially consider:

Use a list for each column of the database table.

Iterate through these lists, creating objects and adding them to a collection, such as a HashSet.

However, there’s a potential issue here regarding references: If you use a single variable for the object being created within the loop, you might overwrite it, leading to unexpected results.

Understanding Object References in Java

Before diving into optimal solutions, it's critical to clarify how object references work in Java.

Key Points about References:

When you create a new object and assign it to a variable, that variable holds a reference to the object, not the object itself.

If you subsequently assign a new object to the same variable, the original object remains intact in memory, and only the reference stored in the variable changes.

Example to Illustrate This Concept

Consider the following code snippet:

[[See Video to Reveal this Text or Code Snippet]]

After the first object addition, mySet contains: {["Object # 1"]}.

Even after changing myOb to refer to a new object Object # 2, mySet still retains a reference to the first object.

Conclusion on References

This demonstrates that objects added to a collection retain their individual instances. Hence, you will not encounter the "pointer problem" as you initially worried; each object persists unless explicitly removed.

Efficiently Creating Multiple Objects

With the understanding of references clarified, let's look at an efficient method for creating a generic number of objects from database entries.

Suggested Approach: Using a Loop to Create Objects

Retrieve Data: Pull the data from your database and store it in a suitable format (like a list of maps).

Iterate and Create: Loop through the retrieved data to create and add each object to a collection.

Store in Collection: Use a Set or List to store your objects.

Example Implementation

Here’s how you could implement this in your Java application:

[[See Video to Reveal this Text or Code Snippet]]

Why This Works Well

Simplifies Management: By creating a new instance for each row, you avoid issues with references.

Efficiency: This method minimizes unwanted overhead and improves readability.

Conclusion

Creating a generic number of objects in Java based on dynamic conditions can be streamlined with an understanding of references and an effective looping strategy. You no longer need to worry about overwriting references, and by leveraging collections like Set or List, you can manage your objects efficiently and cleanly.

By following this approach, you'll not only simplify your code but also avoid common pitfalls associated with object creation in Java.