Warum Grundprinzipien der Softwareentwicklung auch in Zeiten von KI unverzichtbar bleiben

/**
 * The Matrix interface defines basic operations on a 2D matrix.
 * Any implementation (e.g., SparseMatrix, DenseMatrix) should implement
 * these methods to ensure compatibility with display or other functionalities.
 */

public interface Matrix {

    /**
     * Retrieves the total number of rows in the matrix.
     *
     * @return the number of rows
     */
    int getNumRows();

    /**
     * Retrieves the total number of columns in the matrix.
     *
     * @return the number of columns
     */
    int getNumCols();

    /**
     * Gets the value at the specified row and column.
     *
     * @param row the row index (0-based)
     * @param col the column index (0-based)
     * @return the value stored at the specified cell
     * @throws IndexOutOfBoundsException if the row or column is out of valid range
     */
    double get(int row, int col);

    /**
     * Sets the value at the specified row and column.
     * If the value is zero, the entry can be removed or not stored 
     * (especially in a sparse representation).
     *
     * @param row   the row index (0-based)
     * @param col   the column index (0-based)
     * @param value the value to store
     * @throws IndexOutOfBoundsException if the row or column is out of valid range
     */
    void set(int row, int col, double value);
}

import java.util.HashMap;
import java.util.Map;

/**
 * The SparseMatrix class implements a 2D matrix where only non-zero values
 * are stored in a nested HashMap structure. This helps to optimize memory usage
 * when the matrix has many zero entries.
 */
public class SparseMatrix implements Matrix {

    private final int numRows;
    private final int numCols;
    private final Map<Integer, Map<Integer, Double>> matrix;

