[Java] Collection framework

What is a collection?

• ** Set of objects **
• java.utul package: Provides generic classes / interfaces (** collection framework **) for working with collection structures
• I want to use it first when dealing with a set of objects

Collection interface

• Collection framework basics
• Implementation class for each subinterface
• ** List **: Ordered, elements can be duplicated
• ArrayList: Variable length array
• LinkedList: A list of linked structures
• ** Set **: Elements cannot be duplicated
• HashSet: A set of elements stored in arbitrary order
• LinkedHashSet: Element set stored in the order of addition
• TreeSet: Element set sorted by key
• ** Queue **: Add / remove first / last elements. Use for queue / stack
• ArrayDeque: Cue
• LinkedList: Same as LinkedList
• ** Map **: Manage by key / value, no duplicate keys
• HashMap: Basic Map
• TreeMap: Map sorted by key

Collection instantiation

• List<String> data = new ArrayList<>();

** Interface type **

• You can minimize class dependency by using interface type instead of variable type (implementation type)
• NG Example: It is not good to pass the real type as an argument as it is
  ʻArrayList data = new ArrayList <> (); <br> public void run (ArrayList data) {…} ``
• → ** If you set List <String> in the interface type from the beginning, you can easily change to Linked List! ** **
• List<String> data = new LinkedList<>();

** Generic syntax **

• ** Mechanism for binding generic classes / methods to specific types **
• In case of List <String>, assign String to general-purpose type (List) and become ** List ** dedicated to string storage!
• Conversely, non-generic collections consider all elements to be object types (all types can be assigned), require explicit type casting, and cannot detect unintended type values. ..
  Strng str = (String) data.get (0)
• → ** Use type-safe generics syntax! ** **
• Optional when the element type on the left side is obvious (** Diamond operator **)
  List <String> data = new ArrayList <> ();

idiom

Initialize the collection at the timing of instantiation

import java.util.ArrayList;
public class Main {
  public static void main(String[] args) {
    //Anonymous class
    var data = new ArrayList<String>() {
      //Initialization block
      {
        add("neko");
        add("inu");
        add("tori");
      }
    };
    System.out.println(data);//[neko, inu, tori]
  }
}

Process under collection in order with extension for

• Internally, syntax sugar of while instruction using ** Iterator ** (simplified syntax)
• Iterator interface methods
• ** hasNext **: Confirmation of the existence of the following elements
• ** next **: Move & get to next element
• ** remove **: Remove current element

import java.util.ArrayList;

public class Main {
  public static void main(String[] args) {
    var data = new ArrayList<String>() {
      {
        add("neko");
        add("inu");
        add("kuma");
      }
    };
    //Process under collection in order
    for (var s : data) {
      System.out.println(s); //neko inu kuma
    }
    //When using an iterator
    //     var itr = data.iterator();
    //     while (itr.hasNext()) {
    //      System.out.println(itr.next());
    //     }
  }
}

Delete elements in a loop

• Note that extension for will result in ConcurrentModificationException.

import java.util.ArrayList;

public class Main {
  public static void main(String[] args) {
    var data = new ArrayList<String>() {
      {
        add("neko");
        add("inu");
        add("niwatori");
      }
    };

    var ite = data.iterator();
    while (ite.hasNext()) {
      System.out.println(ite.next()); //neko inu niwatori
      ite.remove();
    }
    System.out.println(data); //[]
  }
}

//NG example:Extension for
    for (var s : data) {
      System.out.println(s);
      data.remove(s);
    }

Read the list in reverse order

• Get ListIterator object with listIterator method
• ** previous method **: move to previous element
• ** hasPrevious method **: Confirm the existence of the previous element
• Specify the read start position in the listIterator argument

import java.util.ArrayList;

public class Main {
  public static void main(String[] args) {
    var data = new ArrayList<String>() {
      {
        add("neko");
        add("inu");
        add("shimaenaga");
      }
    };
    //Set the end to the start position
    var ite = data.listIterator(data.size());
    while (ite.hasPrevious()) {
      System.out.println(ite.previous()); //shimaenaga inu neko
    }
  }
}

Array and collection transformations

