arrays in java a tutorial

1- Declaring and Creating arrays

A variable of type array , can be declared by using either Type[] nameOfVariable or Type nameOfVariable[] . In the first case all the variables after Type[] are of type array . In the second case , only the variable with the square brackets is of type array . There can be spaces between Type and [] .

int[] iArrayOne , iArrayTwo ;
/* 
iArrayOne and iArrayTwo are variables 
  of type int[] , since the square brackets
  are placed after the int type .*/
 
 
String sArray[] , aString ;
/* 
sArray is a variable of type
  String[] , since the square 
  brackets is placed after sArray.
aString is a variable of type
  String .*/

A variable of type array can be assigned a reference of type array . If no array reference is assigned to a variable of type array , the value assigned to the variable of type array is null .

int iArray[];
/*
iArray is a variable of type 
  int[] .
No array reference was assigned
  to iArray , as such it is 
  assigned the null value .*/

To create an array , The notations :

• {expression , expression ...} .
• new Type[length] .
• new Type[]{expression , expression ...}

can be used .

The notation {expression , expression ...} can only be used while declaring an array , while other notations can be used everywhere .

jshell> 
 
> String[] sArrayOne;
/*
Declare the sArrayOne variable , to
  be an array of type 
  String . 
The sArrayOne variable is not 
  initialized with any value
  that holds a reference to 
  an array of type String[]
  ,as such it has a null
  value .*/
sArrayOne ==> null
 
 
> int[] iArrayOne , iArrayTwo = { 1, 2, 3+5 }
/*
Declare iArrayOne and iArrayTwo to 
be variables of type int[] . 
iArrayOne is not initialized , to 
  any value which holds a reference 
  to an array of type int[] . As 
  such it has a null value . 
iArrayTwo is initialized using 
  { 1, 2, 3+5 } . 
  An array of type int[] is created . 
    Its length is equal to the number of 
      elements inside { 1, 2, 3+5 } . 
    The expressions in { 1, 2, 3+5 }
      are evaluated and are assigned 
      to the first , second and third 
      element of the newly created array . 
  A reference of the newly created array , 
    is stored inside iArrayTwo .*/
iArrayOne ==> null
iArrayTwo ==> [ 1, 2, 8 ]
 
 
> Object[] oArrayOne , oArrayTwo = {new Object()};
/*
oArrayOne is a variable , of type 
  Object[]. It is not initialized ,
  to hold a reference to an array 
  of type Object[] , as such it 
  is assigned a null value . 
oArrayTwo is a variable of type 
  Object[]. It is initialized using 
    {new Object()}. 
  An array of type Object is created , 
    it has a length of 1 . The expression 
    new Object is evaluated , it creates
    a new instance of Object . A reference 
    of  the newly created object is stored 
    inside the first element of the newly 
    created array . 
  A reference of the newly created array
    is stored inside oArrayTo .*/
oArrayOne ==> null
oArrayTwo ==> [ java.lang.Object@59f99ea ]
 
 
> oArrayOne = {new Object()}
/* 
It is illegal to use 
  {expression , expression ..}
  anywhere beside in array 
  declaration .*/
|  Error:
|  illegal start of expression
|  oArrayOne = {new Object()}
 
> oArrayOne = oArrayTwo
/*
Assign the value of the variable 
  oArrayTwo to oArrayOne .*/
oArrayOne ==> [ java.lang.Object@59f99ea ]

When using the notation new Type[length_expression] , an array of the specified length and type is created , and all of its elements are null , unless the array is of the primitive type , in this case the element are initialized to their default value . For example the default value of int is 0.

The length expression must evaluate to a type int , and must be >=0 . As such the max length of an array that can be created is 2147483647 .

jshell> 
 
> import java.util.Arrays;
/* 
import the Arrays utility 
  class .*/
 
 
> String []sArray;
/* 
Declare a variable of type 
  String [] .
It is not initialized ,
  as such its value is 
  null .*/
sArray ==> null
 
 
> sArray = new String[3];
/* 
Create an array of type String[]
  which has three elements 
  initialized to null . 
A reference of this array is 
  stored inside the variable 
  sArray .*/
sArray ==> [ null, null, null ]
 
 
> int k = 1 ; 
> int j = 3 ; 
> int iArray[] = new int[k*j];
/* 
Declare the iArray variable
  to be an array of type 
  int .
Evaluate the expression 
  k*j , its value is 3 .  
Create a new array of 
  length three , of type 
  int , with all of its 
  elements having a value 
  of 0. 
Assign a reference of
  the newly created array 
  to the variable iArray .*/
iArray ==> [ 0, 0, 0 ]
 
 
> char cArray[] = new char[2];
/* 
Declare cArray to be a variable
  of type char[]. 
Create a char array of length 
  two , with all of its elements 
  initialized to their default
  values . 
Assign a reference of the newly 
  created array to the
  variable cArray .*/
cArray ==> [ '\000', '\000' ]
 
 
> Arrays.toString(new int[5])
/*
Create a new array of type int ,
  which has a length of 5 . 
Pass a reference to it , 
  to Arrays toString method . 
Arrays.toString method will print 
  the elements contained in this 
  array .*/
[0, 0, 0, 0, 0]

When using the notation new Type[]{expression , expression ...} , an array of the given type and of the length of the {expression , expression ...} is created .

The expressions are evaluated. If the array type is primitive , the value of the expression is stored inside the array . If the array type is of the reference type , a reference to the evaluated value is stored .

jshell> 
 
> import java.util.Arrays;
/* 
import the Arrays utility 
  class .*/
 
 
> Arrays.toString(new int[]{ 1, 2, 3 })
/*
Create an anonymous array , 
  of type int .
Its elements are initialized to 
  the three elements 1 , 2 and 3 .
Use the Arrays.toString method 
  to print the value of each
  element in the newly created 
  array .*/
[ 1, 2, 3 ]
 
 
> int[] iArrayOne = new int[]{}
/*
Declare iArrayOne to be a variable 
  of type int [] . 
Create an new array of type
  int , containing no elements .
Assign a reference to the
  newly created array to 
  iArrayOne .*/
iArrayOne ==> []

Variable of type multidimensional arrays can be created by adding brackets to the variable declaration , each additional brackets corresponds to an additional dimension .

jshell>
 
> int[][] iArrayOne , iArratTwo;
/*
Create two variables of the type :
  int [][] . 
int[][] is an an array , which 
  elements references arrays 
  of the type int [] .*/
iArrayOne ==> null
iArratTwo ==> null
 
 
> int iArrayOne[][] , iArratTwo;
/*
Declare a variable of the type :
  int [][] , and a variable of 
  the type int .*/
iArrayOne ==> null
iArratTwo ==> 0

To create a multidimensional array , we can also use the methods describe earlier on .

jshell>
 
/* 
Creating arrays using the notation
  {expression , expression ...} */
 
