La clase Arrays en el paquete java.util es parte de Java Collection Framework . Esta clase proporciona métodos estáticos para crear y acceder dinámicamente a arreglos Java . Consiste solo en métodos estáticos y los métodos de la clase Object. Los métodos de esta clase pueden ser utilizados por el propio nombre de la clase.
La jerarquía de clases es la siguiente:
java.lang.Object ↳ java.util.Arrays
Geek, ahora debe preguntarse por qué necesitamos la clase Java Arrays cuando podemos declarar, inicializar y calcular operaciones sobre arrays. Sin embargo, la respuesta a esto se encuentra dentro de los métodos de esta clase que discutiremos más a fondo, ya que prácticamente estas funciones ayudan a los programadores a expandir horizontes con arrays, por ejemplo, a menudo hay ocasiones en que los bucles se usan para realizar algunas tareas en una array como:
- Rellena una array con un valor particular.
- Ordenar una array.
- Buscar en una array.
- Y muchos más.
Aquí, la clase Arrays proporciona varios métodos estáticos que se pueden usar para realizar estas tareas directamente sin el uso de bucles, lo que hace que nuestro código sea súper corto y optimizado.
Sintaxis: declaración de clase
public class Arrays
extends Object
Sintaxis: Para usar Arrays
Arrays.<function name>;
Métodos en la clase de array de Java
La clase Arrays del paquete java.util contiene varios métodos estáticos que se pueden usar para llenar, ordenar, buscar, etc. en arrays. Ahora analicemos los métodos de esta clase que se muestran a continuación en un formato tabular de la siguiente manera:
| Métodos | Acción realizada |
|---|---|
| comoLista() | Devuelve una lista de tamaño fijo respaldada por las arrays especificadas |
| búsqueda binaria() | Busca el elemento especificado en la array con la ayuda del algoritmo de búsqueda binaria |
| binarySearch(array, fromIndex, toIndex, key, Comparator) | Busca un rango de la array especificada para el objeto especificado utilizando el algoritmo de búsqueda binaria |
| comparar (array 1, array 2) | Compara lexicográficamente dos arrays pasadas como parámetros. |
| copyOf(arrayoriginal, nuevaLongitud) | Copia la array especificada, truncando o rellenando con el valor predeterminado (si es necesario) para que la copia tenga la longitud especificada. |
| copyOfRange(originalArray, fromIndex, endIndex) | Copia el rango especificado de la array especificada en un nuevo Arrays. |
| deepEquals(Objeto[] a1, Objeto[] a2) | Devuelve verdadero si las dos arrays especificadas son profundamente iguales entre sí. |
| deepHashCode(Objeto[] a) | Devuelve un código hash basado en el «contenido profundo» de las arrays especificadas. |
| deepToString(Objeto[] a) | Devuelve una representación de string del «contenido profundo» de las arrays especificadas. |
| es igual a (array1, array2) | Comprueba si ambas arrays son iguales o no. |
| relleno (array original, valor de relleno) | Asigna este valor de relleno a cada índice de estas arrays. |
| código hash (array original) | Devuelve un hashCode entero de esta instancia de array. |
| discrepancia (array1, array2) | Busca y devuelve el índice del primer elemento no coincidente entre las dos arrays especificadas. |
| prefijoparalelo(arrayoriginal, desdeíndice, índicefinal, operadorfuncional) | Realiza ParallelPrefix para el rango dado de la array con el operador funcional especificado. |
| prefijoparalelo(arrayoriginal, operador) | Realiza ParallelPrefix para una array completa con el operador funcional especificado. |
| ParallelSetAll (array original, generador funcional) | Establece todos los elementos de esta array en paralelo, utilizando la función de generador proporcionada. |
| ordenaciónparalela(arrayoriginal) | Ordena la array especificada utilizando la ordenación paralela. |
| setAll(arrayoriginal, generador funcional) | Establece todos los elementos de la array especificada utilizando la función de generador proporcionada. |
| ordenar (arrayoriginal) | Ordena la array completa en orden ascendente. |
| sort(arrayoriginal, desdeíndice, índicefinal) | Ordena el rango especificado de array en orden ascendente. |
| sort(T[] a, int fromIndex, int toIndex, Comparator< super T> c) | Ordena el rango especificado de la array de objetos especificada según el orden inducido por el comparador especificado. |
| sort(T[] a, Comparador<super T> c) | Ordena la array de objetos especificada según el orden inducido por el comparador especificado. |
| divisor (array original) | Devuelve un Spliterator que cubre todas las arrays especificadas. |
| divisor (array original, desde el índice, índice final) | Devuelve un Spliterator del tipo de la array que cubre el rango especificado de las arrays especificadas. |
| flujo (array original) | Devuelve un flujo secuencial con la array especificada como fuente. |
| toString(arrayoriginal) | Devuelve una representación de string del contenido de esta array. La representación de string consta de una lista de los elementos de la array, entre corchetes («[]»). Los elementos adyacentes están separados por los caracteres una coma seguida de un espacio. Los elementos se convierten en strings mediante la función String.valueOf(). |
Implementación:
Ejemplo 1: Método asList()
Java
// Java Program to Demonstrate Arrays Class
// Via asList() method
// Importing Arrays utility class
// from java.util package
import java.util.Arrays;
// Main class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Get the Array
int intArr[] = { 10, 20, 15, 22, 35 };
// To convert the elements as List
System.out.println("Integer Array as List: "
+ Arrays.asList(intArr));
}
}
Producción
Integer Array as List: [[I@2f4d3709]
Ejemplo 2: Método binarySearch()
Este método busca el elemento especificado en la array con la ayuda del algoritmo de búsqueda binaria.
Java
// Java Program to Demonstrate Arrays Class
// Via binarySearch() method
// Importing Arrays utility class
// from java.util package
import java.util.Arrays;
// Main class
public class GFG {
// Main driver method
public static void main(String[] args)
{
// Get the Array
int intArr[] = { 10, 20, 15, 22, 35 };
Arrays.sort(intArr);
int intKey = 22;
// Print the key and corresponding index
System.out.println(
intKey + " found at index = "
+ Arrays.binarySearch(intArr, intKey));
}
}
Producción
22 found at index = 3
Ejemplo 3: método binarySearch(array, fromIndex, toIndex, key, Comparator)
Este método busca un rango de la array especificada para el objeto especificado utilizando el algoritmo de búsqueda binaria.
Java
// Java program to demonstrate
// Arrays.binarySearch() method
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// Get the Array
int intArr[] = { 10, 20, 15, 22, 35 };
Arrays.sort(intArr);
int intKey = 22;
System.out.println(
intKey
+ " found at index = "
+ Arrays
.binarySearch(intArr, 1, 3, intKey));
}
}
Producción
22 found at index = -4
Ejemplo 4: método de comparación (array 1, array 2)
Java
// Java program to demonstrate
// Arrays.compare() method
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// Get the Array
int intArr[] = { 10, 20, 15, 22, 35 };
// Get the second Array
int intArr1[] = { 10, 15, 22 };
// To compare both arrays
System.out.println("Integer Arrays on comparison: "
+ Arrays.compare(intArr, intArr1));
}
}
Producción
Integer Arrays on comparison: 1
Ejemplo 5: Método compareUnsigned(array 1, array 2)
Java
// Java program to demonstrate
// Arrays.compareUnsigned() method
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// Get the Arrays
int intArr[] = { 10, 20, 15, 22, 35 };
// Get the second Arrays
int intArr1[] = { 10, 15, 22 };
// To compare both arrays
System.out.println("Integer Arrays on comparison: "
+ Arrays.compareUnsigned(intArr, intArr1));
}
}
Producción
Integer Arrays on comparison: 1
Ejemplo 6: método copyOf(originalArray, newLength)
Java
// Java program to demonstrate
// Arrays.copyOf() method
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// Get the Array
int intArr[] = { 10, 20, 15, 22, 35 };
// To print the elements in one line
System.out.println("Integer Array: "
+ Arrays.toString(intArr));
System.out.println("\nNew Arrays by copyOf:\n");
System.out.println("Integer Array: "
+ Arrays.toString(
Arrays.copyOf(intArr, 10)));
}
}
Producción
Integer Array: [10, 20, 15, 22, 35] New Arrays by copyOf: Integer Array: [10, 20, 15, 22, 35, 0, 0, 0, 0, 0]
Ejemplo 7: Método copyOfRange(originalArray, fromIndex, endIndex)
Java
// Java program to demonstrate
// Arrays.copyOfRange() method
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// Get the Array
int intArr[] = { 10, 20, 15, 22, 35 };
// To print the elements in one line
System.out.println("Integer Array: "
+ Arrays.toString(intArr));
System.out.println("\nNew Arrays by copyOfRange:\n");
// To copy the array into an array of new length
System.out.println("Integer Array: "
+ Arrays.toString(
Arrays.copyOfRange(intArr, 1, 3)));
}
}
Producción
Integer Array: [10, 20, 15, 22, 35] New Arrays by copyOfRange: Integer Array: [20, 15]
Ejemplo 8: método deepEquals(Object[] a1, Object[] a2)
Java
// Java program to demonstrate
// Arrays.deepEquals() method
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// Get the Arrays
int intArr[][] = { { 10, 20, 15, 22, 35 } };
// Get the second Arrays
int intArr1[][] = { { 10, 15, 22 } };
// To compare both arrays
System.out.println("Integer Arrays on comparison: "
+ Arrays.deepEquals(intArr, intArr1));
}
}
Producción
Integer Arrays on comparison: false
Ejemplo 9: Método deepHashCode(Object[] a)
Java
// Java program to demonstrate
// Arrays.deepHashCode() method
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// Get the Array
int intArr[][] = { { 10, 20, 15, 22, 35 } };
// To get the dep hashCode of the arrays
System.out.println("Integer Array: "
+ Arrays.deepHashCode(intArr));
}
}
Producción
Integer Array: 38475344
Ejemplo 10: método deepToString(Object[] a)
Java
// Java program to demonstrate
// Arrays.deepToString() method
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// Get the Array
int intArr[][] = { { 10, 20, 15, 22, 35 } };
// To get the deep String of the arrays
System.out.println("Integer Array: "
+ Arrays.deepToString(intArr));
}
}
Producción
Integer Array: [[10, 20, 15, 22, 35]]
Ejemplo 11: método equals(array1, array2)
Java
// Java program to demonstrate
// Arrays.equals() method
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// Get the Arrays
int intArr[] = { 10, 20, 15, 22, 35 };
// Get the second Arrays
int intArr1[] = { 10, 15, 22 };
// To compare both arrays
System.out.println("Integer Arrays on comparison: "
+ Arrays.equals(intArr, intArr1));
}
}
Producción
Integer Arrays on comparison: false
Ejemplo 12: método de relleno (array original, valor de relleno)
Java
// Java program to demonstrate
// Arrays.fill() method
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// Get the Arrays
int intArr[] = { 10, 20, 15, 22, 35 };
int intKey = 22;
Arrays.fill(intArr, intKey);
// To fill the arrays
System.out.println("Integer Array on filling: "
+ Arrays.toString(intArr));
}
}
Producción
Integer Array on filling: [22, 22, 22, 22, 22]
Ejemplo 13: Método hashCode(originalArray)
Java
// Java program to demonstrate
// Arrays.hashCode() method
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// Get the Array
int intArr[] = { 10, 20, 15, 22, 35 };
// To get the hashCode of the arrays
System.out.println("Integer Array: "
+ Arrays.hashCode(intArr));
}
}
Producción
Integer Array: 38475313
Ejemplo 14: método de desajuste (array1, array2)
Java
// Java program to demonstrate
// Arrays.mismatch() method
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// Get the Arrays
int intArr[] = { 10, 20, 15, 22, 35 };
// Get the second Arrays
int intArr1[] = { 10, 15, 22 };
// To compare both arrays
System.out.println("The element mismatched at index: "
+ Arrays.mismatch(intArr, intArr1));
}
}
Producción
The element mismatched at index: 1
Ejemplo 15: método de clasificación paralela (array original)
Java
// Java program to demonstrate
// Arrays.parallelSort() method
// Importing Arrays class from
// java.util package
import java.util.Arrays;
// Main class
public class Main {
public static void main(String[] args)
{
// Get the Array
int intArr[] = { 10, 20, 15, 22, 35 };
// To sort the array using parallelSort
Arrays.parallelSort(intArr);
System.out.println("Integer Array: "
+ Arrays.toString(intArr));
}
}
Producción
Integer Array: [10, 15, 20, 22, 35]
Ejemplo 16: método sort(arrayoriginal )
Java
// Java program to demonstrate
// Arrays.sort() method
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// Get the Array
int intArr[] = { 10, 20, 15, 22, 35 };
// To sort the array using normal sort-
Arrays.sort(intArr);
System.out.println("Integer Array: "
+ Arrays.toString(intArr));
}
}
Producción
Integer Array: [10, 15, 20, 22, 35]
Ejemplo 17: método sort(originalArray, fromIndex, endIndex)
Java
// Java program to demonstrate
// Arrays.sort() method
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// Get the Array
int intArr[] = { 10, 20, 15, 22, 35 };
// To sort the array using normal sort
Arrays.sort(intArr, 1, 3);
System.out.println("Integer Array: "
+ Arrays.toString(intArr));
}
}
Producción
Integer Array: [10, 15, 20, 22, 35]
Ejemplo 18: sort(T[] a, int fromIndex, int toIndex, Comparator< super T> c) Método
Java
// Java program to demonstrate working of Comparator
// interface
import java.util.*;
import java.lang.*;
import java.io.*;
// A class to represent a student.
class Student {
int rollno;
String name, address;
// Constructor
public Student(int rollno, String name,
String address)
{
this.rollno = rollno;
this.name = name;
this.address = address;
}
// Used to print student details in main()
public String toString()
{
return this.rollno + " "
+ this.name + " "
+ this.address;
}
}
class Sortbyroll implements Comparator<Student> {
// Used for sorting in ascending order of
// roll number
public int compare(Student a, Student b)
{
return a.rollno - b.rollno;
}
}
// Driver class
class Main {
public static void main(String[] args)
{
Student[] arr = { new Student(111, "bbbb", "london"),
new Student(131, "aaaa", "nyc"),
new Student(121, "cccc", "jaipur") };
System.out.println("Unsorted");
for (int i = 0; i < arr.length; i++)
System.out.println(arr[i]);
Arrays.sort(arr, 1, 2, new Sortbyroll());
System.out.println("\nSorted by rollno");
for (int i = 0; i < arr.length; i++)
System.out.println(arr[i]);
}
}
Producción
Unsorted 111 bbbb london 131 aaaa nyc 121 cccc jaipur Sorted by rollno 111 bbbb london 131 aaaa nyc 121 cccc jaipur
Ejemplo 19: Método sort(T[] a, Comparator< super T> c)
Java
// Java program to demonstrate working of Comparator
// interface
import java.util.*;
import java.lang.*;
import java.io.*;
// A class to represent a student.
class Student {
int rollno;
String name, address;
// Constructor
public Student(int rollno, String name,
String address)
{
this.rollno = rollno;
this.name = name;
this.address = address;
}
// Used to print student details in main()
public String toString()
{
return this.rollno + " "
+ this.name + " "
+ this.address;
}
}
class Sortbyroll implements Comparator<Student> {
// Used for sorting in ascending order of
// roll number
public int compare(Student a, Student b)
{
return a.rollno - b.rollno;
}
}
// Driver class
class Main {
public static void main(String[] args)
{
Student[] arr = { new Student(111, "bbbb", "london"),
new Student(131, "aaaa", "nyc"),
new Student(121, "cccc", "jaipur") };
System.out.println("Unsorted");
for (int i = 0; i < arr.length; i++)
System.out.println(arr[i]);
Arrays.sort(arr, new Sortbyroll());
System.out.println("\nSorted by rollno");
for (int i = 0; i < arr.length; i++)
System.out.println(arr[i]);
}
}
Producción
Unsorted 111 bbbb london 131 aaaa nyc 121 cccc jaipur Sorted by rollno 111 bbbb london 121 cccc jaipur 131 aaaa nyc
Ejemplo 20: Método spliterator(originalArray)
Java
// Java program to demonstrate
// Arrays.spliterator() method
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// Get the Array
int intArr[] = { 10, 20, 15, 22, 35 };
// To sort the array using normal sort
System.out.println("Integer Array: "
+ Arrays.spliterator(intArr));
}
}
Producción
Integer Array: java.util.Spliterators$IntArraySpliterator@4e50df2e
Ejemplo 21: Método spliterator(originalArray, fromIndex, endIndex)
Java
// Java program to demonstrate
// Arrays.spliterator() method
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// Get the Array
int intArr[] = { 10, 20, 15, 22, 35 };
// To sort the array using normal sort
System.out.println("Integer Array: "
+ Arrays.spliterator(intArr, 1, 3));
}
}
Producción
Integer Array: java.util.Spliterators$IntArraySpliterator@4e50df2e
Ejemplo 22: método stream(originalArray)
Java
// Java program to demonstrate
// Arrays.stream() method
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// Get the Array
int intArr[] = { 10, 20, 15, 22, 35 };
// To get the Stream from the array
System.out.println("Integer Array: "
+ Arrays.stream(intArr));
}
}
Producción
Integer Array: java.util.stream.IntPipeline$Head@7291c18f
Ejemplo 23: Método toString(originalArray)
Java
// Java program to demonstrate
// Arrays.toString() method
import java.util.Arrays;
public class Main {
public static void main(String[] args)
{
// Get the Array
int intArr[] = { 10, 20, 15, 22, 35 };
// To print the elements in one line
System.out.println("Integer Array: "
+ Arrays.toString(intArr));
}
}
Producción
Integer Array: [10, 20, 15, 22, 35]
Este artículo es una contribución de Rishabh Mahrsee . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo y enviarlo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA