Java/Collections Data Structure/Array

Array 2D

   
/*
 * Copyright (c) Ian F. Darwin, http://www.darwinsys.ru/, 1996-2002.
 * All rights reserved. Software written by Ian F. Darwin and others.
 * $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS""
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 * 
 * Java, the Duke mascot, and all variants of Sun"s Java "steaming coffee
 * cup" logo are trademarks of Sun Microsystems. Sun"s, and James Gosling"s,
 * pioneering role in inventing and promulgating (and standardizing) the Java 
 * language and environment is gratefully acknowledged.
 * 
 * The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for
 * inventing predecessor languages C and C++ is also gratefully acknowledged.
 */
public class Array2D {
  public static void main(String[] args) {
    int[][] data;
    data = new int[10][];
    data[0] = new int[5];
    data[1] = new int[20];
    System.out.println("data.length = " + data.length);
    System.out.println("data[0].length = " + data[0].length);
    System.out.println("data[1].length = " + data[1].length);
  }
}

Array Copy Demo

   
/*
 * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * -Redistribution of source code must retain the above copyright notice, this
 *  list of conditions and the following disclaimer.
 *
 * -Redistribution in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *
 * Neither the name of Sun Microsystems, Inc. or the names of contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 *
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
 * ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
 * OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MIDROSYSTEMS, INC. ("SUN")
 * AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE
 * AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
 * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
 * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
 * INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY
 * OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
 * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 *
 * You acknowledge that this software is not designed, licensed or intended
 * for use in the design, construction, operation or maintenance of any
 * nuclear facility.
 */
public class ArrayCopyDemo {
  public static void main(String[] args) {
    char[] copyFrom = { "d", "e", "c", "a", "f", "f", "e", "i", "n", "a",
        "t", "e", "d" };
    char[] copyTo = new char[7];
    System.arraycopy(copyFrom, 2, copyTo, 0, 7);
    System.out.println(new String(copyTo));
  }
}

Array Hunt game

   
/*
 * Copyright (c) Ian F. Darwin, http://www.darwinsys.ru/, 1996-2002.
 * All rights reserved. Software written by Ian F. Darwin and others.
 * $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS""
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 * 
 * Java, the Duke mascot, and all variants of Sun"s Java "steaming coffee
 * cup" logo are trademarks of Sun Microsystems. Sun"s, and James Gosling"s,
 * pioneering role in inventing and promulgating (and standardizing) the Java 
 * language and environment is gratefully acknowledged.
 * 
 * The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for
 * inventing predecessor languages C and C++ is also gratefully acknowledged.
 */
import java.util.Arrays;
import java.util.Random;
/**
 * Array Hunt "game" (pathetic: computer plays itself).
 * 
 * @author Ian Darwin
 * @version $Id: ArrayHunt.java,v 1.3 2004/03/08 00:11:18 ian Exp $
 */
public class ArrayHunt {
  /** the maximum (and actual) number of random ints to allocate */
  protected final static int MAX = 4000;
  /** the value to look for */
  protected final static int NEEDLE = 1999;
  int[] haystack;
  Random r;
  public static void main(String[] argv) {
    ArrayHunt h = new ArrayHunt();
    if (argv.length == 0)
      h.play();
    else {
      int won = 0;
      int games = Integer.parseInt(argv[0]);
      for (int i = 0; i < games; i++)
        if (h.play())
          ++won;
      System.out
          .println("Computer won " + won + " out of " + games + ".");
    }
  }
  /** Construct the hunting ground */
  public ArrayHunt() {
    haystack = new int[MAX];
    r = new Random();
  }
  /** Play one game. */
  public boolean play() {
    int i;
    // Fill the array with random data (hay?)
    for (i = 0; i < MAX; i++) {
      haystack[i] = (int) (r.nextFloat() * MAX);
    }
    // Precondition for binary search is that data be sorted!
    Arrays.sort(haystack);
    // Look for needle in haystack
    i = Arrays.binarySearch(haystack, NEEDLE);
    if (i >= 0) { // Found it, we win.
      System.out.println("Value " + NEEDLE + " occurs at haystack[" + i
          + "]");
      return true;
    } else { // Not found, we lose.
      System.out.println("Value " + NEEDLE
          + " does not occur in haystack; nearest value is "
          + haystack[-(i + 2)] + " (found at " + -(i + 2) + ")");
      return false;
    }
  }
}

Array initialization

   
// : c04:ArrayInit.java
// Array initialization.
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
public class ArrayInit {
  public static void main(String[] args) {
    Integer[] a = { new Integer(1), new Integer(2), new Integer(3), };
    Integer[] b = new Integer[] { new Integer(1), new Integer(2),
        new Integer(3), };
  }
} ///:~

Array Initializers

   
public class Main {
  public static void main(String[] args) {
    int[] odds = { 1, 3, 5, 7, 9 };
    System.out.println("odds.length = " + odds.length);
    for (int i = 0; i < odds.length; i++) {
      System.out.println("odds[" + i + "] = " + odds[i]);
    }
    String[] daysOfWeek = { "Saturday", "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
        "Friday" };
    System.out.println("\ndaysOfWeek.length = " + daysOfWeek.length);
    for (int i = 0; i < daysOfWeek.length; i++) {
      System.out.println("daysOfWeek[" + i + "] = " + daysOfWeek[i]);
    }
  }
}

ArrayListDemo done over using an ArrayList

   
/*
 * Copyright (c) Ian F. Darwin, http://www.darwinsys.ru/, 1996-2002.
 * All rights reserved. Software written by Ian F. Darwin and others.
 * $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS""
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 * 
 * Java, the Duke mascot, and all variants of Sun"s Java "steaming coffee
 * cup" logo are trademarks of Sun Microsystems. Sun"s, and James Gosling"s,
 * pioneering role in inventing and promulgating (and standardizing) the Java 
 * language and environment is gratefully acknowledged.
 * 
 * The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for
 * inventing predecessor languages C and C++ is also gratefully acknowledged.
 */
