Examples

• Improvements requested by Stephen C:

  • Other: This example is totally out of hand. It is supposedly about "creating and initializing arrays", but people have added all sorts of irrelevant stuff about how arrays work, whether they should be sorted. etc. Even attempting to cover all the different ways to initialize an array is a bad idea. - 1d ago

  Edit Example Delete Example
  652

  Creating and Initializing Arrays

  edit move example delete share 1

  652

  Basic cases

  int[]   numbers1 = new int[3];                 // Array for 3 int values, default value is 0
  int[]   numbers2 = { 1, 2, 3 };                // Array literal of 3 int values
  int[]   numbers3 = new int[] { 1, 2, 3 };      // Array of 3 int values initialized
  int[][] numbers4 = { { 1, 2 }, { 3, 4, 5 } };  // Jagged array literal
  int[][] numbers5 = new int[5][];               // Jagged array, one dimension 5 long
  int[][] numbers6 = new int[5][4];              // Multidimensional array: 5x4
  

  Arrays, Collections, and Streams

  // parameters requires Objects and not primitives
  
  // Auto-boxing happening for int 127 here
  Integer[]       initial        = { 127, Integer.valueOf( 42 ) };
  List<Integer>   toList         = Arrays.asList( initial );  // Fixed size! 
  
  // Note: works with all Collections
  Integer[]       fromCollection = toList.toArray( new Integer[toList.size()] );
  
  // Streams - JDK 8+
  Stream<Integer> toStream       = Arrays.stream( initial );
  Integer[]       fromStream     = toStream.toArray( Integer[]::new );
  

  Intro

  An array is a data structure that holds a fixed number of primitive values or references to a single type of consecutive addresses in memory. Each item in an array is called an element, and each element is accessed by its numerical index. The length of an array is established when the array is created. After creation, its length is fixed.

  Arrays use a zero-based index system, which means indexing starts at 0 and ends at n - 1 where n is size of the array.

  For example, the following image represents an array with size 10. Here, the first element is at index 0 and the last element is at index 9, instead of the first element being at index 1 and the last element at index 10 (see figure below).

  

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

  • 0 for primitive numerical types: byte, short, char, int, 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, a Collection class such as ArrayList should be used instead:

  int size = 42;
  int[] array = new int[size];
  

  The size of an array can be specified by an int only as all arrays are int-indexed. An array can't be created with the size as a long:

  long size = 23L;
  int[] array = new int[size]; // Compile-time error:
                               // incompatible types: possible lossy conversion from
                               // long to int
  

  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 int[3];            // Equivalent to { 0, 0, 0 }
  int[] array4 = null;                  // The array itself is an object, so it
                                        // can be set as null.
  

  When declaring an array, [] may appear as part of the type at the beginning of the declaration (after the type name), or as part of the declarator for a particular variable (after variable name), 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;
  int a, []b, c[][];  /* Compilation Error, because [] is not part of the type at beginning
                         of the declaration, rather it is before 'b'. */    
  // The same rules apply when declaring a method that returns an array:
  int foo()[] { ... } /* equivalent to */  int[] foo() { ... }
  

  In the following example, both declarations are correct and are able to compile and run without any problems. However, both 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. The same should be used for method return signatures.

  float array[]; /* and */ int foo()[] { ... } /* are discouraged */
  float[] array; /* and */ int[] foo() { ... } /* are encouraged */
  

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

  In Java, it is possible to have arrays of size 0:

  int[] array = new int[0]; // Compiles and runs fine.
  

  However, since it's an empty array, no elements can be assigned to it:

  array[0] = 1; // Throws java.lang.ArrayIndexOutOfBoundsException.
  

  Such empty arrays are typically useful as return values, so that the calling code only has to worry about dealing with an array, rather than a potential null value that may lead to a NullPointerException.

  The length of an array must be a non-negative integer:

  int[] array = new int[-1]; // Throws java.lang.NegativeArraySizeException
  

  The array size can be determined using a public final field called length:

  System.out.println(array.length); // Prints 0 in this case.
  

  Note: array.length returns the actual size of the array and not the number of array elements which were assigned a value, unlike ArrayList#size() which returns the number of array elements which were assigned a value.

  Creating and initializing multi-dimensional arrays

  The simplest way to create a multi-dimensional array is as follows:

  int[][] a = new int[2][3];
  

  It will create two three-length int arrays—a[0] and a[1]. This is very similar to the classical, C-style initialization of rectangular multi-dimensional arrays.

  You can create and initialize at the same time:

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

  Unlike C, where only rectangular multi-dimensional arrays are supported, inner arrays do not need to be of the same length:

  int[][] a = { {1}, {2,3}, null };
  

  Here, a[0] is a one-length int array, whereas a[1] is a two-length int array and a[2] is null. Arrays like this are called jagged arrays or ragged arrays, that is, they are arrays of arrays. Multi-dimensional arrays in Java are implemented as arrays of arrays, i.e. array[i][j][k] is equivalent to ((array[i])[j])[k]. Unlike C#, the syntax array[i,j] is not supported in Java.

  Multidimensional array representation in Java

  

  Source - Live on Ideone

  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

  In addition to the String literals and primitives shown above, the shortcut syntax for array initialization also works with canonical Object types:

  Object[] array10 = { new Object(), new Object() };
  

  An array can be initialized with zero elements by using String[] emptyArray = new String[0]. For example, an array with zero length like 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.

  Creating and initializing generic type arrays

  In generic classes, arrays of generic types cannot be initiated like so due to type erasure:

  public class MyGenericClass<T> {
      private T[] a;
  
      public MyGenericClass() {
          a = new T[5]; // Compile time error: generic array creation
      }
  }
  

  Instead, they can be created using one of the following methods:

  1. By creating an Object array, and casting it to the generic type:

     a = (T[])new Object[5];
     

     This is the simplest method, but since the underlying array is still of type Object[], this method does not provide type safety, so the array is best used only within the generic class, not exposed publicly.

  2. By using Array.newInstance with a class parameter:

     public MyGenericClass(Class<T> clazz) {
         a = (T[]) Array.newInstance(clazz, 5);
     }
     

     Here the class of T has to be explicitly passed to the constructor. The return type of Array.newInstance is always Object. However, the newly created array is in fact of type T[], and can be safely externalized.

  Filling an array after initialization

  Java SE 1.2

  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 all of its elements to their respective 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

  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:

  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 }
  

  Java SE 1.0

  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:

  // First initialization of array
  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.
  array = new int[] { 4, 5, 6 };
  
  // Prints "4 5 6 ".
  for (int i : array) {
      System.out.print(i + " ");
  }
  
  array = { 1, 2, 3, 4 }; // Compile-time error! Can't re-initialize an array via shortcut 
                          // syntax with array initializer.
  

  Live on Ideone

  ---

  Array initialization syntax when not in a declaration

  You can declare an array like

  AClass[] array = {object1, object2};
  

  and

  AClass[] array = new AClass[2];
  ...
  array[0] = object1;
  array[1] = object2;
  

  But you cannot write

  AClass[] array;
  ...
  array = {object1, object2};
  

  because it is blocked by Java and there might be some subtle grammatical reason for the restriction. Note that some of the array creation / initialization constructs were not in Java 1.0, and (IIRC) were added in Java 1.1. You can find more about this here.

  Sorted Arrays Pros and Cons:

  Pros:

  1. Access to an element is fast using the index - access time is O(1).
  2. Much faster to process - see this question.

  Cons:

  1. Insertion and deletion are slow, subsequent elements must be moved - complexity for insertion in that case is O(n).
  2. A large enough block of memory is needed to hold the array.
  3. Easily corrupted (data could be inserted in the middle).

  edited yesterday

  

  

  

  

  

  +146
