Java/Collections Data Structure/Array

Материал из Java эксперт
Перейти к: навигация, поиск

Содержание

Array 2D

   <source lang="java">
  

/*

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

}



 </source>
   
  
 
  



Array Copy Demo

   <source lang="java">
  

/*

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

}



 </source>
   
  
 
  



Array Hunt game

   <source lang="java">
  

/*

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

}



 </source>
   
  
 
  



Array initialization

   <source lang="java">
  

// : 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), };
 }

} ///:~



 </source>
   
  
 
  



Array Initializers

   <source lang="java">
  

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

}


 </source>
   
  
 
  



ArrayListDemo done over using an ArrayList

   <source lang="java">
  

/*

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

}



 </source>
   
  
 
  



Array Of Arrays Demo 2

   <source lang="java">
  

/*

* 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();
   }
 }

}



 </source>
   
  
 
  



Arrays of primitives

   <source lang="java">
  

// : 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]);
 }

} ///:~



 </source>
   
  
 
  



Can you change the .length of an array

   <source lang="java">
  

/*

* 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
   //-
 }

}




 </source>
   
  
 
  



Clone Array

   <source lang="java">
  

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

}



 </source>
   
  
 
  



Convert array of primitives into array of objects

   <source lang="java">
  

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

}



 </source>
   
  
 
  



Copy an array

   <source lang="java">
  

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

  • /


 </source>
   
  
 
  



Copying Elements from One Array to Another

   <source lang="java">
  

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

}


 </source>
   
  
 
  



Create a repeated sequence of character

   <source lang="java">
  

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

}



 </source>
   
  
 
  



Create multidimension arrays

   <source lang="java">
  

// : 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++;
 }

} ///:~



 </source>
   
  
 
  



Creating an array of nonprimitive objects

   <source lang="java">
  

// : 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]);
   }
 }

} ///:~



 </source>
   
  
 
  



Creating arrays with new

   <source lang="java">
  

// : 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]);
 }

} ///:~



 </source>
   
  
 
  



Creating a Two-Dimensional Array

   <source lang="java">
  

/*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];
 }

}



 </source>
   
  
 
  



Define array for class

   <source lang="java">
  

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

}



 </source>
   
  
 
  



Doubling the size of an array

   <source lang="java">
  

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

}



 </source>
   
  
 
  



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

   <source lang="java">
  

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

}


 </source>
   
  
 
  



Dump multi-dimensional arrays

   <source lang="java">
  

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

}


 </source>
   
  
 
  



Extend the size of an array

   <source lang="java">
  

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

  • /


 </source>
   
  
 
  



Get array upperbound

   <source lang="java">
  

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

  • /


 </source>
   
  
 
  



Grow array

   <source lang="java">
  

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

}



 </source>
   
  
 
  



Initialization and re-assignment of arrays

   <source lang="java">
  

// : 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);
 }

} ///:~



 </source>
   
  
 
  



Initialize a static array

   <source lang="java">
  

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

}


 </source>
   
  
 
  



Initialize multidimensional array

   <source lang="java">
  

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[]) {
 }

}


 </source>
   
  
 
  



Initializing Array Values

   <source lang="java">
  

/* 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]);
 }

}



 </source>
   
  
 
  



Initializing a Two Dimensional Array

   <source lang="java">
  

//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]);
 }

}



 </source>
   
  
 
  



Java program to demonstrate multidimensional arrays

   <source lang="java">
  

/* 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
 }

}



 </source>
   
  
 
  



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

   <source lang="java">
  

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

}


 </source>
   
  
 
  



Multi Dimension Array

   <source lang="java">
  

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

}



 </source>
   
  
 
  



Multiply two matrices

   <source lang="java">
  

/**

* 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);
   //-
 }

}



 </source>
   
  
 
  



Reinitializes a byte array

   <source lang="java">
 

/*

* $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);
           }
       }
   }

}


 </source>
   
  
 
  



Reinitializes an int array

   <source lang="java">
 

/*

* $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);
           }
       }
   }

}


 </source>
   
  
 
  



Resize an array, System.arraycopy()

   <source lang="java">
  

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

}


 </source>
   
  
 
  



Reverse array elements order

   <source lang="java">
  

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

}


 </source>
   
  
 
  



Show Two-Dimensional Array of Objects

   <source lang="java">
  

/*

* 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]);
 }

}



 </source>
   
  
 
  



String array and output to console

   <source lang="java">
  

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

}



 </source>
   
  
 
  



Sum all elements in the array

   <source lang="java">
 

/*

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

}


 </source>
   
  
 
  



Timing array loop performance

   <source lang="java">
  

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

}



 </source>
   
  
 
  



To get the number of dimensions

   <source lang="java">
  

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


 </source>
   
  
 
  



Triangular array

   <source lang="java">
  

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

}



 </source>
   
  
 
  



Use the new shorthand notation to iterate through an array

   <source lang="java">
  

public class Main {

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

}


 </source>
   
  
 
  



Using the length Variable

   <source lang="java">
  

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

}



 </source>