Al nivel más simple, puede crear una estructura de datos de una hoja de cálculo en Java usando un simple array 2D. Sin embargo, este enfoque deja mucho que desear. Idealmente, una estructura de datos de hoja de cálculo debe ser capaz de cambiar el tamaño de manera eficiente, insertar y eliminar filas y columnas completas, y estas operaciones son computacionalmente costosa en una matriz de Java, lo que requiere Java para reconstruir toda la estructura de datos desde cero detrás de las escenas cada vez que tal se realiza la operación.
En su lugar, debe usar algo un poco más sofisticado: una lista enlazada de listas enlazadas. Esto permitirá la inserción y extracción de filas y columnas, así como el cambio de tamaño de la tabla a ocurrir mucho más rápidamente. Sin embargo, vendrá con un pequeño costo de rendimiento, cuando llega el momento de acceder a células específicas de la hoja de cálculo fuera de turno.
Instrucciones
1 Crear un nuevo archivo de Java y el nombre de "SpreadsheetStructure.java." Si usted tiene un favorito entorno de desarrollo integrado (IDE), puede hacerlo haciendo clic en "Archivo", "Nueva Clase". Como alternativa, puede abrir el Bloc de notas de Windows haciendo clic en "Inicio", "Todos los programas", "Accesorios", "Bloc de notas" y guarda el archivo con ese nombre de archivo.
2 Cree su interfaz de clase pegando lo siguiente en el archivo que ha creado en el paso 1. El resto de los pasos se dedica a llenar en el código para cada uno de los métodos definidos en este paso:
Hoja de cálculo public class {
LinkedList<LinkedList> data = new LinkedList<LinkedList>();
Hoja de cálculo pública () {}
addRow public void () {}
pública addRow void (int index) {}
pública RemoveRow void (int index) {}
pública removeColumn void (int index) {}
addColumn public void () {}
pública addColumn void (int index) {}
SetCell public void (int x, int y, Cadena newData) {}
public int getWidth () {}
public int getHeight () {}
public String toString () {}
/ **
* Prueba de la clase,
* /
void main (String [] args) {} public static
}
La estructura de datos básica será un LinkedList de filas que contienen una LinkedList de columnas. Aunque un simple array 2D sería más sencillo de implementar, sino que también sería mucho más lento para muchas operaciones de hojas de cálculo comunes, especialmente la inserción y eliminación de filas.
3 Pegue el siguiente código entre los corchetes del método constructor, "hoja de cálculo":
public Spreadsheet() {
añadir fila();
añadir columna();
}
Esto simplemente asegura que empezamos con al menos una sola fila y columna.
4 Pega el siguiente para rellenar los dos métodos AddRow. Uno no tiene argumentos y automáticamente añade la fila al final de la hoja de cálculo, mientras que el otro permite al usuario especificar dónde agregar la fila:
public void addRow() {
data.addLast (new LinkedList & lt; String> ());
for (int x = 0; x & lt; getHeight (); x ++) {
. Data.getLast () add (new String ());
}
}
pública addRow void (int index) {
data.add (índice, new LinkedList & lt; String> ());
for (int x = 0; x & lt; getHeight (); x ++) {
data.get (índice) .add (new String ());
}
}
5 Pegar el código para eliminar una fila en el archivo de origen:
public void removeRow(int index) {
data.remove (índice);
}
6 Pegar el código para los dos métodos AddColumn. Estos funcionan de forma similar a los métodos AddRow - hay dos, una para la adición de una columna a la final de la hoja y una para la inserción de una columna en el medio:
public void addColumn() {
de (l LinkedList: datos) {
l.addLast (new String ());
}
}
pública addColumn void (int index) {
de (l LinkedList: datos) {
l.add (índice, new String ());
}
}
7 Pegar el código para la eliminación de columnas:
public void removeColumn(int index) {
de (l LinkedList: datos) {
l.remove (índice);
}
}
8 Pegar el código que establece el contenido de una celda dada a una cadena de datos:
public void setCell(int x, int y, String newData) {
data.get (x) .el juego (y, newData);
}
9 Rellena los métodos para obtener la anchura y la altura de la hoja de cálculo:
public int getWidth() {
volver data.getFirst size () ().;
}
public int getHeight () {
volver data.size ();
}
10 Implementar el método toString. Esto devolverá una cadena con formato se presentan, en una tabla de filas y columnas, los datos en la hoja de cálculo:
public String toString() {
String temp = "";
de (l LinkedList: datos) {
para (Object o: l) {
String s = (String) o;
(si s.equals ( "")) s = "-vacío-";
temp + = s + "";
}
temp + = "\ n";
}
temp retorno;
}
11 Pega el siguiente método principal que pone a la estructura de datos de hojas de cálculo a través de sus pasos y se asegura de que todo funciona como se esperaba:
public static void main(String[] args) {
hoja de hoja de cálculo nueva hoja de cálculo = ();
System.out.println (sheet.toString ());
System.out.print (sheet.getWidth ());
System.out.print ( "x");
System.out.println (sheet.getHeight ());
sheet.addRow ();
System.out.print (sheet.getWidth ());
System.out.print ( "x");
System.out.println (sheet.getHeight ());
sheet.setCell (0,0, "1");
sheet.setCell (0,1 ", 2");
sheet.setCell (1,0, "3");
sheet.setCell (1,1 ", 4");
System.out.println (sheet.toString ());
sheet.addColumn (1);
sheet.setCell (1,0, "TEMP");
sheet.setCell (1,1, "TEMP");
System.out.println (sheet.toString ());
sheet.removeRow (1);
System.out.println (sheet.toString ());
sheet.removeColumn (1);
System.out.println (sheet.toString ());
}