Java by API/java.util/Arrays

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

Содержание

Arrays: asList(T[] a)

   <source lang="java">

/* 

Output:

a b c 

* */

import java.util.*; public class MainClass { 

 public static void main (String args[]) {
   String[] a = new String[]{"a","b","c"};
   List list = Arrays.asList(a);
   Iterator i = list.iterator();
   while (i.hasNext()) {
     System.out.println(i.next());
   }
 }

} 



 </source>



Arrays: binarySearch(int[] a,int key)

   <source lang="java">

/** 

*Output:

Original contents: 0 3 6 9 12 15 18 21 24 27 Sorted: 0 3 6 9 12 15 18 21 24 27 After fill(): 0 3 -1 -1 -1 -1 18 21 24 27 After sorting again: -1 -1 -1 -1 0 3 18 21 24 27 The value 9 is at location -7 

*/

import java.util.Arrays; public class MainClass { 

 public static void main(String args[]) {
   int array[] = new int[10];
   for (int i = 0; i < 10; i++)
     array[i] = 3 * i;
   System.out.print("Original contents: ");
   display(array);
   Arrays.sort(array);
   System.out.print("Sorted: ");
   display(array);
   Arrays.fill(array, 2, 6, -1);
   System.out.print("After fill(): ");
   display(array);
   Arrays.sort(array);
   System.out.print("After sorting again: ");
   display(array);
   System.out.print("The value 9 is at location ");
   int index = Arrays.binarySearch(array, 9);
   System.out.println(index);
 }
 static void display(int array[]) {
   for (int i : array) {
     System.out.print(i + " ");
   }
   System.out.println();
 }

} 



 </source>



Arrays: binarySearch(Object[] a, Object key)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] a) {
   String str[] = { "B", "H", "L", "M", "I", "N", "R" };
   // Ensure list sorted
   Arrays.sort(str);
   for (String s : str) {
     System.out.println(s);
   }
   // Search for element in list
   int index = Arrays.binarySearch(str, "M");
   System.out.println("Found M @ " + index);
 }

} 


 </source>



Arrays: copyOfRange(String[] original, int from, int to)

   <source lang="java">

import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.Arrays; public class Main { 

 public static void main(String... args) {
   try {
     Class<?> c = Class.forName(args[0]);
     Class[] argTypes = new Class[] { String[].class };
     Method main = c.getDeclaredMethod("main", argTypes);
     String[] mainArgs = Arrays.copyOfRange(args, 1, args.length);
     System.out.format("invoking %s.main()%n", c.getName());
     main.invoke(null, (Object) mainArgs);
     // production code should handle these exceptions more gracefully
   } catch (ClassNotFoundException x) {
     x.printStackTrace();
   } catch (NoSuchMethodException x) {
     x.printStackTrace();
   } catch (IllegalAccessException x) {
     x.printStackTrace();
   } catch (InvocationTargetException x) {
     x.printStackTrace();
   }
 }

} 


 </source>



Arrays: copyOf(String[] original, int newLength)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String args[]) {
   System.out.printf("Before (original)\t%s%n", Arrays.toString(args));
   String copy[] = Arrays.copyOf(args, 4);
   System.out.printf("Before (copy)\t\t%s%n", Arrays.toString(copy));
   copy[0] = "A";
   copy[1] = "B";
   copy[2] = "C";
   copy[3] = "D";
   System.out.printf("After (original)\t%s%n", Arrays.toString(args));
   System.out.printf("After (copy)\t\t%s%n", Arrays.toString(copy));
 }

} 

 </source>



Arrays: deepToString(Object[] a)

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



Arrays: equals(boolean[] a, boolean[] a2)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] argv) throws Exception {
   boolean[] bArr1 = null;
   boolean[] bArr2 = null;
   boolean b = Arrays.equals(bArr1, bArr2); // true
 }

} 


 </source>



