Examples

• 469

  Creating and Initializing Arrays

  edit move example delete share

  469

  Java provides several ways of defining and initializing arrays, including literal and constructor notations. When declaring arrays without explicit values, the content will be initialized with a default value:

  • 0 or the equivalent value for primitive numerical types like byte, short, int, char, long, float, and double.
  • false for the boolean type.
  • null for reference types.

  The size of an array is fixed at runtime when initialized. It cannot be changed after initialization. If the size is still unknown at initialization, another Collection class such as ArrayList should be used instead.

  Creating and initializing primitive type arrays

  int[] array1 = new int[] { 1, 2, 3 }; // Create an array
  

  // with new operator and //array initializer. int[] array2 = { 1, 2, 3 }; // Shortcut syntax with array initializer. int[] array3 = new int3; // { 0, 0, 0 } int[] array4 = null; // The array itself is an object, so it // can be set to the null reference.

  When declaring an array, [] may appear as part of the type at the beginning of the declaration, or as part of the declarator for a particular variable, or both.

  int array5[];       /* equivalent to */  int[] array5;
  int a, b[], c[][];  /* equivalent to */  int a; int[] b; int[][] c;
  int[] a, b[];       /* equivalent to */  int[] a; int[][] b;
  
  // When declaring a method that returns an array:
  int foo()[] { ... } /* equivalent to */ int[] foo() { ... }
  

  Although both are correct,and as such compile and run without any problems, the Java Coding Convention and the Google Java Style Guide discourage the form with brackets after the variable name; the brackets identify the array type and should appear with the type designation.

  float array[];  // discouraged
  float[] array;  // encouraged
  

  The discouraged type is meant to accommodate transitioning C users, who are familiar with syntax for C which has the brackets after the variable name.

  Creating and initializing reference type arrays

  String[] array6 = new String[] { "Laurel", "Hardy" }; // Create an array with new 
                                                        //   operator and array initializer.
  String[] array7 = { "Laurel", "Hardy" };              // Shortcut syntax with array 
                                                        //   initializer.
  String[] array8 = new String[3];                      // { null, null, null }
  String[] array9 = null;                               // null
  

  Live on Ideone

  An array can be initialized with a zero length like String[] emptyArray = new String[0]; for example, this is used for Creating an Array from a Collection when the method needs the runtime type of an object.

  In both primitive and reference types, an empty array initialization (for example String[] array8 = new String[3];) will initialize the array with the default value for each data type.

  Filling an array after initialization

  Arrays.fill() can be used to fill an array with the same value after initialization:

  Arrays.fill(array8, "abc");        // { "abc", "abc", "abc" }
  

  Live on Ideone

  fill() can also assign a value to each element of the specified range of the array.

  Arrays.fill(array8, 1, 2, "aaa"); // Placing "aaa" from index 1 to 2.
  

  Live on Ideone

  Java SE 8

  Since Java version 8, the method setAll, and its Concurrent equivalent parallelSetAll, can be used to set every element of an array to generated values. These methods are passed a generator function which accepts an index and returns the desired value for that position.

  The following example creates an integer array and sets for all of its elements to their index value:

  int[] array = new int[5];
  Arrays.setAll(array, i -> i); // the array becomes { 0, 1, 2, 3, 4 }
  

  Live on Ideone

  Separate declaration and initialization of arrays

  int[] array9;             // array declaration - uninitialized
  array9 = new int[3];      // initialize array  - { 0, 0, 0 }
  array9[0] = 10;           // set index 0 value - { 10, 0, 0 }
  array9[1] = 20;           // set index 1 value - { 10, 20, 0 }
  array9[2] = 30;           // set index 2 value - { 10, 20, 30 }
  

  The value of an index for an array element must be a non-negative integer (0, 1, 2, 3, 4, ...) and less than the length of the array (indexes are zero-based). Otherwise, an ArrayIndexOutOfBoundsException will be thrown.

  Covariance

  Arrays are covariant. That means it's not necessary for all of the array elements to share the same type, as long as they are a subclass of the array's type:

  interface I {}
  
  class A implements I {}
  class B implements I {}
  class C implements I {}
  
  I[] array10 = new I[] { new A(), new B(), new C() }; // Create an array with new
                                                       //   operator and array initializer.
  
  I[] array11 = { new A(), new B(), new C() };         // Shortcut syntax with array
                                                       //   initializer.
  
  I[] array12 = new I[3];                              // { null, null, null }
  
  I[] array13 = new A[] { new A(), new A() };          // Works because A implements I.
  
  Object[] array14 = new Object[] { "Hello, World!", 3.14159, 42 }; // Create an array with
                                                       // new operator and array initializer.
  
  Object[] array15 = { new A(), 64, "My String" };     // Shortcut syntax 
                                                       //   with array initializer.
  

  Anonymous arrays

  An anonymous array is an array without a name.

  float avg(int[] arr) {
      int sum = 0;
      for(int i = 0; i < arr.length; i++){
          sum += arr[i];
      }
      return (float)sum / arr.length;
  }
  
  float average = avg(new int[]{2, 4, 6, 7}); // The argument for `avg` is an anonymous array.
  

  Live on Ideone

  Arrays may not be re-initialized with array initializer shortcut syntax

  It is not possible to re-initialize an array via a shortcut syntax with an array initializer since an array initializer can only be specified in a field declaration or local variable declaration, or as a part of an array creation expression.

  However, it is possible to create a new array and assign it to the variable being used to reference the old array. While this results in the array referenced by that variable being re-initialized, the variable contents are a completely new array. To do this, a new operator can be used with an array initializer and assigned to the array variable:

  int[] array = new int[] { 1, 2, 3 };
  
  // Prints "1 2 3 ".
  for (int i : array) {
      System.out.print(i + " ");
  }
  
  // Re-initializes array to a new int[] array.
  arr = new int[] { 4, 5, 6 };
  
  // Prints "4 5 6 ".
  for (int i : array) {
      System.out.print(i + " ");
  }
  
  array = { 1, 2, 3, 4 }; // Error! Can't re-initialize an array via shortcut syntax
                          //   with array initializer.
  

  Reclaiming memory from arrays

  Once there are no references to an array, the memory allocated for that array may be reclaimed by the Garbage Collector. In the above example, when array is assigned to a the new int[] array, { 4, 5, 6 }, there is no longer any reference to the int[] array, { 1, 2, 3 }, which may subsequently be reclaimed by the Garbage Collector.

  edited 2 hours ago

  

  

  

  

  

  +88