• 105

  Creating a List from an Array

  edit move example delete share

  105

  Array vs List

  	Array	List
  Size	Fixed length. Cannot change the size after creation	Dynamic in size. Capacity grows as the elements are added
  Content	Can contain primitive data types and objects	Objects only. No primitive data types
  Dimension	Can be multi-dimensional	Always single-dimensional
  Type-Safety	Typesafe, meaning that array will contain objects of specific class or primitives of specific data type	Not type safe by default. Generics can be used to make a List type safe
  Insertion/Deletion	Shifting existing elements may be needed if action is performed not at the end of the array	Easy insertion/deletion methods provided

  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: 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. This means the type information can be left out 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.

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

  A point worth noting about the Diamond Operator is that it cannot be used with Anonymous Classes.

  Java SE 8

  // Using Streams
  
  int[] ints = {1, 2, 3};
  List<Integer> list = Arrays.stream(ints).boxed().collect(Collectors.toList());
  
  String[] stringArray = new String[] {"foo", "bar", "baz"};
  List<Object> list = Arrays.stream(stringArray).collect(Collectors.toList());
  

  ---

  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 of 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 original array-backed List to the constructor of a new List. This creates a new copy of the data, which is not of fixed-size anymore, but also not backed by the original 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 behavior 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, this will print false:

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

    View Demo

    On the other hand, this will print true:

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

    View Demo

  edited 2 days ago

  

  

  

  

  

  +43