    /**
     * Constructs a new SparseMatrix with the specified number of rows and columns.
     *
     * @param numRows the total number of rows in the matrix
     * @param numCols the total number of columns in the matrix
     */
    public SparseMatrix(int numRows, int numCols) {
        this.numRows = numRows;
        this.numCols = numCols;
        this.matrix = new HashMap<>();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public int getNumRows() {
        return numRows;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public int getNumCols() {
        return numCols;
    }

    /**
     * {@inheritDoc}
     * 
     * Stores the provided value at (row, col). If the value is 0.0, any existing 
     * entry is removed to maintain sparsity. If the value is non-zero, it is stored 
     * in the nested HashMap.
     */
    @Override
    public void set(int row, int col, double value) {
        if (row < 0 || row >= numRows || col < 0 || col >= numCols) {
            throw new IndexOutOfBoundsException("Invalid row or column index.");
        }

        if (value != 0.0) {
            // Store the non-zero value
            matrix.computeIfAbsent(row, r -> new HashMap<>()).put(col, value);
        } else {
            // Remove the entry if it exists
            if (matrix.containsKey(row)) {
                matrix.get(row).remove(col);
                // If no entries are left in this row, remove the row from the map
                if (matrix.get(row).isEmpty()) {
                    matrix.remove(row);
                }
            }
        }
    }

    /**
     * {@inheritDoc}
     * 
     * Retrieves the value at (row, col). If there is no stored value, 0.0 is returned.
     */
    @Override
    public double get(int row, int col) {
        if (row < 0 || row >= numRows || col < 0 || col >= numCols) {
            throw new IndexOutOfBoundsException("Invalid row or column index.");
        }

        if (matrix.containsKey(row) && matrix.get(row).containsKey(col)) {
            return matrix.get(row).get(col);
        }
        return 0.0;
    }
}

/**
 * The ConsoleMatrixDisplayer class is responsible for displaying matrices
 * in the console. It provides two methods: a simple tabular display and
 * a more advanced grid display with optional ANSI color highlighting.
 */
 
public class ConsoleMatrixDisplayer {

    /**
     * Displays the matrix in a simple tabular form (values separated by tabs).
     *
     * @param matrix the matrix to be displayed (any class implementing the Matrix interface)
     */
    public void display(Matrix matrix) {
        int numRows = matrix.getNumRows();
        int numCols = matrix.getNumCols();

        if (numRows == 0 || numCols == 0) {
            System.out.println("Empty matrix.");
            return;
        }

        // Print values row by row
        for (int row = 0; row < numRows; row++) {
            for (int col = 0; col < numCols; col++) {
                System.out.print(matrix.get(row, col) + "\t");
            }
            System.out.println(); // New line after each row
        }
    }

    /**
     * Displays the matrix with grid lines and enhanced formatting, including 
     * optional ANSI color highlighting for non-zero values. It first calculates 
     * the maximum width needed to format the cell contents properly, then prints
     * the grid.
     *
     * @param matrix the matrix to be displayed (any class implementing the Matrix interface)
     */
    public void displayWithGrid(Matrix matrix) {
        int numRows = matrix.getNumRows();
        int numCols = matrix.getNumCols();

        if (numRows == 0 || numCols == 0) {
            System.out.println("Empty matrix.");
            return;
        }

        // Determine the maximum string length of the matrix values for formatting
        int maxNumberLength = 0;
        for (int row = 0; row < numRows; row++) {
            for (int col = 0; col < numCols; col++) {
                String valueStr = String.format("%.2f", matrix.get(row, col));
                if (valueStr.length() > maxNumberLength) {
                    maxNumberLength = valueStr.length();
                }
            }
        }

        // The width of each cell in the grid (with a bit of extra padding)
        int cellWidth = Math.max(5, maxNumberLength + 2);

        // Prepare a separator line, which is reused for each row
        StringBuilder separator = new StringBuilder();
        for (int col = 0; col < numCols; col++) {
            separator.append("+");
            for (int i = 0; i < cellWidth; i++) {
                separator.append("-");
            }
        }
        separator.append("+");

        // ANSI color codes used for highlighting non-zero values
        final String ANSI_RESET = "\u001B[0m";
        final String ANSI_GREEN = "\u001B[32m";

        // Print the rows of the matrix
        for (int row = 0; row < numRows; row++) {
            // Print the separator line before each row
            System.out.println(separator);

            // Build a string for the current row
            StringBuilder rowBuilder = new StringBuilder();
            for (int col = 0; col < numCols; col++) {
                rowBuilder.append("| ");
                double value = matrix.get(row, col);
                String formattedValue = String.format("%.2f", value);

                // If the value is non-zero, highlight it in green
                if (value != 0.0) {
                    rowBuilder.append(String.format(
                            ANSI_GREEN + "%" + (cellWidth - 2) + "s " + ANSI_RESET,
                            formattedValue
                    ));
                } else {
                    rowBuilder.append(String.format("%" + (cellWidth - 2) + "s ", formattedValue));
                }
            }
            rowBuilder.append("|"); // Close the last cell
            System.out.println(rowBuilder.toString());
        }

        // Print the final separator line at the bottom of the grid
        System.out.println(separator);
    }
}

/**
 * The MatrixApp class shows how to create and manipulate a SparseMatrix 
 * and display it in the console using ConsoleMatrixDisplayer.
 */

public class MatrixApp {

    /**
     * Main method to run the demo. Creates a 4x4 sparse matrix, assigns some
     * non-zero values, and displays it in two different formats.
     *
     * @param args command-line arguments (not used)
     */
    public static void main(String[] args) {
        // Create a 4x4 SparseMatrix
        Matrix sparseMatrix = new SparseMatrix(4, 4);

        // Set some values at specific (row, col) positions
        sparseMatrix.set(0, 1, 5.0);
        sparseMatrix.set(2, 3, 10.0);
        sparseMatrix.set(3, 0, 3.5);

        // Create a displayer that handles console output
        ConsoleMatrixDisplayer displayer = new ConsoleMatrixDisplayer();

        // Display the matrix in a simple tabular form
        System.out.println("Simple Display:");
        displayer.display(sparseMatrix);

        // Display the matrix in a more detailed grid format
        System.out.println("\nGrid Display:");
        displayer.displayWithGrid(sparseMatrix);
    }
}