• 76

  Creating a List from an Array

  edit move example delete share

  76

  The Arrays.asList() method can be used to return a fixed-size List containing the elements of the given array. The resulting List will be of the same type as the array.

  String[] stringArray = new String[] {"foo", "bar", "baz"};
  List<String> stringList = Arrays.asList(stringArray);
  

  Note that this list is backed by (a view of the) array, meaning any changes to the list changes the initial array and vice versa.

  To create a copy of the list, use the constructor of java.util.ArrayList taking a Collection:

  Java SE 5

  String[] stringArray = new String[] {"foo", "bar", "baz"};
  List<String> stringList = new ArrayList<String>(Arrays.asList(stringArray));
  

  Java SE 7

  In Java SE 7 and later, a pair of angle brackets <> (empty set of type arguments) can be used, which is called the Diamond Operator. The compiler can determine the type arguments from the context. That means we can leave out the type when calling the constructor of ArrayList and it will be inferred automatically during compilation. This is called Type Inference which is a part of Java Generics.

  String[] stringArray = new String[] {"foo", "bar", "baz"};
  List<String> stringList = new ArrayList<>(Arrays.asList(stringArray));
  

  An important remark about the Diamond Operator is that, although it comes in handy, it cannot be used with Anonymous Classes.

  ---

  Important notes related to using Arrays.asList() method

  • Changes to the List affect the array, and vice-versa:

    String[] stringArray = new String[] {"very", "related", "strings"};
    List<String> stringList = Arrays.asList(stringArray);
    
    System.out.println(stringArray[0]);    // "very"
    stringList.set(0, "boo");
    System.out.println(stringArray[0]);    // "boo"
    
    System.out.println(stringArray[2]);    // "strings"
    stringArray[2] = "faz";
    System.out.println(stringList.get(2)); // "faz"
    

  • The resulting List is fixed-size. That means, adding or removing elements is not supported and will throw an UnsupportedOperationException:

    stringList.add("something"); // throws java.lang.UnsupportedOperationException
    

  • A new List can be created by passing the array-backed List to the constructor of a new one. This creates a new copy of the data, which is not fixed-size anymore, but also not backed by the array:

    List<String> modifiableList = new ArrayList<>(Arrays.asList("foo", "bar"));
    

  • Calling <T> List<T> asList(T... a) on a primitive array, such as an int[], will produce a List<int[]> whose only element is the source primitive array instead of the actual elements of the source array.

    The reason for that behaviour is that primitive types cannot be used in place of generic type parameters, so the entire primitive array replaces the generic type parameter in this case. In order to convert a primitive array to a List, first convert the primitive array to an array of the corresponding wrapper type (i.e. call Arrays.asList on an Integer[] instead of an int[]). Therefore:

    int[] arr = {1, 2, 3};      // primitive array of int
    System.out.println(Arrays.asList(arr).contains(1));
    

    Live demo

    will print false, while on the other hand:

    Integer[] arr = {1, 2, 3};  // object array of Integer (wrapper for int)
    System.out.println(Arrays.asList(arr).contains(1));
    

    Live demo

    will print true.

  ---

  Using Java SE 8:

  Java SE 8

  int[] ints = {1, 2, 3};
  List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList());
  

  edited 7 hours ago

  

  

  

  

  

  +29