> int[][] iArray = { { 1, 2 } , { 1, 2, 3, 4 } };
iArray ==> [ [ 1, 2 ] , [ 1, 2, 3, 4 ] ] 
/*
Create a multi dimensional array of length
  2 and of type int [][]. 
Each element of this multidimensional array 
  references an array of type int []. 
The first element reference an array of 
  type int [] which has a length of 2 , 
  and which contains the elements 1 
  and 2 . 
The second element also reference an array 
  of type int[] which has a length of 
  4 ,  and contains the elements 1 2 3 
  and 4 .
Store a reference of the array of 
  type int [][] into the variable 
  iArray .*/
 
 
/*
Creating arrays using the notation 
  new Type[length] .*/
  
> String sArray[][];
/*
Declare a variable of type String[][] .*/
 
> sArray = new String[2][2]
/*
Create an array of type String[][]
  and of length two .
It contain references to arrays of 
  type String[] .
The first element reference an array
  of type String[] , of length two , 
  which elements contains references to
  null . 
The second element reference an array 
  of type String[] , of length two , 
  which elements contains references to 
  null . 
Assign a reference to the array of type 
  String[][] to the variable sArray .*/
sArray ==> [ [ null, null ],[ null, null ] ]
 
 
> sArray = new String[3][]
/*
Create an array of length 3 , 
  which elements hold references
  to arrays of type String[] .*/
sArray ==> [ null , null , null ]
 
> sArray[0] = new String[]{ "hello", "arrays" };
/*
Each element of sArray , can be assigned
  an array of type String[]
Create a new array of type String[] , 
  which elements reference the two
  String "hello" and "arrays".
Store a reference to this array in
  sArray[0] .*/
 
> sArray
sArray ==> [ [ "hello", "arrays" ], null, null ]
 
 
/*
Creating arrays using the notation 
  new Type[]{expression , expression ...} .*/
 
> sArray = new String[][]{ { "hey", "java" }, { "chrome", "help" , "space" } }
sArray ==> [ [ "hey", "java" ], [ "chrome", "help", "space" ] ]

2- Array length

An array length can be gotten using the .length property .

Example of accessing the array length of arrays having a single dimension.

jshell>
 
> int []iArrayOne = {} , iArrayTwo = { 1, 2 } , iArrayThree;
/*
Declare three variables of type int[].
iArrayOne contains a reference 
  to an array which contains 
  no elements. 
iArrayTwo contains a reference 
  to an array which contains 
  2 elements. 
iArrayThree contains a reference 
  to null .*/
iArrayOne ==> []
iArrayTwo ==> [ 1, 2 ]
iArrayThree ==> null
 
> iArrayOne.length
/*
iArrayOne reference an array 
  which contains no elements
  , the length of the array 
  is 0 .*/
0
 
> iArrayTwo.length
/*
iArrayTwo reference an array
  which contains two elements , 
  as such its length is 2 .*/
2
 
> iArrathree.length
/*
iArrayThree does not reference
  any array . It contains a
  reference to a null value , as 
  such it cannot access the 
  length property .*/
