Java - Array

1 - About

Collection - Array in Java.

Arrays implement most of the List operations, but not remove and add. They are “fixed-size” Lists.

An array is a container object that holds :

  • a fixed number of values
  • of a single type.

The length of an array is established when the array is created. After creation, its length is fixed.

In Java, arrays cannot be resized dynamically. Another approach is to use a list.

3 - Management

3.1 - Initialization

  • Declaration

// declares an array of 
//     - integers
int[] anArray;
//     - string
String[] anArray
// A generic
T[] anGenericArray = (T[]) Array.newInstance(clazz, values.size())
// ...

  • Array Initialization

int[] anArray= {1,2,3,4,5,6,7,8,9,10};
anArray= new Integer[]{1,2,3,4};
string[] stringArray = new String[]{"foo","bar"}

  • Memory Allocation

// allocates memory for 3 integers with the index (0,1,2)
anArray = new int[3];
// allocates memory for 3 strings
anArray = new String[3];

  • Unit Initialization

// initialize first element
anArray[0] = "Nic";
// initialize second element
anArray[1] = "o";

anArray[2] = "Nic";
anArray[3] = "Nicooooo";
// and so forth

3.1.1 - fromList


Foo[] array = new Foo[list.size()];
list.toArray(array); // fill the array


int[] array = new int[list.size()];
for(int i = 0; i < list.size(); i++) {
         array[i] = list.get(i);
}

3.2 - IsArray


obj.getClass().isArray()

3.3 - Array vs List - Pro / Cons

  • Pro: You can cast an array but not a list. Example: casting an array at the end of a stream

String[] names = (String[]) personss.stream().map(Person::getName).toArray();

3.4 - Conversion

3.4.1 - ToList


Arrays.asList

3.4.2 - ToStream

Java - Stream Processing


Arrays.asList(array).stream()
// or shortcut
Arrays.stream(array)

3.5 - Loop

3.5.1 - For

for


for (int i = 0; i < anArray.length; i++) {

	System.out.println(i+" : "+anArray[i]);
	
}

3.6 - Size


int size = array.length;

3.7 - Copy


char[] copyTo = java.util.Arrays.copyOfRange(copyFrom, 2, 9);
char[] copyTo = java.util.Arrays.copyOf(copyFrom, copyFrom.length)
System.arraycopy(copyFrom, 2, copyTo, 0, 7);

3.8 - Concat


public static <T> T[] concatAll(T[] first, T[]... rest) {
    int totalLength = first.length;
    for (T[] array : rest) {
      totalLength += array.length;
    }
    T[] result = Arrays.copyOf(first, totalLength);
    int offset = first.length;
    for (T[] array : rest) {
      System.arraycopy(array, 0, result, offset, array.length);
      offset += array.length;
    }
    return result;
  }

3.9 - Add an element in the first position


public static <T> T[] addElementFirst(T[] elements, T first) {
    int totalLength = elements.length + 1;
    T[] result = Arrays.copyOf(elements, totalLength);
    result[0]=first;
    System.arraycopy(elements, 0, result, 1, totalLength-1);
    return result;
}

3.10 - Remove the last one


String[] arr = {"1","2","3"};
String[] arrMinOne = new String[arr.length-1];
System.arraycopy(arr,0,arrMinOne,0,arr.length-1);

3.11 - Equality


import java.util.Arrays;
Arrays.equals(firstArray, secondArray));

3.12 - Class

Class literal


type[].class

Example for a byte:


byte[].class

3.13 - Functional Programm

3.13.1 - Transformation


String[] arr = {"1","2",""};
arr = Arrays
	.stream(arr)
	.map(s -> {
		if (s.equals("")) {
			return null;
		} else {
			return s;
		}
	})
	.toArray(String[]::new);

3.13.2 - Select by index

Example: select the even elements


List<String> evenElement = IntStream
      .range(0, elements.length)
      .filter(i -> i % 2 == 0)
      .mapToObj(i -> elements[i])
      .collect(Collectors.toList());

3.14 - Slice


String[] args = Arrays.copyOfRange(args, 1, args.length);

3.15 - Join


String.join(" ",args)

4 - Documentation / Reference


Data Science
Data Analysis
Statistics
Data Science
Linear Algebra Mathematics
Trigonometry

Powered by ComboStrap