Cómo añadir objetos a una matriz 2D basado en caracteres en un archivo de entrada utilizando Java Corriente

USQ91:

Estoy leyendo las entradas de un archivo en el que cada línea tiene el mismo número de caracteres.

ootooooooo 

ooooooo T oo 

rrroooo T oo 

rrrroooooo 

rrrrrtoooo

Estoy tratando de agregar objetos a una matriz 2D de tipo cuadrado [] []. Square es una interfaz con múltiples implementaciones como SquareOne, SquareTwo, SquareThree etc.

Dondequiera que el archivo tiene 'o', tengo la intención de añadir un objeto SquareOne para esa ubicación. Asimismo SquareTwo de 't', SquareThree de 'r' y así sucesivamente. Por ejemplo cuadrado [0] [0] debe tener SquareOne obj mientras [0] [2] debe tener SquareTwo obj.

¿Cómo puedo lograr que el uso de Java 8 corriente?

He llegado tan lejos como para leer los caracteres de este archivo y añadir a todos ellos a un char [] [] Array. Pero en cambio, quiero añadir objetos basado en el carácter de la plaza [] [].

 public static char[][] addFromFileToSquareArray(String filePath){
        char[][] doubleChar = new char[5][10];
        try (Stream<String> stream = Files.lines(Paths.get(filePath))) {
           doubleChar =  stream
                         .map(x->x.replaceAll(" ",""))
                         .map(String::toCharArray).toArray(char[][]::new);

        } catch (IOException e) {
            e.printStackTrace();
        }
        return doubleChar;
    }

Holger:

Un enfoque sería para transmitir a través de los personajes de cada cadena, como

public static Square[][] addFromFileToSquareArray(String filePath) {
    Square[][] squares;
    try(Stream<String> stream = Files.lines(Paths.get(filePath))) {
        squares = stream
            .filter(line -> !line.isEmpty())
            .map(line -> line.chars()
                .filter(ch -> ch != ' ')
                .mapToObj(ch -> ch =='o'? new SquareOne():
                          ch == 't'? new SquareTwo(): new SquareThree())
                .toArray(Square[]::new) )
            .toArray(Square[][]::new);
    } catch(IOException e) {
        throw new UncheckedIOException(e);
    }
    return squares;
}

En general, yo prefiero a declarar throws IOExceptionen el método para hacer cumplir la persona que llama para hacer frente a posibles excepciones razonable. Al menos, no se debe coger excpeptions, sólo para imprimirlos y devolver un valor de resultado que causar otros problemas en un momento posterior (como un array sin inicializar como en su código original).

Desde el mapeo parece tener la intención de ser extensible, vale la pena y que se incorpore un método propio, por ejemplo,

public static Square squareFor(int type) {
    switch(type) {
        case 'o': return new SquareOne();
        case 't': return new SquareTwo();
        case 'r': return new SquareThree();
        default: throw new IllegalArgumentException("type "+(char)type);
    }
}

y use

public static Square[][] addFromFileToSquareArray(String filePath) {
    Square[][] squares;
    try(Stream<String> stream = Files.lines(Paths.get(filePath))) {
        squares = stream
            .filter(line -> !line.isEmpty())
            .map(line -> line.chars()
                .filter(ch -> ch != ' ')
                .mapToObj(Square::squareFor)
                .toArray(Square[]::new) )
            .toArray(Square[][]::new);
    } catch(IOException e) {
        throw new UncheckedIOException(e);
    }
    return squares;
}

^{Hice el squareFormétodo correcto en la Squareinterfaz. De lo contrario, usted tiene que cambiar la clase de la Square::squareForreferencia.}

Alternativamente, se puede utilizar una Map

public static Square[][] addFromFileToSquareArray(String filePath) {
    Square[][] squares;
    Pattern spaces = Pattern.compile(" ");
    try(Stream<String> stream = Files.lines(Paths.get(filePath))) {
        squares = stream
            .filter(line -> !line.isEmpty())
            .map(line -> spaces.splitAsStream(line)
                .map(Square::squareFor)
                .toArray(Square[]::new) )
            .toArray(Square[][]::new);
    } catch(IOException e) {
        throw new UncheckedIOException(e);
    }
    return squares;
}
static final Map<String,Supplier<Square>> MAP = Map.of(
    "o", SquareOne::new,
    "t", SquareTwo::new,
    "r", SquareThree::new
);
public static Square squareFor(String type) {
    Supplier<Square> s = MAP.get(type);
    if(s == null) throw new IllegalArgumentException("type "+type);
    return s.get();
}

En este caso, la línea se divide en subseries utiliza los espacios como delimitador, que eliminarán intrínsecamente ellos, así que no hay filteroperación necesaria después. Sin embargo, su vida sería mucho más fácil si pudiera volver a definir su formato de entrada a no contener estos espacios.