import java.util.ArrayList;
/**
 * ArrayListDemo done over using an ArrayList
 */
public class ArrayListDemo {
  public static void main(String[] argv) {
    ArrayList al = new ArrayList();
    // Create a source of Objects
    StructureDemo source = new StructureDemo(15);
    // Add lots of elements to the ArrayList...
    al.add(source.getDate());
    al.add(source.getDate());
    al.add(source.getDate());
    // First print them out using a for loop.
    System.out.println("Retrieving by index:");
    for (int i = 0; i < al.size(); i++) {
      System.out.println("Element " + i + " = " + al.get(i));
    }
  }
}

Array Of Arrays Demo 2

   
/*
 * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * -Redistribution of source code must retain the above copyright notice, this
 *  list of conditions and the following disclaimer.
 *
 * -Redistribution in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *
 * Neither the name of Sun Microsystems, Inc. or the names of contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 *
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
 * ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
 * OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MIDROSYSTEMS, INC. ("SUN")
 * AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE
 * AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
 * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
 * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
 * INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY
 * OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
 * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 *
 * You acknowledge that this software is not designed, licensed or intended
 * for use in the design, construction, operation or maintenance of any
 * nuclear facility.
 */
public class ArrayOfArraysDemo2 {
  public static void main(String[] args) {
    int[][] aMatrix = new int[4][];
    //populate matrix
    for (int i = 0; i < aMatrix.length; i++) {
      aMatrix[i] = new int[5]; //create sub-array
      for (int j = 0; j < aMatrix[i].length; j++) {
        aMatrix[i][j] = i + j;
      }
    }
    //print matrix
    for (int i = 0; i < aMatrix.length; i++) {
      for (int j = 0; j < aMatrix[i].length; j++) {
        System.out.print(aMatrix[i][j] + " ");
      }
      System.out.println();
    }
  }
}

Arrays of primitives

   
// : c04:Arrays.java
// Arrays of primitives.
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
public class Arrays {
  public static void main(String[] args) {
    int[] a1 = { 1, 2, 3, 4, 5 };
    int[] a2;
    a2 = a1;
    for (int i = 0; i < a2.length; i++)
      a2[i]++;
    for (int i = 0; i < a1.length; i++)
      System.out.println("a1[" + i + "] = " + a1[i]);
  }
} ///:~

Can you change the .length of an array

   
/*
 * Copyright (c) Ian F. Darwin, http://www.darwinsys.ru/, 1996-2002.
 * All rights reserved. Software written by Ian F. Darwin and others.
 * $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS""
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 * 
 * Java, the Duke mascot, and all variants of Sun"s Java "steaming coffee
 * cup" logo are trademarks of Sun Microsystems. Sun"s, and James Gosling"s,
 * pioneering role in inventing and promulgating (and standardizing) the Java 
 * language and environment is gratefully acknowledged.
 * 
 * The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for
 * inventing predecessor languages C and C++ is also gratefully acknowledged.
 */

/**
 * Can you change the .length of an array?
 * @author Ian F. Darwin, http://www.darwinsys.ru/
 * @version $Id: ChangeArrayLength.java,v 1.5 2004/02/09 03:33:53 ian Exp $
 */
public class ChangeArrayLength {
  public static void main(String[] argv) {
    //+
    int[] a = new int[4];
    System.out.println(a.length);
    a.length = 5;  // EXPECT COMPILE ERROR
    //-
  }
}

