Admin: 1 версия

2010-05-31T14:11:31Z

1 версия

Новая страница

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

Java by API/java.util/Arrays - История изменений

в 17:43, 31 мая 2010

Admin: 1 версия

← Предыдущая	Версия 17:43, 31 мая 2010
(нет различий)