Arrays. O método equals() não compara recursivamente se um array contém outro array em outro Arrays. O método deepEquals() compara recursivamente se um array contém outro array.
Arrays.equals (Object [], Object [])
Sintaxe:
public static boolean equals(int[] a, int[] a2)Parâmetros:
- a - uma matriz a ser testada quanto à igualdade
- a2 - a outra matriz a ser testada quanto à igualdade
Retorna: verdadeiro se as duas matrizes forem iguais
- Retorne True se as matrizes forem iguais umas às outras.
- Se ambas as matrizes contiverem um número igual de elementos e o mesmo elemento em cada índice.
- Além disso, se os dois arrays forem nulos, eles serão considerados iguais.
- O método Arrays.equals() não compara recursivamente se um array contém outro array.
- Em todos os outros casos, ele retorna False.
Array.deepEquals (Object [], Object [])
Sintaxe:
public static boolean deepEquals(Object[] o1, Object[] o2) o1 = First Array to test for Equality o2 = Second Array to test for Equality- Retorne True se as duas matrizes forem iguais uma à outra.
- Se ambas as matrizes contiverem o mesmo número de elementos e o mesmo elemento em cada índice.
- Além disso, os dois arrays são nulos, então eles são considerados iguais.
- Além disso, se o elemento aninhado for novamente array, os elementos do array aninhado também são comparados de maneira iterativa.
- O método Arrays.deepEquals() compara recursivamente se uma matriz contiver outra matriz.
Principais diferenças:
Se em qualquer Array, um item for outro Array, a chamada para equals() vai para java.lang.Object equals(), que compara a referência de dois Object e não realiza comparação profunda e falha na comparação lógica no caso de Array aninhado .
Por outro lado, o método Arrays.deepEquals() executa várias verificações e chama Arrays.equals() para comparação sem matriz e chama recursivamente Arrays.deepEquals() para comparação de tipo de matriz, o que permite comparar matrizes aninhadas logicamente em Java .
Observação: é sempre recomendável usar Arrays.equals() para comparar Array não aninhado e Arrays.deepEquals() para comparar Array aninhado, já que Array.equals() é mais rápido do que Arrays.deepEquals() no caso de não aninhado Variedade.
Ilustração de equals() em java:
// Java program to compare two arrays // using .equals() method import java.io.*; import java.util.*; class GFG { public static void main(String[] args) { int[] A = { 1, 2, 3, 4, 5 }; int[] B = { 1, 2, 3, 4, 5 }; int[] C = { 2, 1, 4, 3, 5 }; // Comparing two arrays A and B using .equals() if (Arrays.equals(A,B)) System.out.println( "Array A and Array B is equal"); else System.out.println( "Array A and Array B is not equal"); if (Arrays.equals(A, C)) System.out.println( "Array A and Array C is equal"); else System.out.println( "Array A and Array C is not equal"); } }SaídaMatriz A e Matriz B são iguais Array A e Array C não são iguais
Abaixo está a ilustração de deepEquals() em java: -
// Java program to compare two arrays // using .deepEquals() method import java.io.*; import java.util.*; class GFG { public static void main(String[] args) { int[][] A = { { 1, 2, 3 }, { 3, 4, 5 }, { 6, 7, 8 } }; int[][] B = { { 1, 2, 3 }, { 3, 4, 5 }, { 6, 7, 8 } }; int[][] C = { { 3, 4, 5 }, { 4, 5, 6 }, { 7, 2, 4 } }; // Comparing A and B arrays using .deepEquals() method if (Arrays.deepEquals(A, B)) System.out.println( "Array A and Array B is equal"); else System.out.println( "Array A and Array B is not equal"); if (Arrays.deepEquals(A, C)) System.out.println( "Array A and Array C is equal"); else System.out.println( "Array A and Array C is not equal"); } }SaídaMatriz A e Matriz B são iguais Array A e Array C não são iguais
Assumindo igualdade de matriz significa que ambas as matrizes têm elementos iguais em índices iguais, existe a SequenceEqualresposta e a IStructuralEquatableresposta .
Mas ambos têm desvantagens, em termos de desempenho.
SequenceEqual a implementação atual não será um atalho quando as matrizes tiverem comprimentos diferentes e, portanto, poderá enumerar uma delas completamente, comparando cada um de seus elementos.
IStructuralEquatablenão é genérico e pode causar o boxe de cada valor comparado. Além disso, não é muito simples de usar e já exige a codificação de alguns métodos auxiliares que o ocultam.
Pode ser melhor, em termos de desempenho, usar algo como:
bool ArrayEquals<T>(T[] first, T[] second) { if (first == second) return true; if (first == null || second == null) return false; if (first.Length != second.Length) return false; for (var i = 0; i < first.Length; i++) { if (first[i] != second[i]) return false; } return true; }Mas é claro que essa também não é uma "maneira mágica" de verificar a igualdade de matrizes.
Portanto, atualmente, não, não existe realmente um equivalente ao Java Arrays.equals()no .Net.
Este post irá verificar se dois arrays são iguais ou não no C#.
Duas matrizes são consideradas iguais em C# se ambas as sequências tiverem comprimento igual e contiverem dados idênticos na mesma ordem. Podemos verificar a igualdade do array usando qualquer um dos seguintes métodos:
1. Usando Enumerable.SequenceEqual() método
Para verificar a igualdade de matrizes, podemos usar o Enumerable.SequenceEquals() método no System.Linq namespace. Isso funciona verificando se duas sequências de origem são de tamanho igual e seus elementos correspondentes são iguais de acordo com o comparador de igualdade padrão para seu tipo.
O exemplo a seguir demonstra o uso do SequenceEqual() método para determinar se duas sequências são iguais.
public static bool checkEquality<T>(T[] first, T[] second) { return Enumerable.SequenceEqual(first, second); public static void Main() int[] first = { 1, 2, 3, 4, 5 }; int[] second = { 1, 2, 3, 4, 5 }; if (checkEquality(first, second)) { Console.WriteLine("Both arrays are equal"); Console.WriteLine("Both arrays are not equal"); |
Download Executar código
O código acima pode ser reescrito da seguinte forma:
public static bool checkEquality<T>(T[] first, T[] second) { return first.SequenceEqual(second); public static void Main() int[] first = { 1, 2, 3, 4, 5 }; int[] second = { 1, 2, 3, 4, 5 }; if (checkEquality(first, second)) { Console.WriteLine("Both arrays are equal"); Console.WriteLine("Both arrays are not equal"); |
Download Executar código
2. Rotina Personalizada
Também podemos escrever nossa própria rotina personalizada para comparar dois arrays genéricos. A rotina deve determinar se as sequências comparadas contêm referências aos mesmos objetos e comparar os dados reais dos objetos dentro das sequências. Para comparar os dados reais dos objetos nas sequências, podemos usar EqualityComparer<T>.
Isso é demonstrado abaixo:
using System.Collections.Generic; public static bool checkEquality<T>(T[] first, T[] second) if (ReferenceEquals(first, second)) { if (first == null || second == null || (first.Length != second.Length)) { EqualityComparer<T> comparer = EqualityComparer<T>.Default; for (int i = 0; i < first.Length; i++) if (!comparer.Equals(first[i], second[i])) { public static void Main() int[] first = { 1, 2, 3, 4, 5 }; int[] second = { 1, 2, 3, 4, 5 }; if (checkEquality(first, second)) { Console.WriteLine("Both arrays are equal"); Console.WriteLine("Both arrays are not equal"); |
Download Executar código
Isso é tudo sobre comparar duas matrizes para igualdade em C#.
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 🙂