Java - List (sequence)

1 - About

A list (also known as a sequence):

  • is ordered
  • allow duplicates (multiple null elements if they allow them)
  • is zero based. The first element is at the position 0.
  • can contain themselves as elements (but caution as the equals and hashCode methods are no longer well defined on such a list)

A special iterator, called a ListIterator, allows element insertion and replacement, and bidirectional access (from begin or from end) in addition to the normal operations.

3 - Interface and Implementation

List is an interface from the Java Collections Framework representing an ordered collection (also known as a sequence).

See List for all implementations. The most known is the ArrayList: a Resizable-array that permits all elements, including null.

4 - Management

4.1 - Instantiation

4.1.1 - From Array

From an array


List<Class> myList = new ArrayList<Class>();

// With String as Class
List<String> messages = new java.util.ArrayList(Arrays.asList("Nico", "Gerard"));

// The java.util.ArrayList transform the list implementation of the return list from Arrays.asList

See asList

  • As generic function

public static <T> List<T> asList(T... object) {
    return Arrays.stream(object)
      .collect(Collectors.toList());
}

4.1.2 - New Operator


List<Class> myList = new ArrayList<Class>();

The ArrayList(int) constructor gives a List that has size 0. It only ensures that n elements can be added before it needs to reallocate the underlying array.

4.1.3 - From scalar


Collections.singletonList(myObject)

4.2 - Concatenation


List<String> list = new ArrayList<String>();
newList.addAll(secondList);

4.3 - Join


String join = String.join("joinSeparator", list);

  • With a stream: Example with columns, to create the first line of a csv

final String headers = columns.stream()
                .map(s->s.getColumnName())
                .collect(Collectors.joining(","));

4.4 - Copy

The element are not copied.


List<String> copyList = new ArrayList<String>();
copyList.addAll(list);

4.5 - Deep Copy

The element are also copied.


for(Object obj:list){
    copyList.add(obj.clone());
    copyList.add(obj.clone());
}

4.6 - Cast

  • cast of generic list with parameters. You can't cast a generic type of one parameter to another directly. However, since you can cast to and from wildcard types, you can cast through an intermediate wildcard type.

List<B> variable = (List<B>)(List<?>) collectionOfListA;

4.7 - Sort

  • Ascending order

foreignKeys = foreignKeys.stream()
                .sorted((s1,s2)->(s1.getForeignPrimaryKey().getTableDef().getName()).compareTo(s2.getForeignPrimaryKey().getTableDef().getName()))
                .collect(Collectors.toList());
// same as
foreignKeys = foreignKeys.stream()
                .sorted(Comparator.comparing(s -> (s.getForeignPrimaryKey().getTableDef().getName())))
                .collect(Collectors.toList());

  • Descending order

foreignKeys = foreignKeys.stream()
                .sorted((s1,s2)->(s2.getForeignPrimaryKey().getTableDef().getName()).compareTo(s1.getForeignPrimaryKey().getTableDef().getName()))
                .collect(Collectors.toList());
// same as
foreignKeys = foreignKeys.stream()
                .sorted(Comparator.comparing(s -> (s.getForeignPrimaryKey().getTableDef().getName())).reversed())
                .collect(Collectors.toList());

4.8 - Reverse

  • Stream

List<String> elements  = elements.stream()
   .sorted(Collections.reverseOrder())
   .collect(Collectors.toList());

  • Collections methods

Collections.reverse() 

4.9 - Stream to

4.9.1 - toList

  • List of object to a list of attribute

List<Person> persons = new ArrayList<>();
// ... add persons
List<String> names = persons.stream()
                .map(a -> a.getName())
                .collect(Collectors.toCollection(ArrayList::new));
                
// or 
//     .collect(Collectors.toList());

  • List of list to list

List<String> groups =
	properties.stream()
	.flatMap(x->x.getListOfStrings().stream())
	.collect(Collectors.toList());

4.9.2 - toMap

  • from a list of object

List<Person> persons = new ArrayList<>();
// ... add persons
Map<Integer, CliWord> personsMap = persons.stream()
                .filter(p -> p.getNummer()!=null)
                .collect(Collectors.toMap(Person::getNummer, Function.identity()));

  • extends a list of string with attributes.

List<String> persons = new ArrayList<>();
Map<String, String> personsMap = persons.stream()
            .collect(Collectors.toMap(
                s -> s, 
                s -> lookupFirstName(s)
            ));

  • groupBy

Map<String, List<Person>> groupedByName = persons
        .stream()
        .collect(Collectors.groupingBy(Person::getName));

  • from a list of generic

Map<T, Double> buckets = genericList
        .stream()
        .collect(Collectors.toMap(
          g->g,
          g->1.0
        ));

4.9.3 - toArray

List to array

  • General construction

list.toArray(new Class[0])
// before version I don't know anymore
list.toArray(new Class[arraySize])

  • from a list of scalar

// For a list of string
list.toArray(new String[5])
// since opendJdk java 6 better not to pre-size
list.toArray(new String[0])

// Example
List<String> myList = new ArrayList<>();
myList.add("first");
myList.add("second");

String[] myArray = myList.toArray(new String[myList.size()])

  • from a list of object Object

// from Stream
final String[] nativeColumns = foreignKeyDef.getNativeColumns().stream()
                        .map(ColumnDef::getColumnName)
                        .toArray(String[]::new);

4.9.4 - toGenericArray


// Based on
T[] arrayGeneric = (T[]) Array.newInstance(clazz,size)

// With Stream
T[] objects = valuesList.stream()
        .map(o -> Casts.cast(o, columnDef.getClazz()))
        .collect(Collectors.toList())
        .toArray((T[]) Array.newInstance(clazz,0));

4.9.5 - ToSet


mySet = new HashSet<>(list);

5 - Documentation / Reference


Data Science
Data Analysis
Statistics
Data Science
Linear Algebra Mathematics
Trigonometry

Powered by ComboStrap