Esto era importante en Visual Basic, y claro esta, tambien en java es igual de importante, siempre necesitaremos recorrer todos los elementos de un array para localizar y en su caso mostrar el seleccionado y en general poder maniobrar con todos los elementos de un array, a continuación el codigo necesario para rellenar dos arrays con elementos aleatorios, luegos los recorremos y comparamos y al final escribimos en pantalla todos los resultados.
CODIGO
package elementosrepetidos;
//Codificado por Nino public class ElementosRepetidos{ static int A=3; static int B=30; static int vectorA[]=new int[A]; static int vectorB[]=new int[B]; static int elemA=0; static int elemB=0; static int z=0; /** * Funcion para llenar los arrays con valores aleatorios */ static void llenaArray(){ // Llenamos un array con valores aleatoriosfor(int i=0;ivectorA[i]=(int)(Math.random()*10+1);}// Llenamos un segundo array con valores aleatorios
for(int i=0;ivectorB[i]=(int)(Math.random()*10+1);}}/*** Funcion para cotejar el contenido de dos arrays*/static void coteja(){// recorremos los valores del array A
for(int i=0;i// recorremos los valores del array B
for(int j=0;j// Cada valor del array A lo comparamos con todos los valores del array B if(vectorA[i]==vectorB[j]) elemA++;}System.out.println("El elemento "+vectorA[i]+" se presenta "+elemA+" veces en B");elemA=0;}}/*** Funcion para mostrar el contenido de los dos arrays*/static void mostrar(){
for(int i=0;iSystem.out.print("A"+"["+i+"]= "+vectorA[i]+"\n");}
for(int i=0;iSystem.out.print("B"+"["+i+"]="+vectorB[i]+"\n");}}//rellenamos la clase principal con las variablespublic static void main(String[] args){llenaArray();mostrar();coteja();}
}
//Os deberia quedar un resultado en la pantalla de netbeans que muestra el resultado tal que asi: run: A[0]= 10A[1]= 7A[2]= 9B[0]=4B[1]=1B[2]=7B[3]=8B[4]=3B[5]=2B[6]=8B[7]=4B[8]=6B[9]=2B[10]=9B[11]=4B[12]=10B[13]=2B[14]=5B[15]=3B[16]=4B[17]=8B[18]=10B[19]=6B[20]=7B[21]=3B[22]=10B[23]=8B[24]=2B[25]=4B[26]=7B[27]=9B[28]=5B[29]=4El elemento 10 se presenta 3 veces en BEl elemento 7 se presenta 3 veces en BEl elemento 9 se presenta 2 veces en BGENERACIÓN CORRECTA (total time: 0 seconds)
Aunque claro esta, con los numeros que estan entre los corchetes y despues del igual distintos, ya que los genera por el metodo random, ya sabeis, aleatoriamente. en fin, una cosa necesaria si vais a hacer un programa con distintos arrays.
Page 2
Escreva um programa para verificar a igualdade de matrizes em Java. Duas matrizes são consideradas iguais se contiverem os mesmos elementos na mesma ordem.
Comparando duas matrizes com equals() retornará true somente ao comparar com a mesma instância de array. Isto porque seus equals() implementações é herdada de java.lang.Object. Este post discutirá como podemos comparar dois arrays em Java.
1. Comparando uma matriz de objetos
As duas matrizes de objetos são consideradas iguais se
- Ambas as referências de matriz são null ou ambos são non-null, e
- Ambas as matrizes têm o mesmo tipo e
- Ambas as matrizes contêm o mesmo número de elementos e
- Todos os pares de objetos correspondentes nas duas matrizes são iguais.
import java.util.Objects; import java.util.stream.IntStream; // Método genérico para verificar a igualdade de array em Java. Ele aceita arrays para serem // testado para igualdade e retorna true se os dois arrays forem iguais private static <U, V> boolean compareArrays(U[] a, V[] b) // 1. Verifique a mesma referência de array // 2. Verifique se qualquer array é nulo if (a == null || b == null) { // 3. Verifique se ambos os arrays são do mesmo tipo ou não if (!a.getClass().equals(b.getClass())) { // 4. Verifique se ambos os arrays têm o mesmo comprimento ou não if (a.length != b.length) { // 5. Por fim, compare os valores do array em cada índice return IntStream.range(0, a.length).allMatch(i -> Objects.equals(a[i], b[i])); public static void main(String[] args) String[] a = { "public", "static", "void", "main" }; String[] b = { "public", "static", "void", "fun" }; if (compareArrays(a, b)) { System.out.println("Arrays are equal"); System.out.println("Arrays are not equal"); |
Download Executar código
Resultado:
Arrays are not equal
2. Comparando Matriz de Primitivos
Também podemos comparar uma matriz de primitivas usando uma lógica semelhante:
import java.util.stream.IntStream; // Método para verificar a igualdade de array em um array int primitivo private static boolean compareArrays(int[] a, int[] b) // 1. Verifique a mesma referência de array // 2. Verifique se qualquer array é nulo if (a == null || b == null) { // 3. Verifique se ambos os arrays têm o mesmo comprimento ou não if (a.length != b.length) { // 4. Por fim, compare os valores do array em cada índice return IntStream.range(0, a.length).noneMatch(i -> a[i] != b[i]); public static void main(String[] args) int[] a = { 1, 2, 3, 4 }; int[] b = { 1, 2, 3, 4 }; if (compareArrays(a, b)) { System.out.println("Arrays are equal"); System.out.println("Arrays are not equal"); |
Download Executar código
Resultado:
Arrays are equal
3. Usando Arrays.equals() método
O framework Java Collections fornece Arrays.equals() método utilitário para comparar matrizes para igualdade. O método está sobrecarregado para todos os tipos e objetos primitivos.
public static void main(String[] args) int[] a = { 1, 2, 3, 4 }; int[] b = { 1, 2, 3, 4 }; if (Arrays.equals(a, b)) { System.out.println("Arrays are equal"); System.out.println("Arrays are not equal"); |
Download Executar código
Resultado:
Arrays are equal
Arrays.equals() falhará quando a matriz contiver um tipo de referência, pois esse método chamará internamente equals() no tipo de referência para determinar a igualdade.
4. Igualdade Profunda – Arrays.deepEquals() método
Com arrays aninhados de profundidade arbitrária, podemos usar Arrays.deepEquals() em vez disso, que retorna true se as duas matrizes especificadas forem profundamente iguais.
Duas referências de matriz são consideradas profundamente iguais se ambas forem null ou referem-se a arrays contendo o mesmo número de elementos. Todos os pares correspondentes de elementos nas duas matrizes são profundamente iguais.
Dois possivelmente null elementos e1 e e2 são profundamente iguais se qualquer uma das seguintes condições se verificar:
- e1 e e2 são ambos arrays de tipos de referência de objeto e Arrays.deepEquals(e1, e2) retornaria verdadeiro. e1 and e2 are arrays of the same primitive type, and the appropriate overloading of Matrizes.iguais(e1, e2) would return true. e1 == e2 e1.equals(e2)` retornaria true.
O programa a seguir demonstra isso:
public static void main(String[] args) String[] a = { "public", "static", "void", "main" }; String[] b = { "public", "static", "void", "main" }; // array de objetos contém um tipo de referência if (Arrays.deepEquals(A, B)) { System.out.println("Arrays are equal"); System.out.println("Arrays are not equal"); |
Download Executar código
Resultado:
Arrays are equal
Isso é tudo sobre igualdade de array em Java.
Referência: Matrizes Javadoc SE 8
Obrigado por ler.
Por favor, use nosso compilador online para postar código em comentários usando C, C++, Java, Python, JavaScript, C#, PHP e muitas outras linguagens de programação populares.
Como nós? Indique-nos aos seus amigos e ajude-nos a crescer. Codificação feliz 🙂