JY feedback

Author: rachel-mack

source/crud/read-operations/distinct.txt

@@ -24,7 +24,7 @@ Overview
 In this guide, you can learn how to retrieve a list of distinct values for a
 field across a collection by calling the ``distinct()`` method on a
 ``MongoCollection`` object. Pass the document field name as the first parameter
-and the class you want to cast the results to as the second parameter as shown
+and the class you want to use for the results format as the second parameter as shown
 below:
 
 .. code-block:: java
@@ -64,7 +64,7 @@ match movies that include "Carl Franklin" as one of the values in the
 
 .. include:: /includes/connect-guide-note.rst
 
-.. literalinclude:: /includes/usage-examples/code-snippets/Distinct.java
+.. literalinclude:: /includes/crud/Distinct.java
    :language: java
 
 When you run the example, you should see output that reports each distinct

source/includes/crud/CountDocuments.java

@@ -29,19 +29,13 @@ public static void main(String[] args) {
 
             Bson query = eq("countries", "Spain");
 
-            try {
-                // Retrieves and prints the estimated number of documents in the collection
-                long estimatedCount = collection.estimatedDocumentCount();
-                System.out.println("Estimated number of documents in the movies collection: " + estimatedCount);
-
-                // Retrieves and prints the number of documents with a "countries" value of "Spain"
-                long matchingCount = collection.countDocuments(query);
-                System.out.println("Number of movies from Spain: " + matchingCount);
-            
-            // Prints a message if any exceptions occur during the operations
-            } catch (MongoException me) {
-                System.err.println("An error occurred: " + me);
-            }
+            // Retrieves and prints the estimated number of documents in the collection
+            long estimatedCount = collection.estimatedDocumentCount();
+            System.out.println("Estimated number of documents in the movies collection: " + estimatedCount);
+
+            // Retrieves and prints the number of documents with a "countries" value of "Spain"
+            long matchingCount = collection.countDocuments(query);
+            System.out.println("Number of movies from Spain: " + matchingCount);
         }
     }
 }

source/includes/crud/Distinct.java

@@ -22,19 +22,13 @@ public static void main(String[] args) {
             MongoDatabase database = mongoClient.getDatabase("sample_mflix");
             MongoCollection<Document> collection = database.getCollection("movies");
 
-            try {
-                // Retrieves the distinct values of the "year" field present in documents that match the filter
-                DistinctIterable<Integer> docs = collection.distinct("year", Filters.eq("directors", "Carl Franklin"), Integer.class);
-                MongoCursor<Integer> results = docs.iterator();
-
-                // Prints the distinct "year" values
-                while(results.hasNext()) {
-                    System.out.println(results.next());
-                }
-
-            // Prints a message if any exceptions occur during the operation
-            } catch (MongoException me) {
-                System.err.println("An error occurred: " + me);
+            // Retrieves the distinct values of the "year" field present in documents that match the filter
+            DistinctIterable<Integer> docs = collection.distinct("year", Filters.eq("directors", "Carl Franklin"), Integer.class);
+            MongoCursor<Integer> results = docs.iterator();
+
+            // Prints the distinct "year" values
+            while(results.hasNext()) {
+                System.out.println(results.next());
             }
         }
     }

source/logging-monitoring/change-streams.txt

@@ -71,15 +71,15 @@ Filter the Events
 ~~~~~~~~~~~~~~~~~
 
 The ``watch()`` method optionally takes an **aggregation pipeline**  which
-consists of an array of **stages** as the first parameter to filter and
-transform the change event output as follows:
+consists of a list of **stages** as the first parameter, which can be used to
+filter and transform the change event output, as follows: 
 
 .. code-block:: java
 
-   List<Bson> pipeline = Arrays.asList(
+   List<Bson> pipeline = List.of(
                            Aggregates.match(
                               Filters.in("operationType",
-                                    Arrays.asList("insert", "update"))),
+                                    List.of("insert", "update"))),
                            Aggregates.match(
                               Filters.lt("fullDocument.runtime", 15)));
    ChangeStreamIterable<Document> changeStream = database.watch(pipeline);
