What is the name of the interface used to represent collection that maintain non unique elements in order?

Although we can use an array as a container to store a group of elements of the same type (primitives or objects). The array, however, does not support so-called dynamic allocation - it has a fixed length which cannot be changed once allocated. Furthermore, array is a simple linear structure. Many applications may require more complex data structure such as linked list, stack, hash table, set, or tree.

Nội dung chính Show

Generic Collection Framework (JDK 5) by Examples
Pre-JDK 5 vs. JDK 5 Collection Framework
The Collection Interfaces
List Interfaces, Implementations and Algorithms
List Ordering/Searching/Sorting with Comparable/Comparator
SetInterfaces, Implementations and Algorithms
QueueInterfaces, Implementations and Algorithms
MapInterfaces, Implementations and Algorithms
Utilities Class java.util.Arrays
What is the name of the collection interface used to represent elements in a sequence?
Which collection interface is responsible for maintaining unique elements?
Which interface is used for collection?
Which collection would you use to keep sorted collection of unique objects?

In Java, dynamically allocated data structures (such as

7) are supported in a unified architecture called the Collection Framework, which mandates the common behaviors of all the classes.

A collection, as its name implied, is simply a container object that holds a collection of objects. Each item in a collection is called an element. A framework, by definition, is a set of interfaces that force you to adopt some design practices. A well-designed framework can improve your productivity and provide ease of maintenance.

The collection framework provides a unified interface to store, retrieve and manipulate the elements of a collection, regardless of the underlying actual implementation. This allows the programmers to program at the interface specification, instead of the actual implementation.

The Java Collection Framework package (

8) contains:

A set of interfaces,
Implementation classes, and
Algorithms (such as sorting and searching).

Similar Collection Framework is the C++ Standard Template Library (STL).

Prior to JDK 1.2, Java's data structures consist of array,

3, and

7 that were designed in a non-unified way with inconsistent public interfaces. JDK 1.2 introduced the unified collection framework, and retrofits the legacy classes (

3 and

7) to conform to this unified collection framework.

JDK 5 introduced Generics (which supports passing of types), and many related features (such as auto-boxing/auto-unboxing and for-each loop). The collection framework is retrofitted to support generics and takes full advantages of these new features.

To understand this chapter, you have to be familiar with:

You also need to be familar with these concepts introduced in JDK 5:

You need to refer to the JDK API specification while reading this chapter. The classes and interfaces for the Collection Framework are kept in package

Generic Collection Framework (JDK 5) by Examples

Example 1: List(List of Strings) Implemented by ArrayList

The

4 interface is the most commonly used data structure of the Collection Framework, which models a resizable (dynamically-allocated) array supporting numerical index access. The

5 class is the most commonly used implementation of

The

7 indicates that the interfaces are generic in design. When you construct an instance of these generic types, you need to provide the specific type of the objects contained in these collection, e.g.,

7. This allows the compiler to perform type-checking when elements are added into the collection at compile-time to ensure type-safety at runtime.

Dissecting the Program

Line 1-3 imports the collection framework classes and interfaces reside in the

8 package.

The class hierarchy of the

1 is shown above. We observe that

1 implements

4 and

5 interfaces. The

4 and

5interfaces define the common behaviors of all the collection implementations.

The interfaces/classes are designed (by the class designer) to take a generics type

8. To construct an instance of an

1, we need to provide the actual type for generic type

8. In this example, we pass the actual type

1 for the generic type

In line 11, we construct an
```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
```
1 instance, and upcast it to the
```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
```
6 interface. This is possible as the
```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
```
1 is a subtype of
```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
```
6. Remember that a good program operates on the specifications instead of an actual implementation. The Collection Framework provides a set of interfaces so that you can program on these interfaces instead of the actual implementation.
JDK 7 supports type inference on instantiation to simplify the codes:

Interface

4 defines how to add and remove an element into the collection. Interface