• Basically, a set of objects is a collection rather than an array ** (affinity with object-oriented syntax)

From array to list

• ** asList method **
• The converted list is just an array covered with the skin of the list!
• Modifying the list affects the original array and cannot be added or removed from the list
• → ** Duplicate with Collections.addAll method **

//NG example: Convert existing character string to list, add and delete value to converted list
import java.util.Arrays;

public class Main {
  public static void main(String[] args) {
    var data = new String[] { "cat", "dog", "bird"};
    var list = Arrays.asList(data);
    list.set(0, "neko");
    System.out.println(list); //[neko, dog, bird]
    System.out.println(Arrays.toString(data)); //[neko, dog, bird]
    //list.add("inu"); //UnsupportedOperationException
    //list.remove(0);  //UnsupportedOperationException
  }
}

//OK Example: Convert existing character string to list, add and delete value to converted list
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Main {
  public static void main(String[] args) {
    var data = new String[] { "cat", "dog", "bird" };
    var list = new ArrayList<String>();
    Collections.addAll(list, data);
    list.set(0, "neko");
    list.add("inu");
    System.out.println(list); //[neko, dog, bird, inu]
    list.remove(1);

    System.out.println(list); //[neko, bird, inu]
    System.out.println(Arrays.toString(data)); //[cat, dog, bird]
  }
}

From collection to array

• ** toArray method **
• If all the elements fit in the argument array, set the elements
• If it does not fit, generate the same array as the argument and then set all elements
• If the collection element cannot be converted to an array element type ʻArrayStoreException`
• Since the elements are copied to the last, the operation to the conversion source list does not affect the array.

import java.util.ArrayList;
import java.util.Arrays;

public class Main {
  public static void main(String[] args) {
    var data = new ArrayList<String>(Arrays.asList("cat", "dog", "bird"));
    //Copy the contents to an array strs of the same size as the list
    var strs = new String[data.size()];
    data.toArray(strs);
    //Add data only to the conversion source list
    data.set(0, "neko");
    System.out.println(Arrays.toString(strs)); //[cat, dog, bird]
    //Only the conversion source list has changed
    System.out.println(data); //[neko, dog, bird]
  }
}

Convert to an immutable collection

• ** unmodifiable method **
• When trying to change ʻUnsupportedOperationException`
• If the element is a reference type, it may not be possible to restrict content changes (such as StringBuilder).
• Of method can also directly generate immutable collection (Java9 or later)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Main {
  public static void main(String[] args) {
    var data = new ArrayList<String>(Arrays.asList("cat", "dog", "bird"));
    //Generate an immutable list
    var udata = Collections.unmodifiableList(data);
    udata.set(0, "neko"); //UnsupportedOperationException
    udata.add("inu");  //UnsupportedOperationException
  }
}

//Collection element contents can be changed in StringBuilder
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Main {
  public static void main(String[] args) {
    var data = new ArrayList<StringBuilder>(Arrays.asList(
        new StringBuilder("Hello"),
        new StringBuilder("Kamesan"),
        new StringBuilder("Yo")));
    var udata = Collections.unmodifiableList(data);
    udata.get(0).append("Kameyo");
    System.out.println(udata); //[Hello,Kamesan,Yo]
  }
}

//Immutable collection directly generated by the of method
import java.util.List;
public class Main {
  public static void main(String[] args) {
    var data = List.of("cat", "dog", "bird");
    System.out.println(data);
    data.set(0, "neko"); //UnsupportedOperationException
  }
}

Empty collection generation

• For methods whose return value is a collection, if the return value is empty ** returns the collection instead of null **
• ** emptyList / emptySet / emptyMap method **
• return Collections.emptyList();

Synchronized collection generation

• ** Synchronized collection **: Method for multi-thread support (= exclusive processing)
• ** synchronizedCollection / synchronizedList / synchronizedSet / synchronizedMap method **
• Can be used safely in a multi-thread environment (= ** thread-safe **)
• var data = Collections.synchronizedList(new ArrayList<String>());
• Better parallel collection generation
  • CopyOnWriteArrayList / CopyOnWriteArraySet / ConcurrentHashMap
• var map = new ConcurrentHashMap<String,String>();