• 27

  Creating an Array from a Collection

  edit move example delete share

  27

  There are two methods of creating an Array from a collection provided in java.util.Collection:

  • Object[] toArray()
  • <T> T[] toArray(T[] a)

  Object[] toArray() can be used as follows:

  Set<Integer> set = new HashSet<Integer>();
  set.add(0);
  set.add(1);
  
  Object[] objectArray = set.toArray();
  

  <T> T[] toArray(T[] a) can be used as follows:

  Set<Integer> set = new HashSet<Integer>();
  set.add(0);
  set.add(1);
  
  /**
   * Note that the array does not need to be created up front with the correct size.
   */
  Integer[] integerArray = set.toArray(new Integer[0]);  
  
  List<String> list = new ArrayList<String>();
  list.add("android");
  list.add("apple");
  
  String[] stringArray = list.toArray(new String[list.size()]);
  

  The difference between them is more than just having untyped vs typed results. There are also performance considerations:

  • Object[] toArray() uses vectorized array copy, which is much faster than the type-checked array copy in T[] toArray(T[] a).
  • T[] toArray(new T[non-zero-size]) needs to zero-out the array, while T[] toArray(new T[0]) does not. Such avoidance makes the latter call faster than the former.

  An alternative of converting ArrayList to Array is to use the Arrays.copyOf method:

  List<String> arrayList = new ArrayList<String>();
  Object[] objectList = arrayList.toArray();
  String[] stringArray =  Arrays.copyOf(objectList, objectList.length, String[].class);
  

  ---

  Java SE 8

  Starting from Java SE 8+, where the concept of Stream has been introduced, it is possible to use the Stream produced by the collection in order to create a new Array using the Stream.toArray function.

  String[] strings = list.stream().toArray(String[]::new);
  

  Examples taken from answers here and here to the question "Converting 'ArrayList to 'String[]'" on Stack Overflow.

  edited 11 hours ago

  

  

  

  

  

  +7
• 15

  Multidimensional and Jagged Arrays

  edit move example delete share

  15

  It is possible to define an array with more than one dimension. Instead of being accessed linearly, a multidimensional array is accessed by specifying an index for each dimension.

  To do this, we repeat the declaration of an array. For instance, to make a 2-dimensional int array, add another set of brackets to the declaration, such as int[][]. This continues for 3-dimensional arrays (int[][][]) and so forth.

  Below, we define a 2-dimensional array with three rows and three columns.

  int rows = 3;
  int columns = 3;
  int[][] table = new int[rows][columns];
  

  With this construct, we can index into the array and assign values. Note that the unassigned values are the default values for the type of an array, in this case 0 for int.

  table[0][0] = 0;
  table[0][1] = 1;
  table[0][2] = 2;
  

  While not as common, you can also instantiate one dimension at a time, and even make non-rectangular arrays. These are more commonly referred to as jagged arrays.

  int[][] nonRect = new int[4][];
  

  It is important to note that you can define any dimension of jagged array; However, it's preceding level must be defined.

  // valid
  String[][] employeeGraph = new String[30][];
  
  // invalid
  int[][] unshapenMatrix = new int[][10];
  
  // also invalid
  int[][][] misshapenGrid = new int[100][][10];
  

  Multidimensional arrays can also be initialized with a literal expression. The following declares and populates a 2x3 int array:

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

  edited yesterday

  

  

  

  

  

  +5
