(1z0-809)le=”font-weight: 400;”>The Oracle Certified Professional, Java SE 8 Programmer certification exam (1Z0-809) requires a solid understanding and practical experience with Java SE 8. To qualify for this certification, candidates must first complete the Oracle Certified Associate (OCA) certification.

In this article, we present a set of free test questions to help you assess your readiness for the OCPJP 8 exam (1Z0-809). These sample questions are designed to reflect the types of questions that could appear on the actual exam and provide insight into the exam pattern.

In the world of Java development, understanding the distinction between abstract classes and interfaces is crucial for writing clean, maintainable, and scalable code. These two mechanisms—abstract classes and interfaces—play a vital role in designing object-oriented programs. They both serve to define contract-like structures, but the way they work and the level of flexibility they offer can vary significantly. Let’s dive deeper into this topic, particularly focusing on a Java class design question that involves an abstract class and an interface. We’ll explore the best practices for using both and explain why one approach may be better than the other in specific scenarios.

The Basics of Abstract Classes and Interfaces in Java

Before diving into the specific Java code example, it’s important to establish a solid understanding of abstract classes and interfaces.

• Abstract Classes: An abstract class is a class that cannot be instantiated on its own. It is meant to be extended by other classes. Abstract classes can have both fully implemented methods (concrete methods) and abstract methods, which do not have a body and must be implemented by subclasses. Abstract classes are typically used when there is a common behavior or state that should be shared among subclasses, but also require some specialized behavior in the subclasses.
• Interfaces: An interface in Java is a reference type, similar to a class, that can contain only abstract methods (prior to Java 8, it could not contain concrete methods). An interface defines a contract that the implementing class must adhere to. Unlike abstract classes, a class can implement multiple interfaces, offering greater flexibility for multi-inheritance scenarios. With the advent of Java 8, interfaces can now include default methods (methods with a body), allowing them to have some form of implementation.

Understanding the differences between these two helps developers decide which one to use based on the requirements of the software system they are working on.

Exploring the Code Example

Now, let’s look at a Java code example to better understand how these concepts are applied in practice. Below is a code snippet that involves both an abstract class and an interface, and we will discuss the advantages of one over the other in the context of the code.

interface Switchable{

    void sw(int i);

}

 

abstract class Switch{

    abstract void sw(int i);

}

class It ___ {

    public void sw(int i){}

    public static void main(String []arg){

        System.out.print(“A”);

    }

}

In the code, we have:

• Switchable interface: This interface declares a method sw(int i) that must be implemented by any class that implements this interface.
• Switch abstract class: This class also defines an abstract method sw(int i), which must be implemented by any subclass of Switch.
• It class: The class It implements the method sw(int i) but does not extend either the abstract class Switch or implement the interface Switchable. The presence of the sw method in It makes this class behave like it implements the interface or extends the abstract class, but the class is incomplete because it is neither formally implementing the interface nor extending the abstract class.

Which Approach is More Flexible?

Now, let’s address the key question: Which of the following statements is true?

1. Extending the abstract class Switch is better than implementing the interface Switchable.
   B. Implementing the interface Switchable is better than extending the abstract class Switch.
   C. Implementing the interface or extending the abstract class won’t make a significant difference.
   D. Both the interface and the abstract class provide the same level of flexibility since both are abstract.
   E. Implementing or extending will cause a compilation error.

The correct answer is B. Implementing the interface Switchable is better than extending the abstract class Switch.

Why is Implementing an Interface More Flexible?

The primary reason why implementing the Switchable interface is more flexible than extending the abstract class Switch lies in the concept of multiple inheritance. In Java, a class can implement multiple interfaces, but it can only extend one class. Therefore, when a class implements an interface, it maintains the freedom to inherit from other classes, which is not possible when it extends an abstract class.

Let’s break this down:

• If a class implements an interface like Switchable, it can still extend another class. This provides flexibility in structuring your program. For example, you could implement the Switchable interface in a class that also extends another class, giving the class more behaviors and properties from multiple sources.
• On the other hand, if a class extends an abstract class like Switch, it is restricted to inheriting from only that class, which limits its flexibility in combining behaviors from other classes. The ability to implement multiple interfaces is a significant advantage of interfaces over abstract classes when designing more complex systems that require flexible class structures.

