Java Collections

import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class HashSetDemo { public static void main(String[] args){ String[] colors={"purple", "green", "red","magenta", "blue", "red", "purple"}; Set<String> set=new HashSet<>(Arrays.asList(colors)); for(String s: set){ System.out.println(s); } } }

for (char c : myString.toCharArray()) {}

class LexicographicComparator implements Comparator<String> {

public int compare(String o1, String o2) {

return o1.compareTo(o2);

}

}

class ByLengthComparator implements Comparator<String> {

public int compare(String o1, String o2) {

return Integer.compare(o1.length(), o2.length());

}

}

public class ComparatorExample {

public static void main(String[] args) {

List<String> fruits = Arrays.asList(

"watermelon",

"apple",

"pear");

Collections.sort(fruits, new LexicographicComparator());

// will print [apple, pear, watermelon]

System.out.println(fruits);

Collections.sort(fruits, new ByLengthComparator());

// will print [pear, apple, watermelon]

System.out.println(fruits);

}

}

Collection interface is the parent of List, Queue and Set interfaces.

Java does not come with a usable implementation of the Collection interface, so you will have to use one of the listed subtypes

Maps such as HashMap are not Collections -they don’t implement the Collection interface.

keySet method of the Map interface returns a Set view of the Map object, consisting of all the keys in the map

WeakHashMap is useful then the desired lifetime of cache

entries is determined by external references to the key, not the value

Set -> SortedSet

Map -> SortedMap

interface: List - this is an ordered list of objects, insertion order is maintained and retrieval order is in the list order but items can also be random accessed, duplicate items are allowed, generally allow storage of null values (the ones below do), generally fast to iterate and find items by position but slow to do lookups

• • ArrayList - Unsychronized, nulls allowed (fastest)

  • Vector - Synchronized, only slightly slower in tests of sizes under 100000

  • Stack - Synchronized, same speed as Vector, LIFO queue

  • LinkedList - Unsynchronized, allows two way iteration and modification of items (like a stack or queue)

  • CopyOnWriteArrayList - Synchronized, significantly slower in tests of large numbers of items or average list changes, only slightly slower when used with very small numbers (<100)>

interface: Set - this a set of items with no duplicates (no two items can compare as equal), ordering is typically inconsistent over multiple set iterations depending on the implementation but you should assume the order is effectively random unless the set specifies ordered iteration, generally ok to iterate and fast to do lookups

• • HashSet - Unsychronized (fastest), slower than HashMap which it is built on, allows nulls

  • LinkedHashSet - Unsychronized, ordered by insertion, allows nulls

  • TreeSet - Unsychronized, ordered by the natural ordering of the items or a comparatorprovided at construction, allows nulls but there are issues with removing them

  • CopyOnWriteArraySet - Synchronized, significantly slower in tests of large numbers of items or average set changes, only slightly slower when used with very small numbers (<100)>

interface: Map - Stores key/value pairs (maps keys to values) where the keys must be unique, order of iteration over keys, values, or pairs is highly dependent on the implementation of the map, allowed nulls also vary by implementation, generally very fast to lookup keys and slow to lookup values

• • IdentityHashMap - Unsychronized (fastest), uses reference equality (==) instead of object equality (equals) to compare keys, actually violates the Map interface guarantee, all iterators are unordered, allows null keys and values

  • HashMap - Unsychronized, this is the fastest general purpose map, all iterators are unordered, allows null keys and values

  • ConcurrentHashMap - Synchronized, all iterators are unordered, does not allow null keys or values

  • Hashtable - Synchronized, all iterators are unordered, does not allow null keys or values

  • LinkedHashMap - Unsychronized, all iterators are ordered based on insertion order of the original key (does not change if a key is reinserted), allows null values but null keys are not allowed

  • TreeMap - Unsychronized, iterators are ordered by the natural or comparator ordering of the keys, allows null keys and values but the comparator needs to understand them

ArrayList is fast as long as you know the size in advance (or as long as you don’t have many resizing) and as long as you don’t have many removals. On the other hand there are memory considerations – LinkedList has the pointers overhead but a large ArrayList might require a big chunk of contiguous memory to be allocated on a resize operation, also a large empty ArrayList is a big waste of memory.

Same for CopyOnWriteArrayList – the performance issue in here is also depending on the usage: modification of the list might cost (it is synchronized and allocates a new list) however it is very efficient for concurrent iteration and you are safe from the concurrent modification exception.