• 9

  ArrayIndexOutOfBoundsException

  edit move example delete share

  9

  The ArrayIndexOutOfBoundsException is thrown when attempting to access an index of the array that doesn't exist.

  Remember that the smallest array index is 0 and the largest is 1 less than the number of elements in the array. Thus, any request to an array, like array[i], where i < 0 || i > array.length - 1 will throw an ArrayIndexOutOfBoundsException.

  The following code is a simple example where an ArrayIndexOutOfBoundsException is thrown.

  String[] people = new String[] { "Carol", "Andy" };
  System.out.println(people[2]);  //throws an ArrayIndexOutOfBoundsException.
  

  Output:

  Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2 at your.package.path.method(YourClass.java:15)

  To avoid this, simply check that the index is within the limits of the array:

  int index = 2;
  if (index >= 0 && index < people.length) {
      System.out.println(people[index]);
  } 
  

  edited 21 hours ago

  

  

  

  

  

  +6
• 8

  Arrays to Stream

  edit move example delete share

  8

  Convert array of objects to Stream

  String[] arr = new String[]{"str1", "str2", "str3"};
  Stream<String> stream = Arrays.stream(arr);
  

  Convert array of primitives to Stream using Arrays.stream will transform array to primitive specialization of Stream.

  int[] intArr = new int[]{1, 2, 3};
  IntStream intStream = Arrays.stream(intArr);
  

  You can also limit the Stream to a range of elements in the array, the start index is inclusive and the end index is exclusive:

  int[] values = { 1, 2, 3, 4 };
  IntStream intStream = Arrays.stream(values, 2, 4);
  

  A similar method to Arrays.stream() appears in the Stream class, Stream.of(). The difference is that Stream.of() uses a varargs parameter, so you can write something like:

  Stream<Integer> intStream = Stream.of(1, 2, 3);
  Stream<String> stringStream = Stream.of("1", "2", "3");
  Stream<Double> doubleStream = Stream.of(new Double[]{1.0, 2.0});
  

  edited Jul 22 at 20:34

  

  

  

  
• 7

  Arrays to a String

  edit move example delete share

  7

  Arrays and multi-dimensional arrays:

  int[] arr = {1, 2, 3, 4, 5};
  System.out.println(Arrays.toString(arr));          // [1, 2, 3, 4, 5]
  
  int[][] arr = { {1, 2, 3},
                  {4, 5, 6},
                  {7, 8, 9} };
  System.out.println(Arrays.deepToString(arr));      // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
  

  Since Arrays.toString() method uses Object.toString() method to produce String values of every item in the array, beside primitive type array, it can be used for all type of arrays. For instance:

  public class Cat { /* implicitly extends Object */
      @Override
      public String toString() {
        return "CAT!";
      }
  }
  
  Cat[] arr = { new Cat(), new Cat() };
  System.out.println(Arrays.toString(arr));            // [CAT!, CAT!]
  

  If no overridden toString() exists for the class, then the inherited toString() from Object will be used. Usually the output is then not very useful, for example:

  public class Dog { /* implicitly extends Object */
  }
  
  Dog[] arr = { new Dog() };
  System.out.println(Arrays.toString(arr));            // [Dog@17ed40e0]
  

  edited Jul 23 at 12:55

  

  

  

  

  

  +1