Additionally, interfaces offer more decoupling. They provide a more abstract contract, ensuring that implementing classes focus on providing the desired functionality rather than inheriting specific behavior or state from a parent class. This can make your system more modular and easier to maintain.

Key Takeaways for Java Class Design

When deciding between using an abstract class or an interface in Java, consider the following:

• Use interfaces when you need to define a contract for different classes that may already inherit from other classes. Interfaces provide greater flexibility by allowing multiple inheritance and decoupling behavior from state.
• Use abstract classes when you want to share code among related classes. Abstract classes are ideal when you want to define some common behavior, while leaving room for specific implementation in subclasses.

In our case, implementing the interface Switchable is better because it allows the class It to be more flexible and extend other classes if needed. It gives the class the ability to be part of a broader class hierarchy, which is crucial for larger, more complex systems.

Additional Considerations for Effective Java Class Design

While the decision between using an interface or an abstract class is important, Java developers should also consider other aspects of object-oriented design, such as:

• Code maintainability: Choose the approach that best promotes maintainable and scalable code. When designing systems, consider how easy it will be to modify or extend the code in the future.
• Separation of concerns: Ensure that interfaces define clear contracts and that abstract classes provide shared functionality when appropriate. This approach will lead to more coherent and modular systems.
• Extensibility: Use interfaces for defining APIs that might be implemented by various unrelated classes. This promotes flexibility, making it easier to add new functionality without modifying existing code.

In summary, understanding the distinction between abstract classes and interfaces is fundamental to writing efficient and scalable Java applications. The decision to use an interface versus an abstract class should be driven by the design needs of your system. Implementing the interface Switchable offers more flexibility compared to extending the abstract class Switch, making it the preferable choice in many scenarios. By leveraging the power of interfaces and abstract classes effectively, Java developers can create more modular, maintainable, and extensible codebases that meet the demands of modern software development.

Understanding Exceptions, Assertions, Generics, and Collections in Java

In Java, exception handling and assertions are integral to writing robust and maintainable code. Similarly, generics and collections play a significant role in ensuring type safety and the effective management of data. Understanding the nuances of these features is essential, especially for those pursuing certifications like the Oracle Certified Associate (OCA) Java SE 8 Programmer I and Oracle Certified Professional (OCP) Java SE 8 Programmer II exams. In this article, we will explore these concepts in depth, analyze the given examples, and provide a detailed breakdown of how to approach such questions in Java exams.

Exception Handling and Assertions in Java

Exception handling is a mechanism that handles runtime errors in Java, ensuring that the normal flow of execution is maintained. Exceptions can be managed using the try-catch-finally blocks, where the finally block is executed regardless of whether an exception is thrown or not. However, Java also provides an advanced form of exception handling called the try-with-resources statement, which is commonly used to automatically close resources like files, sockets, or database connections, ensuring that they are closed after use, thus preventing resource leaks.

In addition to exceptions, assertions in Java serve as a tool for debugging and ensuring that certain conditions hold true during runtime. Assertions are used to check assumptions in code, and if an assertion fails, it throws an AssertionError. This mechanism is especially useful for identifying logic errors during development.

Let’s take a closer look at the statements presented in the question.

Question: Which of the following statements are true regarding try-with-resources in Java?

1. A try-with-resources statement without a catch block requires a finally block.
2. A try-with-resources statement without a finally block requires a catch block.
3. A try-with-resources statement with only one statement can omit the curly braces.

Answer: E. None of the above

Let’s break down each statement:

1. A try-with-resources statement without a catch block requires a finally block – This statement is not true. A try-with-resources statement does not require a catch or finally block. You can use it with only the try block to ensure resources are closed after use. The requirement for a finally block is not dependent on the presence of a catch block.
2. A try-with-resources statement without a finally block requires a catch block – Again, this is incorrect. You can have a try-with-resources statement without either a catch or finally block. The resources will be closed automatically when the execution leaves the try block, even if no exceptions occur.
3. A try-with-resources statement with only one statement can omit the curly braces – This statement is also false. Even if the try block contains only one statement, you must still use curly braces to enclose the block. This is a syntax requirement in Java.

Thus, the correct answer is E. None of the above statements are accurate.

Exploring Generics and Collections in Java