5 defines a mechanism to iterate or traverse through all the elements of a collection.

The super-interface

4 interface defines the common behaviors expected from a

4 object (such as getting the size, adding and removing element). Instead of using the interface

4 directly, it is more common to use one of its specialized sub-interfaces:

6 (an ordered list supporting numerical indexed access),

3 (models mathematical set with no duplicate elements) or

4 (FIFO, priority queues).
The super-interface

4 declares these

6 methods, implemented in concrete class

1: Line 14-16 adds elements (of the instantiated actual type

1) to the

There are a few ways of traversing through the elements of a

Via an associated

1 (Lines 20-24)

Use the new for-each loop introduced in JDK 5 (Line 30)
Use aggregate operations on Stream introduced in JDK 8. See "Example 4".

The super-interface

5 defines a mechanism to iterate (or traverse) through all the elements of a

4 object via a so-called

1 object. The

5 interface declares one

6 method to retrieve the object associated with the

The

1 interface declares the following

6 methods for traversing through the

4. Lines 20-24 retrieve the

1 associated with this

1, and use a while-loop to iterate through all the elements of this

1. Take note that you need to specify the actual type.

Line 30 uses the new for-each loop introduced in JDK 5 to iterate through all the elements of a

6 supports numerical index access via

6 method, with index begins from 0, shown in Lines 36-38.

With the use of generics, the compiler checks the type of elements added or retrieved and issue compilation error "incompatible type", as shown in lines 44-47. This is known as compiled-time type-safe.

Example 2: Listwith Auto-Boxing/Auto-Unboxing

Collection can hold only objects, not primitives (such as

8). JDK 5 introduces auto-boxing/auto-unboxing to simplify the conversion between primitives and their wrapper classes (such as

0, etc.)

Dissecting the Program

In this example, we pass actual type

1 for the generic type

8. In Line 9, we construct an

1 and upcast to

In lines 10-11, we pass

7 value into the

6. The

7 value is auto-boxed into an

1 object, and added into the

In line 13, the returns an

1 object, which is auto-unboxed to an

7 value.

Example 3: SetImplemented by HashSet

This example shows how to create a

4 of an user-defined objects.

The

3 interface models an unordered mathematical set without duplicate elements.

5 is the most common implementation of

We define a

06 class with two private variables

07 and

08, as follows:

Person.java

We shall test a

3 is follows:

Dissecting the Program

We define our custom objects called

06 in "

11".

In this example, we pass actual type

06 for the generic type

8. In Line 7, we construct an instance of

5, and upcast to

Take note that the elements in a
```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
```
3 are not ordered, as shown in the output of Line 11.

3 does not duplicate elements, as shown in the output of Line 20. To compare two

18 objects, we override the

19 and

20 methods in "

11".

Example 4: JDK 8 Collection, Stream and Functional Programming (Preview)

JDK 8 greatly enhances the Collection Framework with the introduction of Stream API to support functional programming.

Person.java: See above

This article focuses on JDK 5 Collection Framework. Read "Lambda Expressions, Streams and Functional Programming" and "Collection Framework, Part 2" for details on JDK 8 enhancements.

Pre-JDK 5 vs. JDK 5 Collection Framework

JDK 5 introduces Generics to support parameterized type and retrofitted the Collection Framework. To understand the differences between Pre-JDK 5 and JDK 5 Collection Framework, read "Generics".

The Collection Interfaces

The hierarchy of the interfaces and the commonly-used implementation classes in the Collection Framework is as shown below:

What is the name of the interface used to represent collection that maintain non unique elements in order?

The base interface is

4 (which is a subtype of

5), that defines the common behaviors.

We hardly program at the

4, but one of its specialized subtypes. The commonly-used subtypes of are

6 (ordered elements supporting index access),

3 (unordered and non-duplicate) and

4 (FIFO and priority queues).

The popular implementation classes for

6 are