• 6

  Iterating over arrays

  edit move example delete share

  6

  You can iterate over arrays either by using extended for (aka foreach) or by using array indices:

  int[] array = new int[10];
  
  //using indices: read and write
  for (int i = 0; i < array.length; i++) {
    array[i] = i;
  }
  
  //extended for: read only
  for (int e : array) {
    System.out.println(e);
  }
  

  It is worth noting here that there is no direct way to use an Iterator on an Array, but through the Arrays library it can be easily converted to a list with Arrays.asList to obtain an Iterable object.

  In two-dimensional arrays or more, both techniques can be used in a slightly more complex fashion.

  Example:

  int[][] array = new int[10][10];
  
  for (int indexOuter = 0; indexOuter < array.length; indexOuter++) {
      for (int indexInner = 0; indexInner < array[indexOuter].length; indexInner++ ) {
          array[indexOuter][indexInner] = indexOuter + indexInner;
      }
  }
  
  for (int[] numbers : array) {
      for (int value : numbers) {
          System.out.println(value);
      }
  }
  

  ---

  It is impossible to set an Array to any non-uniform value without using an index based loop.

  Of course you can also use while or do-while loops when iterating using indices.

  One note of caution: when using array indices, make sure the index is between 0 and array.length - 1 (both inclusive). Don't make hard coded assumptions on the array length otherwise you might break your code if the array length changes but your hard coded values don't.

  Example:

  int[] numbers = {1,2,3,4};
  
  public void incrementNumbers() {
    //DO 
    for (int i = 0; i < numbers.length; i++) {
      numbers[i] += 1; //or this: numbers[i] = numbers[i] + 1; or numbers[i]++;      
    }
   
    //DON'T
    for (int i = 0; i < 4; i++) {
      numbers[i] += 1;
    }
  }
  

  ---

  It's also best if you don't use fancy calculations to get the index but use the index to iterate and if you need different values calculate those.

  Example:

  public void fillArrayWithDoubleIndex( int[] array ) {
    //DO 
    for (int i = 0; i < array.length; i++) {
      array[i] = i * 2;
    }
   
    //DON'T
    int doubleLength = array.length * 2;
    for (int i = 0; i < doubleLength; i += 2) {
      array[i/2] = i;
    }
  }
  

  How to access array elements backwards?

  int[] array = {0, 1, 1, 2, 3, 5, 8, 13};
  for (int i = array.length-1; i >= 0; i--) {
     System.out.println(array[i]);
  }
  

  edited yesterday

  

  

  

  

  

  +2
• 5

  Accessing Contents of an Array

  edit move example delete share

  5

  The content in an array is referenced by its index, starting from 0.

  int[] primes = { 2, 3, 5, 7 };
  int firstPrime  = primes[0]; //retrieves the first item from the array. now firstPrime contains int value 2
  int secondPrime = primes[1]; //retrieves the second item from the array. now secondPrime contains int value 3
  

  You can access the content iterating it in a C-Style for-loop :

  for (int i = 0; i < primes.length; i++) {
      int currenVal = primes[i];
  }
  

  Or for-each loop using auto-created iterator:

  for (int prime : primes) {
      int currentVal = prime;
  }
  

  edited Jul 22 at 11:25

  

  

  

  

  

  +3
• 5

  Array Covariance

  edit move example delete share

  5

  Object arrays are covariant, which means that just as Integer is a subclass of Number, Integer[] is a subclass of Number[]. This may seem intuitive, but can result in surprising behavior:

  Integer[] integerArray = {1, 2, 3};
  Number[] numberArray = integerArray;  // valid
  Number firstElement = numberArray[0]; // valid
  numberArray[0] = 4L;                  // throws ArrayStoreException at runtime
  

  Although Integer[] is a subclass of Number[], it can only hold Integers, and trying to assign a Long element throws a runtime exception.

  Note that this behavior is unique to arrays, and can be avoided by using a generic List instead:

  List<Integer> integerList = Arrays.asList(1, 2, 3);
  //List<Number> numberList = integerList;  // compile error
  List<? extends Number> numberList = integerList;
  Number firstElement = numberList.get(0);
  //numberList.set(0, 4L);                  // compile error
  

  created Jul 21 at 21:19

  