Arrays: equals(char[] a, char[] a2)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] argv) throws Exception {
   boolean b = Arrays.equals(new char[] { "a" }, new char[] { "a" }); // true
 }

} 


 </source>



Arrays: equals(double[] a, double[] a2)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] argv) throws Exception {
   boolean b = Arrays.equals(new double[] { 0D }, new double[] { 0D }); // true
 }

} 


 </source>



Arrays: equals(float[] a, float[] a2)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] argv) throws Exception {
   boolean b = Arrays.equals(new float[] { 0F }, new float[] { 0F }); // true
 }

} 


 </source>



Arrays: equals(int[] a, int[] a2)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] a) {
   int[] i = new int[] { 1, 2, 3 };
   int[] j = new int[] { 1, 2, 4 };
   System.out.println(Arrays.equals(i, j));
 }

} 


 </source>



Arrays: equals(long[] a, long[] a2)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] argv) throws Exception {
   boolean b = Arrays.equals(new long[] { 0L }, new long[] { 0L }); // true
 }

} 


 </source>



Arrays: equals(Object[] a, Object[] a2)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] args) {
   String[] abc = { "a", "b", "c", "d" };
   String[] xyz = { "A", "b", "c", "s" };
   String[] java = { "Java", "Dot", "Com" };
   System.out.println(Arrays.equals(abc, xyz));
   System.out.println(Arrays.equals(abc, java));
 }

} 


 </source>



Arrays: equals(short[] a, short[] a2)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] argv) throws Exception {
   boolean b = Arrays.equals(new short[] { 0 }, new short[] { 0 }); // true
 }

} 


 </source>



Arrays: fill(boolean[] a, boolean val)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] argv) throws Exception {
   boolean[] booleanArr = new boolean[10];
   boolean booleanFillValue = false;
   Arrays.fill(booleanArr, booleanFillValue);
 }

} 


 </source>



Arrays: fill(boolean[] a, int fromIndex, int toIndex, boolean val)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] argv) throws Exception {
   int startIndex = 0;
   int endIndex = 4;
   boolean[] booleanArr = new boolean[10];
   boolean booleanFillValue = true;
   Arrays.fill(booleanArr, startIndex, endIndex, booleanFillValue);
 }

} 


 </source>



Arrays: fill(byte[] a, byte val)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] a) {
   byte array[] = new byte[10];

// Arrays.fill(array, 4); // illegal 

   for (int i : array) {
     System.out.println(i);
   }
   Arrays.fill(array, (byte) 4); // Okay
   for (int i : array) {
     System.out.println(i);
   }
 }

} 


 </source>



Arrays: fill(byte[] a, int fromIndex, int toIndex, byte val)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] argv) throws Exception {
   int startIndex = 0;
   int endIndex = 4;
   byte[] byteArr = new byte[10];
   byte byteFillValue = 1;
   Arrays.fill(byteArr, startIndex, endIndex, byteFillValue);
 }

} 


 </source>



Arrays: fill(char[] a, char val)

   <source lang="java">

public class Main{ 

 public static void main(String[] arg){
    char[] message = new char[50];
    java.util.Arrays.fill(message, "A");
    for(char ch: message){
      System.out.println(ch);
    }
 }

} 


 </source>



Arrays: fill(char[] a, int fromIndex, int toIndex, char val)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] argv) throws Exception {
   int startIndex = 0;
   int endIndex = 4;
   char[] charArr = new char[10];
   char charFillValue = 1;
   Arrays.fill(charArr, startIndex, endIndex, charFillValue);
 }

} 


 </source>



Arrays: fill(double[] a, double val)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] arg) {
   double[] data = new double[50]; // An array of 50 values of type double
   Arrays.fill(data, 1.0);                     // Fill all elements of data with 1.0
   
   for (double d: data) { 
     System.out.println(d);
   }
   
 }

} 


 </source>



