Expand Authors Top

If you have a few years of experience in the Java ecosystem and you’d like to share that with the community, have a look at our Contribution Guidelines.

Expanded Audience – Frontegg – Security (partner)
announcement - icon User management is very complex, when implemented properly. No surprise here.

Not having to roll all of that out manually, but instead integrating a mature, fully-fledged solution - yeah, that makes a lot of sense.
That's basically what Frontegg is - User Management for your application. It's focused on making your app scalable, secure and enjoyable for your users.
From signup to authentication, it supports simple scenarios all the way to complex and custom application logic.

Have a look:

>> Elegant User Management, Tailor-made for B2B SaaS

1. Overview

MongoDB is the most popular open-source and distributed document-oriented NoSQL database. A document in MongoDB is a data structure with JSON-like objects having field and value pairs.

In order to insert documents into a MongoDB collection, we can use different methods such as insert(), insertOne() and insertMany().

In this tutorial, we'll discuss how to insert an array inside a MongoDB document. First, we'll look at inserting an array into documents using the MongoDB Shell query. Then we'll use the MongoDB Java driver code.

2. Database Initialization

Before we move on to the insert queries, let's first create a database. Let's call it baeldung. We'll also create a sample collection named student:

use baeldung;

With this command, our sample baeldung database and student collection are successfully set up. We will use these to demonstrate in all the examples.

3. Using the MongoDB Shell

To insert an array into a collection using the MongoDB Shell, we can simply pass the array as a JSON Array type to the shell:

    "studentId" : "STU1",
    "name" : "Avin",
    "Age" : 12,
    "courses" : ["Science", "Math"]

The above query inserts a single document with an array in the student collection. We can verify the result by querying the documents of the student collection using the find operator:


The above query returns the inserted student collection document:

    "_id" : ObjectId("631da4197581ba6bc1d2524d"),
    "studentId" : "STU1",
    "name" : "Avin",
    "Age" : 12,
    "courses" : [ "Science", "Math" ]

4. Insert Operation Using Java Driver Code

The MongoDB Java Driver provides various convenience methods to help us insert documents into a collection:

  • insert() – Inserts a single document or multiple documents into a collection
  • insertOne() – Inserts a single document into a collection
  • insertMany() – Inserts multiple documents into a collection

Any of the above methods can be used to perform the insert operation on the MongoDB collection.

Next, let's dive into implementing the array insertion operation using the Java MongoDB Driver. The MongoDB Java driver supports both the DBObject and BSON document.

5. Using the DBObject

Here, the DBObject is part of the MongoDB legacy driver, but it is deprecated in newer versions of MongoDB.

Let's insert a DBObject document with an array into the student collection:

BasicDBList coursesList = new BasicDBList();

DBObject student = new BasicDBObject().append("studentId", "STU1")
  .append("name", "Jim")
  .append("age", 13)
  .append("courses", coursesList);


The above query inserts a single DBObject document with an array into the student collection.

6. Using the BSON Document

The BSON Document is the new way to access the MongoDB document in Java and is built with the newer client stack. Luckily, it's also easier to use.


The Java driver provides an org.bson.Document class to insert a Bson document object with an array into the student collection.

6.1. Insert a Single Document with an Array

Firstly, let's insert a single document with an array into the collection using the insertOne() method:

List coursesList = new ArrayList<>();

Document student = new Document().append("studentId", "STU2")
  .append("name", "Sam")
  .append("age", 13)
  .append("courses", coursesList);


The above query inserts a single document with an array into the student collection. It is important to note that the append(String, Object) method of the Document class accepts an Object as the value. We can pass a List of any Object type as the value to insert it as an array into the document.

6.2. Insert Multiple Documents with an Array

Let's insert multiple documents with an array into the collection using the insertMany() method:

List coursesList1 = new ArrayList<>();

Document student1 = new Document().append("studentId", "STU3")
  .append("name", "Sarah")
  .append("age", 12)
  .append("courses", coursesList1);

List coursesList2 = new ArrayList<>();

Document student2 = new Document().append("studentId", "STU4")
  .append("name", "Tom")
  .append("age", 13)
  .append("courses", coursesList2);

List<Document> students = new ArrayList<>();


The above query inserts multiple documents with an array into the student collection.

6.3. Insert an Object Array

Finally, let's insert an Object array type of document into the MongoDB collection:

Document course1 = new Document().append("name", "C1")
  .append("points", 5);

Document course2 = new Document().append("name", "C2")
  .append("points", 7);

List<Document> coursesList = new ArrayList<>();

Document student = new Document().append("studentId", "STU5")
  .append("name", "Sam")
  .append("age", 13)
  .append("courses", coursesList);


The above query inserts multiple documents with an Object array into the student collection. Here, we have inserted a document having a list of documents as an array into the collection. Similarly, we can construct any complex array Object and insert it into a MongoDB collection.

7. Conclusion

In this article, we've seen various ways to insert documents with an array Object into the MongoDB collection. We discussed these use cases using both the MongoDB Shell query as well as the corresponding Java driver code implementation.

With the Java drive code, we first looked at the implementation using the deprecated DBObject class. Then, we learned to implement the same using the new BSON Document class.

The implementations of all these examples and code snippets are available over on GitHub.

NoSql Bottom

Build a Dashboard Using Cassandra, Astra, and Stargate

Persistence bottom

Get started with Spring Data JPA through the reference Learn Spring Data JPA course:

Persistence footer banner
Comments are closed on this article!