• 5

  Remove an element from an array

  edit move example delete share

  5

  Java doesn't provide a direct method in java.util.Arrays to remove an element from an array. To perform it, you can either copy the original array to a new one without the element to remove or convert your array to another structure allowing the removal.

  Using ArrayList

  You can convert the array to a java.util.List, remove the element and convert the list back to an array as follows:

  String[] array = new String[]{"foo", "bar", "baz"};
  
  List<String> list = new ArrayList<>(Arrays.asList(array));
  list.remove("foo");
  
  // Creates a new array with the same size as the list and copies the list
  // elements to it.
  array = list.toArray(new String[list.size()]);
  
  System.out.println(Arrays.toString(array)); //[bar, baz]
  

  ---

  Using System.arraycopy

  System.arraycopy() can be used to make a copy of the original array and remove the element you want. Below an example:

  int[] array = new int[] { 1, 2, 3, 4 }; // Original array.
  int[] result = new int[array.length - 1]; // Array which will contain the result.
  int index = 1; // Remove the value "2".
  
  // Copy the elements at the left of the index.
  System.arraycopy(array, 0, result, 0, index);
  // Copy the elements at the right of the index.
  System.arraycopy(array, index + 1, result, index, array.length - index - 1);
  
  System.out.println(Arrays.toString(result)); //[1, 3, 4]
  

  ---

  Using Apache Commons Lang

  To easily remove an element, you can use the Apache Commons Lang library and especially the static method removeElement() of the class ArrayUtils. Below an example:

  int[] array = new int[]{1,2,3,4};
  array = ArrayUtils.removeElement(array, 2); //remove first occurrence of 2
  System.out.println(Arrays.toString(array)); //[1, 3, 4]
  

  edited Jul 23 at 12:55

  

  

  

  

  

  +1
• 5

  Test if an array contains an element

  edit move example delete share

  5

  ---

  Non-primitive array

  For arrays that don't contain primitive elements, the following can be used:

  String[] array = new String[]{"foo", "bar", "baz"};
  Arrays.asList(array).contains("foo"); // true
  

  ---

  Primitive array

  Since primitives are not generic, you cannot use Arrays.asList(array).contains(). Instead, you can perform the check as below:

  Java SE 8

  int[] array = {4, 1, 3, 2};
  boolean anyMatch = IntStream.of(array).anyMatch(x -> x == 4); // true
  

  Java SE 8

  There is no native Java utility to do this, so you have to manually loop over the array to check if it contains the element.

  int[] array = {4, 1, 3, 2};
  boolean contains = false;
  
  for(int arrayValue : array) {
      if(arrayValue == 4) {
          contains = true;
          break;
      }
  }
  

  You can also use org.apache.commons library to easily perform the check:

  int[] array = {4, 1, 3, 2};
  org.apache.commons.lang3.ArrayUtils.ArrayUtils.contains(array, 4); // true
  

  ---

  Sorted arrays

  If your array is already sorted, the fastest way is by using the appropriate Arrays.binarySearch method:

  int[] array = { 4, 1, 3, 2 };
  boolean found1 = Arrays.binarySearch(array, 1) >= 0;
  

  edited 4 hours ago

  

  

  

  

  

  +3
• 4

  Copying arrays

  edit move example delete share

  4

  Java provides several ways to copy an array.

  for loop

   int[] a = { 4, 1, 3, 2 };
   int[] b = new int[a.length]; 
   for (int i = 0; i < a.length; i++)
   {
      b[i] = a[i];
   }
  

  Note that using this option with an Object array instead of primitive array will fill the copy with reference to the original content instead of copy of it.

  Object.clone()

  Since Array is considered as an Object in Java, you can use Object.clone().

  int[] a = { 4, 1, 3, 2 };
  int[] b = a.clone(); // [4, 1, 3, 2]
  

  Note that the clone method returns a reference to a new array which references the same elements as the source array.

  ---

  Arrays.copyOf()

  java.util.Arrays provides a easy way to perform the copy of an array to another. Here is the basic usage:

  int[] a = {4, 1, 3, 2};
  int[] b = Arrays.copyOf(a, a.length); // [4, 1, 3, 2]
  

  ---

  System.arraycopy()

  public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) Copies an array from the specified source array, beginning at the specified position, to the specified position of the destination array.

  Below an example of use

  int[] a = { 4, 1, 3, 2 };
  int[] b = new int[a.length];
  System.arraycopy(a, 0, b, 0, a.length); // [4, 1, 3, 2]
  

  ---

  Arrays.copyOfRange()

  Mainly used to copy a part of an Array, you can also use it to copy whole array to another as below:

  int[] a = { 4, 1, 3, 2 };
  int[] b = Arrays.copyOfRange(a, 0, a.length); // [4, 1, 3, 2]
  

  edited Jul 23 at 12:55

  

  

  

  

  