1 and

2; for

3 are

5 and

33; for Quene is

34.

The

1 is used to traverse (or iterate) through each element of a

37 (or associative array), which supports key-value pair, is NOT a subtype of

4. The popular implementation class is

The
```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
```
40 (like Arrays) is a utility class, which contains
```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
```
41 methods to support algorihtms like searching and sorting.

Iterable/IteratorInterfaces and for-each Loop

There are three ways to traverse through all the elements of a

Via the associated

1 object retrieved from the super-type

Using the for-each loop (introduced in JDK 5)
Via the Stream API (introduced in JDK 8) (to be discussed in "Collection Framework, Part 2")

The IterableInterface

The

45 interface, which takes a generic type

7 and read as

5 of elements of type

8, declares one

6 method called

50 to retrieve the

1 object associated with the

4 object. This

1 object can then be used to traverse through all the elements of the associated collection.

All implementations of the

4 (e.g.,

3) must implement this method, which returns an object that implements

1 interface, for traversal of the

The IteratorInterface

The

1 interface, declares the following three

6 methods:

You can use a while-loop to iterate through the elements with the

1 as follows:

The for-each Loop

JDK 5 introduces a new for-each loop to simplify traversal of a

4, as shown in the above code.

for-each Loop vs. Iterator

The for-loop provides a convenience way to traverse through a collection of elements. But it hides the

1, hence, you CANNOT remove (via

65) or replace the elements.

On the other hand, as the loop variable receives a "cloned" copy of the object reference, the enhanced for-loop can be used to modify "mutable" elements (such as

66) via the "cloned" object references, but it cannot modify "immutable" objects (such as

1 and primitive wrapper classes) as new references are created.

Example: Using Enhanced for-each Loop on Collection of "Mutable" Objects (such as StringBuilder)

Example: Using Enhanced for-each loop on Collection of "Immutable" Objects (such as String)

CollectionInterface

The

4, which takes a generic type

8 and read as

4 of element of type

8, is the root interface of the Collection Framework. It defines the common behaviors expected of all classes, such as how to add or remove an element, via the following

6 methods:

Take note that many of these operations are mutable, i.e., they modify the

4 object. (In the Functional Programming introduced in JDK 8, operations are immutable and should not modify the source collection.)

Collection of Primitives?

4 can only contain objects, not primitives (such as

7 or

8). Primitive values are to be wrapped into objects (via the respective wrapper classes such as

1 and

78). JDK 5 introduces auto-boxing and auto-unboxing to simplify the wrapping and unwrapping processes. Read "Auto-Boxing and Auto-Unboxing" section for example.

List, Setand Queue: Specialized Sub-Interfaces of Collection

In practice, we typically program on one of the specialized sub-interfaces of the

4 interface:

3, or

6: models a resizable linear array, which allows numerical indexed access, with index starting from 0.

6 can contain duplicate elements. Implementations of

6 include

3 and

3: models a mathematical set, where no duplicate elements are allowed. Implementations of

3 include

5 and

93. The sub-interface

94 models an ordered and sorted set of elements, implemented by

33.

4: models queues such as First-in-First-out (FIFO) queue and priority queue. It sub-interface

97 models queues that can be operated on both ends. Implementations include

34,

99 and

The details of these sub-interfaces and implementations will be covered later in the implementation section.

MapInterface

In Java, a

37 (also known as associative array) contains a collection of key-value pairs. It is similar to

6 and array. But instead of an numerical key 0, 1, 2, ..., a

37's key could be any arbitrary objects.

The interface

37, which takes two generic types

05 and

06 (read as

37 of key type

05 and value type

06), is used as a collection of "key-value pairs". No duplicate key is allowed. Implementations include

7 and

12. Its sub-interface

13 models an ordered and sorted map, based on its key, implemented in

14.

Take note that

37 is not a sub-interface of

4, as it involves a pair of objects for each element. The details will be covered later.

