public class Super {\r\n\u00a0\u00a0\u00a0 protected String name = \"Whizlabs\";\r\n\u00a0\u00a0\u00a0 protected void print() {\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 System.out.println(name);\r\n\r\n\u00a0\u00a0\u00a0 }\r\n\r\n}\r\n\r\npublic class Sub extends Super { }\r\n<\/pre>\nSince the Sub<\/i> class extends the Super<\/i> class, it inherits the name<\/i> field and print<\/i> method from the superclass and can use these members without defining them.<\/p>\n
Let’s run a code fragment:<\/p>\n
Sub object = new Sub();\r\nobject.print();\r\n<\/pre>\nThe above fragment prints “Whizlabs”<\/i> when executed, although the Sub<\/i> class does not define any member of its own. The print<\/i> method is, in fact, inherited from the Super<\/i> class.<\/p>\n\n- Polymorphism<\/b><\/li>\n<\/ol>\n
Polymorphism is a principle in which an object reference can take many different forms. Polymorphic features of the Java language are often demonstrated via the use of one reference variable referencing objects of various types. The reference type is the same as, or a parent of, the referenced object types. As a result, a method can behave differently depending on the actual objects it is invoked on.<\/p>\n
The following class declarations illustrate this principle:<\/p>\n
public class Super {\r\n\u00a0\u00a0\u00a0 protected void print() { }\r\n}\r\n\r\npublic class Sub1 extends Super {\r\n\u00a0\u00a0\u00a0 public void print() {\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 System.out.println(\"Printed from Sub1\");\r\n\u00a0\u00a0\u00a0 }\r\n}\r\n\r\npublic class Sub2 extends Super {\r\n\u00a0\u00a0\u00a0 public void print() {\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 System.out.println(\"Printed from Sub2\");\r\n\u00a0\u00a0\u00a0 }\r\n}\r\n<\/pre>\nLet’s execute the following code fragment:<\/p>\n
Super object = null;\r\nobject = new Sub1();\r\nobject.print();\r\nobject = new Sub2();\r\nobject.print();\r\n<\/pre>\nThe above fragment prints out “Printed from Sub1”<\/i> and “Printed from Sub2”<\/i> in sequence, even though the print<\/i> method is invoked twice on the same reference variable, object<\/i>. The reason is that variable object<\/i> references two different objects when these invocations are made. This discrepancy in method behavior is called polymorphism.<\/p>\n\n- Abstraction<\/b><\/li>\n<\/ol>\n
Abstraction is a process of hiding the implementation details from users and exposing only essential features of the underlying objects. Generally speaking, abstraction allows users to know what an object does without the need to understand how it does.<\/p>\n
In the Java programming language, abstraction is typically achieved through the use of interfaces and abstract classes. The following examples illustrate the abstraction principle. Let’s get started with the declaration of an interface and abstract class:<\/p>\n
public interface MyInterface {\r\n\u00a0 \u00a0 void complicatedLogic();\r\n}\r\n\r\npublic abstract class MyAbsClass {\r\n\u00a0 \u00a0 abstract void complicatedLogic();\r\n}\r\n<\/pre>\nA user can use the complicatedLogic<\/i> method of MyInterface<\/i> or MyAbsClass<\/i> without knowing its implementation:<\/p>\npublic void callInterfaceMethod(MyInterface arg) {\r\n\u00a0 \u00a0 arg.complicatedLogic ();\r\n}\r\n\r\npublic void callAbsClassMethod(MyAbsClass arg) {\r\n\u00a0 \u00a0 arg.complicatedLogic ();\r\n}\r\n<\/pre>\nIn the above examples, the MyInterface<\/i> interface and MyAbsClass<\/i> class abstract away the implementation details from the user, allowing the implementation provider to change the code if necessary.<\/p>\n\n- Encapsulation<\/b><\/li>\n<\/ol>\n
Encapsulation is a mechanism of including within an object everything it needs, and doing this in a way that other objects cannot access its internal structure. In other words, encapsulation refers to wrapping data (variables) and code acting on the data (methods) together as a single unit. When applying encapsulation, variables of a class are hidden from others, and can only be accessed and operated on through methods of their own class.<\/p>\n
In the Java programming language, encapsulation is often achieved by declaring variables of a class with the private<\/i> access modifier and providing public<\/i> methods to work on these variables, like the following example:<\/p>\npublic class Data {\r\n\u00a0\u00a0\u00a0 private int value;\r\n\u00a0\u00a0\u00a0 public int getValue() {\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 return this.value;\r\n\u00a0\u00a0\u00a0 }\r\n\u00a0\u00a0\u00a0 public void setValue(int value) {\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 this.value = value;\r\n\u00a0\u00a0\u00a0 }\r\n}<\/pre>\n<\/span>2. How does the Java virtual machine manage the lifecycle of an object in the memory?<\/span><\/h2>\n\n- Background information<\/b><\/li>\n<\/ol>\n
The lifecycle of an object starts when it is created with the new<\/i> operator or a similar mechanism. However, it cannot be explicitly destroyed through an executable code. The only way to remove an object in Java is to use garbage collection.<\/p>\n
When a new object is generated, it is stored in the heap memory, and kept there as long as this object is referenced from somewhere in the program. It can be referenced from a static variable in the metaspace, an instance variable in the heap memory itself, a local variable in the stack memory, etc.<\/p>\n
The most interesting thing about the lifecycle of an object is when it is dereferenced, or no longer referenced from any section of the program. At this point, the object is eligible for automatic garbage collection and ready to be discarded.<\/p>\n
Automatic garbage collection is the process of looking into the heap memory to mark live objects and remove the leftover. When an unreferenced object is removed, the memory space it occupied can be reclaimed to be reused. This process helps free developers of a tedious and error-prone task: allocating and deallocating memory.<\/p>\n
\n- Generational garbage collection process<\/b><\/li>\n<\/ol>\n
In general, the collection process works through two steps:<\/p>\n
\n- First, object trees are navigated from the garbage collection roots; these roots include local variables, static variables, active Java threads and Java native interface references. All objects in these trees are marked referenced.<\/li>\n
- Second, unreferenced objects, which have not been marked in the previous step, are removed and the free space is returned to the JVM. If a garbage collection process is major (major and minor garbage collections will be described later), referenced objects may be compacted, allowing new objects to occupy contiguous memory space.<\/li>\n<\/ul>\n
Marking and removing objects is a time-consuming process, and always applying it to all objects is inefficient. Empirical analysis has shown that most objects have a very short life. To take advantage of this pattern and insure all unused objects are removed in an effective way, the idea of generational garbage collection has come up.<\/p>\n
The following image illustrates memory allocation in a heap with generational garbage collection (the ratios between different areas in the image illustrate default values in a server JVM \u2013 Eden over S0 or S1 = 8:1, Young Generation over Old Generation = 1:2):<\/p>\n
The young generation\u00a0is the place where all new objects are allocated. If an object survives minor garbage collections, it will be moved to the old generation, where the object may be destroyed during a major collection, or live until the program terminates.<\/p>\n
The young generation is comprised of three spaces –\u00a0eden\u00a0and two\u00a0survivor spaces, S0 and S1:<\/p>\n
\n- The eden space is where all objects are first allocated. When this space fills up, a minor collection is triggered. Referenced objects are moved to the first survivor space (S0), while the unreferenced are deleted. At this point, the eden space is cleared and ready to keep new objects. Both eden and the second survivor space (S1) are empty now.<\/li>\n
- When the next minor collection cycle is set off, the same things happen again. Unused objects are discarded, and live objects are moved to a survivor space. This time, however, the survivors are moved to S1 instead of S0. Objects in S0 that survived the last collection may be deleted (due to being unreferenced), copied to S1, or promoted to the old generation. Now, both eden and S0 are clear.<\/li>\n
- The above steps are repeated over and over. An object will eventually be moved to the old generation if it survives all minor collections and a certain criterion is met, such as its age reaches a threshold, the number of times it is copied increases to a limit, or it is too large to be copied to the other survivor space.<\/li>\n<\/ul>\n
The\u00a0old generation\u00a0is where long-lived objects that have survived minor collections are promoted to. This space is often garbage-collected when it fills up. A collection in the old generation may include object compaction, and is called major garbage collection.<\/p>\n
All garbage collections are “Stop the World” events, meaning that all application threads are stopped until the operation finishes. A major collection is typically takes much longer than a minor one as it must go through all referenced objects. This will affect the responsiveness of the program. As a result, the type of the garbage collector in use may have an impact on JVM performance.<\/p>\n
\n- Performance goals<\/b><\/li>\n<\/ol>\n
Different applications have different requirements on garbage collections. Typically, a garbage collector focus on either of two main goals: throughput and responsiveness:<\/p>\n
\n- Throughput is the amount of work implemented by an application in a specific duration. Specifically, it is the percentage of total time not spent in garbage collection over a long period of time. This goal is important in a web server, for example, as the number of serviced requests is much more important than pause time, which may be hidden in the disguise of network latencies.<\/li>\n
- Responsiveness (pause time) refers to how quickly an application responds to a request. This is measured by the time when the application is unresponsive due to a garbage collection in progress. For instance, a game application should consider this goal one of the top priorities since even short pauses may negatively affect the user experience.<\/li>\n<\/ul>\n
Some other goals may be taken into consideration, such as footprint or promptness. Footprint\u00a0is the working set of a process, measured in pages and cache lines. This goal is critical in systems with limited physical memory. Promptness\u00a0is the duration between an object becoming unused and the memory being reclaimed. This performance measure is important for distributed systems.<\/p>\n
Generally, it is hard to achieve multiple performance goals at the same time. For instance, a large young generation may maximize throughput, but has a negative effect on responsiveness, footprint and promptness.<\/p>\n
The Java HotSpot VM includes three different types of collectors to attain various performance goals:<\/p>\n
\n- A serial collector uses a single thread to perform all collection operations. This collector is efficient in systems with a single processor as no communication overhead between threads occurs.<\/li>\n
- A parallel collector performs minor collections in parallel. This can considerably reduce garbage collection overhead.<\/li>\n
- A mostly concurrent collector performs most of its work concurrently to minimize collection pauses and increase the responsive level.<\/li>\n<\/ul>\n
<\/span>3. What are annotations and how to define and use them?<\/span><\/h2>\nAnnotations are a form of metadata that describes the annotated code. Annotations themselves are not part of a program and declared to provide information for tools or other programs to work on. Here are several applications of annotations:<\/p>\n
\n- To be used by the compiler to detect errors or suppress warnings at compile time.<\/li>\n
- To be used by a container to set up the operational environment at deployment time.<\/li>\n
- To instruct the JVM to implement additional jobs at runtime.<\/li>\n<\/ul>\n
An annotation is specified using the at sign character (@)<\/i>, which signifies that what follows in an annotation, such as @MyAnnotation<\/i>. The following sections describe annotations in detail.<\/p>\n\n- Declaring annotation types<\/b><\/li>\n<\/ol>\n
The definition of an annotation type is similar to that of an interface where the interface<\/i> keyword\u00a0is preceded by the @<\/i> character. An annotation definition may contain elements, whose declaration is akin to abstract methods and may consist of default values.<\/p>\n
Here is an example of annotation type definitions:<\/p>\n
@interface MyAnnotation {\r\n\u00a0\u00a0\u00a0 String url() default \"whizlabs.com\";\r\n\u00a0\u00a0\u00a0 String[] exams();\r\n\u00a0\u00a0\u00a0 int year();\r\n}\r\n<\/pre>\nThe above annotation type defines three elements: url<\/i>, exams<\/i> and year<\/i>. The values of these elements are of types String<\/i>, String[]<\/i> and int<\/i>, respectively. If the value of url<\/i> is not specified, it defaults to “whizlabs.com”<\/i>.<\/p>\n
The Java SE API declares several built-in useful annotations. One of the most commonly used is @Override<\/i>. This annotation is useful during development as it helps to make sure that the annotated method actually overrides a superclass method or implements an interface one.<\/p>\n
In addition to annotations applied to Java elements of other kinds, e.g. a field, method or type, there are a few annotations that only work on other annotations. These are called meta-annotations, which are important when defining a custom annotation type. Meta-annotations are described below:<\/p>\n
\n- @Retention\u00a0<\/i>annotation: Specifies how the marked annotation is stored, with the following allowable values:<\/li>\n
- SOURCE<\/i>: The annotated annotation is used only for compile-time reports and ignored by the compiler when compiling the source code. This does not mean that the compiler completely skip the annotation. Instead, it may report errors based on the annotated annotation, but still goes ahead despite such an error.<\/li>\n
- CLASS<\/i>: The annotated annotation is preserved by the compiler at compile time. It is compiled into the class file, but ignored by the Java virtual machine at runtime. This is the default behavior if no value is set.<\/li>\n
- RUNTIME<\/i>: The annotated annotation is recorded in the class file and utilized by the Java virtual machine at runtime.<\/li>\n
- @Target\u00a0<\/i>annotation: Indicates the contexts in which the annotated annotation is applicable. The following are values allowed to be specified in this annotation:<\/li>\n
- ANNOTATION_TYPE<\/i>: The annotated annotation can be applied to an annotation type.<\/li>\n
- CONSTRUCTOR<\/i>: The annotated annotation\u00a0can be applied to a constructor.<\/li>\n
- FIELD<\/i>: The annotated annotation\u00a0can be applied to a field or property.<\/li>\n
- LOCAL_VARIABLE<\/i>:\u00a0The annotated annotation\u00a0can be applied to a local variable.<\/li>\n
- METHOD<\/i>: The annotated annotation\u00a0can be applied to a method.<\/li>\n
- PACKAGE<\/i>:\u00a0The annotated annotation\u00a0can be applied to a package declaration.<\/li>\n
- PARAMETER<\/i>: The annotated annotation\u00a0can be applied to the parameters of a method.<\/li>\n
- TYPE<\/i>: The annotated annotation\u00a0can be applied to a class, interface (including annotation type) or enum.<\/li>\n<\/ul>\n
In the absence of the @Target<\/i> meta-annotation, an annotation may be used on any declarations except for the declaration of type parameters.<\/p>\n\n- @Documented\u00a0<\/i>annotation: Indicates that an annotation is to be documented by javadoc or similar tools. This annotation is important to clients if the annotated annotation influences the use of the element it is declared on. By default, annotation types are not included in the generated Java API.<\/li>\n
- @Inherited\u00a0<\/i>annotation: Indicates that the annotated annotation can be inherited in a class hierarchy. If a parent class is declared with an @Inherited<\/i> annotation, subclasses of this superclass can use the annotation without re-declaring it. The annotated annotation applies to type declarations only. By default, annotation types are not inheritable.<\/li>\n
- @Repeatable\u00a0<\/i>annotation: Indicates that the annotated annotation can be applied more than once to the same declaration or type use. The value of\u00a0@Repeatable<\/i><\/i>indicates the\u00a0containing annotation type\u00a0for the repeatable annotation type.<\/li>\n<\/ul>\n
\n- Using annotations<\/b><\/li>\n<\/ol>\n
Annotations are often applied to declaration of various Java elements, such as:<\/p>\n
@MyAnnotation(exams = { \"OCAJP\", \"OCPJP }, year = 2017)\r\npublic class Whizlabs {\r\n\u00a0\u00a0\u00a0 \/\/ class body\r\n}\r\n<\/pre>\nOr:<\/p>\n
@Override\r\npublic void myMethod() { ... }\r\n<\/pre>\nFrom Java SE 8, annotations can also be applied to the use of\u00a0type. In other words, annotations can be used anywhere a type is used. Several examples are shown below:<\/p>\n
\n- Class instance creation expression: new @Interned MyObject();<\/i><\/li>\n
- Type cast: myString = (@NonNull String) string;<\/i><\/li>\n
- Thrown exception declaration: void myMethod() throws @Severe MyException { … }<\/i><\/li>\n<\/ul>\n
Type annotations were created to support stronger type checking. The Java SE platform does not provide a type checking framework, but many third-party ones are available as pluggable modules that can be used with the Java compiler.<\/p>\n
<\/span>4.\u00a0<\/b>What is generics? Describe and illustrate generic types and generic methods.<\/span><\/h2>\n\n- What is generics?<\/b><\/li>\n<\/ol>\n
Generally, generics are a facility that allows types to be used as parameters when defining classes, interfaces and methods. Type parameters provide a way to re-use the same declaration with different type inputs. By using generics, you can implement type-safe algorithms that work on collections of different types.<\/p>\n
The following are a couple of use cases demonstrating the application of generic code:<\/p>\n
\n- Stronger type checks at compile time: The compiler applies strong type checking when compiling generic code, raising an error if there is a violation. This helps to find many bugs at compile time, which otherwise only emerge at runtime. Fixing a bug at runtime is more expensive than doing so at compile time.<\/li>\n
- Elimination of casting: Prior to the introduction of generics, many operations need to be cast to the target type, such as:<\/li>\n<\/ul>\n
Map map = new HashMap();\r\nmap.put(\"name\", \"Whizlabs\");\r\nString name = (String) map.get(\"name\");\r\n<\/pre>\nIn this case, using generics can eliminate casting:<\/p>\n
Map<String, String> map = new HashMap<String, String>();\r\nmap.put(\"name\", \"Whizlabs\");\r\nString name = map.get(\"name\");<\/pre>\n\n- Generic types<\/b><\/li>\n<\/ol>\n
A generic type is a class or interface that is parameterized over types. A generic type is declared as follows:<\/p>\n
class name<T1, T2, ..., Tn> { ... }\r\ninterface name<T1, T2, ..., Tn> { ... }\r\n<\/pre>\nType parameters T1, T2, …, Tn<\/i> are enclosed within a pair of angle brackets following the name of the type being declared (a class or interface). These type parameters can be used anywhere in the class or interface.<\/p>\n
The following is an example of the definition of a generic type:<\/p>\n
public class Whizlabs<T> {\r\n\u00a0\u00a0\u00a0 private T t;\r\n\u00a0\u00a0\u00a0 public T get() {\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 return t;\r\n\u00a0\u00a0\u00a0 }\r\n\r\n\u00a0\u00a0\u00a0 public void set(T t) {\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 this.t = t;\r\n\u00a0\u00a0\u00a0 }\r\n}\r\n<\/pre>\nThe above generic type can be invoked with any type that are not primitive. An invocation of a generic type, which is also called a parameterized type, replaces type parameters with specific type arguments. A parameterized type can then be used in the same way as a non-generic type:<\/p>\n
Whizlabs<String> whizlabs = new Whizlabs<String>();\r\n<\/pre>\nThe type arguments used to invoke the constructor of a generic class in the above statement can be replaced by an empty set of type arguments (<>)<\/i>, also known as the diamond, if the compiler can determine the type arguments from the context:<\/p>\nWhizlabs<String> whizlabs = new Whizlabs<>();\r\n<\/pre>\n\n- Generic methods<\/b><\/li>\n<\/ol>\n
A generic method\u00a0is a method with its own type parameters. Declaring type parameters for a generic method is similar to doing for a generic type. These type parameters are scoped to the method where it is declared. This is true for constructors as well.<\/p>\n
The syntax of a generic method declaration is shown below:<\/p>\n
modifiers <T1, T2, …, Tn> return-type method-name(parameters) { … }<\/p>\n
Type parameters T1, T2, …, Tn<\/i> are enclosed within a pair of angle brackets preceding the method’s return type. These parameters must follow all modifiers.<\/p>\n
Here is an example:<\/p>\n
public static <T> boolean compareEquality(T t1, T t2) {\r\n\u00a0 \u00a0 return t1.equals(t2);\r\n}\r\n<\/pre>\nThe compareEquality<\/i> method can be invoked as follows (assume it is defined in the Whizlabs<\/i> class):<\/p>\n
boolean check = Whizlabs.<Integer> compareEquality(1, 2);<\/i><\/p>\n
If the compiler can infer the type argument from the context, it can be left out as follows:<\/p>\n
boolean check = Whizlabs.compareEquality(1, 2);<\/i><\/p>\n<\/span>5.\u00a0<\/b>Describe Java lambda expressions and give examples to demonstrate their usage.<\/span><\/h2>\nA Java lambda expression is a function that is defined outside of any class. It was introduced to facilitate functional programming in the Java platform. Lambda expressions enable functionality to be treated as method argument, or code as data.<\/p>\n
\n- Functional interfaces<\/b><\/li>\n<\/ol>\n
Functional interfaces are interfaces that define exactly one abstract method. It may contain any number of non-abstract methods. The following is an example of functional interface:<\/p>\n
interface MyInterface {\r\n\u00a0 \u00a0 void myMethod();\r\n}\r\n<\/pre>\nThe following declaration is also a functional interface despite two additional methods:<\/p>\n
interface MyInterface {\r\n\u00a0 \u00a0 void myMethod();\r\n\u00a0 \u00a0 default void defaultMethod() { ... }\r\n\u00a0 \u00a0 static void staticMethod() { ... }\r\n}\r\n<\/pre>\nAssume there is a method that has a parameter of type MyInterface<\/i>:<\/p>\npublic void handleMyInterface(MyInterface arg) {\r\n\u00a0 \u00a0 arg.myMethod();\r\n}\r\n<\/pre>\nPrior to Java SE 8, the most concise way to pass around an instance of a functional interface, like any other interface, is to use an anonymous class, like this:<\/p>\n
handleMyInterface(new MyInterface() {\r\n\u00a0 \u00a0 public void myMethod() {\r\n\u00a0 \u00a0 \u00a0 \u00a0 System.out.println(\"Whizlabs\");\r\n\u00a0 \u00a0 }\r\n});\r\n<\/pre>\nWith the introduction of functional interfaces in Java SE 8, the above invocation can be even more succinct:<\/p>\n
handleMyInterface(() -> System.out.println(\"Whizlabs\"));<\/i>\r\n<\/pre>\nThe syntax of lambda expressions is given in the following section.<\/p>\n
\n- Lambda expression syntax<\/b><\/li>\n<\/ol>\n
A lambda expression can only be used in places where a functional interface is expected. Its structure must correspond to the signature and return type of the unique abstract method of that functional interface.<\/p>\n
A lambda expression consists of three elements:<\/p>\n
\n- A comma-separated list of formal parameters enclosed in parentheses<\/li>\n
- The arrow token (->)<\/i><\/li>\n
- A body, which consists of a single expression or a statement block<\/li>\n<\/ul>\n
Let’s see an example now. Given a functional interface:<\/p>\n
public interface NumberComparator {<\/i>\r\n\u00a0\u00a0\u00a0 boolean compare(int i, int j);<\/i>\r\n}<\/i><\/i>\r\n<\/pre>\nThe following lambda expression can be used anywhere an instance of the NumberComparator<\/i> interface is required:<\/p>\n(int i, int j) -> { return i == j; }<\/i>\r\n<\/pre>\nThe above lambda expression takes in two arguments of type int<\/i>, and returns a boolean<\/i> value. These types are the same as those of the abstract method of the corresponding interface, NumberComparator<\/i>.<\/p>\n
Since the body of the lambda expression is comprised of only one statement, and the parameter types can be inferred from the NumberComparator.compare<\/i> method, the above lambda expression can be reduced to:<\/p>\n(i, j) -> i == j<\/i><\/pre>\n<\/span>6.\u00a0<\/b>Describe commonly used methods of three interfaces of the Java Collections API: List<\/i>, Set<\/i> and Map<\/i>.<\/span><\/h2>\nThe Java Collections API provide many classes and interfaces that are useful to process a collection of Java objects. List<\/i>, Set<\/i> and Map<\/i> are among the most commonly used interfaces. List<\/i> and Set<\/i> are subtypes of the Collection<\/i> interface, while Map<\/i> is not.<\/p>\n\n- The Collection<\/i> interface<\/b><\/li>\n<\/ol>\n
The\u00a0Collection\u00a0<\/i>interface is used to represent a collection of objects. Its methods are inherited by subinterfaces, including List<\/i> and Set<\/i>.<\/p>\n
The\u00a0Collection\u00a0<\/i>interface contains methods that perform basic operations, e.g.:<\/p>\n\n- size()<\/i>: Returns the number of elements in this collection.<\/li>\n
- isEmpty()<\/i>: Returns whether this collection contains no elements.<\/li>\n
- contains(Object)<\/i>: Returns whether this collection contains the specified element.<\/li>\n
- add(E)<\/i>: Insures that this collection contains the specified element.<\/li>\n
- remove(Object)<\/i>: Removes a single instance of the specified element from this collection if it is present.<\/li>\n
- iterator()<\/i>: Returns an iterator over the elements in this collection.<\/li>\n<\/ul>\n
This interface also defines methods that operate on entire collections, such as:<\/p>\n
\n- containsAll(Collection<?>)<\/i>: Returns\u00a0true\u00a0if this collection contains all of the elements in the specified collection.<\/li>\n
- addAll(Collection<? extends E>)<\/i>: Adds all of the elements in the specified collection to this collection.<\/li>\n
- retainAll(Collection<?>)<\/i>: Retains only the elements in this collection that are contained in the specified collection.<\/li>\n
- removeAll(Collection<?>)<\/i>: Removes all of this collection’s elements that are also contained in the specified collection.<\/li>\n
- clear()<\/i>: Removes all of the elements from this collection.<\/li>\n<\/ul>\n
Moreover, the Collection<\/i> interface comprises methods converting a collection to an array or stream as well:<\/p>\n\n- toArray()<\/i>, toArray(T[])<\/i>: Returns an array containing all of the elements in this collection.<\/li>\n
- stream()<\/i>, parallelStream()<\/i>: Returns a sequential\/parallel\u00a0Stream\u00a0with this collection as its source.<\/li>\n<\/ul>\n
\n- The Set<\/i> interface<\/b><\/li>\n<\/ol>\n
A\u00a0Set\u00a0<\/i>is a\u00a0Collection<\/i> that allows no duplicate elements, and no more than one null value. Specifically, a