Generics and collections are two of the most powerful features in Java. Generics enable you to define classes, interfaces, and methods with type parameters, enhancing code reuse and type safety. Collections, on the other hand, are a set of interfaces and classes that represent groups of objects, such as lists, sets, and maps.

Question: What will be the output of the following code?

import java.util.*;

import java.util.function.Predicate;

public class Examlabs {

    public static void main(String[] args) {

        List<Integer> numbers = new ArrayList<>();

        numbers.add(10);

        numbers.add(11);

        numbers.add(13);

        numbers.add(19);

        numbers.add(5);

        numbers.stream().filter(pred);

        

        System.out.println(numbers);

    }

}

Answer: C. [10, 11, 13, 19, 5]

Here’s why this is the correct answer:

In the provided code, the numbers list is initialized with several integer values. A Predicate is defined to check if a number is greater than 10. However, it’s important to note that the filter() method in streams is an intermediate operation. Intermediate operations, such as filter(), are lazy and are only executed when a terminal operation is invoked. In this case, the code does not invoke a terminal operation like collect(), forEach(), or reduce(). As a result, the filter() operation does not modify the list, and the original list is printed.

Therefore, the output will be the original list, which is:

[10, 11, 13, 19, 5]

Key Takeaways

1. Try-with-resources and Exception Handling: The try-with-resources statement is an advanced feature in Java designed to automatically close resources without requiring a catch or finally block. The statement’s behavior is not affected by the presence or absence of catch or finally blocks. Understanding how to use these constructs efficiently is essential for writing clean and error-free Java code.
2. Stream Operations: Stream operations like filter() are used to process collections of data in a functional style. However, since they are lazy, they only execute when a terminal operation is called. This is an important distinction when working with streams in Java, as failure to include a terminal operation will lead to no changes being made to the collection.
3. Generics and Type Safety: Generics play a crucial role in maintaining type safety, allowing developers to write more flexible and reusable code. Understanding how to use generics with collections (like List, Set, or Map) ensures that your code is both robust and maintainable.

In Java, exception handling, assertions, generics, and collections are vital concepts that significantly impact how developers write code. Mastering these concepts is crucial for anyone pursuing Java certification, especially when preparing for exams like the Oracle Certified Associate (OCA) Java SE 8 Programmer I and Oracle Certified Professional (OCP) Java SE 8 Programmer II exams. By understanding the practical applications and nuances of exception handling and generics, you can write more efficient, maintainable, and error-free Java code.

To further strengthen your preparation, make sure to use high-quality study materials, including practice tests and certification courses. Platforms like ExamLabs offer a variety of resources, including mock exams, to help you test your knowledge and improve your readiness for these certification exams.

Understanding Java Class Design and Concurrency Concepts

In Java, mastering class design and concurrency principles is key to writing efficient, maintainable, and thread-safe code. Java offers a broad range of tools and constructs for creating robust applications, but understanding the fundamentals of object-oriented design, as well as how to effectively manage concurrency, is crucial for any serious Java developer. This article will explore some of the core concepts in Java, including static variables in class design and the differences between the Callable and Runnable interfaces in concurrency.

Understanding Static Variables in Java Class Design

When designing Java classes, one of the important concepts to grasp is the use of static variables. Static variables are shared among all instances of a class, meaning that the value of a static variable is the same for every object of that class. This can have significant implications on the behavior of the class when multiple instances interact with it, especially when methods modify the value of the static variable.

Let’s take a look at a Java code example involving static variables and methods:

public class Exam {

    static int x;

    