Clone Array

   
public class CloneArray {
  public static void main(String args[]) {
    int array1[] = { 1, 2, 3, 4, 5 };
    int array2[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    System.out.println("Original size: " + array1.length);
    System.out.println("New size: " + cloneArray(array1).length);
    System.out.println("Original size: " + array2.length);
    System.out.println("New size: " + cloneArray(array2).length);
  }
  static int[] cloneArray(int original[]) {
    return (int[]) original.clone();
  }
}

Convert array of primitives into array of objects

   
import org.apache.rumons.lang.ArrayUtils;
public class Main {
  public static void main(String[] args) {
    int numbers[] = { 1, 2, 3, 4, 5 };
    boolean bools[] = { true, false, false, true };
    float decimals[] = { 10.1f, 3.14f, 2.17f };
    Integer numbersObj[] = ArrayUtils.toObject(numbers);
    Boolean boolsObj[] = ArrayUtils.toObject(bools);
    Float decimalsObj[] = ArrayUtils.toObject(decimals);
  }
}

Copy an array

   
public class Main {
  public static void main(String[] args) {
    int[] intArray = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    int[] arrayCopy = new int[intArray.length];
    System.arraycopy(intArray, 0, arrayCopy, 0, intArray.length);
    for (int i = 0; i < arrayCopy.length; i++)
      System.out.println(arrayCopy[i]);
  }
}
/*
1
2
3
4
5
6
7
8
9
0
*/

Copying Elements from One Array to Another

   
public class Main {
  public static void main(String[] argv) throws Exception {
    int[] src = { 1, 2, 3 };
    int[] dst = { 1, 1, 1 };
    System.arraycopy(src, 0, dst, 0, Math.min(src.length, dst.length));
  }
}

Create a repeated sequence of character

   
import java.util.Arrays;
public class Main {
  public static void main(String[] args) {
    char c = "x";
    int length = 10;
    // creates char array with 10 elements
    char[] chars = new char[length];
    // fill each element of chars array with "x"
    Arrays.fill(chars, c);
    // print out the repeated "x"
    System.out.println(String.valueOf(chars));
  }
}

Create multidimension arrays

   
// : c04:MultiDimArray.java
// Creating multidimensional arrays.
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
import java.util.Random;
public class MultiDimArray {
  static Random rand = new Random();
  public static void main(String[] args) {
    int[][] a1 = { { 1, 2, 3, }, { 4, 5, 6, }, };
    for (int i = 0; i < a1.length; i++)
      for (int j = 0; j < a1[i].length; j++)
        System.out.println("a1[" + i + "][" + j + "] = " + a1[i][j]);
    // 3-D array with fixed length:
    int[][][] a2 = new int[2][2][4];
    for (int i = 0; i < a2.length; i++)
      for (int j = 0; j < a2[i].length; j++)
        for (int k = 0; k < a2[i][j].length; k++)
          System.out.println("a2[" + i + "][" + j + "][" + k + "] = "
              + a2[i][j][k]);
    // 3-D array with varied-length vectors:
    int[][][] a3 = new int[rand.nextInt(7)][][];
    for (int i = 0; i < a3.length; i++) {
      a3[i] = new int[rand.nextInt(5)][];
      for (int j = 0; j < a3[i].length; j++)
        a3[i][j] = new int[rand.nextInt(5)];
    }
    for (int i = 0; i < a3.length; i++)
      for (int j = 0; j < a3[i].length; j++)
        for (int k = 0; k < a3[i][j].length; k++)
          System.out.println("a3[" + i + "][" + j + "][" + k + "] = "
              + a3[i][j][k]);
    // Array of nonprimitive objects:
    Integer[][] a4 = { { new Integer(1), new Integer(2) },
        { new Integer(3), new Integer(4) },
        { new Integer(5), new Integer(6) }, };
    for (int i = 0; i < a4.length; i++)
      for (int j = 0; j < a4[i].length; j++)
        System.out.println("a4[" + i + "][" + j + "] = " + a4[i][j]);
    Integer[][] a5;
    a5 = new Integer[3][];
    for (int i = 0; i < a5.length; i++) {
      a5[i] = new Integer[3];
      for (int j = 0; j < a5[i].length; j++)
        a5[i][j] = new Integer(i * j);
    }
    for (int i = 0; i < a5.length; i++)
      for (int j = 0; j < a5[i].length; j++)
        System.out.println("a5[" + i + "][" + j + "] = " + a5[i][j]);
    // Output test
    int ln = 0;
    for (int i = 0; i < a3.length; i++)
      for (int j = 0; j < a3[i].length; j++)
        for (int k = 0; k < a3[i][j].length; k++)
          ln++;
  }
} ///:~

Creating an array of nonprimitive objects

   
// : c04:ArrayClassObj.java
// Creating an array of nonprimitive objects.
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
import java.util.Random;
public class ArrayClassObj {
  static Random rand = new Random();
  public static void main(String[] args) {
    Integer[] a = new Integer[rand.nextInt(20)];
    System.out.println("length of a = " + a.length);
    for (int i = 0; i < a.length; i++) {
      a[i] = new Integer(rand.nextInt(500));
      System.out.println("a[" + i + "] = " + a[i]);
    }
  }
} ///:~

Creating arrays with new

   
// : c04:ArrayNew.java
// Creating arrays with new.
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
import java.util.Random;
public class ArrayNew {
  static Random rand = new Random();
  public static void main(String[] args) {
    int[] a;
    a = new int[rand.nextInt(20)];
    System.out.println("length of a = " + a.length);
    for (int i = 0; i < a.length; i++)
      System.out.println("a[" + i + "] = " + a[i]);
  }
} ///:~

Creating a Two-Dimensional Array

   

/*This example creates a two-dimensional array with 9 rows and a variable number 
of columns for each row. The first row is given 21 columns. The second row is 
given 5000 columns.
*/
public class Test2Darray2 {
  public static void main(String args[]) {
    int[][] multD = new int[9][];
    multD[0] = new int[21];
    multD[1] = new int[5000];
  }
}

Define array for class

   
public class EmployeeTest {
  public static void main(String[] args) {
    Employee[] staff = new Employee[3];
    staff[0] = new Employee("Harry Hacker", 3500);
    staff[1] = new Employee("Carl Cracker", 7500);
    staff[2] = new Employee("Tony Tester", 3800);
    for (int i = 0; i < 3; i++)
      staff[i].print();
  }
}
class Employee {
  private String name;
  private double salary;
  public Employee(String n, double s) {
    name = n;
    salary = s;
  }
  public void print() {
    System.out.println(name + " " + salary);
  }
}

Doubling the size of an array

   
public class DoubleArray {
  public static void main(String args[]) {
    int a1[] = { 1, 2, 3, 4, 5 };
    int a2[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    System.out.println("Original size: " + a1.length);
    System.out.println("New size: " + doubleArray(a1).length);
    System.out.println("Original size: " + a2.length);
    System.out.println("New size: " + doubleArray(a2).length);
  }
  static int[] doubleArray(int original[]) {
    int length = original.length;
    int newArray[] = new int[length * 2];
    System.arraycopy(original, 0, newArray, 0, length);
    return newArray;
  }
}

Dump array content: Convert the array to a List and then convert to String

   
import java.util.Arrays;
public class Main {
  public static void main(String args[]) {
    String s[] = {"a", "b", "c", "d"};
    System.out.println(Arrays.asList(s).toString());
  }
}

Dump multi-dimensional arrays

   
import java.util.Arrays;
public class Main {
  public static void main(String args[]) {
    String s[] = {"a", "b", "c", "d"};
    double d [][]= {
        {0.50, 0.20,  0.20, 0.30},
        {0.50, 1.10,  0.50, 0.80},
        {0.50, 0.70,  0.40},
        {0.50, 0.70},
        {0.50},
    };
    System.out.println(Arrays.toString(s));
    System.out.println(Arrays.deepToString(d));
  }
}

Extend the size of an array

   
public class Main {
  public static void main(String[] args) {
    String[] names = new String[] { "A", "B", "C" };
    String[] extended = new String[5];
    extended[3] = "D";
    extended[4] = "F";
    System.arraycopy(names, 0, extended, 0, names.length);
    for (String str : extended)
      System.out.println(str);
  }
}
/*
A
B
C
D
F
*/

Get array upperbound

   
public class Main {
  public static void main(String args[]) {
    String[][] data = new String[3][4];
    System.out.println("Dimension 1: " + data.length);
    System.out.println("Dimension 2: " + data[0].length);
  }
}
/*
Dimension 1: 3
Dimension 2: 4
*/

Grow array

   
import java.lang.reflect.Array;
public class ArrayGrowTest {
  public static void main(String[] args) {
    int[] a = { 1, 2, 3 };
    a = (int[]) arrayGrow(a);
    arrayPrint(a);
  }
  static Object arrayGrow(Object a) {
    Class cl = a.getClass();
    if (!cl.isArray())
      return null;
    Class componentType = a.getClass().getComponentType();
    int length = Array.getLength(a);
    int newLength = length + 10;
    Object newArray = Array.newInstance(componentType, newLength);
    System.arraycopy(a, 0, newArray, 0, length);
    return newArray;
  }
  static void arrayPrint(Object a) {
    Class cl = a.getClass();
    if (!cl.isArray())
      return;
    Class componentType = a.getClass().getComponentType();
    int length = Array.getLength(a);
    System.out.println(componentType.getName() + "[" + length + "]");
    for (int i = 0; i < length; i++)
      System.out.println(Array.get(a, i));
  }
}

Initialization and re-assignment of arrays

   
// : c11:ArraySize.java
//Initialization & re-assignment of arrays.
//From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
//www.BruceEckel.ru. See copyright notice in CopyRight.txt.
class Weeble {
} // A small mythical creature
public class ArraySize {
  public static void main(String[] args) {
    // Arrays of objects:
    Weeble[] a; // Local uninitialized variable
    Weeble[] b = new Weeble[5]; // Null references
    Weeble[] c = new Weeble[4];
    for (int i = 0; i < c.length; i++)
      if (c[i] == null) // Can test for null reference
        c[i] = new Weeble();
    // Aggregate initialization:
    Weeble[] d = { new Weeble(), new Weeble(), new Weeble() };
    // Dynamic aggregate initialization:
    a = new Weeble[] { new Weeble(), new Weeble() };
    System.out.println("a.length=" + a.length);
    System.out.println("b.length = " + b.length);
    // The references inside the array are
    // automatically initialized to null:
    for (int i = 0; i < b.length; i++)
      System.out.println("b[" + i + "]=" + b[i]);
    System.out.println("c.length = " + c.length);
    System.out.println("d.length = " + d.length);
    a = d;
    System.out.println("a.length = " + a.length);
    // Arrays of primitives:
    int[] e; // Null reference
    int[] f = new int[5];
    int[] g = new int[4];
    for (int i = 0; i < g.length; i++)
      g[i] = i * i;
    int[] h = { 11, 47, 93 };
    // Compile error: variable e not initialized:
    //!System.out.println("e.length=" + e.length);
    System.out.println("f.length = " + f.length);
    // The primitives inside the array are
    // automatically initialized to zero:
    for (int i = 0; i < f.length; i++)
      System.out.println("f[" + i + "]=" + f[i]);
    System.out.println("g.length = " + g.length);
    System.out.println("h.length = " + h.length);
    e = h;
    System.out.println("e.length = " + e.length);
    e = new int[] { 1, 2 };
    System.out.println("e.length = " + e.length);
  }
} ///:~

Initialize a static array

   
public class Main {
  static Integer[] integerArray;
  static {
    integerArray = new Integer[] { new Integer(1), new Integer(2) };
  }
  public static void main(String args[]) {
    for (int i = 0; i < integerArray.length; i++) {
      System.out.println(integerArray[i]);
    }
  }
}

Initialize multidimensional array

   
public class Main {
  static double[][] d = { { 4.6, 8.5, 3.2, 5.1 }, { 6.4, 11.1, 4.1, 6.2 } };
  public static void main(String args[]) {
  }
}

Initializing Array Values

   
/*
This example creates a four element array with 1, 2, 3, 4 as the values. 
The length of the array, and the element at index 2, are printed out.
*/
public class TestArray {
  public static void main(String args[]) {
    int[] data = {
      1, 2, 3, 4
    };
        
    System.out.println("The length of the array is " + data.length);
    System.out.println("The element at index 2 is " + data[2]);
  }
}

Initializing a Two Dimensional Array

   
//A two dimensional array of int values is initialized, and the element 
//at [0][2] is displayed.
public class Test2Darray {
  public static void main(String args[]) {
    int[][] multiD = {
      { 1, 2, 3, 4 },
      { 5, 6, 7 }
    };
    System.out.println("The element at [0][2] is " + multiD[0][2]);
  }
}

Java program to demonstrate multidimensional arrays

   
/*
Java Programming for Engineers
Julio Sanchez
Maria P. Canton

ISBN: 0849308100
Publisher: CRC Press
*/

// File name: MultiArray.java
//Reference: Chapter 6
//
//Java program to demonstrate multidimensional arrays
//Topics:
// 1. Simultaneous declaration and initialization
// 2. Use of the length operator to obtain the size
//    of multidimensional arrays
public class MultiArray {
  // Declare constants
  final static int ROWS = 10;
  final static int COLS = 5;
  public static void main(String[] args) {
    // Local varaibles
    int rowCount;
    int colCount;
    int totalSize;
    // Declare and allocate an array of bytes
    byte[][] screenPix = new byte[ROWS][COLS];
    // Obtain and store array dimensions
    rowCount = screenPix.length;
    colCount = screenPix[COLS].length;
    totalSize = rowCount * colCount;
    // To obtain the total number of elements of a
    // two-dimensional ragged array you need to get the size of
    // each array dimension separately
    // Display array dimensions
    System.out.println("Array row size:    " + rowCount);
    System.out.println("Array column size: " + colCount);
    System.out.println("Total size:        " + totalSize);
    //*************************
    //      ragged arrays
    //*************************
    // First allocate the rows of an array
    byte[][] raggedArray = new byte[5][];
    // Now allocate the columns
    raggedArray[0] = new byte[2];
    raggedArray[1] = new byte[2];
    raggedArray[2] = new byte[4];
    raggedArray[3] = new byte[8];
    raggedArray[4] = new byte[3];
    // The resulting ragged array is as follows:
    //  x x
    //  x x
    //  x x x x
    //  x x x x x x x x
    //  x x x
    //************************************
    //     static array initialization
    //************************************
    byte[][] smallArray = { { 10, 11, 12, 13 }, { 20, 21, 22, 23 },
        { 30, 31, 32, 33 }, { 40, 41, 42, 43 }, };
    // Display the array element at row 2, column 3
    System.out.println(smallArray[1][2]); // Value is 21
  }
}

java.utils.Arrays provides ways to dump the content of an array.

   

import java.util.Arrays;
public class Main {
  public static void main(String args[]) {
    String s[] = {"a", "b", "c", "d"};
    double d [][]= {
        {0.50, 0.20,  0.20, 0.30},
        {0.50, 1.10,  0.50, 0.80},
        {0.50, 0.70,  0.40},
        {0.50, 0.70},
        {0.50},
    };
    System.out.println(Arrays.toString(s));
    System.out.println(Arrays.deepToString(d));
  }
}

Multi Dimension Array

   
public class MultiArray1 {
  public static void main(String args[]) {
    //      int array[][] = {{1,2,3}, {4,5,6}, {7,8,9}};
    //      int []array[] = {{1,2,3}, {4,5,6}, {7,8,9}};
    //      System.out.println(array[0][0]);
    //      System.out.println(array[1][0]);
    //      System.out.println(array[2][0]);
    //      System.out.println([0][0]array);
    //      System.out.println([1][0]array);
    //      System.out.println([2][0]array);
    Object events[][] = { { new Integer(1452), new String("Italy") },
        { new Integer(1472), new String("b.jpg") },
        { new Integer(1483), new String("Hr") },
        { new Integer(1495), new String("Pte") },
        { new Integer(1503), new String("m.jpg") },
        { new Integer(1519), new String("F") } };
  }
}

Multiply two matrices

   
/**
 * Multiply two matrices.
 * Only defined for int: TODO: rewrite using 1.5 Generics to add 
 * support for long, float, and double.
 * @author Ian F. Darwin, http://www.darwinsys.ru/
 * @version $Id: Matrix.java,v 1.4 2004/03/07 02:53:53 ian Exp $
 */
public class Matrix {
  /* Matrix-multiply two arrays together.
   * The arrays MUST be rectangular.
   * @author Tom Christiansen & Nathan Torkington, Perl Cookbook version.
   */
  public static int[][] multiply(int[][] m1, int[][] m2) {
    int m1rows = m1.length;
    int m1cols = m1[0].length;
    int m2rows = m2.length;
    int m2cols = m2[0].length;
    if (m1cols != m2rows)
      throw new IllegalArgumentException("matrices don"t match: " + m1cols + " != " + m2rows);
    int[][] result = new int[m1rows][m2cols];
    // multiply
    for (int i=0; i<m1rows; i++)
      for (int j=0; j<m2cols; j++)
        for (int k=0; k<m1cols; k++)
        result[i][j] += m1[i][k] * m2[k][j];
    return result;
  }
  /** Matrix print.
   */
  public static void mprint(int[][] a) {
    int rows = a.length;
    int cols = a[0].length;
    System.out.println("array["+rows+"]["+cols+"] = {");
    for (int i=0; i<rows; i++) {
      System.out.print("{");
      for (int j=0; j<cols; j++)
        System.out.print(" " + a[i][j] + ",");
      System.out.println("},");
    }
    System.out.println(":;");
  }
  public static void main(String[] argv) {
    //+
    int x[][] = {
      { 3, 2, 3 },
      { 5, 9, 8 },
    };
    int y[][] = {
      { 4, 7 },
      { 9, 3 },
      { 8, 1 },
    };
    int z[][] = Matrix.multiply(x, y);
    Matrix.mprint(x);
    Matrix.mprint(y);
    Matrix.mprint(z);
    //-
  }
}

Reinitializes a byte array

  
/*
 * $RCSfile: ArrayUtil.java,v $
 * $Revision: 1.1 $
 * $Date: 2005/02/11 05:02:24 $
 * $State: Exp $
 *
 * Class:                   ArrayUtil
 *
 * Description:             Utillities for arrays.
 *
 *
 *
 * COPYRIGHT:
 *
 * This software module was originally developed by Raphaël Grosbois and
 * Diego Santa Cruz (Swiss Federal Institute of Technology-EPFL); Joel
 * Askelöf (Ericsson Radio Systems AB); and Bertrand Berthelot, David
 * Bouchard, Félix Henry, Gerard Mozelle and Patrice Onno (Canon Research
 * Centre France S.A) in the course of development of the JPEG2000
 * standard as specified by ISO/IEC 15444 (JPEG 2000 Standard). This
 * software module is an implementation of a part of the JPEG 2000
 * Standard. Swiss Federal Institute of Technology-EPFL, Ericsson Radio
 * Systems AB and Canon Research Centre France S.A (collectively JJ2000
 * Partners) agree not to assert against ISO/IEC and users of the JPEG
 * 2000 Standard (Users) any of their rights under the copyright, not
 * including other intellectual property rights, for this software module
 * with respect to the usage by ISO/IEC and Users of this software module
 * or modifications thereof for use in hardware or software products
 * claiming conformance to the JPEG 2000 Standard. Those intending to use
 * this software module in hardware or software products are advised that
 * their use may infringe existing patents. The original developers of
 * this software module, JJ2000 Partners and ISO/IEC assume no liability
 * for use of this software module or modifications thereof. No license
 * or right to this software module is granted for non JPEG 2000 Standard
 * conforming products. JJ2000 Partners have full right to use this
 * software module for his/her own purpose, assign or donate this
 * software module to any third party and to inhibit third parties from
 * using this software module for non JPEG 2000 Standard conforming
 * products. This copyright notice must be included in all copies or
 * derivative works of this software module.
 *
 * Copyright (c) 1999/2000 JJ2000 Partners.
 *
 *
 *
 */

/**
 * This class contains a colleaction of utility static methods for arrays.
 * */
public class ArrayUtil {
    /** The maximum array size to do element by element copying, larger
     * arrays are copyied in a n optimized way. */
    public static final int MAX_EL_COPYING = 8;
    /** The number of elements to copy initially in an optimized array copy */
    public static final int INIT_EL_COPYING = 4;
    /**
     * Reinitializes an int array to the given value in an optimized way. If
     * the length of the array is less than MAX_EL_COPYING, then the array
     * is set element by element in the normal way, otherwise the first
     * INIT_EL_COPYING elements are set element by element and then
     * System.arraycopy is used to set the other parts of the array.
     *
     * @param arr The array to set.
     *
     * @param val The value to set the array to.
     *
     *
     * */
    public static void intArraySet(int arr[], int val) {
        int i,len,len2;
        len = arr.length;
        // Set array to "val" in an optimized way
        if (len < MAX_EL_COPYING) {
            // Not worth doing optimized way
            for (i=len-1; i>=0; i--) { // Set elements
                arr[i] = val;
            }
        }
        else { // Do in optimized way
            len2 = len>>1;
            for (i=0; i<INIT_EL_COPYING; i++) { // Set first elements
                arr[i] = val;
            }
            for (; i <= len2 ; i<<=1) {
                // Copy values doubling size each time
                System.arraycopy(arr,0,arr,i,i);
            }
            if (i < len) { // Copy values to end
                System.arraycopy(arr,0,arr,i,len-i);
            }
        }
    }
    /**
     * Reinitializes a byte array to the given value in an optimized way. If
     * the length of the array is less than MAX_EL_COPYING, then the array
     * is set element by element in the normal way, otherwise the first
     * INIT_EL_COPYING elements are set element by element and then
     * System.arraycopy is used to set the other parts of the array.
     *
     * @param arr The array to set.
     *
     * @param val The value to set the array to.
     *
     *
     * */
    public static void byteArraySet(byte arr[], byte val) {
        int i,len,len2;
        len = arr.length;
        // Set array to "val" in an optimized way
        if (len < MAX_EL_COPYING) {
            // Not worth doing optimized way
            for (i=len-1; i>=0; i--) { // Set elements
                arr[i] = val;
            }
        }
        else { // Do in optimized way
            len2 = len>>1;
            for (i=0; i<INIT_EL_COPYING; i++) { // Set first elements
                arr[i] = val;
            }
            for (; i <= len2 ; i<<=1) {
                // Copy values doubling size each time
                System.arraycopy(arr,0,arr,i,i);
            }
            if (i < len) { // Copy values to end
                System.arraycopy(arr,0,arr,i,len-i);
            }
        }
    }
}

Reinitializes an int array

  
/*
 * $RCSfile: ArrayUtil.java,v $
 * $Revision: 1.1 $
 * $Date: 2005/02/11 05:02:24 $
 * $State: Exp $
 *
 * Class:                   ArrayUtil
 *
 * Description:             Utillities for arrays.
 *
 *
 *
 * COPYRIGHT:
 *
 * This software module was originally developed by Raphaël Grosbois and
 * Diego Santa Cruz (Swiss Federal Institute of Technology-EPFL); Joel
 * Askelöf (Ericsson Radio Systems AB); and Bertrand Berthelot, David
 * Bouchard, Félix Henry, Gerard Mozelle and Patrice Onno (Canon Research
 * Centre France S.A) in the course of development of the JPEG2000
 * standard as specified by ISO/IEC 15444 (JPEG 2000 Standard). This
 * software module is an implementation of a part of the JPEG 2000
 * Standard. Swiss Federal Institute of Technology-EPFL, Ericsson Radio
 * Systems AB and Canon Research Centre France S.A (collectively JJ2000
 * Partners) agree not to assert against ISO/IEC and users of the JPEG
 * 2000 Standard (Users) any of their rights under the copyright, not
 * including other intellectual property rights, for this software module
 * with respect to the usage by ISO/IEC and Users of this software module
 * or modifications thereof for use in hardware or software products
 * claiming conformance to the JPEG 2000 Standard. Those intending to use
 * this software module in hardware or software products are advised that
 * their use may infringe existing patents. The original developers of
 * this software module, JJ2000 Partners and ISO/IEC assume no liability
 * for use of this software module or modifications thereof. No license
 * or right to this software module is granted for non JPEG 2000 Standard
 * conforming products. JJ2000 Partners have full right to use this
 * software module for his/her own purpose, assign or donate this
 * software module to any third party and to inhibit third parties from
 * using this software module for non JPEG 2000 Standard conforming
 * products. This copyright notice must be included in all copies or
 * derivative works of this software module.
 *
 * Copyright (c) 1999/2000 JJ2000 Partners.
 *
 *
 *
 */

/**
 * This class contains a colleaction of utility static methods for arrays.
 * */
public class ArrayUtil {
    /** The maximum array size to do element by element copying, larger
     * arrays are copyied in a n optimized way. */
    public static final int MAX_EL_COPYING = 8;
    /** The number of elements to copy initially in an optimized array copy */
    public static final int INIT_EL_COPYING = 4;
    /**
     * Reinitializes an int array to the given value in an optimized way. If
     * the length of the array is less than MAX_EL_COPYING, then the array
     * is set element by element in the normal way, otherwise the first
     * INIT_EL_COPYING elements are set element by element and then
     * System.arraycopy is used to set the other parts of the array.
     *
     * @param arr The array to set.
     *
     * @param val The value to set the array to.
     *
     *
     * */
    public static void intArraySet(int arr[], int val) {
        int i,len,len2;
        len = arr.length;
        // Set array to "val" in an optimized way
        if (len < MAX_EL_COPYING) {
            // Not worth doing optimized way
            for (i=len-1; i>=0; i--) { // Set elements
                arr[i] = val;
            }
        }
        else { // Do in optimized way
            len2 = len>>1;
            for (i=0; i<INIT_EL_COPYING; i++) { // Set first elements
                arr[i] = val;
            }
            for (; i <= len2 ; i<<=1) {
                // Copy values doubling size each time
                System.arraycopy(arr,0,arr,i,i);
            }
            if (i < len) { // Copy values to end
                System.arraycopy(arr,0,arr,i,len-i);
            }
        }
    }
    /**
     * Reinitializes a byte array to the given value in an optimized way. If
     * the length of the array is less than MAX_EL_COPYING, then the array
     * is set element by element in the normal way, otherwise the first
     * INIT_EL_COPYING elements are set element by element and then
     * System.arraycopy is used to set the other parts of the array.
     *
     * @param arr The array to set.
     *
     * @param val The value to set the array to.
     *
     *
     * */
    public static void byteArraySet(byte arr[], byte val) {
        int i,len,len2;
        len = arr.length;
        // Set array to "val" in an optimized way
        if (len < MAX_EL_COPYING) {
            // Not worth doing optimized way
            for (i=len-1; i>=0; i--) { // Set elements
                arr[i] = val;
            }
        }
        else { // Do in optimized way
            len2 = len>>1;
            for (i=0; i<INIT_EL_COPYING; i++) { // Set first elements
                arr[i] = val;
            }
            for (; i <= len2 ; i<<=1) {
                // Copy values doubling size each time
                System.arraycopy(arr,0,arr,i,i);
            }
            if (i < len) { // Copy values to end
                System.arraycopy(arr,0,arr,i,len-i);
            }
        }
    }
}

Resize an array, System.arraycopy()

   
import java.lang.reflect.Array;
public class Main {
  public static void main(String arg[]) {
    String[] s = (String[]) expand(new String[20]);
    System.out.println(s.length);
  }
  public static Object expand(Object a) {
    Class cl = a.getClass();
    if (!cl.isArray())
      return a;
    int length = Array.getLength(a);
    int newLength = 1000;
    Class componentType = a.getClass().getComponentType();
    Object newArray = Array.newInstance(componentType, newLength);
    System.arraycopy(a, 0, newArray, 0, length);
    return newArray;
  }
}

Reverse array elements order

   
 
import org.apache.rumons.lang.ArrayUtils;
public class Main {
  public static void main(String[] args) {
    String[] colors = { "Red", "Green", "Blue", "Cyan", "Yellow", "Magenta" };
    System.out.println(ArrayUtils.toString(colors));
    ArrayUtils.reverse(colors);
    System.out.println(ArrayUtils.toString(colors));
  }
}

Show Two-Dimensional Array of Objects

   
/*
 * Copyright (c) Ian F. Darwin, http://www.darwinsys.ru/, 1996-2002.
 * All rights reserved. Software written by Ian F. Darwin and others.
 * $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS""
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 * 
 * Java, the Duke mascot, and all variants of Sun"s Java "steaming coffee
 * cup" logo are trademarks of Sun Microsystems. Sun"s, and James Gosling"s,
 * pioneering role in inventing and promulgating (and standardizing) the Java 
 * language and environment is gratefully acknowledged.
 * 
 * The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for
 * inventing predecessor languages C and C++ is also gratefully acknowledged.
 */
/** Show Two-Dimensional Array of Objects */
public class ArrayTwoDObjects {
  /** Return list of subscript names (unrealistic; just for demo). */
  public static String[][] getArrayInfo() {
    String info[][];
    info = new String[10][10];
    for (int i=0; i < info.length; i++) {
      for (int j = 0; j < info[i].length; j++) {
        info[i][j] = "String[" + i + "," + j + "]";
      }
    }
    return info;
  }
  /** Return list of allowable parameters (Applet method). */
  public static String[][] getParameterInfo() {
    String param_info[][] = {
      {"fontsize",    "9-18",    "Size of font"},
      {"URL",    "-",    "Where to download"},
    };
    return param_info;
  }
  /** Run both initialization methods and print part of the results */
  public static void main(String[] args) {
    print("from getArrayInfo", getArrayInfo());
    print("from getParameterInfo", getParameterInfo());
  }
  /** Print selected elements from the 2D array */
  public static void print(String tag, String[][] array) {
    System.out.println("Array " + tag + " is " + array.length + " x " + 
      array[0].length);
    System.out.println("Array[0][0] = " + array[0][0]);
    System.out.println("Array[0][1] = " + array[0][1]);
    System.out.println("Array[1][0] = " + array[1][0]);
    System.out.println("Array[0][0] = " + array[0][0]);
    System.out.println("Array[1][1] = " + array[1][1]);
  }
}

String array and output to console

   
public class Welcome {
  public static void main(String[] args) {
    String[] greeting = new String[3];
    greeting[0] = "This is the greeting";
    greeting[1] = "from";
    greeting[2] = "Java Source and Support.";
    for (int i = 0; i < greeting.length; i++)
      System.out.println(greeting[i]);
  }
}

Sum all elements in the array

  
/*
 * Copyright (c) 2003 - 2007 OpenSubsystems s.r.o. Slovak Republic. All rights reserved.
 * 
 * Project: OpenSubsystems
 * 
 * $Id: ArrayUtils.java,v 1.9 2007/01/23 06:00:30 bastafidli Exp $
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License. 
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 */

/**
 * Collection of useful utilities to work with arrays. 
 * 
 * @version $Id: ArrayUtils.java,v 1.9 2007/01/23 06:00:30 bastafidli Exp $
 * @author Peter Satury
 * @code.reviewer Miro Halas
 * @code.reviewed 1.5 2005/07/29 07:36:24 bastafidli
 */
public final class ArrayUtils
{
   /** 
    * Private constructor since this class cannot be instantiated
    */
   private ArrayUtils(
   )
   {
      // Do nothing
   }
   
