Java: Crear matriz de Object y averiguar tipo de dato de cada item instanceof

[Kabuto]

Hola, estoy empezando a aprender Java y de momento no tengo categoría ni de novato xD.

El caso es que para ir practicando lo poquito que llevo aprendido (aprendido, y no del todo entendido...), se me ha ocurrido desempolvar unos ejercicios prácticos que tengo de un curso anterior que hice de JavaScript, para intentar hacerlos ahora en Java.
Pues el primero de todos, ya se me ha atragantado 

Os publico el enunciado:

1) Realizar una serie de operaciones con la siguiente matriz:

var valores = [true, 5, false, "hola", "adios", 2]

a) Concatenar ambas cadenas y presentar resultado
b) Comparar los números entre sí con todos los operadores de comparación.
c) Comparar todos los valores de la matriz entre sí de dos en dos y ver el resultado
d) Realizar diferentes operaciones aritméticas con los valores numéricos

En JavaScript no hay mayor problema ya que se pueden mezclar tipos de datos en una matriz. Pero no en Java....

Bueno, pensando como resolver esto, he probado creando un set a partir de 3 matrices con distintos tipos de datos. Es lo único que se me ha ocurrido para crear  algo similar a una matriz como esa.

Tal como lo he hecho, los datos/objetos no quedan en el mismo orden que el propuesto en el enunciado, pero eso es irrelevante.

El caso es que consigo juntarlos y mostrarlos uno a uno en pantalla.

Código: [Seleccionar]

import java.util.ArrayList;
import java.util.Set;
import java.util.HashSet;
import java.util.Arrays;
import java.util.Iterator;

public class OperacionesMatriz{
    public static void main (String[] args){
        ArrayList<Set> matrizVariada = new ArrayList <Set>();

        //Creacion de matriz con datos Boolean
        Boolean [] matrizBool = {true, false};
        HashSet<Boolean> datosBool = new HashSet<Boolean> (Arrays.asList(matrizBool));

        //Creacion de matriz con Integer       
        Integer [] matrizInt = {5, 2};
        HashSet<Integer> datosInt = new HashSet<Integer> (Arrays.asList(matrizInt));

        //Creacion de matriz de Strings
        String [] matrizString = {"hola", "adios"};
        HashSet<String> datosString = new HashSet<String> (Arrays.asList(matrizString));

        //Juntamos las tres matrices
        matrizVariada.add(datosBool); matrizVariada.add(datosInt); matrizVariada.add(datosString);

        //Recorremos y mostramos en pantalla para comprobar resultado
        for (Set tmp: matrizVariada){
            Iterator it = tmp.iterator();
            int i=0;
            while (it.hasNext()){
                System.out.println("i: " + (i++) + " - " + it.next());
            }
        }
    }
}


Ahora mi desconocimiento plantea estas dudas.

• ¿Puedo operar con estos objetos tras haberlos unidos de este modo?
• ¿Puedo hacer que al recorrer el set, el programa distinga si el objeto es (o era) un Integer, un String, un Boolean para almacenarlos en distintas variables según el tipo  y luego operar con ellas (concatenar, comparar, etc..)?
• ¿Debería de haberlos juntado de otra manera para poder operar con ellos?

A la espera quedo de vuestros sabios consejos. Gracias y un saludo. 

[Mastermind]

Hola, Java no admite arrays o matrices del tipo var valores = [true, 5, false, "hola", "adios", 2] y no permite algunas cosas que sí permite JavaScript.

De hecho, Java y JavaScript son bastante diferentes. Sí tienen parecido el nombre, pero lo que es la programación es bastante distinta.

Para aprender Java te recomiendo seguir este curso que están siguiendo muchas personas, https://www.aprenderaprogramar.com/index.php?option=com_content&view=category&id=68&Itemid=188

Dentro de ese curso se explica todo lo necesario, también cómo se puede distinguir el tipo de objeto dentro de una colección usando instanceOf, etc.

Saludos!!

[Kabuto]

Gracias por tu respuesta.

Precisamente llevo un par de semanitas haciendo el curso de aprendizaje básico y antes de seguir con él, quería hacer más ejercicios extra porque como dije, he aprendido muchas cosas, pero otra cosa es haberlas "comprendido".
Aprender == Comprender --> False xDD

Y gracias a que se me ha atragantado este ejercicio, he comprendido mejor cosas que había aprendido. Y ya lo he resuelto (con ayudita de alguien más versado que yo en Java).
Lo cierto es que es mucho más fácil que toda la movida que estaba intentando yo hacer montando esa Colección.
Basta con usar un array de tipo Object y ya tenemos una matriz equivalente a la propuesta en el ejercicio de JavaScript.
Pego aquí el código, con el ejercicio completamente resuelto, para quien pueda ser de ayuda.