Arrays: fill(double[] a, int fromIndex, int toIndex, double val)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] argv) throws Exception {
   int startIndex = 0;
   int endIndex = 4;
   double[] doubleArr = new double[10];
   double doubleFillValue = 1;
   Arrays.fill(doubleArr, startIndex, endIndex, doubleFillValue);
 }

} 


 </source>



Arrays: fill(float[] a, float val)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] argv) throws Exception {
   float[] floatArr = new float[10];
   float floatFillValue = -1;
   Arrays.fill(floatArr, floatFillValue);
 }

} 


 </source>



Arrays: fill(float[] a, int fromIndex, int toIndex, float val)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] argv) throws Exception {
   int startIndex = 0;
   int endIndex = 4;
   float[] floatArr = new float[10];
   float floatFillValue = 1;
   Arrays.fill(floatArr, startIndex, endIndex, floatFillValue);
 }

} 


 </source>



Arrays: fill(int[] a,int fromIndex,int toIndex,int val)

   <source lang="java">

/** 

*Output:

Original contents: 0 3 6 9 12 15 18 21 24 27 Sorted: 0 3 6 9 12 15 18 21 24 27 After fill(): 0 3 -1 -1 -1 -1 18 21 24 27 After sorting again: -1 -1 -1 -1 0 3 18 21 24 27 The value 9 is at location -7 

*/

import java.util.Arrays; public class MainClass { 

 public static void main(String args[]) {
   int array[] = new int[10];
   for (int i = 0; i < 10; i++)
     array[i] = 3 * i;
   System.out.print("Original contents: ");
   display(array);
   Arrays.sort(array);
   System.out.print("Sorted: ");
   display(array);
   Arrays.fill(array, 2, 6, -1);
   System.out.print("After fill(): ");
   display(array);
   Arrays.sort(array);
   System.out.print("After sorting again: ");
   display(array);
   System.out.print("The value 9 is at location ");
   int index = Arrays.binarySearch(array, 9);
   System.out.println(index);
 }
 static void display(int array[]) {
   for (int i : array) {
     System.out.print(i + " ");
   }
   System.out.println();
 }

} 



 </source>



Arrays: fill(int[] a, int val)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] a) {
   int array[] = new int[10];
   Arrays.fill(array, 100);
   for(int i: array){
     System.out.println(i);
   }
   Arrays.fill(array, 3, 6, 50);
   for(int i: array){
     System.out.println(i);
   }
 }

} 


 </source>



Arrays: fill(long[] a, int fromIndex, int toIndex, long val)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] argv) throws Exception {
   int startIndex = 0;
   int endIndex = 4;
   long[] longArr = new long[10];
   long longFillValue = 1;
   Arrays.fill(longArr, startIndex, endIndex, longFillValue);
 }

} 


 </source>



Arrays: fill(long[] a, long val)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] argv) throws Exception {
   long[] longArr = new long[10];
   long longFillValue = -1;
   Arrays.fill(longArr, longFillValue);
 }

} 


 </source>



Arrays: fill(Object[] a, int fromIndex, int toIndex, Object val)

   <source lang="java">

import java.util.Arrays; class Person implements Comparable<Person> { 

 public Person(String firstName, String surname) {
   this.firstName = firstName;
   this.surname = surname;
 }
 public String toString() {
   return firstName + " " + surname;
 }
 public int compareTo(Person person) {
   int result = surname.rupareTo(person.surname);
   return result == 0 ? firstName.rupareTo(((Person) person).firstName) : result;
 }
 private String firstName;
 private String surname;

} public class Main { 

 public static void main(String[] a) {
   Person[] people = new Person[100];
   Arrays.fill(people, 0, 50, new Person("A", "B"));
   Arrays.fill(people, 50, 100, new Person("C", "D"));
   for (Person person : people) {
     System.out.println(person);
   }
 }

} 


 </source>



Arrays: fill(Object[] a, Object val)

   <source lang="java">

