Java - Array
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.
Management
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
fromList
- for arrays of reference types
Foo[] array = new Foo[list.size()];
list.toArray(array); // fill the array
- for arrays of primitive types
int[] array = new int[list.size()];
for(int i = 0; i < list.size(); i++) {
array[i] = list.get(i);
}
IsArray
obj.getClass().isArray()
Array vs List - Pro / Cons
String[] names = (String[]) personss.stream().map(Person::getName).toArray();
- Cons: This is a primitive data type and as therefore limited functionalities
Conversion
ToList
Arrays.asList
ToStream
Arrays.asList(array).stream()
// or shortcut
Arrays.stream(array)
Loop
For
for (int i = 0; i < anArray.length; i++) {
System.out.println(i+" : "+anArray[i]);
}
Size
int size = array.length;
Resize
- Integer array:
public static double [] resize(int[] array, int newSize){
if (newSize == 0) {
return [];
}
return array.length == newSize ? array : Arrays.copyOf(array, newSize);
}
- Generic where array factory is a functional interface that creates the array in the good type
public static <T> T [] resize(T[] array, int newSize, ArrayFactory<? extends T> factory) {
int oldSize = array.length;
if (oldSize == newSize) {
return array;
}
T[] result = factory.create(newSize);
if (newSize == 0) {
return result;
}
System.arraycopy(array, 0, result, 0, Math.min(oldSize, newSize));
return result;
}
@FunctionalInterface
public interface ArrayFactory<T> {
T[] create(int count);
}
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);
Concat
- One element and an array, see add_an_element_in_the_first_position
- Several arrays (More)
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;
}
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;
}
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);
Equality
import java.util.Arrays;
Arrays.equals(firstArray, secondArray));
Class
type[].class
Example for a byte:
byte[].class
Functional Programming
Transformation
String[] arr = {"1","2",""};
arr = Arrays
.stream(arr)
.map(s -> {
if (s.equals("")) {
return null;
} else {
return s;
}
})
.toArray(String[]::new);
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());
Slice
String[] args = Arrays.copyOfRange(args, 1, args.length);
Join
String.join(" ",args)