Como comparar duas matrizes em c

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 🙂