   // Public methods ///////////////////////////////////////////////////////////
   /**
    * Method to exclude 2 arrays of ints so that the result contains all elements
    * from the first array, which are not in the second array.
    *  
    * @param arrBase - base array to exclude from 
    * @param arrExclude - array to exclude from the first one
    * @return int[] - array which contains all elements from the first array 
    *                 which are not in the second array or null
    */
   public static int[] exclude(
      int[] arrBase, 
      int[] arrExclude
   )
   {
      int[] arrReturn = null;
      if ((arrBase != null) && (arrBase.length > 0) && (arrExclude != null)
         && (arrExclude.length > 0))
      {
         int[] arrHelp;
         int   iCount1;
         int   iHelp;
         int   iLength = 0;
         
         arrHelp = new int[arrBase.length];
         for (iCount1 = 0; iCount1 < arrBase.length; iCount1++)
         {
            iHelp = arrBase[iCount1];
            if (ArrayUtils.contains(arrExclude, iHelp) == -1)
            {
               // If the element is not part of the second array then it should
               // be included in the result
               arrHelp[iLength++] = iHelp;
            }
         }
         
         // Shrink the array
         // TODO: Performance: Replace this with System.arraycopy
         arrReturn = new int[iLength];
         for (int iCount = 0; iCount < iLength; iCount++)
         {
            arrReturn[iCount] = arrHelp[iCount];
         }
      }
      else
      {
         arrReturn = arrBase;
      }
      
      return arrReturn;
   }
   