    public static void main(String[] args) {

        Exam w1 = new Exam();

        Exam w2 = new Exam();

        Exam w3 = new Exam();

        w1.method();

        w2.method();

        w3.method();

    public void method() {

        while (++x < 3) {

            System.out.print(“A”);

        }

    }

}

In this code:

• x is a static variable. This means that x is shared across all instances of the Exam class. It is not unique to each instance but is common to all instances.
• The method method() is called three times by three different objects (w1, w2, and w3). Each time the method is called, it increments the value of x and prints the letter “A” while x is less than 3.

Output Analysis

Now, let’s break down what happens when the method() is called:

1. First Call (w1.method()): Initially, x is 0 (the default value for an integer). The while loop condition ++x < 3 increments x to 1, and “A” is printed. The loop runs again, incrementing x to 2 and printing another “A”. On the third increment, x becomes 3, and the condition ++x < 3 is no longer true, so the loop exits.
2. Second Call (w2.method()): Since x is static, its value is now 3 after the first call. The condition ++x < 3 is checked, but since x is already 3, the loop does not print anything and exits immediately.
3. Third Call (w3.method()): The value of x remains 3, so again, the loop does not print anything.

Conclusion for the Exam Example

The output of this code will be “AA”. This is because only the first call to method() prints anything, as the static variable x reaches 3 after the second call, preventing further output.

Correct Answer: B (AA)

This scenario demonstrates the impact of static variables on class behavior. When designing classes, it’s important to consider whether a variable should be static, as it will affect the behavior of all instances of the class.

Java Concurrency: Callable vs Runnable

Concurrency is another core concept that Java developers need to master. The Callable and Runnable interfaces are integral to Java’s approach to managing concurrent tasks, especially when dealing with multithreading. Both interfaces allow developers to execute tasks in parallel, but there are key differences between them.

Let’s examine these differences in detail:

• Runnable Interface: The Runnable interface defines a single method, run(), which contains the code to be executed by a thread. However, the run() method does not return a result or throw checked exceptions. This makes it useful for tasks where you don’t need a return value or need to handle exceptions outside the task.
• Callable Interface: The Callable interface is very similar to Runnable, but it allows tasks to return a result and throw checked exceptions. The call() method, instead of run(), can return a value (of type V), which is a significant advantage when the task produces a result that needs to be used later. Additionally, call() can throw exceptions, which can be handled by the calling thread.

Key Differences Between Callable and Runnable

Let’s look at the question involving Callable and Runnable:

Which of the following statements are true?

1. There is no difference between Callable’s call() method and Runnable’s run() method.
   B. Callable’s call() method allows a return value, while Runnable’s run() does not.
   C. Callable is a class, while Runnable is an interface.
   D. Both Callable and Runnable interfaces have only one method.
   E. Both Callable’s call() method and Runnable’s run() methods cannot throw checked exceptions.

Explanation of Correct Answers

• B. Callable’s call() method allows a return value, while Runnable’s run() does not.
  This is correct because the run() method in Runnable has a void return type, which means it cannot provide any result. On the other hand, Callable’s call() method can return a value, making it more useful when you need to return results from a task.
• D. Both Callable and Runnable interfaces have only one method.
  This is true because both Runnable and Callable are functional interfaces, meaning they each contain only one abstract method—run() for Runnable and call() for Callable.

Incorrect Options

• A. There is no difference between Callable’s call() method and Runnable’s run() method.
  This is incorrect. The key difference is that Callable can return a value and throw exceptions, whereas Runnable cannot.
• C. Callable is a class, while Runnable is an interface.
  This is incorrect. Both Runnable and Callable are interfaces, not classes.
• E. Both Callable’s call() method and Runnable’s run() methods cannot throw checked exceptions.
  This is incorrect because the call() method in Callable can throw checked exceptions, whereas run() in Runnable cannot.

Correct Answers: B and D

Practical Use of Callable and Runnable

The choice between Callable and Runnable depends on the task at hand:

• Use Runnable when the task doesn’t need to return a result and doesn’t need to throw checked exceptions.
• Use Callable when the task needs to return a result or might throw checked exceptions that need to be handled.

For example, if you’re working with a thread pool and need to retrieve the results of tasks, Callable is ideal because it allows you to use the Future object to retrieve the result once the task completes.

Designing Robust Java Applications

Mastering Java class design, including understanding static variables, interfaces, and concurrency mechanisms, is essential for building scalable and efficient applications. In the case of static variables, understanding their shared nature can help prevent unintended side effects in your program. Additionally, when dealing with concurrency, knowing the differences between Runnable and Callable ensures that you choose the correct interface for your tasks, helping to create more robust and efficient multithreaded applications.

Java Class Design and JDBC Connection: Exploring Key Concepts

In Java programming, understanding core concepts such as class design, interfaces, database connections, and exception handling is crucial for developing robust applications. Additionally, mastering these concepts can significantly contribute to your preparation for certification exams, such as the Oracle Certified Associate (OCA) Java SE 8 Programmer I and Oracle Certified Professional (OCP) Java SE 8 Programmer II exams. In this article, we will delve into various Java class design questions, JDBC database connections, and exception handling, offering insights into how these topics are tested in certification exams.

Understanding Java Class Design: Static Methods in Interfaces

In Java, interfaces play a crucial role in defining contracts for classes. However, one of the lesser-understood concepts in Java interfaces is how static methods behave. Unlike instance methods in interfaces, static methods are not inherited by classes that implement the interface. This can sometimes lead to confusion, particularly when working with multiple interfaces that define static methods.

public class Exam {