import java.util.Arrays; import java.util.Date; public class Main { 

 public static void main(String args[]) {
   int array[] = new int[10];
   Arrays.fill(array, 100);
   for (int i=0, n=array.length; i<n; i++) {
     System.out.println(array[i]);
   }
   System.out.println();
   Arrays.fill(array, 3, 6, 50);
   for (int i=0, n=array.length; i<n; i++) {
     System.out.println(array[i]);
   }
   byte array2[] = new byte[10];
   Arrays.fill(array2, (byte)4);
   System.out.println();
   Date array3[] = new Date[10];
   Arrays.fill(array3, "Help");
 }

} 


 </source>



Arrays: fill(short[] a, int fromIndex, int toIndex, short val)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] argv) throws Exception {
   int startIndex = 0;
   int endIndex = 4;
   short[] shortArr = new short[10];
   short shortFillValue = 1;
   Arrays.fill(shortArr, startIndex, endIndex, shortFillValue);
 }

} 


 </source>



Arrays: fill(short[] a, short val)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] argv) throws Exception {
   short[] shortArr = new short[10];
   short shortFillValue = 2;
   Arrays.fill(shortArr, shortFillValue);
 }

} 


 </source>



Arrays: sort(byte[] a)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] args) {
   byte[] b1 = new byte[] { 3, 2, 5, 4, 1 };
   for (byte b: b1){
     System.out.println(b);
   }
   Arrays.sort(b1);
   for (byte b: b1){
     System.out.println(b);
   }
   byte[] b2 = new byte[] { 5, 2, 3, 1, 4 };
   Arrays.sort(b2, 1, 4);
   for (byte b: b2){
     System.out.println(b);
   }
 }

} 


 </source>



Arrays: sort(byte[] a, int fromIndex, int toIndex)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] args) {
   byte[] b1 = new byte[] { 3, 2, 5, 4, 1 };
   for (byte b: b1){
     System.out.println(b);
   }
   Arrays.sort(b1);
   for (byte b: b1){
     System.out.println(b);
   }
   byte[] b2 = new byte[] { 5, 2, 3, 1, 4 };
   Arrays.sort(b2, 1, 4);
   for (byte b: b2){
     System.out.println(b);
   }
 }

} 


 </source>



Arrays: sort(char[] a)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] args) {
   char[] c1 = new char[] { "c", "h", "a", "r", "s" };
   for (char ch: c1){
     System.out.print(ch);
   }
   Arrays.sort(c1);
   for (char ch: c1){
     System.out.print(ch);
   }
   char[] c2 = new char[] { "c", "h", "a", "r", "s" };
   Arrays.sort(c2, 1, 4);
   for (char ch: c1){
     System.out.print(ch);
   }
 }

} 


 </source>



Arrays: sort(char[] a, int fromIndex, int toIndex)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] args) {
   char[] c1 = new char[] { "c", "h", "a", "r", "s" };
   for (char ch: c1){
     System.out.print(ch);
   }
   Arrays.sort(c1);
   for (char ch: c1){
     System.out.print(ch);
   }
   char[] c2 = new char[] { "c", "h", "a", "r", "s" };
   Arrays.sort(c2, 1, 4);
   for (char ch: c1){
     System.out.print(ch);
   }
 }

} 


 </source>



Arrays: sort(double[] a)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] args) {
   double[] d1 = new double[] { 3.1, 2.1, 5.1, 4.1, 1.1 };
   for (double d: d1){
     System.out.print(" " +d);
   }
   Arrays.sort(d1);
   for (double d: d1){
     System.out.print(" " +d);
   }

   double[] d2 = new double[] { 5, 2, 3, 1, 4 };
   Arrays.sort(d2, 1, 4);
   for (double d: d2){
     System.out.print(" " +d);
   } 
 }

} 


 </source>



Arrays: sort(double[] a, int fromIndex, int toIndex)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] args) {
   double[] d1 = new double[] { 3.1, 2.1, 5.1, 4.1, 1.1 };
   for (double d: d1){
     System.out.print(" " +d);
   }
   Arrays.sort(d1);
   for (double d: d1){
     System.out.print(" " +d);
   }

   double[] d2 = new double[] { 5, 2, 3, 1, 4 };
   Arrays.sort(d2, 1, 4);
   for (double d: d2){
     System.out.print(" " +d);
   } 
 }

} 


 </source>