   /**
    * Test if specified array contains given element and if it does, find 
    * its position.
    * 
    * @param source - array to search, can be null
    * @param iTarget - element to find
    * @return int - -1 if it doesn"t exist there otherwise its position
    */
   public static int contains(
      int[] source,
      int   iTarget
   )
   {
      int iReturn = -1;
      
      if ((source != null) && (source.length > 0))
      {   
         int iIndex;
         
         for (iIndex = 0; iIndex < source.length; iIndex++)
         {
            if (source[iIndex] == iTarget)
            {
               iReturn = iIndex;
               break;
            }
         }
      }
      
      return iReturn;
   }
   /**
    * Sum all elements in the array.
    * 
    * @param source - array to sum elements of
    * @return long - sum of the elements in the array
    */
   public static long sum(
      int[] source
   )
   {
      int iReturn = 0;
      
      if ((source != null) && (source.length > 0))
      {   
         int iIndex;
         
         for (iIndex = 0; iIndex < source.length; iIndex++)
         {
            iReturn += source[iIndex];
         }
      }
      
      return iReturn;
   }
}

Timing array loop performance

   
public class TimeArray {
  public static void main(String args[]) {
    long startTime = System.currentTimeMillis();
    for (int i = 0, n = Integer.MAX_VALUE; i < n; i++) {
      ;
    }
    long midTime = System.currentTimeMillis();
    for (int i = Integer.MAX_VALUE - 1; i >= 0;) {
      ;
    }
    long endTime = System.currentTimeMillis();
    System.out.println("Increasing: " + (midTime - startTime));
    System.out.println("Decreasing: " + (endTime - midTime));
  }
}

To get the number of dimensions

   
public class Main {
  public static void main(String args[]) {
    String[][] data = new String[3][4];
    System.out.println(getDimension(data));
  }
  public static int getDimension(Object array) {
    int dim = 0;
    Class c = array.getClass();
    while (c.isArray()) {
      c = c.getComponentType();
      dim++;
    }
    return (dim);
  }
}
//2

Triangular array

   
import java.text.Format;
public class TriangularArray {
public static void main(String[] args) {
    final int MAX_HIGH = 10;
    // allocate triangular array
    int[][] odds = new int[MAX_HIGH + 1][];
    for (int i = 0; i <= MAX_HIGH; i++)
      odds[i] = new int[i + 1];
    // fill triangular array
    for (int i = 0; i < odds.length; i++)
      for (int j = 0; j < odds[i].length; j++)
        odds[i][j] = i+j;
    // print triangular array
    for (int i = 0; i < odds.length; i++) {
      for (int j = 0; j < odds[i].length; j++){
        System.out.print(odds[i][j] + " ");  
      }
      System.out.println();
      
    }
  }
}

Use the new shorthand notation to iterate through an array

   
public class Main {
  public static void main(String args[]) {
    String s[] = { "a", "b", "c", "d" };
    for (String element : s)
      System.out.println(element);
  }
}

Using the length Variable

   
//The length variable is used to access the length of the firstrowof a 
//two dimensional array.
public class TestLength {
  public static void main(String args[]) {
    int[][] multiD = {
      { 1, 2, 3, 4 },
      { 5, 6, 7 }
    };
        
    System.out.println("The length of the first row is "+multiD[0].length);
  }
}