@@ -92,38 +92,42 @@ transform the change event output as follows:
    by calling the ``fullDocument()`` member method of the ``ChangeStreamIterable``
    object with the value ``FullDocument.UPDATE_LOOKUP`` as follows:
 
+   .. code-block:: java
+
+      ChangeStreamIterable<Document> changeStream = database.watch()
+             .fullDocument(FullDocument.UPDATE_LOOKUP);
+
 Manage the Output
 ~~~~~~~~~~~~~~~~~
 
-The ``watch()`` method returns an instance of ``ChangeStreamIterable``, a class
+The ``watch()`` method returns an instance of ``ChangeStreamIterable``, an interface
 that offers several methods to access, organize, and traverse the results.
-``ChangeStreamIterable`` also inherits methods from its parent class,
+``ChangeStreamIterable`` also inherits methods from its parent interface,
 ``MongoIterable`` which implements the core Java interface ``Iterable``.
 
 You can call ``forEach()`` on the ``ChangeStreamIterable`` to handle
 events as they occur, or you can use the ``iterator()`` method which
-returns a ``MongoCursor`` instance that you can use to traverse the results.
-
-.. important:: forEach() blocks the current thread
+returns a ``MongoChangeStreamCursor`` instance that you can use to traverse the results.
 
-   Calls to ``forEach()`` block the current thread while the
-   corresponding change stream listens for events. If your program
-   needs to continue executing other logic, such as processing requests or
-   responding to user input, consider creating and listening to your
-   change stream in a separate thread.
-
-You can call the following methods on the ``MongoCursor`:
+You can call the following methods on the ``MongoChangeStreamCursor`:
 
  - ``hasNext()``: checks if there are more results. 
  - ``next()`` returns the next document in the collection.
- - ``tryNext()`` immediately returns eitherthe next available element in the
+ - ``tryNext()`` immediately returns either the next available element in the
    change stream or ``null``. 
 
-Unlike the ``MongoCursor`` returned by other queries, a ``MongoCursor`` associated
-with a change stream waits until a change event arrives before
-returning a result from ``next()``. As a result, calls to ``next()``
-using a change stream's ``MongoCursor`` never throw a
-``java.util.NoSuchElementException``.
+.. important:: Iterating the Cursor Blocks the Current Thread
+
+   Iterating through a cursor using ``forEach()`` or any ``iterator()`` method
+   blocks the current thread while the corresponding change stream listens for
+   events. If your program needs to continue executing other logic, such as
+   processing requests or responding to user input, consider creating and
+   listening to your change stream in a separate thread.
+
+Unlike the ``MongoCursor`` returned by other queries, a
+``MongoChangeStreamCursor`` associated with a change stream waits until a change
+event arrives before returning a result from ``next()``. As a result, calls to
+``next()`` using a change stream's ``MongoChangeStreamCursor`` never throw a ``java.util.NoSuchElementException``.
 
 To configure options for processing the documents returned from the change
 stream, use member methods of the ``ChangeStreamIterable`` object returned
@@ -198,8 +202,7 @@ Full File Example Output
 
 The preceding applications will generate the following output:
 
-``Watch.java`` will capture on the  ``insert`` and ``update`` operations are
-printed, since the aggregation pipeline filters out the ``delete`` operation:
+``Watch.java`` will capture only the  ``insert`` and ``update`` operations, since the aggregation pipeline filters out the ``delete`` operation:
 
 .. code-block::
    :copyable: false
@@ -319,7 +322,7 @@ The following example modifies your change stream by using the
 .. code-block:: java
 
    ChangeStreamIterable<Document> changeStream = collection.watch(
-         Arrays.asList(Document.parse("{ $changeStreamSplitLargeEvent: {} }")));
+         List.of(Document.parse("{ $changeStreamSplitLargeEvent: {} }")));
 
 .. note::