• 45

  Creating an Array from a Collection

  edit move example delete share

  45

  There are two methods of creating an array from a collection 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);
  
  // although a set was of type Integer, a returned array is of type Object
  Object[] objectArray = set.toArray();
  

  Live demo

  <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.
   * Only its type matters.
  **/
  Integer[] integerArray = set.toArray(new Integer[0]);  
  
  List<String> list = new ArrayList<String>();
  list.add("android");
  list.add("apple");
  
  // toArray() method here uses generics, so the returned array is of type String
  String[] stringArray = list.toArray(new String[list.size()]);
  

  Live demo

  ---

  The difference between them is more than just having untyped vs typed results. Their performance odds too (for details please read this performance analysis section):

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

  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 method.

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

  Examples taken from two answers (1, 2) to Converting 'ArrayList to 'String[]' in Java on Stack Overflow.

  edited Aug 2 at 19:06

  

  

  

  

  

  +13
• 19

  Multidimensional and Jagged Arrays

  edit move example delete share

  19

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

  The declaration of multidimensional array can be done by adding [] for each dimension to a regular array decleration. 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.

  ---

  To define a 2-dimensional array with three rows and three columns:

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

  The array can be indexed and assign values to it with this construct. 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;
  

  It is also possible to instantiate a 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 although it is possible to define any dimension of jagged array, 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];
  

  How Multidimensional Arrays are represented in Java

  

  ^{Image source: http://math.hws.edu/eck/cs124/javanotes3/c8/s5.html}

  ---

  Jagged array literal intialization

  Multidimensional arrays and jagged 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}
  };
  

  Note: Jagged subarrays may also be null. For instance, the following code declares and populates a two dimensional int array whose first subarray is null, second subarray is of zero length, third subarray is of one length and the last subarray is a two length array:

  int[][] table = {
      null,
      {},
      {1},
      {1,2}
  };
  

  edited Aug 11 at 20:36

  

  

  

  

  

  +9
• 14

  ArrayIndexOutOfBoundsException

  edit move example delete share

  14

  The ArrayIndexOutOfBoundsException is thrown when a non-existing index of an array is being accessed.

  Arrays are zero-based indexed, so the index of the first element is 0 and the index of the last element is the array capacity minus 1 (i.e. array.length - 1).

  Therefore, any request for an array element by the index i has to satisfy the condition 0 <= i < array.length, otherwise the ArrayIndexOutOfBoundsException will be thrown.

  ---

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

  String[] people = new String[] { "Carol", "Andy" };
  
  // An array will be created:
  // people[0]: "Carol"
  // people[1]: "Andy"
  
  // Notice: no item on index 2. Trying to access it triggers the exception:
  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)
  

  Note that the illegal index that is being accessed is also included in the exception (2 in the example); this information could be useful to find the cause of the exception.

  ---

  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 Aug 4 at 20:10

  

  

  

  

  

  +13
• 12

  Arrays to Stream

  edit move example delete share

  12

  Java SE 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 31 at 6:11

  

  

  

  

  

  +1
• 11

  Iterating over arrays

  edit move example delete share

  11

  You can iterate over arrays either by using enhanced for loop (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;
  }
  

  Java SE 5

  // 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 to obtain an Iterable object.

  For boxed arrays use Arrays.asList:

  Integer[] boxed = {1, 2, 3};
  Iterable<Integer> boxedIt = Arrays.asList(boxed); // list-backed iterable
  Iterator<Integer> fromBoxed1 = boxedIt.iterator();
  

  For primitive arrays (using java 8) use streams (specifically in this example - Arrays.stream -> IntStream):

  int[] primitives = {1, 2, 3};
  IntStream primitiveStream = Arrays.stream(primitives); // list-backed iterable
  PrimitiveIterator.OfInt fromPrimitive1 = primitiveStream.iterator();
  

  If you can't use streams (no java 8), you can choose to use google's guava library:

  Iterable<Integer> fromPrimitive2 = Ints.asList(primitives);
  

  ---

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

  Java SE 5

  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 THIS :
      for (int i = 0; i < numbers.length; i++) {
          numbers[i] += 1; //or this: numbers[i] = numbers[i] + 1; or numbers[i]++;      
      }
   
      // DON'T DO THIS :
      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 THIS :
      for (int i = 0; i < array.length; i++) {
          array[i] = i * 2;
      }
   
      // DON'T DO THIS :
      int doubleLength = array.length * 2;
      for (int i = 0; i < doubleLength; i += 2) {
          array[i/2] = i;
      }
  }
  

  Accessing Arrays in reverse order

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

  Using temporary Arrays to reduce code repetition

  Iterating over a temporary array instead of repeating code can make your code cleaner. It can be used where the same operation is performed on multiple variables.

  // we want to print out all of these
  String name = "Margaret";
  int eyeCount = 16;
  double height = 50.2;
  int legs = 9;
  int arms = 5;
  
  
  // copy-paste approach:
  System.out.println(name);
  System.out.println(eyeCount);
  System.out.println(height);
  System.out.println(legs);
  System.out.println(arms);
  
  
  // temporary array approach:
  for(Object attribute : new Object[]{ name, eyeCount, height, legs, arms })
      System.out.println(attribute);
  
  // using only numbers
  for(double number : new double[]{ eyeCount, legs, arms, height })
      System.out.println( Math.sqrt(number) );
  

  Keep in mind that this code should not be used in performance-critical sections, as an array is created every time the loop is entered.

  edited Aug 3 at 12:55

  

  

  

  

  

  +6
