Java

/**
 * The array buffer into which the elements of the ArrayList are stored.
 * The capacity of the ArrayList is the length of this array buffer. Any
 * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
 * will be expanded to DEFAULT_CAPACITY when the first element is added.
 */
transient Object[] elementData; // non-private to simplify nested class access

/**
 * The size of the ArrayList (the number of elements it contains).
 *
 * @serial
 */
private int size;

int[] anArray;

int anOtherArray[];

int[] anArray = new int[10];

int anOtherArray[] = new int[] {1, 2, 3, 4, 5};

anArray[0] = 10;

int anOtherArray[] = new int[] {1, 2, 3, 4, 5};
for (int i = 0; i < anOtherArray.length; i++) {
    System.out.println(anOtherArray[i]);
}

for (int element : anOtherArray) {
    System.out.println(element);
}

void varargsMethod(String... varargs) {}

public class VarargsDemo
{

    public VarargsDemo()
    {
    }

    transient void varargsMethod(String as[])
    {
    }
}

VarargsDemo demo = new VarargsDemo();
String[] anArray = new String[] {"", ""};
demo.varargsMethod(anArray);

demo.varargsMethod("", "");

int[] anArray = new int[] {1, 2, 3, 4, 5};

List<Integer> aList = new ArrayList<>();
for (int element : anArray) {
    aList.add(element);
}

List<Integer> aList = Arrays.asList(anArray);

List<Integer> aList1 = Arrays.asList(1, 2, 3, 4, 5);

List<Integer> aList = Arrays.stream(anArray).boxed().collect(Collectors.toList());

private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable{}

new ArrayList<>(Arrays.asList(anArray));

String[] anArray = new String[] {"", "", ""};
Stream<String> aStream = Arrays.stream(anArray);

int[] anArray = new int[] {5, 2, 1, 4, 8};
Arrays.sort(anArray);

[1, 2, 4, 5, 8]

String[] yetAnotherArray = new String[] {"A", "E", "Z", "B", "C"};
Arrays.sort(yetAnotherArray, 1, 3,
                Comparator.comparing(String::toString).reversed());

int[] anArray = new int[] {5, 2, 1, 4, 8};
for (int i = 0; i < anArray.length; i++) {
    if (anArray[i] == 4) {
        System.out.println(" " + i);
        break;
    }
}

int[] anArray = new int[] {1, 2, 3, 4, 5};
int index = Arrays.binarySearch(anArray, 4);

public String substring(int beginIndex) {
    return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}

public String(char value[], int offset, int count) {
    this.value = Arrays.copyOfRange(value, offset, offset+count);
}

public static native void arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);

int[] array1 = {1, 2, 3};
int[] array2 = {4, 5, 6};

// 
int[] mergedArray = new int[array1.length + array2.length];

// 
System.arraycopy(array1, 0, mergedArray, 0, array1.length);
System.out.println(Arrays.toString(mergedArray));

// 
System.arraycopy(array2, 0, mergedArray, array1.length, array2.length);
System.out.println(Arrays.toString(mergedArray));

[1, 2, 3, 0, 0, 0]
[1, 2, 3, 4, 5, 6]

int[] array1 = {1, 2, 3};
int[] array2 = {4, 5, 6};

// 
int[] mergedArray = new int[array1.length + array2.length];

// 
int index = 0;
for (int element : array1) {
    mergedArray[index++] = element;
}

// 
for (int element : array2) {
    mergedArray[index++] = element;
}

int[] anArray = new int[] {1, 2, 3, 4, 5};
System.out.println(anArray[5]);