    public static void main(String[] args) {

        I2.print();

        I1.print();

    }

}

interface I1 {

    public static void print() {

        System.out.print(“1”);

    }

}

 

interface I2 extends I1 {

    public static void print() {

        System.out.print(“2”);

    }

}

Question: What is the output of this code?

1. 11
   B. 22
   C. 12
   D. 21
   E. Compilation fails

Correct Answer: D

Explanation: In the code above, both interfaces I1 and I2 define static print() methods. However, static methods in interfaces are not inherited by implementing classes. This means that when I2.print() is called, it will invoke the print() method defined in interface I2, printing “2”. Similarly, I1.print() will call the static method in I1, printing “1”. As a result, the output is “21”.

This behavior is important to note in your certification preparation, as it highlights the key difference between static and instance methods in interfaces. Static methods are not inherited and must be invoked through the interface that declares them.

Building Database Applications with JDBC

Java Database Connectivity (JDBC) is an essential API that allows Java applications to interact with relational databases. Understanding how to correctly establish a database connection is crucial for developers working with databases in Java. Let’s explore how to correctly form JDBC URLs for connecting to a MySQL database.

Question: You need to connect to a MySQL database located on localhost with the database name “School”, username “admin”, and password “abcd”. Which of the following connection URLs are correct?

1. jdbc:mysql://localhost:3306/School?user=admin&password=abcd
   B. jdbc:mysql://School:3306?user=admin&password=abcd
   C. jdbc:mysql://localhost:3306/School, “abcd”, “admin”
   D. jdbc:mysql://School:3306/localhost?user=admin&password=abcd
   E. jdbc:mysql://:3306/School, “admin”, “abcd”

Correct Answer: A and E

Explanation: The JDBC connection URL format for MySQL follows the pattern:

jdbc:mysql://<host>:<port>/<database>?user=<username>&password=<password>

In this case, localhost:3306 refers to the MySQL server running on the local machine at port 3306, and the database is named “School”. Both options A and E correctly follow this format, with option E omitting the localhost part (which defaults to the local machine) but still functioning correctly.

It is important to remember the correct format for JDBC URLs to ensure smooth communication with the database. Having a solid understanding of JDBC and how to configure connection strings is essential for Java developers working with databases.

Understanding Assertions in Java

Assertions in Java provide a powerful mechanism for validating assumptions during development. By using assertions, developers can test assumptions about their code, which can help identify bugs early. However, assertions must be enabled during runtime, and they are typically disabled in production environments to avoid performance overhead.

Let’s consider the following code to explore how assertions work in Java.

public class Examlabs {