• 10

  Arrays to a String

  edit move example delete share

  10

  Java SE 5

  Since Java 1.5 you can get a String representation of the contents of the specified array without iterating over its every element. Just use Arrays.toString(Object[]) or Arrays.deepToString(Object[]) for multidimentional 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]]
  

  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 Aug 3 at 12:55

  

  

  

  

  

  +4
• 9

  Array Covariance

  edit move example delete share

  9

  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
  

  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.
  

  edited Jul 28 at 12:56

  

  
• 7

  Finding an element in the Array

  edit move example delete share

  7

  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 Jul 25 at 21:32

  

  

  

  

  

  +3
• 7

  Test if an array contains an element

  edit move example delete share

  7

  ---

  Non-primitive array

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

  String[] array = new String[] e{"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 Jul 31 at 6:11

  

  

  

  

  

  +4
• 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];
  }
  

  Java SE 5

  Or for-each loop using auto-created iterator:

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

  edited Jul 27 at 7:26

  

  

  

  

  

  +4
• 5

  Copying arrays

  edit move example delete share

  5

  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 Object.clone method for an array performs a shallow copy, i.e. it 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]
  

  Note that Arrays.copyOf also provides an overload which allows you to change the type of the array:

  Double[] doubles = { 1.0, 2.0, 3.0 };
  Number[] numbers = Arrays.copyOf(doubles, doubles.length, Number[].class);
  

  ---

  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 Aug 11 at 15:54

  

  

  

  

  

  +3
• 5

  Getting the Length of an Array

  edit move example delete share

  5

  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 Jul 26 at 16:15

  

  

  

  

  
• 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
• 3

  Arrays in Memory

  edit move example delete share

  3

  How arrays are stored in memory

  In memory Java arrays either store primitive data types or references. When an array of n elements is initialized, the size of the arrays datatype * n space in allocated in memory on the heap. Thus references of all elements in an array are stored consecutively one after the other in memory.

  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. This is generally an automated process, involving no effort from the developer.

  In the example above, when array is assigned to new int[] { 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 Jul 29 at 16:49

  
• 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);
  

  Java SE provides the method Arrays.copyOf(original, newLength, newType) for this purpose:

  Double[] doubles = { 1.0, 2.0, 3.0 };
  Number[] numbers = Arrays.copyOf(doubles, doubles.length, Number[].class);
  

  edited Aug 3 at 12:55

  

  

  

  

  

  +1
• 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

  Converting an Array of Objects to an Array of primitives

  edit move example delete share

  3

  Java SE 8

  Integer[] integerArray = new Integer[]{1, 2, 3, 4, 5};
  int[] intArray = new int[integerArray.length];
  int len = integerArray.length;
  for (int i = 0; i < len; ++i) {
      intArray[i] = integerArray[i];
  }
  

  Java SE 8

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

  edited Aug 2 at 16:09

  

  

  
• 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

  

  
• 3

  Reversing an array

  edit move example delete share

  3

  In this simple example we reverse an array of Strings, but you can use this pattern to reverse any type of an array in Java.

  import java.util.Arrays;
  
      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:");
              System.out.println(Arrays.toString(names));
  
              reverseArray(names);
              
              System.out.println("Reversed array:");
              System.out.println(Arrays.toString(names));
          }
  
          static void reverseArray(Object[] array) {
              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;
              }
          }
      }
  

  ---

  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
  }
  

  Note: This method doesn't work on arrays of primitives (int[], double[], ...).

  edited Aug 8 at 4:38

  

  

  

  

  

  +1
