int[] array1;                  // Square brackets before variable name (recommended)
int key [];                    // Square brackets after variable name, legal but not recommended

Thread[] threads;              // Recommended
Thread threads [];             // Legal but less readable

String [][][] occupantName;    // 3 dimensional array
String [][] managerName;       // 2 dimensional array
int[5] array1;                 // ERROR: You cannot include the size of an array, the compiler will complain 

int a, b[], c;                 // you can declare multiple variables and arrays on the same line

String[]  string Array[];      // this actually declares a multi-dimension String array

int[] array1;                     // Declare the array of ints
array1 = new init[4];             // constructs an array of 4 elements and assigns the variable name array1
Note: the array will now be on the heap with each element set to 0 (default)

int[] myIntArray = null;          // you can set an array to null

Object o = new int[5];            // Array's are Objects so this is perfectly legal

int[] array1 = new int[14];       // Declare an array in one statement, 14 elements are created (0-13)

int[] a = new int[]{1,2,3,4,5};   // You can combine the initializer with the new operator, but don't define the size

int[] array1 = new int[];         // ERROR: This swill not compile missing array size

# Multidimension arrays
int[][] ratings = new int[3][];   // only first brackets are given a size which is acceptable 

// Setting values for sepcific elements within the array 
animals[0] = new Animal();              // Object type 
x[4] = 2;                               // primitive type

# Initializing a multidimensional array 
array[0] = new init[4];                 // Specify that element 0 holds an array of 4 int elements
array[1] = new init[6];                 // Specify that element 1 holds an array of 6 int elements
          
array[0][0] = 5;
array[0][1] = 6; 

int[] dots = {3,6,9,12};                                        // 4 element array of type int

int[][] scores = { {3,4,5}, {9,2}, {3,4,5} };                   // Multidimensional array 
 
String[] names = {new String("Paul"), new String("Lorraine")};  // Object array
String[] names = {"Paul", "Lorraine"};                          // Shorthand of above

// A second short cut is called an anonymous array, below creates a 3 element array of type int. 
int[] testScores;
testScores = new int[] {4,7,2};                                // the right hand is the anonymous array

public class Array1 {

   public static void main(String[] args) {

      // array declaration and initialization
      int[] counter;
      counter = new int[3];

      // declaration and initialization in one statement
      String[] names = { "Paul", "Lorraine", "Dominic", "Jessica" };

      // add some data to the counter array
      counter[0] = 0;
      counter[1] = 1;
      counter[2] = 2;

      System.out.println("Counter: " + counter[0] + " " + counter[1] + " " + counter[2] + "\n");

      for (int x=0; x < names.length; x++)   // Use the length variable to get number of elements
      {
         System.out.println("Name: " + names[x]);
      }
   } // END MAIN
}

Note: arrays have a length variable that contains the number of elements.

String[] names1 = {"Will", "Graham", "Moore", "Arthur", "Norman"};

String[] names2 = {"Will", "Graham", "Moore", "Arthur", "Norman"};

String[] names3 = {"Will", "Graham", "Moore", "Arthur"};

String[] names4 = names1;

String[] names5 = {};

// Equals checks if the arrays are the same (same reference)
System.out.println(names1.equals(names2));                  // contents are the same but they are different arrays
System.out.println(names1.equals(names3));                  // both contents and arrays are different
System.out.println(names1.equals(names4));

// Arrays.compare checks the contents of the arrays, it does not care if they are not the same array (same reference)
System.out.println(Arrays.compare(names1, names2));         // only checks that the contents are the same
System.out.println(Arrays.compare(names1, names3));         // contents are not the same
System.out.println(Arrays.compare(names1, names4));         // contents are the same

// We have to convert to a list before we can use the List.isEmpty method
System.out.println(Arrays.asList(names1).isEmpty());
System.out.println(Arrays.asList(names5).isEmpty());        // the array has to be empty not NULL

int[] numbers1 = {0, 1, 2, 3, 4, 5, 6};                           // sorted array
int[] numbers2 = {6, 3, 2, 1, 5, 0, 4};                           // unsorted array

String[] names1 = {"Will", "Graham", "Moore", "Arthur", "Norman"};
String[] names2 = {"Will", "Graham", "Moore", "Arthur", "Norman"};

System.out.println(Arrays.binarySearch(numbers1, 3));             // display the index where the pattern matched
System.out.println(Arrays.binarySearch(numbers2, 3));             // arrays must be sorted for the binarySearch to work, this display -7

Arrays.sort(names1);
System.out.println(Arrays.toString(names1));                      // list is now in sorted order
System.out.println(Arrays.binarySearch(names1, "Arthur"));        // the array MUST be sorted

System.out.println(Arrays.asList(names2).contains("Moore"));      // a LIST is a ordered collection (ordering is as they were entered) of objects that contain duplicates
System.out.println(Arrays.asList(names2).indexOf("Norman"));

System.out.println(Arrays.toString(names2));

int[] numbers1 = {0, 1, 2, 3, 4, 5, 6};                     // sorted array

String[] names1 = {"Will", "Graham", "Moore", "Arthur", "Norman"};

Arrays.fill(numbers1, 0);
System.out.println(Arrays.toString(numbers1));

Arrays.setAll(numbers1, p -> p = 1);                        // you could have complex lambda (operator) here
System.out.println(Arrays.toString(numbers1));

// You can use some of the List methods as well
System.out.println(Arrays.asList(names1).size());
System.out.println(Arrays.asList(names1).get(1));

Arrays.asList(names1).replaceAll(p -> p = "Paul");          // this updates the array using the List interface
System.out.println(Arrays.toString(names1));

int[] numbers1 = {0, 1, 2, 3, 4, 5, 6};                                  // sorted array

String[] names1 = {"Will", "Graham", "Moore", "Arthur", "Norman"};

int[] numbers2 = Arrays.copyOf(numbers1, numbers1.length);               // returns the copied number of elements
System.out.println(Arrays.toString(numbers2));

int[] numbers3 = Arrays.copyOf(numbers1, 3);                             // you can just copy a subset of the array
System.out.println(Arrays.toString(numbers3));

 System.out.println(Arrays.asList(names1).subList(1, 3).toString());     // this returns a List, from index, to index (excluding), notice we did not pickup Arthur at index 3