    public static void main(String[] args) {

        int j = 9;

        assert(++j > 7): “Error”;

        assert(j == 12): j;

        assert(++j > 8): System.out.println(j);

    }

}

Question: What is the output of this code when assertions are enabled?

1. 8
   B. 9
   C. Compilation fails due to line 5
   D. Compilation fails due to line 6
   E. Compilation fails due to multiple errors

Correct Answer: D

Explanation: The issue arises from the second assertion, which contains the expression assert(j == 12): j;. In Java, the second part of an assertion must be an expression that can be evaluated to provide an error message or value if the assertion fails. In this case, j is an integer, and Java cannot use an integer value as an error message. Therefore, this line causes a compilation error. The other assertions in the code would work if the second part of the assertion in line 6 were a valid expression.

Key Takeaways

1. Static Methods in Interfaces: In Java, static methods defined in interfaces are not inherited by implementing classes. This is an important distinction to remember when working with multiple interfaces, as static methods must be accessed directly through the interface that defines them.
2. JDBC Database Connections: Establishing a proper JDBC connection is fundamental for any Java application that interacts with a database. Understanding the format of JDBC connection URLs and how to pass credentials is critical for connecting to MySQL and other relational databases.
3. Assertions in Java: Assertions are a useful tool for debugging and ensuring code correctness during development. However, they must be enabled during runtime, and their second part must be a valid expression that can be evaluated. Misusing assertions can lead to compilation errors, so it’s important to understand the syntax and correct usage.

Mastering concepts such as class design, database connectivity, and exception handling is crucial for any Java developer. These fundamental concepts are not only essential for building efficient and scalable applications but are also heavily tested in Java certification exams. To succeed in exams like the OCA Java SE 8 Programmer I and OCP Java SE 8 Programmer II, candidates must understand how to leverage static methods in interfaces, properly form JDBC connection URLs, and correctly use assertions in their code.

In preparation for these exams, it is helpful to use resources like ExamLabs, which offer comprehensive training courses, mock exams, and practice tests. These tools can enhance your learning experience and increase your chances of success in obtaining your Java certification.

Understanding Generics and Collections in Java

In Java, generics and collections are fundamental concepts for writing type-safe and efficient code. Generics allow you to define classes, interfaces, and methods with type parameters, ensuring type safety at compile time and reducing the need for type casting. Collections, on the other hand, are a framework that provides a set of classes and interfaces for storing and manipulating groups of objects, offering powerful data structures such as lists, sets, and maps.

One of the common operations when dealing with collections is modifying or retrieving elements from a list. Let’s take a closer look at an example involving generics and the List interface in Java, particularly focusing on the use of the set() method.

Example Code: Understanding the set() Method

Consider the following Java code snippet that demonstrates the usage of the set() method in a List:

import java.util.ArrayList;

import java.util.List;

public class Exam {

    public static void main(String[] args) {

        List list = new ArrayList();

        list.add(“1”);

        list.add(“2”);

        list.add(“3”);

        list.add(“4”);

        System.out.println(list.set(3, “3”));

    }

}

Code Breakdown:

1. Creating a List:
   The code begins by creating a List of type Object since no generic type is specified (the raw type is used). This list can hold any type of object, which is less type-safe than using generics.
2. Adding Elements:
   The add() method is used to add elements to the list. The elements added are strings: “1”, “2”, “3”, and “4”.
3. Using the set() Method:
   The set() method is called with two arguments: the index 3 (representing the fourth element in the list) and the new value “3”. The set() method is used to replace the element at the specified index with the new element. The method also returns the element that was previously at that index.

What Happens During Execution:

• The list is populated with the strings “1”, “2”, “3”, and “4”. These strings are placed at indices 0, 1, 2, and 3, respectively.
• The set() method is called to replace the element at index 3 (which is the string “4”) with the new value “3”.
• The set() method returns the element that was replaced, which is “4”.
• Therefore, the output printed to the console is “4”.

Explanation of the Output:

• A. 4: This is the correct answer because the set() method replaces the element at index 3 (which is “4”) with the new value “3” and returns the replaced element, which is “4”.
• B. 3: This is incorrect because the set() method does not return the new value; it returns the old value that was replaced.
• C. -1: This is not relevant to the set() method. The set() method does not return a numerical index or -1; it returns the element that was replaced.
• D. An exception is thrown: This is not the case here. The code is valid, and no exception is thrown. The set() method can successfully replace an element at a valid index in the list.
• E. Compilation fails: The code is valid, but it uses raw types, which is not recommended in modern Java programming. However, it compiles and runs without issues.

Best Practices with Generics:

• Avoid Raw Types: Using raw types (like List instead of List<String>) can lead to type safety issues, as it bypasses compile-time type checking. It’s best practice to use generics to specify the type of elements that a collection can hold. For example, List<String> list = new ArrayList<>(); would ensure that only strings are added to the list, reducing the risk of ClassCastException.
• Type Safety: With generics, you can ensure that only objects of a specific type are added to a collection, preventing runtime errors related to type mismatches.
• Enhanced Readability: Using generics makes your code more readable and maintainable because it provides clear expectations about the types of objects in your collections.

Conclusion

The use of the set() method in the List interface is a common operation when you want to replace an element at a specific index. Understanding how it works, especially when dealing with generics and raw types, is important for writing clean and efficient code. In the provided example, the set() method successfully replaces the element at index 3 with the new value and returns the previously replaced element, which is “4”.

By following best practices such as using generics, you can make your code more type-safe and maintainable, avoiding potential issues that arise from using raw types. This is particularly important in large applications where collections are frequently used.