Arrays: sort(float[] a)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] args) {
   float[] f1 = new float[] { 3.1f, 2.1f, 5.1f, 4.1f, 1.1f };
   for (float f: f1){
     System.out.print(" " + f);
   }
   Arrays.sort(f1);
   for (float f: f1){
     System.out.print(" " + f);
   }
   float[] f2 = new float[] { 5.1f, 2.1f, 3.1f, 1.1f, 4.1f };
   Arrays.sort(f2, 1, 4);
   for (float f: f2){
     System.out.print(" " + f);
   }
 }

} 


 </source>



Arrays: sort(float[] a, int fromIndex, int toIndex)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String[] args) {
   float[] f1 = new float[] { 3.1f, 2.1f, 5.1f, 4.1f, 1.1f };
   for (float f: f1){
     System.out.print(" " + f);
   }
   Arrays.sort(f1);
   for (float f: f1){
     System.out.print(" " + f);
   }
   float[] f2 = new float[] { 5.1f, 2.1f, 3.1f, 1.1f, 4.1f };
   Arrays.sort(f2, 1, 4);
   for (float f: f2){
     System.out.print(" " + f);
   }
 }

} 


 </source>



Arrays: sort(in[] a)

   <source lang="java">

/** 

*Output:

Original contents: 0 3 6 9 12 15 18 21 24 27 Sorted: 0 3 6 9 12 15 18 21 24 27 After fill(): 0 3 -1 -1 -1 -1 18 21 24 27 After sorting again: -1 -1 -1 -1 0 3 18 21 24 27 The value 9 is at location -7 

*/

import java.util.Arrays; public class MainClass { 

 public static void main(String args[]) {
   int array[] = new int[10];
   for (int i = 0; i < 10; i++)
     array[i] = 3 * i;
   System.out.print("Original contents: ");
   display(array);
   Arrays.sort(array);
   System.out.print("Sorted: ");
   display(array);
   Arrays.fill(array, 2, 6, -1);
   System.out.print("After fill(): ");
   display(array);
   Arrays.sort(array);
   System.out.print("After sorting again: ");
   display(array);
   System.out.print("The value 9 is at location ");
   int index = Arrays.binarySearch(array, 9);
   System.out.println(index);
 }
 static void display(int array[]) {
   for (int i : array) {
     System.out.print(i + " ");
   }
   System.out.println();
 }

} 



 </source>



Arrays: sort(T[] a, Comparator c)

   <source lang="java">

/* 

Output:

c b a 

* */

import java.util.Arrays; import java.util.Collections; import java.util.ruparator; public class MainClass { 

 public static void main(String args[]) throws Exception {
   Comparator comp = Collections.reverseOrder();
   String[] a = new String[] { "a", "b", "c" };
   Arrays.sort(a, comp);
   for (int i = 0, n = a.length; i < n; i++) {
     System.out.println(a[i]);
   }
 }

} 



 </source>



Arrays: toString(Object[] a)

   <source lang="java">

import java.util.Arrays; public class Main { 

 public static void main(String args[]) {
   System.out.printf("Before (original)\t%s%n", Arrays.toString(args));
   String copy[] = Arrays.copyOf(args, 4);
   System.out.printf("Before (copy)\t\t%s%n", Arrays.toString(copy));
   copy[0] = "A";
   copy[1] = "B";
   copy[2] = "C";
   copy[3] = "D";
   System.out.printf("After (original)\t%s%n", Arrays.toString(args));
   System.out.printf("After (copy)\t\t%s%n", Arrays.toString(copy));
 }

} 


 </source>
Источник — «http://jexp.ru/index.php?title=Java_by_API/java.util/Arrays&oldid=147»