Lo cierto es que la solución original es menos enrevesada, bastaba con hacer las operaciones apuntando a los objetos de la matriz original, puesto que sabemos donde están los valores booleanos (posiciones 0 y 2), donde los números(posiciones 1 y 5) y donde las cadenas(posiciones 3 y 4).

Pero yo he querido complicarlo un poco más  y simular que no sabemos donde encontrar cada objeto, y por eso hay que recorrer la matriz, preguntar que tipo de objeto es y moverlo al sitio adecuado para posteriormente realizar las operaciones.

Código: [Seleccionar]

/**
 * Ejercicio con una matriz de objetos de distinto tipo con los que luego hacer diversas operaciones
 * a) Concatenar las dos cadenas y mostrarlas
 * b) Compara los números entre sí con todos los comparadores de comparación
 * c) Comparar todos los valores de la matriz entre sí de dos en dos y ver el resultado
 * d) Realizar diferentes operaciones aritméticas con los números
 * @author Kabuto
 * @version 08/04/2015
 */
public class OperacionesMatriz{
    public static void main (String[] args){
        //Inicializamos array tipo Object que contiene objetos de distinto tipo
        final Object[] matrizVariada = new Object[]{true, 5, false, "hola", "adios", 2};
        //Declaramos una variable para concatenar cadenas
        String cadenaConcatenada ="";
        //Declaramos dos matrices para almacenar booleanos y enteros según los encontremos.
        //También declaramos dos contadores para usar como índices en estas matrices
        Boolean[] matrizBool = new Boolean[2]; int x=0;
        Integer[] matrizInt = new Integer[2]; int y=0;
       
        //Recorremos la matriz para extraer valores usando "instanceof" para discriminar a que tipo pertenecen.
        for (Object tmp: matrizVariada) {
            if (tmp instanceof String) {cadenaConcatenada += tmp;} // Las cadenas las concatenamos sobre la marcha
            if (tmp instanceof Integer) {matrizInt[y] = (int)tmp; y++;}//Guardamos el valor en la matriz adecuada y aumentamos el índice para que el próximo elemento se guarde en el siguiente campo
            if (tmp instanceof Boolean) {matrizBool[x] = (boolean)tmp; x++;}
        }

        //Comenzamos con las operaciones
        System.out.println("A) Concatenar las dos cadenas y mostrarlas:");
        System.out.println(cadenaConcatenada);
        System.out.println("");
        System.out.println("B) Compara los números entre sí con todos los comparadores de comparación:");
        System.out.println(matrizInt[0] + " < " + matrizInt[1] + " es: " + (matrizInt[0] < matrizInt[1]));
        System.out.println(matrizInt[0] + " > " + matrizInt[1] + " es: " + (matrizInt[0] > matrizInt[1]));
        System.out.println(matrizInt[0] + " == " + matrizInt[1] + " es: " + (matrizInt[0] == matrizInt[1]));
        System.out.println(matrizInt[0] + " != " + matrizInt[1] + " es: " + (matrizInt[0] != matrizInt[1]));
        System.out.println("");
        System.out.println("C) Comparar todos los valores de la matriz entre sí de dos en dos y ver el resultado:");
        //Para este usamos un bucle for anidado dentro de otro for, así obtenemos dos índices para recorrer la matriz de manera que cada elemento se compara con sí mismo y con el resto de elementos
        for (int i=0; i < matrizVariada.length; i++){
            for (int j=0; j < matrizVariada.length; j++){System.out.println(matrizVariada[i] + " es igual a " + matrizVariada[j] + " : " + (matrizVariada[i] == matrizVariada[j]));}
        }
        System.out.println("");
        System.out.println("D) Realizar diferentes operaciones aritméticas con los números:");
        System.out.println(matrizInt[0] + " + " + matrizInt[1] + " = " + (matrizInt[0] + matrizInt[1]));
        System.out.println(matrizInt[0] + " - " + matrizInt[1] + " = " + (matrizInt[0] - matrizInt[1]));
        System.out.println(matrizInt[0] + " * " + matrizInt[1] + " = " + (matrizInt[0] * matrizInt[1]));
        System.out.println(matrizInt[0] + " / " + matrizInt[1] + " = " + (matrizInt[0] / matrizInt[1]));
        System.out.println(matrizInt[0] + " % " + matrizInt[1] + " = " + (matrizInt[0] % matrizInt[1]));
    }
}


[Ogramar]

Hola Kabuto, gracias por pegar la solución, le puede servir de ayuda para otras personas. Salu2