• 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 Jul 24 at 7:54

  

  

  

  
• 2

  Sorting arrays

  edit move example delete share

  2

  Sorting arrays can be easily done with the Arrays api.

  import java.util.Arrays;
  
  // creating an array with integers
  int[] array = {7, 4, 2, 1, 19};
  // this is the sorting part just one function ready to be used
  Arrays.sort(array);
  // prints [1, 2, 4, 7, 19]
  System.out.println(Arrays.toString(array));
  

  ---

  Sorting String arrays:

  String is not a numeric data, it defines it's own order which is called lexicographic order, also known as alphabetic order. When you sort an array of String using sort() method, it sorts array into natural order defined by Comparable interface, as shown below :

  Increasing Order

  String[] names = {"John", "Steve", "Shane", "Adam", "Ben"};
  System.out.println("String array before sorting : " + Arrays.toString(names));
  Arrays.sort(names); 
  System.out.println("String array after sorting in ascending order : " + Arrays.toString(names));
  

  Output:

  String array before sorting : [John, Steve, Shane, Adam, Ben]

  String array after sorting in ascending order : [Adam, Ben, John, Shane, Steve]

  Decreasing Order

  Arrays.sort(names, 0, names.length, Collections.reverseOrder());
  System.out.println("String array after sorting in descending order : " + Arrays.toString(names));
  

  Output:

  String array after sorting in descending order : [Steve, Shane, John, Ben, Adam]

  ---

  Sorting an Object array

  In order to sort an object array, all elements must implement either Comparable or Comparator interface to define the order of the sorting.

  We can use either sort(Object[]) method to sort an object array on its natural order, but you must ensure that all elements in the array must implement Comparable.

  Furthermore, they must be mutually comparable as well, for example e1.compareTo(e2) must not throw a ClassCastException for any elements e1 and e2 in the array. Alternatively you can sort an Object array on custom order using sort(T[], Comparator) method as shown in following example.

  // How to Sort Object Array in Java using Comparator and Comparable
  Course[] courses = new Course[4];
  courses[0] = new Course(101, "Java", 200);
  courses[1] = new Course(201, "Ruby", 300);
  courses[2] = new Course(301, "Python", 400);
  courses[3] = new Course(401, "Scala", 500);
         
  System.out.println("Object array before sorting : " + Arrays.toString(courses));
         
  Arrays.sort(courses);
  System.out.println("Object array after sorting in natural order : " + Arrays.toString(courses));
         
  Arrays.sort(courses, new Course.PriceComparator());
  System.out.println("Object array after sorting by price : " + Arrays.toString(courses));
         
  Arrays.sort(courses, new Course.NameComparator());
  System.out.println("Object array after sorting by name : " + Arrays.toString(courses));
  

  Output:

  Object array before sorting : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 , #401 Scala@500 ]

  Object array after sorting in natural order : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 , #401 Scala@500 ]

  Object array after sorting by price : [#101 Java@200 , #201 Ruby@300 , #301 Python@400 , #401 Scala@500 ]

  Object array after sorting by name : [#101 Java@200 , #301 Python@400 , #201 Ruby@300 , #401 Scala@500 ]

  edited Jul 30 at 14:21

  

  

  

  

  

  +1
• 1

  Converting arrays between primitives and boxed types

  edit move example delete share

  1

  Sometimes conversion of primitive types to boxed types is necessary. A common example is Arrays.asList which works differently for primitive/boxed arrays:

  Arrays of boxed types work as expected:

  List<Integer> boxed = Arrays.asList(1, 2, 3);
  

  While primitive arrays the return type is a single-element list with the entire array:

  List<int[]> primitives = Arrays.asList(new int[]{1, 2, 3});
  

  To convert the array, it's possible to use streams (java 8 and above):

  Java SE 8

  int[] arr = {1,2,3,4};
  List<Integer> list = Arrays.stream(arr).boxed().collect(Collectors.toList());
  System.out.println(list.toString());
  

  With lower versions it can be more explicitly done by iteration:

  Java SE 6

  int[] arr = {1,2,3,4};
  List<Integer> list = new ArrayList<Integer>(arr.length);
  for (int item : arr) {
      list.add(item);
  }
  
  System.out.println(list.toString());
  

  edited Aug 4 at 12:48