public class Person {
    static String name = "UNKNOWN";  // Class Variable
    String instanceName = "UNKNOWN"; // Instance Variable;
    String age = "25";  // Instance Variable initialized;

    // Single Parameter Constructor.
    public Person(String age) {
        // Constructors are perfect examples of how a method parameter
        // name can have same name as class or instance variable name.

        // In this constructor,  the Person instance age does not get
        // set at all, because age not qualified by 'this'.
        // This is a common mistake and may be tested on exam
        age = age;
    }

    // Two Args Constructor
    public Person(String name, String age) {
        // constructor parameters are named and typed the same as the
        // class variable 'name' and the instance variable 'age'

        // Correctly setting object's age using 'this' qualifier
        this.age = age;

        // instanceName is an instance variable and has different
        // name from the parameter which will be assigned to it, so
        // this not required, but good practice to use it

        // Also setting static variable name in same assignment
        // statement
        this.instanceName = Person.name = name;
    }
    // Simple setter for age
    public void setAge(String age) {
        // method sets instance variable age to the parameter passed.
        this.age = age;
    }

    // Simple setter for instanceName
    public void setInstanceName(String instanceName) {
        this.instanceName = instanceName;
    }
    
    // Simple get decade to explain loop scope
    public String getDecade(int age) {
      // a method local variable
      String decadeString = "";
      
      // A method local variable
      int decadeNumver = age/10;
      
      // A method local variable
      int j = 0;
      for (int i = j = 0; i < (decadeNumber + 1); i++, j++) {
        // local loop block variable named decade, scope is loop
        String decade = "Decade " + (age / 10);
        
        // i variable is local to the loop
        if (i == (decadeNumber)) {
           decadeString = decade;
        }
      }
      int modyear = age % 10;
      decadeString += ", Year " + modyear;
      return decadeString;
    }
}

public class NestedScope {
    public static void main(String[] args) {
        // local variable i declared and initialized
        int i = 10;
        class locallyDefinedClass {
            {
                // i from method scope still visible in nested local class
                System.out.println("value of i BEFORE LOOP  " + i);
                System.out.println("---------------");

                // Because this for loop is within a local class,this is valid
                for (int i = 0; i< 5; i++) {
                    System.out.println("value of i during FIRST loop " + i);
                }
                System.out.println("---------------");

                // the local variable i from previous loop has gone out of scope
                // so it is ok to create another local variable in the second loop
                // declaration of the same name.
                for (int i = 5; i > 0; i--) {
                    System.out.println("value of i during SECOND loop " + i);
                }
                System.out.println("---------------");

                //  assign local loop variable j to local variable i from the
                // surrounding method of the nested class,
                for (int j = i; j < 15; j++) {
                    System.out.println("value of i,j during THIRD loop " + i + "," + j);
                }
                System.out.println("value of i AFTER LOOP  " + i);
            }
        }
        System.out.println("value of i before local class instantiated " + i);
        new locallyDefinedClass();
        System.out.println("value of i after local class instantiated " + i);
    }
}

public class VarTest {
    public static void main(String[] args) {
        var p1 = new Person();
        p1.setName("Paul");
        System.out.println(p1);

        // Adding some other var declarations:
        // i is inferred to be an int, since it's assigned a literal int
        var i = 1;

        // An array can be assigned to an LVTI variable
        var aVarArray = new int[3];

        // Valid to assign a method return value to an LVTI variable
        var methodVal = p1.getName();

        // OK to assign a null object to LVTI variable but not literal null
        // Note that i am using var as a variable name which is valid
        Object nullObject = null;
        var var = nullObject;

        // Invalid var declarations:

//        // cannot use var declaration in a compound statement
//        var j = 0, k = 0;
//
//        // again, cannot use var declaration in a compound statement
//        var m, n = 0;
//
//        // Cannot declare a var variable without also initializing it
//        var someObject;
//
//        // Cannot assign null to var variable, type cannot be inferred
//        var newvar = null;
//
//        // Cannot use array initializer in var declaration/initialization
//        var myArray = {"A", "B"};
//
//        // Cannot have an array of var
//        var[]newarray = new int[2];
    }
}

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

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[] array1;           // Declare the array of ints
array1 = new init[4];   // constructs an 4 element array and assigns the variable name array1

Note: the array will now be on the heap with each element set to 0 (default)

# Declare an array in one statement
int[] array1 = new int[14];

# Will not compile
int[] array1 = new int[];   // ERROR: 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;

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

# Multidimensional array
int[][] scores = { {3,4,5}, {9,2}, {3,4,5} };

# Object array
String[] names = {new String("Paul"), new String("Lorraine")};

# 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};

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.

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

int aLen = array1.length;
int bLen = array2.length;
int[] result = new int[aLen + bLen];

System.arraycopy(array1, 0, result, 0, aLen);
System.arraycopy(array2, 0, result, aLen, bLen);

Arrays.stream(result).sorted().forEach(p -> System.out.print(p + " "));

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

public class converting_int_array_to_list {

    public static void main(String[] args) {

        int[] intArray = {0, 1, 2, 3, 4, 5, 6};

        System.out.println("Converting int array to List");
        System.out.println("================================================================");

        // convert int array to List using for loop
        List<Integer> list1 = new ArrayList<>(intArray.length);
        for(int i : intArray) {
            list1.add(i);
        }
        System.out.println("List1 (for loop): " + list1);

        // convert int array to List (Streams)
        List<Integer> list2 = Arrays.stream(intArray).boxed().collect(Collectors.toList());
        System.out.println("List2 (Streams): " + list2);

        // convert int array to List (Collections)
        List<Integer> list3 = new ArrayList<>();
        Collections.addAll(list3, Arrays.stream(intArray).boxed().toArray(Integer[]::new));
        System.out.println("List3 (Collections): " + list3);

        // convert int array to List (IntStream)
        List<Integer> list4 = IntStream.of(intArray).boxed().collect(Collectors.toList());
        System.out.println("List4 (IntStream): " + list4);

        // yo can use the same for double, float, etc
        double[] doubleArray = {0.1, 0.2, 0.3, 0.4, 0.5};
        List<Double> list5 = Arrays.stream(doubleArray).boxed().collect(Collectors.toList());
        System.out.println("List5 (convert double): " + list5);

    }
}

public class converting_string_array_list {

    public static void main(String[] args) {

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

        // convert String array to List using for loop
        List<String> list1 = new ArrayList<>(stringArray.length);
        for(String s : stringArray) {
            list1.add(s);
        }
        System.out.println("List1 (for loop): " + list1);

        // convert String array to List using Arrays.asList
        List<String> list2 = Arrays.asList(stringArray);
        System.out.println("List2 (asList) : " + list2);

        // convert String array to List (Streams)
        List<String> list3 = Arrays.stream(stringArray).collect(Collectors.toList());
        System.out.println("List3 (Streams): " + list3);

        // convert String array to List (Collections)
        List<String> list4 = new ArrayList<>();
        Collections.addAll(list4, stringArray);
        System.out.println("List4 (Collections): " + list4);

        // convert String array to List (new ArrayList)
        List<String> list5 = new ArrayList<>(Arrays.asList(stringArray));
        System.out.println("List5 (new array): " + list5);
    }
}