Comparar dois arrays

[FireBlade]

Boas ppl,

O exercício é o seguinte:

Dados dois vetores quaisquer de booleanos compare-os e informe se ambos são

idênticos, para serem idênticos os vetores devem possuir o mesmo tamanho e

os mesmos elementos em cada posição.

O meu código:

public class exercicio_5{
 public static void main (String[] args){

boolean[] arum = {true,false,false,true,true};
boolean[] ardois = {false,true,false,true,true};

for (int i=arum.length, j=ardois.length; i<j;i++,j++){
  if (arum.length == ardois.length && arum[i] == ardois[j]){
  System.out.println("São idênticos");
  }else{System.out.println("São diferentes");}
}
}
}

Na minha óptica não vejo problemas no códg mas o DrJava não me dá nenhum output.

Há algum problema no códg?

Cumprimentos

[saca-rolhas]

i nunca é menor que j porque se os inicias com os tamanhos do arrays (que neste caso é 5) i nunca vai ser menor que j pois são ambos 5.

Aqui tens um método para realizar o que pretendes:

   public boolean compareBooleanArray(boolean[] a, boolean[] b) {
    try {
	    //verifica todos os elementos de ambos os arrays e caso haja alguma diferença devolve falso
	    for (int i = 0; i < a.length; i++) {
		    if (a[i] != b[i]) {
			    return false;
		    }
	    }
    } catch (IndexOutOfBoundsException e) {
	    //esta excepção aparece caso os arrays tenham tamanhos diferentes
	    return false;
    }
    //caso não tenha devolvido falso é porque são iguais
    return true;
   }

Edited October 16, 2013 at 12:20 PM by saca-rolhas

[HappyHippyHippo]

comparação de dois arrays :

public class exercicio_5{
 public static void main (String[] args){
   boolean[] arum   = {true, false,false,true,true};
   boolean[] ardois = {false,true, false,true,true};

   if (java.util.Arrays.equals(arum, ardois)) {
     System.out.println("São idênticos");
   } else {
     System.out.println("São diferentes");}
   }
 }
}

i nunca é menor que j porque se os inicias com os tamanhos do arrays (que neste caso é 5) i nunca vai ser menor que j pois são ambos 5.

Aqui tens um método para realizar o que pretendes:

   public boolean compareBooleanArray(boolean[] a, boolean[] b) {
       try {
           //verifica todos os elementos de ambos os arrays e caso haja alguma diferença devolve falso
           for (int i = 0; i < a.length; i++) {
               if (a[i] != b[i]) {
                   return false;
               }
           }
       } catch (IndexOutOfBoundsException e) {
           //esta excepção aparece caso os arrays tenham tamanhos diferentes
           return false;
       }
       //caso não tenha devolvido falso é porque são iguais
       return true;
   }

qual o resultado desta chamada ?

boolean[] arum   = {true};
boolean[] ardois = {true,false};
compareBooleanArray(arum, ardois); // <------

[FireBlade]

Obrigado pela ajuda HappyHippyHippo.

saca-rolhas, não entendi muito bem aquele catch

[HappyHippyHippo]

Obrigado pela ajuda HappyHippyHippo.

saca-rolhas, não entendi muito bem aquele catch

aquele catch é o centro da minha questão ao @saca-rolhas.

serve para caso o array a seja maior que o array b, irás ter uma acesso inválido ao array b.

imagina que a tem 2 elementos e b tem 1. ne segundo ciclo for, terás um acesso inválido ao array b porque a condição de paragem só verifica o array a. isso despoleta a excecção que é apanhada pela catch.

a minha questão ao @saca-rolhas é para que ele verifique o caso contrário : o array a é menor que o array b mas tendo todos os valores de a iguais aos primeiros valores de b

[saca-rolhas]

i nunca é menor que j porque se os inicias com os tamanhos do arrays (que neste caso é 5) i nunca vai ser menor que j pois são ambos 5.

Aqui tens um método para realizar o que pretendes:

public static boolean compareBooleanArray(boolean[] a, boolean[] b) {
	try {
		//verifica todos os elementos de ambos os arrays e caso haja alguma diferença devolve falso
		for (int i = 0; i < a.length || i < b.length; i++) {
			if (a[i] != b[i]) {
				return false;
			}
		}
	} catch (IndexOutOfBoundsException e) {
		//esta excepção aparece caso os arrays tenham tamanhos diferentes
		return false;
	}
	//caso não tenha devolvido falso é porque são iguais
	return true;
}

Sorry código corrigido

Eu também tinha te dado a solução do Hippo, mas como referiste exercício sei que pedem coisas a pensar em criar algo sem recorrer a métodos externos, contudo num contexto diferente a melhor resposta é aquela.

Edited October 16, 2013 at 02:11 PM by saca-rolhas

[HappyHippyHippo]

Sorry código corrigido

achas mesmo que o uso do sistema de excepções é eficiente ?

public static boolean compareBooleanArray(boolean[] a, boolean[] b) {
 // verificar tamanhos, simples e sem rodeios das excepções
 if (a.length != b.length)
   return false;

 //verifica todos os elementos de ambos os arrays e caso haja alguma diferença devolve falso
 for (int i = 0; i < a.length || i < b.length; i++) {
   if (a[i] != b[i])
     return false;
 }

 //caso não tenha devolvido falso é porque são iguais
 return true;
}

[saca-rolhas]

Se usares um if para resolver o mesmo problema vais ter essa validação sempre a correr para verificar um certo e determinado aspecto contudo se sabes que o que queres validar num if pode nem sempre acontecer contudo existe essa possibilidade. com um try/catch vais prever a mesma situação contudo o programa só corre o catch numa eventualidade e não sempre.

Ou seja o try/catch é mais eficaz.

[HappyHippyHippo]

Ou seja o try/catch é mais eficaz.

sabes qual é o peso de uma comparação ?

sabes quel é o peso do tratamento de uma excecção ?

http://stackoverflow.com/questions/299068/how-slow-are-java-exceptions

[Flinger]

Se usares um if para resolver o mesmo problema vais ter essa validação sempre a correr para verificar um certo e determinado aspecto contudo se sabes que o que queres validar num if pode nem sempre acontecer contudo existe essa possibilidade. com um try/catch vais prever a mesma situação contudo o programa só corre o catch numa eventualidade e não sempre.

Ou seja o try/catch é mais eficaz.

Seria verdade se tu o usasses para salvaguardar acontecimentos realmente excepcionais, o que não acontece, visto que a possibilidade de 2 arrays terem tamanhos diferentes é bastante grande.

Além disso, tens que somar ao tratamento da excepção o custo da comparação de todos os elementos do array até à excepção ser levantada. No caso do hippo, tens apenas o custo de uma condição. Mais, se o hippo retirar do for a condição de um dos arrays (como já testou se eles são iguais, não há a necessidade de no for estar a testar as 2), ainda mais ganhos vais ter (a menos que o compilador optimize o código).

Finalmente, eu sou fã do uso de excepções por uma questão de legibilidade do código. Neste caso acho que não só não trazem nada de novo, como a dificultam.