|  Exception java.lang.NullPointerException
|        at (#26:1)

Example of accessing the array length of arrays having multiple dimensions .

jshell>
 
> int[][] iArrayOne = new int[2][] , iArrayTwo  , iArrayThree = { { 1, 2, 3 }, { } } ;
/*
Create three variables of type 
  int [][] .
The first variable references an 
  array of length 2 , which elements 
  references array of type int [] .
The second variable is of type int[][] ,
  but does not reference any array of 
  type int [][] , as such it 
  references a null value.
The third variable references an 
  array of length 2 , which elements
  references an array of type 
  int [] .*/
iArrayOne ==> [ null, null ]
iArrayTwo ==> null
iArrayThree ==> [ [ 1, 2, 3 ], [ ] ]
 
> iArrayOne.length;
/*
The length of the array which 
  elements contain references
  to arrays of type int[]
  is : */
2
 
> iArrayOne[0].length;
/* 
The first element of the array
  referenced by iArrayOne does 
  not reference any array
  of type int[] , as such it 
  references a null value . 
Trying to access the length property
  of null will result in 
  NullPointerException .*/
 Exception java.lang.NullPointerException
|        at (#5:1)
 
> iArrayTwo.length;
/*
iArrayTwo references a null value , 
  so trying to access the length 
  property of a null value results 
  in a null pointer exception. */
|  Exception java.lang.NullPointerException
|        at (#4:1)
 
> iArrayThree[1].length
/*
Access the first element of 
  int[][] , which is {} an array
  of type int [] .
Access its length property .*/
0

3- Assigning values to elements of an array

An array is formed of zero or more elements . Elements of an array can be assigned a value using the square notation , which takes an expression which is evaluated .

When an element of an array is assigned a value , the value is assigned based on the rules of assigning a primitive or a reference type .

If the value to be assigned is of the primitive type , then the primitive type value is copied and stored in the array .

jshell>
 
> int []iArrayOne = new int[1];
/*
iArrayOne is a variable of type int[] .
new int[1] , creates an array 
  of the primitive type int , 
  of length 1 . 
The elements of the newly created 
  array are initialized to the 
  default value 0 . 
A reference to the newly created 
  array is stored inside iArrayOne .*/
iArrayOne ==> [ 0 ]
 
 
> iArrayOne[1-1]  = 10 ;
/*
1 - 1 is evaluated to 0 . 
The first element of the 
  array reference by iArrayOne 
  is assigned the value 10 . 
10 is a primitive value , 
  as such it is copied and 
  stored inside the array .*/
 
 
> int anInt = 1 ; 
/*
anInt contains the value
  1 .*/
 
 
> iArrayOne[0]  = anInt ; 
/*
The value contained in anInt
  is copied to iArrayOne[0] .
anInt contains 1 , as such 
  iArrayOne[0] contains 1 .*/
 
 
> iArrayOne
/*
iArrayOne is a variable which
  references an array of type
  int[] , and which contains
  the element 1 .*/
iArrayOne ==> [1]

If the value to be assigned is a reference type , then the reference is copied and stored inside the array .

jshell>
 
> String aString = "hello";
/*
Create a variable of type
  String . 
Assign a reference of 
  the String "hello" to
  aString .*/
 
> String[] sArray = {aString};
/*
sArray is a variable of type
  String [] . 
it is initialized using 
  {aString} .
A new array of type String[]
  and of length 1 is created . 
  aString is a reference type , 
  as such the value  of aString ,
  which is a reference , is stored 
  inside the first element of 
  sArray . 
A reference of the newly created 
  array is stored inside the 
  variable sArray .
sArray[0] and aString contain the  
  same reference .*/
 
> sArray[0] = "hey"
/*
"hey" is a string literal , 
  a reference for the String
  "hey" is stored inside 
  sArray[0] . 
sArray[0] and aString do not
  contain the same reference 
  anymore .*/
sArray[0] ==> "hey"
 
> aString
/*
aString is still referencing the
  String literal "hello"*/
aString ==> "hello"
 
/*
String are immutable , so their 
  values cannot change .*/
 
 
> class WWW{
	String address; 
}
/*
Create the WWW class , with one
  field of type String . */
 
> WWW aWWW = new WWW();
/*
Create a new instance of WWW , 
  and store a reference to
  it in the variable aWWW . 
aWWW address attribute is initialized , 
  to null. */
aWWW ==> WWW@6ddf90b0
 
> aWWW.address
aWWW.address ==> null
 
> WWW wwwArray[] = {aWWW};
/*
wwwArray is a variable of 
  type WWW[] .
A new array is created , 
  of type WWW and of length 
  1 . 
The reference contained in
  the variable aWWW , is copied
  and stored inside aWWW[0].
aWWW[0] and the variable 
  aWWW contain the same reference . 
A reference of the newly created
  array is stored in the 
  wwwArray variable .*/
wwwArray ==> [ WWW@6ddf90b0 ]
 
> wwwArray[0].address = "http://difyel.com";
/*
wwwArray[0] address field is 
  assigned the value of 
  "http://difyel.com" .*/
wwwArray[0].address ==> "http://difyel.com"
 
> aWWW.address
/*
aWWW refers to the same object , 
  referenced by wwwArray[0] . As 
  such aWWW.address field has a 
  value of http://difyel.com .*/
aWWW.address ==> "http://difyel.com"
 
> aWWW = new WWW();
/*
A new instance of WWW is 
  created . Its reference is 
  assigned to the variable 
  aWWW .*/
aWWW ==> WWW@369f73a2
/*
aWWW and wwwArray[0] do not refer to 
  the same object . So changing 
  the field value of aWWW , will 
  not affect the field value 
  of wwwArray[0] and the inverse
  is also true .*/
 
 
> int[][] iArrayOne = new int[2][];
/*
Declare a variable iArrayOne 
  of the type int[][] . 
Create an array of length 2 , 
  which elements reference an array
  of type int [] .
Assign a reference to the newly created
  array inside the variable 
  iArrayOne .*/
iArrayOne ==> [ null, null ]
 
> iArrayOne[0] = new int[1] ;
/*
Create an array of type int[]
  of length 1 . 
Store a reference to the newly
  created array to iArrayOne[0] .*/
 
> iArrayOne[0][0] = 1 
/*
Access the first array of type 
  int[] .
Store inside the first element
  of the array of type int[] ,
  the value 1 .*/

4- Accessing the elements of an array

Elements of an array can be accessed using the square brackets notation , which takes an int value >=0 and less than the length of the array .

jshell>
 
> int[] iArray = new int[]{ 0, 1, 2 }
/*
iArray is a variable of type int[].
It is assigned a reference to an
  array of length 3 and of type 
  int[] .*/
iArray ==> [ 0, 1, 2 ]
 
> iArray[0]
/*
Access the first element 
  of the array referenced by 
  iArray[0] .*/
iArray[0] ==> 0
 
> iArray[0+2]
/*
0+2 is evaluated to 2 .
Access the third element 
  of the array referenced by 
  iArray[2] .*/
iArray[2] ==> 2
 
> iArray[3]
/*
An ArrayIndexOutOfBoundsException is 
  thrown , when trying to access an element
  with index <0 or >= length of the array .*/
|  Exception java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
|        at (#3:1)
 
> iArray[-1]
|  Exception java.lang.ArrayIndexOutOfBoundsException: Index -1 out of bounds for length 3
|        at (#4:1)
 
 
> int iArrayTwo[][] = {{}} 
/*
Create an array which references
  an array of type int [] . 
The array of type int[] does not
  contain any elements .
Store a reference of the newly
  created array inside the 
  variable iArrayTwo .*/
iArrayTwo ==> [ [ ] ]
 
> iArrayTwo[0][0]
/*
Access the first element of
  the array referenced by the
  variable iArrayTwo . 
Access the first element 
  referenced by the array of type
  int [] .
There is no elements found in 
  the array of type int[] , 
  as such an index out of 
  bound exception is thrown .*/
|  Exception java.lang.ArrayIndexOutOfBoundsException: Index 0 out of bounds for length 0
|        at (#5:1)

5- Looping through arrays

To loop through an array , a for loop can be used as follows .

jshell>
 
> int iArray[] = {1, 2, 3 }
/*
iArray is a variable of type int[] .
  It holds a reference to an array
  of three elements 1 , 2 and 3 .*/
iArray ==> [ 1, 2, 3 ]
 
> /* Loop through the array using a for loop */
for( int i = 0 ; i < iArray.length ; i++ )
{
    int elementAtIndexI = iArray[i];
    /*
      do something , for example 
      print the array elements .*/
    System.out.println(elementAtIndexI);
}
1
2
3
 
 
> int iArrayTwo[][] = { { 1, 2 }, { 3, 4 } }
/*
iArrayTwo is a variable of type 
  int[][] . It hold a reference to 
  an array of type int[][]. 
The array of type int[][] has a 
  length of two , and contains 
  references to two arrays of 
  type int[] .
The arrays of type int[] , each 
  contain two int elements .*/
iArrayTwo ==> [ [ 1, 2 ], [ 3, 4 ] ]
 
> /* For each additional dimension , 
  an additional for loop must 
  be added .*/
for( int i = 0 ; i < iArrayTwo.length ; i++ )
{
    for( int j = 0 ; j < iArrayTwo[i].length ; j++ )
    {
        int elementAtIndexIJ = iArrayTwo[i][j];
        /*
            Do something , for example 
            print the array elements .*/
        System.out.println(elementAtIndexIJ);  
    }
}
1
2
3
4

A for each loop can also be used to loop through an array . The difference between a for and a for each loop , is that in a for each loop it is not necessary to declare the index used to loop through the array , but at the same time this means no access to the index .

A for and a for each loop can be mixed .

jshell>
 
> String sArray[] = { "Hello", "Search" }
/*
sArray is a variable of type
  String [] .
It holds a reference to an array 
  of type String [] .
The array of type String []
  holds two references for 
  Strings .*/
sArray ==> [ "Hello", "Search" ]
 
> /* Loop through an array using a for each loop */
for( String element : sArray )
{
    /*
      do something , with the
      element .*/
    System.out.println(element);
}
Hello
Search
 
 
> String sArrayOne[][] =  { {"java"} , {"red" , "green"} }
/*
sArrayOne is a variable of type String [][] .
It hold a reference to an array which
  contains two references to arrays of 
  type String[] .*/
sArrayOne ==> [ [ "java" ] , [ "red", "green" ] ]
 
> for( String[] stArray : sArrayOne )
{
    for(String sElem : stArray)
    {
        /*
          Do something with the element .*/
          System.out.println(sElem);
    }
}
java
red
green

A Spliterator can also be used to loop through an array . As its name convey , a Spliterator is an iterator which can be split . It allows to perform looping one element at a time using its tryAdvance method , or for all the remaining elements using its forEachRemaining method , or to obtain another Spliterator from this Spliterator using the trySplit method , which ideally may try to split the Spliterator in half , but might split it at other points , or might fail .

A Spliterator source must not be modified , if it does not have the immutable or concurrent characteristics .

A Spliterator can be iterated over only once .

jshell>
 
> import java.util.Arrays;
> import java.util.Spliterator;
 
 
> int iArray[] = { 1, 2, 3, 4 } ;
/*
iArray is a variable which contains
  a reference to an array of
  type int [] .*/
iArray ==> [ 1, 2, 3, 4 ]
 
> Spliterator<Integer> iSpliterator = Arrays.spliterator(iArray);
/*
Use Arrays.spliterator to create a 
  Spliterator which has a source , 
  the array referenced by 
  iArray .*/
iSpliterator ==> java.util.Spliterators$IntArraySpliterator@68be2bc2
 
> iSpliterator.hasCharacteristics(Spliterator.IMMUTABLE)
/*
Using hasCharacteristics , check 
  if the created Spliterator 
  has the characteristic of being 
  Immutable .*/
$ ==> true
 
> iSpliterator.hasCharacteristics(Spliterator.CONCURRENT)
/*
Using hasCharacteristics , check 
  if the created Spliterator
  has the characteristic of being
  Concurrent .*/
$ ==> false
 
> iSpliterator.hasCharacteristics(Spliterator.NONNULL)
/*
Using hasCharacteristics , check 
  if the Source guarantees 
  that encountered elements
  will not be null .*/
$ ==> false
 
> iSpliterator.hasCharacteristics(Spliterator.ORDERED)
/*
Using hasCharacteristics , check 
  if an encounter order
  is defined for the
  elements .*/
$ ==> true
 
> iSpliterator.tryAdvance(System.out::println)
/*
Using the tryAdvance method , try 
  to advance one element in the 
  Spliterator .
Returns true on success , false 
  on failure.
Pass the println function as argument 
  to tryAdvance , to print the 
  element .*/
1
$ ==> true
 
> int index = 1 ; 
/*
Declare a variable containing the 
  current index of the 
  Spliterator .*/
 
> iSpliterator.forEachRemaining( iElement -> {
    System.out.println(iElement);
    if(index < iArray.length - 1)
        iArray[++index] *= 2;
    } )
/*
Use forEachRemaining , to loop 
  through the remaining elements 
  of the Spliterator . 
Pass a lambda function to 
  forEachRemaining, which takes 
  as argument : iElement , the 
  current iterating element , print 
  it , and modify the next element 
  by doubling it .*/
2
6
8
 
 
> String [][]sArray = { { "ae", "ar" }, { "be", "br" }, { "ce", "ck" } }
/*
Create an array of type 
  String [][] . It contains 
  three references to arrays
  of types String [] . Each
  contains two references to
  Strings .*/
sArray ==> [ [ "ae", "ar" ] , ["be" , "br"]  , [ "ce", "ck" ] ]
 
> Spliterator<String []> saSpliterator = Arrays.spliterator(sArray , 1 , 3 ) ;
/*
Use Arrays.spliterator , to create 
  a Spliterator which has a 
  source the array referenced by 
  the  variable sArray , starting 
  from index 1 inclusive , till
  index 3 non inclusive .*/
 
> Spliterator<String []> splitSaSplitIerator = saSpliterator.trySplit();
/*
Use trySplit to split the 
  Spliterator which has a source 
  the array referenced by sArray .
Store a reference to the created 
  Spliterator in the variable 
  splitSaSplitIerator .*/
 
> saSpliterator.forEachRemaining(
    aElement -> {
        for(String sElement : aElement)
            System.out.println(sElement);
    })
/*
Use forEachRemaining , to loop 
  through the elements of the
  Spliterator referenced by
  the variable saSpliterator .
Pass in a lambda function , 
  which takes one argument ,
  of type String [] : aElement .
Loop through aElement , which 
  is an array of type String [] , 
  using a for each loop . 
Print the values referenced 
  by the elements of the
  array of type String[] .*/
ce
ck 
 
> splitSaSplitIerator.forEachRemaining(
    aElement -> {
        for(String sElement : aElement)
            System.out.println(sElement);
    })
/*
Use forEachRemaining to loop 
  through the elements of the 
  Spliterator referenced by 
  splitSaSplitIerator . They 
  are of type String [] .
Pass in a lambda function , 
  which takes one argument 
  of type String[] : aElement . 
Loop through the elements
  of the array referenced by 
  the variable aElement . 
Each element contains a 
  reference to a String .
Print the String . */
be
br

Also a Stream can be obtained from an array , and it can be used to loop over the element of the array . A Stream can only be iterated over once .

jshell>
 
> import java.util.Arrays ;
> import java.util.stream.IntStream ;
> import java.util.stream.Stream ;
 
> int iArray[] = { 0, 3, 1, 2 };
/*
Create an array of type int[]
  , which has 4 elements .
Store a reference to it in
  the variable iArray .*/
iArray ==> [ 0, 3, 1, 2 ]
 
> IntStream iStream = Arrays.stream(iArray);
/*
Use Arrays.stream , to create 
  a sequential Stream .
It has a source the array 
  referenced by the variable 
  iArray .*/
iStream ==> java.util.stream.IntPipeline$Head@29ee9faa
 
> iStream.forEach(System.out::println);
/*
Iterate over the stream using 
  the forEach method.
The forEach method takes as 
  argument the function println , 
  and use it to print the 
  stream .*/
0
3
1
2
 
> iStream = Arrays.stream(iArray);
/*
Using Arrays.stream , create 
  a sequential stream , which 
  source is the array referenced 
  by iArray .*/
 
> iStream.parallel().forEach(System.out::println);
/*
Create a parallel Stream from the 
  sequential stream referenced by 
  the variable iStream.
The forEach method does not guarantee 
  the order of encounter as defined
  in the Stream source for parallel 
  streams .*/
1
2
3
0
 
> iStream = Arrays.stream(iArray);
/*
Use Arrays.stream to create 
  a sequential stream , which 
  source is the array referenced 
  by iArray .*/
 
> iStream.parallel().forEachOrdered(System.out::println);
/*
Create a parallel Stream from the
  sequential stream referenced
  by the variable iStream .
Iterate over the parallel Stream using 
  forEachOrdered .
The forEachOrdered guarantees the order
  of encounter as defined in the Stream
  source for parallel Streams. */
0
3
1
2
 
 
> String[][] sArray = { { "aa", "ab" }, { "cd", "c" } }
/*
Create an array of type String[][]
  and assign a reference to it 
  to the variable sArray .*/
sArray ==> [ [ "aa", "ab" ], [ "cd", "c" ] ]
 
> Stream<String[]> saStream = Arrays.stream(sArray , 1 , 2);
/* 
Use Arrays.stream to create a 
  sequential Stream which has a 
  source the array  referenced by 
  sArray , starting at index 1 
  inclusive , ending index 2 
  exclusive .*/
saStream ==> java.util.stream.ReferencePipeline$Head@6f7fd0e6
 
> saStream.forEach( aString -> Arrays.stream(aString).forEach(System.out::println));
/*
Iterate over the Stream using
  forEach Method.
Pass in a lambda function , which
  takes as argument an element of
  type String[] . 
Create a Stream from this element ,
  and use the forEach method , to
  iterate over its elements .
  Pass to the forEach method , 
    the println function to print
    the elements .*/
cd
c

6- Printing arrays

The Arrays.toString , and Arrays.deepToString , can be used to get a String representation of an array . The Arrays.deepToString will get the String representation of arrays containing other arrays .

jshell> 
 
> int iArray[][] = { { 1, 2 }, { 3, 4 } }
/*
Create an array of type int [][] ,
  and store a reference to it 
  in the variable iArray .*/
iArray ==> [ [ 1, 2 ], [ 3, 4 ] ]
 
> Arrays.toString(iArray)
/*
Use Arrays.toString to get a 
  toString representation of 
  the array referenced by the 
  variable iArray .*/
$ ==> "[[I@58651fd0, [I@4520ebad]"
 
> Arrays.deepToString(iArray)
/*
Use Arrays.deepToString to 
  get a deep toString 
  representation of the array , 
  referenced by the variable
  iArray .*/
$ ==> "[[1, 2], [3, 4]]"

7- Copying and cloning arrays

The clone method can be used to clone an array . This will return a shallow copy of the elements of the array .

If the array is an array of primitive types , this works well . If the array is of reference type , this means the elements of the array and its clone contains the same references , as such they share the same objects .

jshell>
 
> int iArray[] = { 1, 2, 4 };
/*
Create an array of type 
  int[] which contains 
  three integers .
Store a reference to it 
  in the variable 
  iArray .*/
iArray ==> [ 1, 2, 4 ]
 
> int iArrayClone[] = iArray.clone() 
/*
Create a new array , and 
  shallow copy the elements 
  1 , 2 and 4 , of the array 
  referenced by the iArray 
  variable .
Store a reference of the 
  newly created array in 
  iArrayClone .*/
iArrayClone ==> [ 1, 2, 4 ]
 
 
> Object oArray[] = { new Object(), new Object() }
/*
Create an array of type 
  Object[] , and which contains 
  two elements . 
Store the reference of 
  this array in the variable 
  oArray .*/
oArray ==> [ java.lang.Object@4520ebad, java.lang.Object@5419f379 ]
 
> Object oArrayClone[] = oArray.clone();
/*
Shallow copy the elements of 
  the array referenced by 
  oArray , into a new array of 
  type Object[] .
They are of reference type , as 
  such shallow copy the 
  references .
Store the reference of the newly 
  created array inside 
  oArrayClone .
The elements of the arrays 
  referenced by the oArray ,
   and oArrayClone variable 
   refer to the same Objects .*/
oArrayClone ==> [ java.lang.Object@4520ebad, java.lang.Object@5419f379 ]
 
 
> int iArrayTwo [][] = { {1, 2, 3 }, { 0 } }
/*
Create an array of length 2 , 
  which elements refers to 
  arrays of type int [] .
Store a reference to this 
  array , in the variable 
  iArrayTwo .*/
iArrayTwo ==> [ [ 1, 2, 3 ], [ 0 ] ]
 
> int[][] iArrayTwoClone = iArrayTwo.clone();
/*
Create a shallow copy of the array
  referenced by the variable
  iArrayTwo .
A new array which elements can
  hold a reference to arrays of 
  type int [] is created . 
The elements of the array referenced
  by the iArrayTwo variable are 
  copied .
They contain references to arrays of 
  type int []. 
Store a reference of the newly 
  created array in the variable
  iArrayTwoClone .
The elements of the arrays referenced
  by iArrayTwo and iArrayTwoClone ,
  reference the same arrays of type 
  int [] .*/
iArrayTwoClone ==> [ [ 1, 2, 3 ], [ 0 ] ]
 
> iArrayTwo[1][0] = 3
/* 
Access the second element of the
  array referenced by the variable
  iArrayTwo.
Assign to this array first 
  element the value of 3 .*/
 
> iArrayTwoClone 
/*
Print the array referenced by 
  the variable iArrayTwoClone .
The arrays referenced by the 
  variables iArrayTwoClone
  and iArrayTwo , contain 
  the same references . 
iArrayTwoClone[1][0] is equal 
  also to 3 .*/
iArrayTwoClone ==> [ [ 1, 2, 3 ] ,[ 3  ] ]

Another method to create a shallow copy of an array , is by using the System.arraycopy method .

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

Its first argument is the source array to copy from . Its second argument is the index from which to start copying from the source array . Its third argument is the array to copy to . Its fourth argument is the index from which to start copying at the destination array . Its fifth argument is the number of elements to copy .

The difference between this method and the clone method , is that this method can be used to copy just a portion of an array , or the whole array , and that both arrays must exists or be created before performing the copying .

jshell>
 
> int [] iArray = { 10, 1, 2, 34, 12 }
/*
Create an array of type int[]
  and store a reference to it
  in the variable iArray .*/
iArray ==> [ 10, 1, 2, 34, 12 ]
 
int [] iArrayCopy = new int[2]
/*
Create an aray of length 2 , 
  of type int[].
Store a reference to it inside 
  iArrayCopy .*/
iArrayCopy ==> [ 0, 0 ]
 
 
> System.arraycopy(iArray , 2 , iArrayCopy , 0 , 2 )
/*
Using System.arraycopy , copy 
  from the array referenced 
  by iArray , starting at index 
  2 , to the array referenced by 
  iArrayCopy , starting at index 
  0 , two elements .*/
 
> iArrayCopy
iArrayCopy ==> [ 2, 34 ]
 
 
> int iArrayTwo[][] = { {}, {1 , 2} }
/*
Create an array of length 2 , 
  which elements contains 
  references to arrays of 
  type int [] .*/
iArrayTwo ==> [ [ ], [ 1, 2 ] ]
 
> int iArrayTwoCopy[][] = new int[4][]
/*
Create an array of length 4 , 
  which elements contain 
  references to arrays of 
  types int[] .*/
iArrayTwoCopy ==> [ null, null, null, null ]
 
> System.arraycopy(iArrayTwo , 0 , iArrayTwoCopy , 0 , 2 )
/*
Use System.arraycopy to copy
  from the array referenced by 
  iArrayTwo , starting at index 0 , 
  to the array referenced by 
  iArrayTwoCopy , starting at 
  position 0 , 2 elements . 
The elements which are copied are
  references to arrays of type 
  int [] .*/
 
> iArrayTwoCopy
iArrayTwoCopy ==> [  [ ], [ 1, 2 ], null, null ]

The source and destination array can be the same . System.araycopy proceeds as if there is a temporary array .

jshell>
 
> int [] iArray = { 10, 1, 2, 34, 12 }
iArray ==> [ 10, 1, 2, 34, 12 ]
 
> System.arraycopy(iArray , 2 , iArray , 0 , 3 )
/*
Use System.arraycopy , to copy from 
  the array referenced by iArray ,
  starting at index 2 , to itself , 
  starting at index 0 , 
  three elements .*/
 
> iArray
iArray ==> [ 2, 34, 12, 34, 12 ]

An IndexOutOfBoundsException is thrown , when any of the source or destination indexes are negative , or larger than the source or destination array length .

An IndexOutOfBoundsException is also thrown , when the srcPos + length is greater than the source array length , or when the destPost + length is greater than the destination array length .

An IndexOutOfBoundsException is also thrown when the length is negative .

If an IndexOutOfBoundsException is thrown the destination array is not modified .

jshell>
 
 
> int [] iArray = { 10, 1, 2, 34, 12 }
/*
Create an array of five elements
  of type int[] , and store
  a reference to it in the 
  variable iArray .*/
iArray ==> [ 10, 1, 2, 34, 12 ]
 
> System.arraycopy(iArray , 2 , iArray , 0 , 10 )
/*
Use System.arraycopy to copy from 
  the array reference by the 
  variable iArray starting at position
  2 , to itself starting position
  0 , 10 elements. 
IndexOutOfBoundsException is 
  thrown because 12 is larger 
  then the length of the source 
  array .*/
|  Exception java.lang.ArrayIndexOutOfBoundsException: arraycopy: last source index 12 out of bounds for int[5]
|        at System.arraycopy (Native Method)
|        at (#11:1)
 
> iArray
/*
The array referenced by 
  iArray is not 
  modified .*/
iArray ==> int[5] { 10, 1, 2, 34, 12 }

A NullPointerException is thrown if the variables pointing to the source or destination arrays are null .

jshell>
 
> int[] iArray = { 10, 1, 2, 34, 12 }
/*
Create an array of type int [] , 
  containing five elements . 
Store a reference to it inside
  the variable iArray .*/
iArray ==> [ 10, 1, 2, 34, 12 ]
 
> int[] iArrayCopy;
/*
Declare a variable iArrayCopy , 
  of type int [] .
It is assigned a null value .*/
iArrayCopy ==> null
 
> System.arraycopy(iArray , 0 , iArrayCopy , 0 , 5 )
/*
iArrayCopy is a variable which does 
  not refer to an array , it contains 
  a null reference , as such 
  System.arraycopy throws a null 
  exception .*/
|  Exception java.lang.NullPointerException
|        at System.arraycopy (Native Method)
|        at (#3:1)

An ArrayStoreException is thrown when the source or destination are not of type array , or when the source or destination are arrays of different primitive types , or when one is an array of primitive type and the other is an array of reference type . In these cases the destination array is not modified .

jshell>
 
> int iArray[] = { 10, 2, 33, 4, 1 }
/*
Create an array of type int[]
  formed of five elements. 
Store a reference to it inside
  the iArray variable .*/
iArray ==> [ 10, 2, 33, 4, 1 ]
 
> System.arraycopy(new Object(), 0 , iArray  , 2 , 3 )
/*
ArrayStoreException is thrown 
  because the source is not 
  of type array .*/
|  Exception java.lang.ArrayStoreException: arraycopy: source type java.lang.Object is not an array
|        at System.arraycopy (Native Method)
|        at (#2:1)
  
> iArray
/*
The array reference by iArray 
  was not modified .*/
iArray ==> [ 10, 2, 33, 4, 1 ]

An ArrayStoreException is is also thrown when both the source and the destination are arrays of the reference type , and an element referenced by the source array cannot be converted to the destination array , elements type . In this case the destination array is modified till when the exception occurs .

jshell>
 
> Object oArray[] = {new Integer(1), new Object() }
/*
Create an array of type Object[] ,
  formed of two elements .
Store a reference to this array 
  inside the variable oArray .*/
oArray ==> [ 1 , java.lang.Object@64bfbc86 ]
 
> Integer iArray[] = new Integer[2] 
/*
Create an array of type Integer[]
  of length 2 .
Store a reference to it inside the 
  variable iArray .*/
iArray ==> [ null, null ]
 
> System.arraycopy(oArray , 0 , iArray , 0 , 2 )
/*
Use System.arraycopy to copy from 
  the array referenced by oArray 
  starting index 0 , to the array
  referenced by iArray starting index 
  0 , 2 elements .
ArrayStoreException is thrown because
  an Object cannot be stored inside
  an Integer array .*/
|  Exception java.lang.ArrayStoreException: arraycopy: element type mismatch: can not cast one of the elements of java.lang.Object[] to the type of the destination array, java.lang.Integer
|        at System.arraycopy (Native Method)
|        at (#5:1)
 
> iArray
/*
Only one element is copied from 
  the array referenced by oArray 
  to iArray .*/
iArray ==> [ 1, null ]

A shallow copy of an array , can also be created using the Stream toArray method .

jshell>
> import java.util.Arrays;
 
> int iArray[] = { 1, 2, 34 };
/*
Create an array of type int[] , 
  and store a reference to it
  inside the variable iArray .*/
iArray ==> [ 1 , 2 , 34 ]
 
> int iArrayClone[] = Arrays.stream(iArray).toArray();
/*
For primitive types : double , int , long ,
  Arrays.stream create a stream of type 
  DoubleStream IntStream and LongStream . 
Use the toArray method to collect 
  the elements of the Stream into
  an array .*/
iArrayClone ==> [ 1, 2, 34 ]
 
 
> String sArray[][] = { {"ae" , "df"}, {"oo", "on"} }
/*
Create an array of type String [][] , and 
  store a reference to it in the variable
  sArray .*/
sArray ==> [ [ "ae", "df" ] , [ "oo", "on" ] ]
 
> String sArrayClone[][] = Arrays.stream(sArray).toArray(String[][]::new);
/* 
Use Arrays.stream method , to
  create a sequential stream 
  backed by  the array 
  referenced by sArray . 
Use the toArray method , to return
  an array containing the elements
  of the Stream .
Pass in the function which will be used
  to create the array , of the specified
  type. 
The function receive as a 
  parameter the length of the 
  to be created array .*/
sArrayClone ==> [ [ "ae", "df" ], [ "oo", "on" ] ]

8- Merging arrays

There is no inbuilt java method to merge multiple arrays , a possible solution is as follows .

jshell>
> import java.lang.reflect.Array;
 
> /*Create a Class named MergeArrays*/
class MergeArrays
{
 
    public static Object mergeArrays(Object ... oElements)
    {
        if(oElements.length == 0)
            /* 
              If no arguments were provided , 
              return null .*/
            return null ;
        int length = 0 ; 
 
        for( int i = 0 ; i < oElements.length ; i++ )
        {
            /* 
            check that oElements types are arrays .
            Check that the arrays referred by 
              oElements , have the same Component
              types or that their component type
              is a subtype of the component type
              of oElements[0] .
            Get the length of the arrays referred 
              by oElements , and calculate 
              the total length of the to be newly 
              created array .*/
            if(! oElements[i].getClass().isArray())
                throw new IllegalArgumentException("All elements must be arrays");
            if(! oElements[0].getClass().getComponentType().isAssignableFrom(oElements[i].getClass().getComponentType()))
                throw new IllegalArgumentException("oElements[" + i + "] component type is not a subclass or class of oElements[0] component type");
            length += Array.getLength(oElements[i]);
        }
 
        Object rASrray = Array.newInstance(oElements[0].getClass().getComponentType(), length);
        System.arraycopy(oElements[0] , 0 , rASrray , 0 , Array.getLength(oElements[0]));
        for(int i = 1 ; i < oElements.length ; i++)
        {
            System.arraycopy(oElements[i] , 0 , rASrray , Array.getLength(oElements[i-1]) , Array.getLength(oElements[i]));
        }
        return rASrray;
    }
}
 
> int iArray[] = (int []) MergeArrays.mergeArrays( new int[]{ 0, 1 }, new int[]{ 2, 3 } )
iArray ==> [ 0, 1, 2, 3 ]
 
> String sArray[][] = (String [][] )MergeArrays.mergeArrays( new String[][]{ {"hello"}, {"world"} } , new String[][]{ { "df", "8" } } )
sArray ==> [ [ "hello" ], [ "world" ], [ "df", "8" ] ]

arrays can also be merged by using the Stream API .

jshell>
 
> import java.util.stream.Stream;
 
> Stream<int []> iaStream = Stream.of(new int[]{ 1, 2, 3 }, new int[]{ 5, 9, 12 })
/*
Create using the Stream.of 
  method a sequential  
  stream whose elements are 
  of type int [] .*/
iaStream ==> java.util.stream.ReferencePipeline$Head@4678c730
 
> int iaMerged[] = iaStream.flatMapToInt(iArray -> Arrays.stream(iArray)).toArray()
/*
The elements of the stream are
  of type int[] .
For each element of the stream , 
  create a stream backed by
  this element using the 
  Arrays.stream method. 
The created stream will be of 
  type int . 
This is why the flatMapToInt 
  method was used . 
This will flat and map each 
  element of the type int[]
  of the Stream referenced by
  iaStream into elements of 
  the type int , creating
  an IntStream . 
Collect the elements of the 
  IntStream into an array .
  array . */
iaMerged ==> [ 1, 2, 3, 1, 5, 9 ]
 
 
> Stream <int [][]> iaaStream = Stream.of(new int[][] { { 1, 2, 3 } , { 4, 5, 6 } }, new int[][]{ {5, 9 , 12 } })
/*
Using the Stream.of method create
  a sequential order Stream 
  whose elements are of type 
  int[][] .*/
iaaStream ==> java.util.stream.ReferencePipeline$Head@6767c1fc
 
> int iaaMerged[][] = iaaStream.flatMap(iaaElement -> Arrays.stream(iaaElement)).toArray(int[][]::new)
/*
For each element of the stream ,
  apply the method Arrays.stream .
This methods will return a stream
  which elements are of type 
  int [] . 
The result of the flatMap function
  is a Stream of objects .
Using the toArray method , collect
  the elements of the flat mapped
  stream of objects , into an array
  of type int[][] .*/
iaaMerged ==>  [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 5, 9, 12 ] ]

9- Sorting arrays

The java.util.Arrays class provides some utility methods to manipulate arrays .

The Arrays.parallelSort method can be used to sort arrays in parallel . If the number of elements of the array to be sorted is less then a specified threshold the Arrays.parallelSort will sort the arrays elements using the Arrays.sort method .

For arrays of primitive types , Arrays.parallelSort and Arrays.sort will sort the element in ascending order.

jshell> 
 
> import java.util.Arrays;
 
 
> int[] iArray = { 4, 1, 7, 8, 3 };
iArray ==> [ 4, 1, 7, 8, 3 ]
 
> Arrays.sort(iArray)
 
> iArray
iArray ==> [ 1, 3, 4, 7, 8 ]
 
 
> double[] dArray = {10 , 12 , 14 , 5.0  , 1/3.0}
 
> Arrays.parallelSort(dArray)
 
> dArray
dArray ==> [ 0.3333333333333333, 5.0, 10.0, 12.0, 14.0 ]
 
 
> char cArray[] = { 'a' , 'e' , 'i' , 'o' , 'u' , 'z' , 'h' , 'r' , 'v' }
 
> Arrays.sort(cArray , 5 , 9)
/*
Sort cArray only from index 5 
    inclusive , till index 9 not
    inclusive .*/
 
> cArray
cArray ==> [ 'a', 'e', 'i', 'o', 'u', 'h', 'r', 'v', 'z' ]
 
> Arrays.parallelSort(cArray , 1 , 9)
/*
Parallel sort cArray from
    index 1 inclusive , till
    index 9 not inclusive .*/
 
> cArray
cArray ==> [ 'a', 'e', 'h', 'i', 'o', 'r', 'u', 'v', 'z' ]
 
 
> int iArrayOne [][] = { { 4, 2 }, { 1, 0 } }
iArrayOne ==> [ [4, 2 ], [ 1, 0 ] ]
 
> for ( int i = 0 ; i < iArrayOne.length ; i++ )
    Arrays.parallelSort(iArrayOne[i]);
 
> iArrayOne
iArrayOne ==> [ [ 2, 4 ], [ 0, 1 ] ]
 
 
> int iArrayTwo [][][] = { { { 4, 2 }, { 1, 0 } } };
iArrayTwo ==> [ [ [ 4, 2 ], [ 1, 0 ] ] ]
 
> for (int i = 0 ; i < iArrayTwo.length ; i++ )
    for(int j = 0 ; j < iArrayTwo[i].length ; j++ )
            Arrays.parallelSort(iArrayTwo[i][j]);
 
> iArrayTwo
iArrayTwo ==> [ [ [ 2, 4 ], [ 0, 1 ] ] ]

For arrays of reference type , if the type implements the Comparable interface , then these methods will use the compareTo method of the Comparable interface to sort the array . This is called the natural ordering , and the compareTo method is called the natural comparison method .

jshell> 
 
> import java.util.Arrays; 
 
> String sArray[] = { "ab", "aa", "ae" }
sArray ==> [ "ab", "aa", "ae" ]
 
> Arrays.parallelSort(sArray)
/*
The String class implements the comparable
  interface as such it is possible 
  to use either of Arrays.parallelSort
  or Arrays.sort to sort an array of 
  Strings .*/
 
> sArray
sArray ==> String[3] { "aa", "ab", "ae" }
 
 
> Object oArray[] = { new Object(), new Object() }
oArray ==> [ java.lang.Object@5e5792a0, java.lang.Object@26653222 ]
 
> Arrays.sort(oArray)
/*
The Object class does not implement 
  the Comparable interface , as such , 
  an array of Objects cannot be sorted
  using Arrays.sort or Arrays.parallelSort .*/
|  Exception java.lang.ClassCastException: class java.lang.Object cannot be cast to class java.lang.Comparable (java.lang.Object and java.lang.Comparable are in module java.base of loader 'bootstrap')
|        at ComparableTimSort.countRunAndMakeAscending (ComparableTimSort.java:320)
|        at ComparableTimSort.sort (ComparableTimSort.java:188)
|        at Arrays.sort (Arrays.java:1249)
|        at (#6:1)
 
 
> /*
Create a class File
  which implements the Comparable 
  interface .*/
class File implements Comparable<File>
{
    String fileName;
    public File(String fileName)
    {
        this.fileName = fileName ;
    }
    @Override
    public int compareTo(File file)
    {
        return this.fileName.compareTo(file.fileName);
    }
}
 
> File files[] = { new File("Manager.java"), new File("File.java") }
files ==> [ File@4b9e13df, File@2b98378d ]
 
> System.out.println( "[ " + files[0].fileName + " , " + files[1].fileName + " ]"); 
[ Manager.java , File.java ]
 
> Arrays.parallelSort(files , 0 , 2 )
 
> System.out.println( "[ " + files[0].fileName + " , " + files[1].fileName + " ]"); 
[ File.java , Manager.java ]

If a type does not implement the Comparable interface , then the Arrays.parallelSort and Arrays.sort , can be passed a Comparator to sort the arrays .

jshell> 
 
> import java.util.Arrays ; 
 
> Object oArray[] = { new Object(), new Object() }
oArray ==> [ java.lang.Object@735b5592, java.lang.Object@58651fd0 ]
 
> Arrays.parallelSort(oArray , 0 , 2 , new Comparator<Object>(){
    @Override 
    public int compare(Object objectOne , Object objectTwo)
    {
        return objectOne.toString().compareTo(objectTwo.toString());
    }
});
/*
Sort the array by passing a
  Comparator which sort by 
  the String value of Object .*/
 
> oArray
oArray ==> [ java.lang.Object@58651fd0, java.lang.Object@735b5592 ]
 
 
> /* 
Create a Class Point
which does not implement 
Comparable .*/
class Point
{
    String axis ; 
    int position ;
     
    public Point(String axis , int position)
    {
        this.axis = axis;
        this.position = position;
    }
 
    public String getAxis()
    {
        return this.axis;
    }
 
    public int getPosition()
    {
        return this.position;
    }
 
    public String toString()
    {
        return this.axis + ":" + position ; 
    }
}
 
 
> Point points[] = { new Point("y",10), new Point("x",5), new Point("y" ,1), new Point("z" , 4) }
/*
Create an array of points .*/
points ==> [ y:10, x:5, y:1, z:4 ]
 
Comparator<Point> axisComparator  = Comparator.comparing(Point::getAxis);
/*
The Comparator class has a static 
  method comparing.
It creates a Comparator using a 
  Comparable value extracted by 
  a function . 
In this case the Comparator created 
  for the Point type is using 
  the axis field which is a Comparable
  of type String .*/
 
> Arrays.sort( points , axisComparator )
/*
Sort the array using the Comparator :
  axisComparator .*/
 
> points
points ==> [ x:5, y:10, y:1, z:4 ]
 
> Arrays.sort( points , axisComparator.reversed())
/*
The reversed method of Comparator
  returns a reverse Comparator . 
  So the ordering will be 
  reversed .*/
 
> points
points ==> [ z:4.0, y:10.0, y:1.0, x:5.0 ]
 
> Comparator<Point> axisPositionComparator = Comparator.comparing(Point::getAxis).thenComparing(Point::getPosition);
/*
Create a Comparator which first 
  compares using the axis field , 
  and when the values are equal 
  compare using the position field .*/
 
> Arrays.parallelSort(points , axisPositionComparator );
 
> points
points ==> [ x:5, y:1, y:10, z:4 ]
 
> Arrays.parallelSort(points , ( point1 , point2 ) -> point1.position - point2.position ) ;
/*
Use lambda expression , to pass
  the compare method of Comparator .*/
 
> points
points ==> [ y:1, z:4, x:5, y:10 ]

The Stream API can also be used to create a sorted shallow copy of the array .

jshell> 
 
> import java.util.Arrays;
 
> int iArray[] = { 10, 3, 5 }
/*
Create an array of type 
  int[] , and store a 
  reference to it in the 
  variable iArray .*/
iArray ==> int[3] { 10, 3, 5 }
 
> int iArrayCopySorted [] = Arrays.stream(iArray).sorted().toArray()
/*
Use Arrays.stream to create a 
  sequential IntStream , with 
  its source being the
  array referenced by the
  variable iArray .
Using the sorted function ,
  create a sorted stream ,
  using primitive types 
  comparaison .
Use toArray method to create 
  an array of type int[]
  from the sorted IntStream 
Store a reference to the 
  created array in the 
  variable iArrayCopySorted .*/
iArrayCopySorted ==> int[3] { 3, 5, 10 }
 
 
> String sArray[] = {"ar" , "ab"}
/*
Create an array of type 
  String[] and store a 
  reference to it in the 
  variable sArray .*/
sArray ==> String[2] { "ar", "ab" }
 
> String sArrayCopySorted[] = Arrays.stream(sArray).sorted().toArray(String[]::new)
/*
Using Arrays.stream , create a 
  stream backed by the array 
  referenced by sArray . 
Using the sorted method , sort
  the String elements . String 
  implements the Comparable 
  interface . As such sort using 
  the compareTo method .
The sorted method returns a 
  sorted Stream of Objects .
Using the toArray method , create 
  an array from the elements of the 
  sorted Stream . 
Pass to the toArray , method the 
  function which will create the 
  array of the given type , and 
  the passed size to the 
  function 
Store a reference to the sorted
  array in the sArrayCopySorted
  variable .*/
sArrayCopySorted ==> [ "ab", "ar" ]
 
 
> int iaa[][] = { { 4, 3 }, { 2, 1 } } 
/*
Create an array of type int[][] ,
  and store a reference to it 
  in iaa .*/
 
> int iaaShallowCopySorted[][] = Arrays.
    stream(iaa).
    sorted(
        (ia1 , ia2)->
            {
                Arrays.parallelSort(ia1);
                Arrays.parallelSort(ia2);
                return ia1[0] - ia2[0];
            }).
    toArray(int[][]::new);
/*
Use Arrays.stream to create a 
  sequential stream backed by 
  the array referenced by the 
  variable iaa.
The elements of the stream are 
  of type int[] , and they don't
  implement the Comparable interface . 
As such we can pass to the sorted
  function a comparator , to be used
  for performing comparison between
  elements .
The comparator is passed as a lambda
  function . 
The lambda function takes , two variables
  of type int[] . Using Arrays.parallelSort
  it sorts , the arrays , and finally to 
  compare the two arrays , it compare 
  the first element of the two arrays , 
  by subtracting them .
The sorted function return a sorted 
  stream of objects .
Use the toArray method , to create
  an array of type int[][] , from 
  this sorted stream .
Store a reference of the newly
  created array in the variable 
  iaaShallowCopySorted .*/
iaaShallowCopySorted ==> [ [ 1, 2 ], [ 3, 4 ] ]
/*
iaaShallowCopySorted[0] is sorted.
iaaShallowCopySorted[1] is sorted.
The array referenced by iaaShallowCopySorted
  is sorted .*/
 
> iaa 
/*
iaa[0] is sorted . 
iaa[1] is sorted .
The array referenced by iaa is 
  not sorted .*/
iaa ==> [ [ 3, 4 ], [ 1, 2 ] ]