• 4

  Finding an element in the Array

  edit move example delete share

  4

  Java offers several ways to find the location of a value in an array:

  • Using Arrays.binarySearch (for sorted arrays only):

    String[] array = new String[] { "A", "B", "C" };
    int index = Arrays.binarySearch(array, "A");
    System.out.println(index); // If non-negative, this is the index of the element.
    

  • Using a List (for non-primitive arrays only)

    String[] array = new String[] { "A", "B", "C" };
    int index = Arrays.asList(array).indexOf("A");
    System.out.println(index);
    

  • Using a stream

  Java SE 8

    String[] array = new String[] { "A", "B", "C" };
    int index = IntStream.range(0, array.length)
                         .filter(i -> "A".equals(array[i]))
                         .findFirst()
                         .orElse(-1); // If not present, gives us -1.
    System.out.println(index);
  

  • Direct search on array using linear search

    String[] array = new String[] { "A", "B", "C" };
    int index = -1;
    for (int i = 0; i < array.length; i++) {
        if ("A".equals(array[i])) {
            index = i;
            break;
        }            
    }
    System.out.println(index);
    

  Note: Using a direct linear search is more efficient than wrapping in a list.

  edited 22 hours ago

  

  

  

  

  

  +3
• 4

  Getting the Length of an Array

  edit move example delete share

  4

  Arrays are objects which provide space to store up to its size of elements of specified type. An array's size can not be modified after the array is created.

  int[] arr1 = new int[0];
  int[] arr2 = new int[2];
  int[] arr3 = new int[]{1, 2, 3, 4};
  int[] arr4 = {1, 2, 3, 4, 5, 6, 7};
  
  int len1 = arr1.length; // 0
  int len2 = arr2.length; // 2
  int len3 = arr3.length; // 4
  int len4 = arr4.length; // 7
  

  The length field in an array stores the size of an array. It is a final field and cannot be modified.

  This code shows the difference between the length of an array and amount of objects an array stores.

  public static void main(String[] args) {
      Integer arr[] = new Integer[] {1,2,3,null,5,null,7,null,null,null,11,null,13};
  
      int arrayLength = arr.length;
      int nonEmptyElementsCount = 0;
  
      for (int i=0; i<arrayLength; i++) {
          Integer arrElt = arr[i];
          if (arrElt != null) {
              nonEmptyElementsCount++;
          }
      }
  
      System.out.println("Array 'arr' has a length of "+arrayLength+"\n"
                              + "and it contains "+nonEmptyElementsCount+" non-empty values");
  }
  

  Result:

  Array 'arr' has a length of 13
  and it contains 7 non-empty values
  

  edited 3 hours ago

  

  

  

  

  
• 3

  Casting Arrays

  edit move example delete share

  3

  Arrays are objects, but their type is defined by the type of the contained objects. Therefore, one cannot just cast A[] to T[], but each A member of the specific A[] must be cast to a T object. Generic example:

  public static <T, A> T[] castArray(T[] target, A[] array) {
      for (int i = 0; i < array.length; i++) {
          target[i] = (T) array[i];
      }
      return target;
  }
  

  Thus, given an A[] array:

  T[] target = new T[array.Length];
  target = castArray(target, array);
  

  You can just use Arrays.copyOf(original, newLength, newType)) as well.

  edited Jul 22 at 9:43

  

  

  

  
• 3

  Comparing arrays for equality

  edit move example delete share

  3

  Array types inherit their equals() (and hashCode()) implementations from java.lang.Object, so equals() will only return true when comparing against the exact same array object. To compare arrays for equality based on their values, use java.util.Arrays.equals, which is overloaded for all array types.

  int[] a = new int[]{1, 2, 3};
  int[] b = new int[]{1, 2, 3};
  System.out.println(a.equals(b)); //prints "false" because a and b refer to different objects
  System.out.println(Arrays.equals(a, b)); //prints "true" because the elements of a and b have the same values
  

  When the element type is a reference type, Arrays.equals() calls equals() on the array elements to determine equality. In particular, if the element type is itself an array type, identity comparison will be used. To compare multidimensional arrays for equality, use Arrays.deepEquals() instead as below:

  int a[] = { 1, 2, 3 };
  int b[] = { 1, 2, 3 };
  
  Object[] aObject = { a }; // aObject contains one element
  Object[] bObject = { b }; // bObject contains one element
  
  System.out.println(Arrays.equals(aObject, bObject)); // false
  System.out.println(Arrays.deepEquals(aObject, bObject));// true
  

  Because sets and maps use equals() and hashCode(), arrays are generally not useful as set elements or map keys. Either wrap them in a helper class that implements equals() and hashCode() in terms of the array elements, or convert them to List instances and store the lists.

  edited Jul 21 at 20:49

  

  
• 3

  Resizing an array to add more elements

  edit move example delete share

  3

  Once an array is initialized, you cannot resize the array if you want to add more elements to it.

  String[] listOfCities = new String[3];
  listOfCities[0] = "New York";
  listOfCities[1] = "London";
  listOfCities[2] = "Berlin";
  

  If a new element needs to be added to above listOfCities, you have a create a new array with size 4 and copy above 3 elements to it (may be using an iterator) and then add the new element at the end (or whatever position you may need).

  String[] newArray = new String[4];
  System.arraycopy( listOfCities, 0, newArray, 0, listOfCities.length );
  

  In such scenario, it is best to use a List implementation like an ArrayList.

  See this example on creating ArrayList and add elements to it.

  Declaring an ArrayList and adding objects

  edited Jul 22 at 9:43

  

  
• 2

  Arrays as method parameter

  edit move example delete share

  2

  You can use the varargs syntax sugar to make passing an array to a method easier for the caller.

  void varargs(String... arguments) {
      if (arguments == null) {                      // guard for null arrays
          return;
      }
      if (arguments.length >= 1) {                  // guard for empty arrays
          String first = arguments[0]; // Access like a normal array
      }
  }
  
  void main() {
      varargs("First", "Second"); // call without explicitly creating the array
      varargs(); // or even without any parameters at all (creates empty, non-null array)
  
      // or directly with given array
      String[] givenArray = {"Third", "Forth"};
      varargs(givenArray)
  
      // null arrays are also supported
      String[] nullArray = null;
      varargs(nullArray);
      varargs((String[]) null);
  }
  

  edited 2 days ago

  

  

  

  
• 2

  Converting an Array of Objects to an Array of primitives

  edit move example delete share

  2

  Integer[] integerArray = new Integer[]{1, 2, 3, 4, 5}; // The array of Integer objects
  int[] intArray = Arrays.stream(integerArray)
                         .mapToInt(Integer::intValue)
                         .toArray(); // The resulting array of ints
  

  edited Jun 9 at 0:59

  

  
• 1

  Reversing an array

  edit move example delete share

  1

  This examples shows how to reverse a String array.(You can change the data type from an Object to a primitive like int, float etc. to reverse arrays of primitive types as well.)

  public class ReversingAnArrayExample
  {
      public static void main(String[] args)
      {
          String[] names={"1-Apricot","2-Banana","3-Coconut","4-Date","5-Elderberry","6-Fig"};
          System.out.println("Original array is:");
          for(String s:names)
          {
              System.out.println(s);
          }
          reverseArray(names);
          
          System.out.println("\nReversed array is:");
          for(String s:names)
          {
              System.out.println(s);
          }
      }
  
      static void reverseArray(Object[] array)
      {
          if(array == null)
              return;
          for(int i=0;i<array.length/2;i++)
          {
              Object temp=array[i];
              array[i]=array[array.length-i-1];
              array[array.length-i-1]=temp;
          }
      }
  }
  

  It is to be noted that this function is not creating any extra copy of array, thus it returns nothing and saves memory as well!

  ---

  A less verbose way of reversing an array would be using built-ins:

  static void reverseArray(Object[] array) {
      List<Object> list = Arrays.asList(array); // to list
      Collections.reverse(list); // reverse
      array = (Object[]) list.toArray(); // back to array
  }
  

  edited 4 hours ago