List Interfaces, Implementations and Algorithms

6 models a resizable linear array, which supports numerical indexed access, with index starts from 0. Elements in a list can be retrieved and inserted at a specific index position based on an

7 index. It can contain duplicate elements. It can contain

19 elements. You can search a list, iterate through its elements, and perform operations on a selected range of values in the list.

6 is the most commonly-used data structure, as a resizable array.

The

6 interface declares the following

6 methods, in additional to its super-interfaces. Since

6 has a positional index. Operation such as

24,

25,

26 can be applied to an element at a specified index position.

The

6 superclass

28 provides implementations to many of the

6 methods declared in

6 and its supertypes

4 and

5. However, some methods such as

33 remains

6. These methods are implemented by the concrete subclasses such as

1 and

[TODO] Example

ArrayListand Vector: Implementation Classes for List

1 is the best all-around implementation of the

6 interface. Many useful methods are already implemented in

28 but overridden for efficiency in

1 (e.g.,

24,

25,

26 etc.).

3 is a legacy class (since JDK 1.0), which is retrofitted to conform to the Collection Framework (in JDK 1.2).

3 is a synchronized thread-safe implementation of the

6 interface. It also contains additional legacy methods (e.g.,

47,

48,

49,

50,

51,

52,

53). There is no reason to use these legacy methods - other than to maintain backward compatibility.

1 is not synchronized. The integrity of

1 instances is not guaranteed under multithreading. Instead, it is the programmer's responsibility to ensure synchronization. On the other hand,

3 is synchronized internally. Read "Synchronized Collection" if you are dealing with multi-threads.

Java Performance Tuning Tip: Synchronization involves overheads. Hence, if synchronization is not an issue, you should use

1 instead of

3 for better performance.

[TODO] Example

Stack: Implementation Class for List

4 is a last-in-first-out queue (LIFO) of elements.

4 extends

3, which is a synchronized resizable array, with five additional methods:

[TODO] Example

LinkedList: Implementation Class for List

2 is a double-linked list implementation of the

6 interface, which is efficient for insertion and deletion of elements, in the expense of more complex structure.

2 also implements

4 and

97 interfaces, and can be processed from both ends of the queue. It can serve as FIFO or LIFO queue.

[TODO] Example

Converting a List to an Array: toArray()

The super-interface

4 defines a method called

68 to create a fixed-length array based on this list. The returned array is free for modification.

Example - List to array

Using an Array as a List: Arrays.asList()

The utility class

69 provides a

41 method

71 to convert an array into a

6. However, change to the list write-thru the array and vice versa. Take note that the name of the method is

73 and not

74.

Example - Array as List

Comparison of ArrayList, Vector, LinkedList and Stack

[TODO] Example on benchmarking

2, and

List's Algorithms

The utility class

79 provides many useful algorithms for collection. Some work for any

4s; while many work for

6s (with numerical index) only.

Mutating Operators

[TODO] example

Sub-List (Range-View) Operations

The

6 supports range-view operation via

83 as follows. The returned

6 is backup by the given

6, so change in the returned

6 are reflected in the original

The Utility class

40 supports these sub-list operations:

For example,

Searching, Sorting and Ordering

The utility class

40 provides these

41 methods for searching, sorting and ordering (max, min) of

Each of these algorithms has two versions:

Requires a

92 object with a

93 method to determine the order of the elements.

Requires a

6 which implement

95 interface, with a method

96 to determine the order of elements.

We shall elaborate in the next section.

List Ordering/Searching/Sorting with Comparable/Comparator

Ordering is needed in these two situations:

To sort a

4 or an array (using the

98 or

99 methods), an ordering specification is needed.

Some

4s, in particular,

94 (

33) and

03 (

14), are ordered. That is, the objects are stored according to a specified order.

There are two ways to specify the ordering of objects:

Create a special

05 object, with a method