MAPS

// key list

List keyList = new ArrayList(map.keySet());

// value list

List valueList = new ArrayList(map.values());

// key-value list

List entryList = new ArrayList(map.entrySet());

https://www.reddit.com/r/programming/comments/59qgyf/did_you_know_java_8_hashmap_automatically/

http://coding-geek.com/how-does-a-hashmap-work-in-java/

What is a HashMap.Entry?

It contains a key, a value, int hash of a key and a pointer to the next entry

It means that an entry occupies 32 bytes = (12 bytes header + 16 bytes data (8 key and 8 value) + 4 bytes padding).

Hence HashMap with size = S has to spend 32 * S bytes for entries storage. Besides, it will use 4 * C bytes for entries array, where C is the map capacity (here 4 is the size of object reference in bytes on 32 bits VM).

Map traversing

for(Map.Entry mapEntry : map.entrySet()) { //this is fast

Key key = mapEntry.getKey();

Value value = mapEntry.getValue();

}

for (Key key : map.keySet()) { //this is slow

Value value = map.get(key);

}

// a method for getting key of a target value

public Character getKey(HashMap<Character,String> map, String target){ for (Map.Entry<Character,String> entry : map.entrySet()) {

if (entry.getValue().equals(target)) {

return entry.getKey();

} }

return null;

}

Prints a frequency table of the words on the command line

• public class Frequency { public static void main(String[] args) {

• Map<String, Integer> m = new TreeMap<String, Integer>();

• for (String word : args) {

• Integer freq = m.get(word);

• m.put(word, (freq == null ? 1 : freq + 1));

• }

• System.out.println(m);

• }

• }

  • Map interface provides three collection views:

    • • Set keySet(): Returns a Set view of the keys contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator’s own remove operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.

      • Collection values(): Returns a Collection view of the values contained in this map. The collection is backed by the map, so changes to the map are reflected in the collection, and vice-versa. If the map is modified while an iteration over the collection is in progress (except through the iterator’s own remove operation), the results of the iteration are undefined. The collection supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Collection.remove, removeAll, retainAll and clear operations. It does not support the add or addAll operations.

      • Set<Map.Entry<K, V>> entrySet(): Returns a Set view of the mappings contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator’s own remove operation, or through the setValue operation on a map entry returned by the iterator) the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll and clear operations. It does not support the add or addAll operations.

LinkedHashMap

The removeEldestEntry(Map.Entry) method may be overridden to impose a policy for removing stale mappings automatically when new mappings are added to the map.

Map<String, Integer> counts = new HashMap<>();

counts.put(“Alice”, 1); // Adds the key/value pair to the map

counts.put(“Alice”, 2); // Updates the value for the key

This example uses a hash map which, as for sets, is usually the better choice if you don’t

need to visit the keys in sorted order. If you do, use a TreeMap instead.

Here is how you can get the value associated with a key:

int count = counts.get(“Alice”);

If the key isn’t present, the get method returns null. In this example, that would cause a

NullPointerException when the value is unboxed. A better alternative is

int count = counts.getOrDefault(“Alice”, 0);

Then a count of 0 is returned if the key isn’t present.

When you update a counter in a map, you first need to check whether the counter is

present, and if so, add 1 to the existing value. The merge method simplifies that common

operation. The call

counts.merge(word, 1, Integer::sum);

associates word with 1 if the key wasn’t previously present, and otherwise combines the

previous value and 1, using the Integer::sum function.

Sometimes, you want to share the contents of a collection but you don’t want it to be

modified. Of course, you could copy the values into a new collection, but that is

potentially expensive. An unmodifiable view is a better choice. Here is a typical situation.

A Person object maintains a list of friends. If the getFriends gave out a reference to

that list, a caller could mutate it. But it is safe to provide an unmodifiable list view:

public class Person {

private ArrayList<Person> friends;

public List<Person> getFriends() {

return Collections.unmodifiableList(friends);

}

…

}

All mutator methods throw an exception when they are invoked on an unmodifiable view.

for (Map.Entry<String, Integer> entry : counts.entrySet()) {

String k = entry.getKey();

Integer v = entry.getValue();

Process k, v

}

Or simply use the forEach method:

counts.forEach((k, v) -> {

public void process(String directions) {

this.directions = Objects.requireNonNull(directions);

…

}

List<String> list = new ArrayList<String>(c)

MovieComparator comparator = new MovieComparator();