93 to specify the ordering of comparing two objects.

Make the objects implement the

07 interface, and override the

96 method to specify the ordering of comparing two objects.

ComparableInterface

07 interface specifies how two objects are to be compared for ordering. It defines one

6 method:

This ordering is referred to as the class's natural ordering.

It is strongly recommended that

96 be consistent with

12 and

13 (inherited from

14):

96 returns a zero,

12 should return

17.

12 returns

17,

13 shall produce the same

All the eight primitive wrapper classes (

22,

23,

25,

26,

78,

28 and

29) implement

95 interface, with the

96 uses the numerical order.

The

1 class also implements

95 interface, which compares two strings lexicographically based on the Unicode value of each character in the strings. The uppercase letters are smaller than the lowercase counterparts.

Example 1: Searching/Sorting String and Primitive Wrapper Types, which implement Comparable

The utility class

69 and

79 provide many

41 method for the various algorithms such as sorting and searching. In this example, we use the

99 and

98 methods to sort an array of

1s and a

6 of

1s, based on their

95's

96 method.

Example 2: Custom Implementation of Comparable

Let's create a subclass of

06 (see "

11" above), called ComparablePerson which implements

95 interface, and try out the

98 and

48 methods.

ComparatorInterface

Besides the

07 for the natural ordering, you can pass a

05 object into the sorting methods (

98 or

99) to provide precise control over the ordering. The

92 will override the

95, if available.

The

92 interface declares one

6 method (known as Functional Interface in JDK 8):

Take note that you need to construct an instance of

92, and invoke

93 to compare

59 and

60. [In the earlier

95, the method is called

96 and it takes only one argument, i.e., this object compare to the given object.]

Example 3: Using Customized Comparatorfor String and Integer

In this example, instead of using the natural

95, we define our customized

92 for

1s and

1s. We can do this via any of the following ways:

A named inner class
An anonymous inner class
Lambda Expressions (JDK 8)

Try: Modify the

92 to sort in A, a ,B, b, C, c ... (uppercase letter before the lowercase).

Notes: You can use Lambda Expressions (JDK 8) to shorten this code, as follows:

More example at "Example: Comparator Lambda".

Example 4: Using Customized Comparatorfor Person Objects

Person.java: See above

SetInterfaces, Implementations and Algorithms

The

3 interface models a mathematical set, where no duplicate elements are allowed (e.g., playing cards). It may contain a single

19 element.

The

3 interface declares the following abstract methods. The insertion, deletion and inspection methods returns

71 if the operation fails, instead of throwing an exception.

The implementations of

3 interface include:

5: Stores the elements in a hash table (hashed via the

74).

5 is the best all-round implementation for

```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
```
93: Stores the elements in a linked-list hash table for better efficiency in insertion and deletion. The element are hashed via the
```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
```
13 and arranged in the linked list according to the insertion-order.

33: Also implements sub-interfaces

80 and

94. Stores the elements in a red-black tree data structure, which are sorted and navigable. Efficient in search, add and remove operations (in

82).

HashSetBy Example

Let's write a

83 class, and create a

3 of

83 objects.

We need to provide an

12 method, so that the

3 implementation can test for equality and duplication. In this example, we choose the

88 as the distinguishing feature. We override

12 to return

17 if two books have the same

88. We also override the

13 to be consistent with

12.

3 cannot hold duplicate element. The elements are check for duplication via the overridden

95.

3 can hold a

19 value as its element (but no duplicate too).

The

98 and

99 perform set union and set intersection operations, respectively.

Take note that the arrangement of the elements is arbitrary, and does not correspond to the order of

24.

LinkedHashSetBy Example

Unlike

93 builds a link-list over the hash table for better efficiency in insertion and deletion (in the expense of more complex structure). It maintains its elements in the insertion-order (i.e., order of

24).

The output clearly shows that the set is ordered according to the order of

24.

SortedSetand NavigableSetInterfaces

Elements in a

94 are sorted during

24, either using the natural ordering in the

95, or given a

92 object. Read "Ordering, Sorting and Searching" for details on

95 and

92.

The

80 is a sub-interface of

94, which declares these additional navigation methods:

TreeSetby Example

33 is an implementation to

80 and

94.

Example - TreeSet with Comparable

This

16 class implements

95, in order to be used in

33. It overrides

96 to compare the

07 in a case insensitive manner. It also overrides

12 and

13, so as they are consistent with the

96.

Observe that the

16 objects are sorted and stored in the order depicted by the

95 during

24 operation.

Example - TreeSet with Comparator

Let's rewrite the previous example to use a

92 object instead of

95. We shall set the

92 to order in descending order of

07 for illustration.

The

31 class does not implement

92. You cannot

24 a

31 object into a

35 as in the above example. Instead, we define a

92 class, and use an instance of

92 to construct a

33.

The

92 orders the

31 objects in descending

07 and case insensitive.

In the test program, we construct a

33 with the

43. We also tried the

44 method to obtain a new

3 in reverse order.

QueueInterfaces, Implementations and Algorithms

A queue is a collection whose elements are added and removed in a specific order, typically in a first-in-first-out (FIFO) manner. A deque (pronounced "deck") is a double-ended queue that elements can be inserted and removed at both ends (head and tail) of the queue.

Besides basic

4 operations,

4 provide additional insertion, extraction, and inspection operations. Each of these methods exists in two forms: one throws an exception if the operation fails, the other returns a special value (either

19 or

71, depending on the operations). The latter form of the insert operation is designed specifically for use with capacity-restricted

4 implementations

97 declares additional methods to operate on both ends (head and tail) of the queue.

97 can be used as FIFO queue (via methods

53,

25,

55,

56,

57,

58) or LIFO queue (via methods

59,

60,

58).

The

4 and

97 implementations include:

```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
```
34: A queue where the elements are ordered based on an ordering you specify, instead of FIFO.

99: A queue and deque implemented as a dynamic array, similar to

2: The

2 also implements the

4 and

97 interfaces, in additional to

6 interface, providing a queue or deque that is implemented as a double- linked list data structure.

The basic operations of

4 include adding an element, polling the queue to retrieve the next element, or peeking at the queue to see if there is an element available in the queue. The

97 operations are similar except element can be added, polled, or peeked at both ends of the deque.

[TODO] Example

MapInterfaces, Implementations and Algorithms

A map is a collection of key-value pairs (e.g., name-address, name-phone, isbn-title, word-count). Each key maps to one and only value. Duplicate keys are not allowed, but duplicate values are allowed. Maps are similar to linear arrays, except that an array uses an integer key to index and access its elements; whereas a map uses any arbitrary key (such as

1s or any objects).

The implementations of

37 interface include:

6: Hash table implementation of the

37 interface. The best all-around implementation. Methods in

6 is not synchronized.

14: Red-black tree implementation of the

13 interface.

12: Hash table with link-list to facilitate insertion and deletion.

7: Retrofitted legacy (JDK 1.0) implementations. A synchronized hash table implementation of the

37 interface that does not allow

19 key or values, with legacy methods.

Basic Operations

The

37 interface declares the following

6 methods for basic operations:

Collection Views

The

87 provides these method to allow a map to be viewed as a

The nested class

89 contains these methods:

The

37 does not have

6-like iterator. The

4 views provides the means to iterate over a map.

Example 1: Iterating through a Map using .entrySet() and .keySet()

Example 2: Word Count using HashMap

Utilities Class java.util.Arrays

The Collection Framework provides two utility classes:

69 and

79, which provide some useful algorithms, such as sort, shuffle, reverse, and search, on arrays and Collections.

Array is a reference type in Java. It can hold primitives, as well as objects. On the other hand, a

4 holds only object.

Array Sorting/Searching: Arrays.sort() and Arrays.binarySearch()

Sorting of Primitive and Object Arrays

There is a pair of

96 methods for each of the primitive types (except

97) and

98.

For example, for

99:

Similar

96 methods are available for primitive arrays

01,

02,

03,

04,

05,

06 (except

07), and

08. For

08, the objects must implement

95 interface so that the ordering can be determined via the

96 method.

Soriting for Generic Arrays

A pair of methods is also defined for generic, to be sorted based on the given

92 (instead of

95).

What is the name of the collection interface used to represent elements in a sequence?

A List is an ordered Collection (sometimes called a sequence). Lists may contain duplicate elements.

Which collection interface is responsible for maintaining unique elements?

Explanation: Set interface extends collection interface to handle sets, which must contain unique elements.

Which interface is used for collection?

The Collection interface is used to pass around collections of objects where maximum generality is desired. For example, by convention all general-purpose collection implementations have a constructor that takes a Collection argument.

Which collection would you use to keep sorted collection of unique objects?

If you just want to sort a list, use any kind of List and use Collections. sort(). If you want to make sure elements in the list are unique and always sorted, use a SortedSet.

What is the name of the interface used to represent collection that maintain non unique elements in order?

Generic Collection Framework (JDK 5) by Examples

Example 1: List(List of Strings) Implemented by ArrayList

Dissecting the Program

Example 2: Listwith Auto-Boxing/Auto-Unboxing

Dissecting the Program

Example 3: SetImplemented by HashSet

Person.java

Dissecting the Program

Example 4: JDK 8 Collection, Stream and Functional Programming (Preview)

Pre-JDK 5 vs. JDK 5 Collection Framework

The Collection Interfaces

Iterable/IteratorInterfaces and for-each Loop

The IterableInterface

The IteratorInterface

The for-each Loop

for-each Loop vs. Iterator

Example: Using Enhanced for-each Loop on Collection of "Mutable" Objects (such as StringBuilder)

Example: Using Enhanced for-each loop on Collection of "Immutable" Objects (such as String)

CollectionInterface

Collection of Primitives?

List, Setand Queue: Specialized Sub-Interfaces of Collection

MapInterface

List Interfaces, Implementations and Algorithms

ArrayListand Vector: Implementation Classes for List

Stack: Implementation Class for List

LinkedList: Implementation Class for List

Converting a List to an Array: toArray()

Example - List to array

Using an Array as a List: Arrays.asList()

Example - Array as List

Comparison of ArrayList, Vector, LinkedList and Stack

List's Algorithms

Mutating Operators

Sub-List (Range-View) Operations

Searching, Sorting and Ordering

List Ordering/Searching/Sorting with Comparable/Comparator

ComparableInterface

Example 1: Searching/Sorting String and Primitive Wrapper Types, which implement Comparable

Example 2: Custom Implementation of Comparable

ComparatorInterface

Example 3: Using Customized Comparatorfor String and Integer

Example 4: Using Customized Comparatorfor Person Objects

SetInterfaces, Implementations and Algorithms

HashSetBy Example

LinkedHashSetBy Example

SortedSetand NavigableSetInterfaces

TreeSetby Example

Example - TreeSet with Comparable

Example - TreeSet with Comparator

QueueInterfaces, Implementations and Algorithms

MapInterfaces, Implementations and Algorithms

Basic Operations

Collection Views

Example 1: Iterating through a Map using .entrySet() and .keySet()

Example 2: Word Count using HashMap

Utilities Class java.util.Arrays

Array Sorting/Searching: Arrays.sort() and Arrays.binarySearch()

Sorting of Primitive and Object Arrays

Soriting for Generic Arrays

What is the name of the collection interface used to represent elements in a sequence?

Which collection interface is responsible for maintaining unique elements?

Which interface is used for collection?

Which collection would you use to keep sorted collection of unique objects?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội