Apache POI - Guía rápida

Muchas veces, se requiere una aplicación de software para generar informes en formato de archivo de Microsoft Excel. A veces, incluso se espera que una aplicación reciba archivos de Excel como datos de entrada. Por ejemplo, se requerirá una aplicación desarrollada para el departamento de Finanzas de una empresa para generar todos sus resultados en Excel.

Cualquier programador de Java que quiera producir archivos de MS Office como salida debe usar una API predefinida y de solo lectura para hacerlo.

¿Qué es Apache POI?

Apache POI es una API popular que permite a los programadores crear, modificar y mostrar archivos de MS Office utilizando programas Java. Es una biblioteca de código abierto desarrollada y distribuida por Apache Software Foundation para diseñar o modificar archivos de Microsoft Office utilizando el programa Java. Contiene clases y métodos para decodificar los datos de entrada del usuario o un archivo en documentos de MS Office.

Componentes de Apache POI

Apache POI contiene clases y métodos para trabajar en todos los documentos compuestos OLE2 de MS Office. La lista de componentes de esta API se proporciona a continuación.

  • POIFS(Sistema de archivos de implementación de ofuscación deficiente): este componente es el factor básico de todos los demás elementos de PDI. Se utiliza para leer distintos archivos de forma explícita.

  • HSSF (Formato de hoja de cálculo horrible): se usa para leer y escribir xls formato de archivos MS-Excel.

  • XSSF (Formato de hoja de cálculo XML): se utiliza para xlsx formato de archivo de MS-Excel.

  • HPSF (Formato de conjunto de propiedades horribles): se utiliza para extraer property sets de los archivos de MS-Office.

  • HWPF (Formato de procesador de texto horrible): se usa para leer y escribir doc archivos de extensión de MS-Word.

  • XWPF (Formato de procesador de textos XML): se utiliza para leer y escribir docx archivos de extensión de MS-Word.

  • HSLF (Formato de diseño de diapositivas horrible): se utiliza para leer, crear y editar presentaciones de PowerPoint.

  • HDGF (Formato de diagrama horrible): contiene clases y métodos para MS-Visio archivos binarios.

  • HPBF (Horrible PuBlisher Format) - Se usa para leer y escribir MS-Publisher archivos.

Este tutorial lo guía a través del proceso de trabajar en archivos de Excel usando Java. Por lo tanto, la discusión se limita a los componentes HSSF y XSSF.

Note - Las versiones anteriores de POI admiten formatos de archivo binarios como doc, xls, ppt, etc. A partir de la versión 3.5, POI admite formatos de archivo OOXML de MS-Office como docx, xlsx, pptx, etc.

Al igual que Apache POI, existen otras bibliotecas proporcionadas por varios proveedores para la generación de archivos de Excel. Éstas incluyenAspose cells for Java por Aspose, JXL por Commons Libraries, y JExcel por Team Dev.

Este capítulo lo lleva a través de algunas de las variantes de la API de Excel de Java y sus características. Hay muchos proveedores que proporcionan API relacionadas con Java Excel; algunos de ellos se consideran en este capítulo.

Aspose Cells para Java

Aspose Cells para Java es una API de Java Excel con licencia pura desarrollada y distribuida por el proveedor Aspose. La última versión de esta API es 8.1.2, lanzada en julio de 2014. Es una API rica y pesada (combinación de clases simples de Java y clases AWT) para diseñar el componente de Excel que puede leer, escribir y manipular hojas de cálculo.

Los usos comunes de esta API son los siguientes:

  • Informes de Excel, cree informes dinámicos de Excel
  • Representación e impresión de Excel de alta fidelidad
  • Importar y exportar datos de hojas de cálculo de Excel
  • Genere, edite y convierta hojas de cálculo

JXL

JXL es un marco de trabajo de terceros diseñado para Selenium que admite la automatización basada en datos en navegadores web (actualización automática de datos en navegadores web). Sin embargo, también se utiliza como una biblioteca de soporte común para la API de JExcel porque tiene características básicas para crear, leer y escribir hojas de cálculo.

Las características básicas son las siguientes:

  • Genera archivos de Excel
  • Importar datos de libros de trabajo y hojas de cálculo
  • Obtenga el número total de filas y columnas

Note - JXL solo admite el formato de archivo .xls y no puede manejar grandes volúmenes de datos.

JExcel

JExcel es una API con licencia pura proporcionada por Team Dev. Con esto, los programadores pueden leer, escribir, mostrar y modificar fácilmente libros de Excel en ambos.xls y .xlsxformatos. Esta API se puede integrar fácilmente con Java Swing y AWT. La última versión de esta API es Jexcel-2.6.12, lanzada en 2009.

Las principales características son las siguientes:

  • Automatice la aplicación de Excel, libros de trabajo, hojas de cálculo, etc.
  • Incrustar libros de trabajo en una aplicación Java Swing como componente normal de Swing
  • Agregar detectores de eventos a libros de trabajo y hojas de cálculo
  • Agregue controladores de eventos para controlar el comportamiento de los eventos del libro de trabajo y la hoja de cálculo
  • Agregue pares nativos para desarrollar funciones personalizadas

PDI de Apache

Apache POI es una biblioteca 100% de código abierto proporcionada por Apache Software Foundation. La mayoría de los desarrolladores de aplicaciones de pequeña y mediana escala dependen en gran medida de Apache POI (HSSF + XSSF). Es compatible con todas las funciones básicas de las bibliotecas de Excel; sin embargo, la renderización y la extracción de texto son sus principales características.

Este capítulo lo lleva a través del proceso de configuración de Apache POI en sistemas basados ​​en Windows y Linux. Apache POI se puede instalar e integrar fácilmente con su entorno Java actual siguiendo unos sencillos pasos sin ningún procedimiento de configuración complejo. Se requiere la administración de usuarios durante la instalación.

Requisitos del sistema

JDK Java SE 2 JDK 1.5 o superior
Memoria 1 GB de RAM (recomendado)
Espacio del disco Sin requisito mínimo
Versión del sistema operativo Windows XP o superior, Linux

Procedamos ahora con los pasos para instalar Apache POI.

Paso 1: Verifique su instalación de Java

En primer lugar, debe tener el kit de desarrollo de software Java (SDK) instalado en su sistema. Para verificar esto, ejecute cualquiera de los dos comandos dependiendo de la plataforma en la que esté trabajando.

Si la instalación de Java se ha realizado correctamente, mostrará la versión actual y la especificación de su instalación de Java. En la siguiente tabla se proporciona un resultado de muestra.

Plataforma Mando Salida de muestra
Ventanas

Abra la consola de comandos y escriba -

\>java –version

Versión de Java "1.7.0_60"

Entorno de tiempo de ejecución Java (TM) SE (compilación 1.7.0_60-b19)

VM de servidor Java Hotspot (TM) de 64 bits (compilación 24.60-b09, modo mixto)
Linux

Abra el terminal de comando y escriba -

$java –version

versión de Java "1.7.0_25"

Entorno de tiempo de ejecución abierto de JDK (rhel-2.3.10.4.el6_4-x86_64)

Abra la máquina virtual del servidor JDK de 64 bits (compilación 23.7-b01, modo mixto)

  • Suponemos que los lectores de este tutorial tienen la versión 1.7.0_60 de Java SDK instalada en su sistema.

  • En caso de que no tenga Java SDK, descargue su versión actual desde https://www.oracle.com/technetwork/java/javase/downloads/index.html y tenerlo instalado.

Paso 2: configura tu entorno Java

Configure la variable de entorno JAVA_HOME para que apunte a la ubicación del directorio base donde está instalado Java en su máquina. Por ejemplo,

No Señor. Plataforma y descripción
1

Windows

Establezca JAVA_HOME en C: \ ProgramFiles \ java \ jdk1.7.0_60
2

Linux

Exportar JAVA_HOME = / usr / local / java-current

Agregue la ruta completa de la ubicación del compilador de Java a la ruta del sistema.

No Señor. Plataforma y descripción
1

Windows

Agregue la cadena "C: \ Archivos de programa \ Java \ jdk1.7.0_60 \ bin" al final de la variable de sistema PATH.
2

Linux

Exportar RUTA = $ RUTA: $ JAVA_HOME / bin /

Ejecuta el comando java -version desde el símbolo del sistema como se explicó anteriormente.

Paso 3: instalar la biblioteca de puntos de interés de Apache

Descargue la última versión de Apache POI de https://poi.apache.org/download.htmly descomprima su contenido en una carpeta desde donde las bibliotecas necesarias se pueden vincular a su programa Java. Supongamos que los archivos se recopilan en una carpeta en la unidad C.

Las siguientes imágenes muestran los directorios y la estructura de archivos dentro de la carpeta descargada.

Agrega la ruta completa de los cinco jars como se resalta en la imagen de arriba en CLASSPATH.

No Señor. Plataforma y descripción
1

Windows

Agregue las siguientes cadenas al final de la variable de usuario

CLASSPATH -

"C: \ poi-3.9 \ poi-3.9-20121203.jar;"

"C: \ poi-3.9 \ poi-ooxml-3.9-20121203.jar;"

"C: \ poi-3.9 \ poi-ooxml-schemas-3.9-20121203.jar;"

"C: \ poi-3.9 \ ooxml-lib \ dom4j-1.6.1.jar;"

"C: \ poi-3.9 \ ooxml-lib \ xmlbeans-2.3.0.jar;.;"
2

Linux

Exportar CLASSPATH = $ CLASSPATH:

/usr/share/poi-3.9/poi-3.9-20121203.tar:

/usr/share/poi-3.9/poi-ooxml-schemas-3.9-20121203.tar:

/usr/share/poi-3.9/poi-ooxml-3.9-20121203.tar:

/usr/share/poi-3.9/ooxml-lib/dom4j-1.6.1.tar:

/usr/share/poi-3.9/ooxml-lib/xmlbeans-2.3.0.tar

Este capítulo explica algunas clases y métodos de la API de POI de Apache que son fundamentales para trabajar con archivos de Excel utilizando programas Java.

Libro de trabajo

Esta es la superinterfaz de todas las clases que crean o mantienen libros de Excel. Pertenece a laorg.apache.poi.ss.usermodelpaquete. Las dos clases que implementan esta interfaz son las siguientes:

  • HSSFWorkbook- Esta clase tiene métodos para leer y escribir archivos de Microsoft Excel en formato .xls. Es compatible con las versiones 97-2003 de MS-Office.

  • XSSFWorkbook- Esta clase tiene métodos para leer y escribir archivos xml de Microsoft Excel y OpenOffice en formato .xls o .xlsx. Es compatible con las versiones 2007 o posteriores de MS-Office.

HSSFWorkbook

Es una clase de alto nivel bajo el org.apache.poi.hssf.usermodelpaquete. Implementa laWorkbookinterfaz y se utiliza para archivos de Excel en formato .xls. A continuación se enumeran algunos de los métodos y constructores de esta clase.

Constructores de clases

No Señor. Constructor y descripción
1

HSSFWorkbook()

Crea un nuevo objeto HSSFWorkbook desde cero.
2

HSSFWorkbook(DirectoryNode directory, boolean preserveNodes)

Crea un nuevo objeto de libro de trabajo HSSFW dentro de un directorio específico.
3

HSSFWorkbook(DirectoryNode directory, POIFSFileSystem fs, boolean preserveNodes)

Dado un objeto POIFSFileSystem y un directorio específico dentro de él, crea un objeto SSFWorkbook para leer un libro de trabajo específico.
4

HSSFWorkbook(java.io.InputStream s)

Crea un nuevo objeto HSSFWorkbook utilizando un flujo de entrada.
5

HSSFWorkbook(java.io.InputStream s, boolean preserveNodes)

Construye un sistema de archivos POI alrededor de su flujo de entrada.
6

HSSFWorkbook(POIFSFileSystem fs)

Construye un nuevo objeto HSSFWorkbook utilizando un objeto POIFSFileSystem.
7

HSSFWorkbook(POIFSFileSystem fs, boolean preserveNodes)

Dado un objeto POIFSFileSystem, crea un nuevo objeto HSSFWorkbook para leer un libro específico.

Los parámetros de uso frecuente dentro de estos constructores son:

  • directory - Es el directorio del sistema de archivos POI desde el que se procesa.

  • fs - Es el sistema de archivos POI que contiene la secuencia del libro de trabajo.

  • preservenodes- Este es un parámetro opcional que decide si preservar otros nodos como macros. Consume mucha memoria ya que almacena todo el POIFileSystem en la memoria (si está configurado).

Note- La clase HSSFWorkbook contiene varios métodos; sin embargo, solo son compatibles con el formato xls. En este tutorial, la atención se centra en la última versión de los formatos de archivo de Excel. Por lo tanto, los métodos de clase de HSSFWorkbook no se enumeran aquí. Si necesita estos métodos de clase, consulte la API de clase POI-HSSFWorkbook enhttps://poi.apache.org/apidocs/org/apache/poi/hssf/usermodel/HSSFWorkbook.html.

XSSFWorkbook

Es una clase que se utiliza para representar formatos de archivo de Excel de alto y bajo nivel. Pertenece a laorg.apache.xssf.usemodel empaquetar e implementar el Workbookinterfaz. A continuación se enumeran los métodos y constructores de esta clase.

Constructores de clases

No Señor. Constructor y descripción
1

XSSFWorkbook()

Crea un nuevo objeto XSSFworkbook desde cero.
2

XSSFWorkbook(java.io.File file)

Construye un objeto XSSFWorkbook a partir de un archivo determinado.
3

XSSFWorkbook(java.io.InputStream is)

Construye un objeto XSSFWorkbook, almacenando en búfer todo el flujo de entrada en la memoria y luego abriendo un objeto OPCPackage para él.
4

XSSFWorkbook(java.lang.String path)

Construye un objeto XSSFWorkbook dada la ruta completa de un archivo.

Métodos de clase

No Señor. Método y descripción
1

createSheet()

Crea una hoja XSSFS para este libro de trabajo, la agrega a las hojas y devuelve la representación de alto nivel.
2

createSheet(java.lang.String sheetname)

Crea una nueva hoja para este Libro de trabajo y devuelve la representación de alto nivel.
3

createFont()

Crea una nueva fuente y la agrega a la tabla de fuentes del libro.
4

createCellStyle()

Crea un nuevo XSSFCellStyle y lo agrega a la tabla de estilos del libro.
5

createFont()

Crea una nueva fuente y la agrega a la tabla de fuentes del libro.
6

setPrintArea(int sheetIndex, int startColumn, int endColumn, int startRow,int endRow)

Establece el área de impresión de una hoja determinada según los parámetros especificados.

Para los métodos restantes de esta clase, consulte el documento API completo en: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFWorkbook.html. para obtener la lista completa de métodos.

Sábana

La hoja es una interfaz bajo el org.apache.poi.ss.usermodelpackage y es una superinterfaz de todas las clases que crea hojas de cálculo de alto o bajo nivel con nombres específicos. El tipo más común de hoja de cálculo es la hoja de trabajo, que se representa como una cuadrícula de celdas.

Hoja HSSFS

Esta es una clase bajo el org.apache.poi.hssf.usermodelpaquete. Puede crear hojas de cálculo de Excel y permite formatear el estilo de la hoja y los datos de la hoja.

Constructores de clases

No Señor. Constructor y descripción
1

HSSFSheet(HSSFWorkbook workbook)

Crea una nueva hoja HSSFS llamada por HSSFWorkbook para crear una hoja desde cero.
2

HSSFSheet(HSSFWorkbook workbook, InternalSheet sheet)

Crea una hoja HSSFS que representa el objeto de hoja dado.

XSSFSheet

Esta es una clase que representa una representación de alto nivel de una hoja de cálculo de Excel. Está bajoorg.apache.poi.hssf.usermodel paquete.

Constructores de clases

No Señor. Constructor y descripción
1

XSSFSheet()

Crea una nueva hoja XSSFS - llamada por XSSFWorkbook para crear una hoja desde cero.
2

XSSFSheet(PackagePart part, PackageRelationship rel)

Crea una hoja XSSFS que representa la parte y la relación del paquete dadas.

Métodos de clase

No Señor. Método y descripción
1

addMergedRegion(CellRangeAddress region)

Agrega una región combinada de células (por lo tanto, esas células forman una).
2

autoSizeColumn(int column)

Ajusta el ancho de la columna para adaptarse al contenido.
3

iterator()

Este método es un alias para rowIterator () para permitir bucles foreach
4

addHyperlink(XSSFHyperlink hyperlink)

Registra un hipervínculo en la colección de hipervínculos de esta hoja

Para los métodos restantes de esta clase, consulte la API completa en: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFSheet.html.

Fila

Esta es una interfaz bajo el org.apache.poi.ss.usermodelpaquete. Se utiliza para la representación de alto nivel de una fila de una hoja de cálculo. Es una superinterfaz de todas las clases que representan filas en la biblioteca de puntos de interés.

XSSFRow

Esta es una clase bajo el org.apache.poi.xssf.usermodelpaquete. Implementa la interfaz Row, por lo que puede crear filas en una hoja de cálculo. A continuación se enumeran los métodos y constructores de esta clase.

Métodos de clase

No Señor. Método y descripción
1

createCell(int columnIndex)

Crea nuevas celdas dentro de la fila y la devuelve.
2

setHeight(short height)

Establece la altura en unidades cortas.

Para los métodos restantes de esta clase, siga el enlace dado https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFRow.html

Celda

Esta es una interfaz bajo el org.apache.poi.ss.usermodelpaquete. Es una superinterfaz de todas las clases que representan celdas en las filas de una hoja de cálculo.

Las celdas pueden tener varios atributos como en blanco, numérico, fecha, error, etc. Las celdas deben tener sus propios números (basados ​​en 0) antes de agregarse a una fila.

XSSFCell

Esta es una clase bajo el org.apache.poi.xssf.usermodelpaquete. Implementa la interfaz Cell. Es una representación de alto nivel de celdas en las filas de una hoja de cálculo.

Campo Resumen

A continuación se enumeran algunos de los campos de la clase XSSFCell junto con su descripción.

No Señor. Tipo de celda y descripción
1

CELL_TYPE_BLANK

Representa celda en blanco
2

CELL_TYPE_BOOLEAN

Representa celda booleana (verdadero o falso)
3

CELL_TYPE_ERROR

Representa el valor de error en una celda
4

CELL_TYPE_FORMULA

Representa el resultado de la fórmula en una celda
5

CELL_TYPE_NUMERIC

Representa datos numéricos en una celda.
6

CELL_TYPE_STRING

Representa una cadena (texto) en una celda

Métodos de clase

No Señor. Método y descripción
1

setCellStyle(CellStyle style)

Establece el estilo de la celda.
2

setCellType(int cellType)

Establece el tipo de celdas (numéricas, de fórmula o de cadena).
3

setCellValue(boolean value)

Establece un valor booleano para la celda.
4

setCellValue(java.util.Calendar value)

Establece un valor de fecha para la celda.
5

setCellValue(double value)

Establece un valor numérico para la celda.
6

setCellValue(java.lang.String str)

Establece un valor de cadena para la celda.
7

setHyperlink(Hyperlink hyperlink)

Asigna un hipervínculo a esta celda.

Para los métodos y campos restantes de esta clase, visite el siguiente enlace: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFCell.html

XSSFCellStyle

Esta es una clase bajo el org.apache.poi.xssf.usermodelpaquete. Proporcionará información posible sobre el formato del contenido en una celda de una hoja de cálculo. También proporciona opciones para modificar ese formato. Implementa la interfaz CellStyle.

Campo Resumen

La siguiente tabla enumera algunos campos que se heredan de la interfaz CellStyle.

No Señor. Campo Descripción
1

ALIGN_CENTER

Alinear al centro el contenido de la celda
2

ALIGN_CENTER_SELECTION

Alineación horizontal de selección central
3

ALIGN_FILL

Ajuste de celda al tamaño del contenido
4

ALIGN_JUSTIFY

Ajustar el contenido de la celda a su ancho
5

ALIGN_LEFT

Alinear a la izquierda el contenido de la celda
6

ALIGN_RIGHT

Alinear a la derecha el contenido de la celda
7

BORDER_DASH_DOT

Estilo de celda con guión y punto
8

BORDER_DOTTED

Estilo de celda con borde punteado
9

BORDER_DASHED

Estilo de celda con borde punteado
10

BORDER_THICK

Estilo de celda con borde grueso
11

BORDER_THIN

Estilo de celda con borde delgado
12

VERTICAL_BOTTOM

Alinear el contenido de la celda en la parte inferior vertical
13

VERTICAL_CENTER

Alinear el centro vertical del contenido de la celda
15

VERTICAL_JUSTIFY

Alinear y justificar el contenido de la celda verticalmente
dieciséis

VERTICAL_TOP

Alineación vertical alineada superior

Constructores de clases

No Señor. Constructor y descripción
1

XSSFCellStyle(int cellXfId, int cellStyleXfId, StylesTable stylesSource, ThemesTable theme)

Crea un estilo de celda a partir de las piezas suministradas
2

XSSFCellStyle(StylesTable stylesSource)

Crea un estilo de celda vacía

Métodos de clase

S. No Método y descripción
1

setAlignment(short align)

Establece el tipo de alineación horizontal de la celda.
2

setBorderBottom(short border)

Establece el tipo de borde para el borde inferior de la celda
3

setBorderColor(XSSFCellBorder.BorderSide side, XSSFColor color)

Establece el color del borde seleccionado
4

setBorderLeft(Short border)

Establece el tipo de borde para el borde izquierdo de la celda
5

setBorderRight(short border)

Establece el tipo de borde para el borde derecho de la celda
6

setBorderTop(short border)

Establece el tipo de borde para el borde superior de la celda
7

setFillBackgroundColor(XSSFColor color)

Establece el color de relleno de fondo representado como un valor XSSFColor.
8

setFillForegroundColor(XSSFColor color)

Establece el color de relleno de primer plano representado como un valor XSSFColor.
9

setFillPattern(short fp)

Especifica la información de relleno de celda para rellenos de celda de patrón y color sólido.
10

setFont(Font font)

Establece la fuente para este estilo.
11

setRotation(short rotation)

Establece el grado de rotación del texto en la celda.
12

setVerticalAlignment(short align)

Establece el tipo de alineación vertical de la celda.

Para los métodos y campos restantes en esta clase, vaya al siguiente enlace: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFCellStyle.html

HSSFColor

Esta es una clase bajo el org.apache.poi.hssf.utilpaquete. Proporciona diferentes colores como clases anidadas. Por lo general, estas clases anidadas se representan mediante sus propios índices. Implementa la interfaz Color.

Clases anidadas

Todas las clases anidadas de esta clase son estáticas y cada clase tiene su índice. Estas clases de color anidadas se utilizan para el formato de celda, como el contenido, el borde, el primer plano y el fondo de la celda. A continuación se enumeran algunas de las clases anidadas.

No Señor. Nombres de clases (colores)
1 HSSFColor.AQUA
2 HSSFColor.AUTOMÁTICO
3 HSSFColor.BLACK
4 HSSFColor.BLUE
5 HSSFColor.BRIGHT_GREEN
6 HSSFColor.BRIGHT_GRAY
7 HSSFColor.CORAL
8 HSSFColor.DARK_BLUE
9 HSSFColor.DARK_GREEN
10 HSSFColor.SKY_BLUE
11 HSSFColor.WHITE
12 HSSFColor.AMARILLO

Métodos de clase

Solo un método de esta clase es importante y se utiliza para obtener el valor del índice.

No Señor. Método y descripción
1

getIndex()

Este método se utiliza para obtener el valor de índice de una clase anidada.

Para los métodos restantes y las clases anidadas, consulte el siguiente enlace: https://poi.apache.org/apidocs/org/apache/poi/hssf/util/HSSFColor.html

XSSFColor

Esta es una clase bajo el org.apache.poi.xssf.usermodelpaquete. Se utiliza para representar el color en una hoja de cálculo. Implementa la interfaz Color. A continuación se enumeran algunos de sus métodos y constructores.

Constructores de clases

No Señor. Constructor y descripción
1

XSSFColor()

Crea una nueva instancia de XSSFColor.
2

XSSFColor(byte[] rgb)

Crea una nueva instancia de XSSFColor usando RGB.
3

XSSFColor(java.awt.Color clr)

Crea una nueva instancia de XSSFColor usando la clase Color del paquete awt.

Métodos de clase

No Señor. Método y descripción
1

setAuto(boolean auto)

Establece un valor booleano para indicar que ctColor es automático y el sistema ctColor es dependiente.
2

setIndexed(int indexed)

Establece el valor ctColor indexado como sistema ctColor.

Para los métodos restantes, visite el siguiente enlace: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFColor.html

XSSFFont

Esta es una clase bajo el org.apache.poi.xssf.usermodelpaquete. Implementa la interfaz de fuentes y, por lo tanto, puede manejar diferentes fuentes en un libro de trabajo.

Constructor de clases

No Señor. Constructor y descripción
1

XSSFFont()

Crea una nueva instancia de XSSFont.

Métodos de clase

No Señor. Método y descripción
1

setBold(boolean bold)

Establece un valor booleano para el atributo 'negrita'.
2

setColor(short color)

Establece el color indexado para la fuente.
3

setColor(XSSFColor color)

Establece el color de la fuente en el valor de color Standard Alpha RGB.
4

setFontHeight(short height)

Establece la altura de la fuente en puntos.
5

setFontName(java.lang.String name)

Establece el nombre de la fuente.
6

setItalic(boolean italic)

Establece un valor booleano para la propiedad 'cursiva'.

Para los métodos restantes, vaya al siguiente enlace: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFFont.html

XSSFHyperlink

Esta es una clase bajo el org.apache.poi.xssf.usermodelpaquete. Implementa la interfaz Hyperlink. Se utiliza para establecer un hipervínculo al contenido de la celda de una hoja de cálculo.

Campos

Los campos de esta clase son los siguientes. Aquí, los campos significan los tipos de hipervínculos utilizados.

No Señor. Campo Descripción
1

LINK_DOCUMENT

Se usa para vincular cualquier otro documento
2

LINK_EMAIL

Se usa para vincular el correo electrónico
3

LINK_FILE

Se utiliza para vincular cualquier otro archivo en cualquier formato
4

LINK_URL

Se usa para vincular una URL web

Métodos de clase

No Señor. Método y descripción
1

setAddress(java.lang.String address)

Dirección de hipervínculo.

Para los métodos restantes, visite el siguiente enlace: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFHyperlink.html

XSSFCreationHelper

Esta es una clase bajo el org.apache.poi.xssf.usermodelpaquete. Implementa la interfaz CreationHelper. Se utiliza como clase de apoyo para la evaluación de fórmulas y la configuración de hipervínculos.

Métodos de clase

No Señor. Método y descripción
1

createFormulaEvaluator()

Crea una instancia XSSFFormulaEvaluator, el objeto que evalúa las celdas de fórmula.
2

createHyperlink(int type)

Crea un nuevo XSSFHyperlink.

Para los métodos restantes, consulte el siguiente enlace: https://poi.apache.org/apidocs/org/apache/poi/xssf/usermodel/XSSFCreationHelper.html

XSSFPrintSetup

Esta es una clase bajo el org.apache.poi.xsssf.usermodelpaquete. Implementa laPrintSetupinterfaz. Se utiliza para configurar el tamaño, el área, las opciones y la configuración de la página de impresión.

Métodos de clase

No Señor. Método y descripción
1

setLandscape(boolean ls)

Establece un valor booleano para permitir o bloquear la impresión horizontal.
2

setLeftToRight(boolean ltor)

Establece si se realiza el pedido de izquierda a derecha o de arriba hacia abajo durante la impresión.
3

setPaperSize(short size)

Establece el tamaño del papel.

Para los métodos restantes, visite el siguiente enlace: https://poi.apache.org/apidocs/org/apache/poi/hssf/usermodel/HSSFPrintSetup.html

Aquí, el término 'Libro de trabajo' significa archivo de Microsoft Excel. Después de completar este capítulo, podrá crear nuevos libros de trabajo y abrir libros de trabajo existentes con su programa Java.

Crear libro de trabajo en blanco

El siguiente programa simple se utiliza para crear un libro de trabajo de Microsoft Excel en blanco.

import java.io.*;
import org.apache.poi.xssf.usermodel.*;

public class CreateWorkBook {
   public static void main(String[] args)throws Exception {
      //Create Blank workbook
      XSSFWorkbook workbook = new XSSFWorkbook(); 

      //Create file system using specific name
      FileOutputStream out = new FileOutputStream(new File("createworkbook.xlsx"));

      //write operation workbook using file out object 
      workbook.write(out);
      out.close();
      System.out.println("createworkbook.xlsx written successfully");
   }
}

Guardemos el código Java anterior como CreateWorkBook.java, y luego compílelo y ejecútelo desde el símbolo del sistema de la siguiente manera:

$javac CreateWorkBook.java $java CreateWorkBook

Si el entorno de su sistema está configurado con la biblioteca de puntos de interés, se compilará y ejecutará para generar el archivo de Excel en blanco llamado createworkbook.xlsx en su directorio actual y muestre el siguiente resultado en el símbolo del sistema.

createworkbook.xlsx written successfully

Abrir libro de trabajo existente

Utilice el siguiente código para abrir un libro existente.

import java.io.*;
import org.apache.poi.xssf.usermodel.*;

public class OpenWorkBook {
   public static void main(String args[])throws Exception { 
      File file = new File("openworkbook.xlsx");
      FileInputStream fIP = new FileInputStream(file);
      
      //Get the workbook instance for XLSX file 
      XSSFWorkbook workbook = new XSSFWorkbook(fIP);
      
      if(file.isFile() && file.exists()) {
         System.out.println("openworkbook.xlsx file open successfully.");
      } else {
         System.out.println("Error to open openworkbook.xlsx file.");
      }
   }
}

Guarde el código Java anterior como OpenWorkBook.java, y luego compílelo y ejecútelo desde el símbolo del sistema de la siguiente manera:

$javac OpenWorkBook.java $java OpenWorkBook

Se compilará y ejecutará para generar la siguiente salida.

openworkbook.xlsx file open successfully.

Después de abrir un libro de trabajo, puede realizar operaciones de lectura y escritura en él.

Este capítulo explica cómo crear una hoja de cálculo y manipularla con Java. La hoja de cálculo es una página en un archivo de Excel; contiene filas y columnas con nombres específicos.

Después de completar este capítulo, podrá crear una hoja de cálculo y realizar operaciones de lectura en ella.

Crea una hoja de cálculo

En primer lugar, creemos una hoja de cálculo utilizando las clases de referencia discutidas en los capítulos anteriores. Siguiendo el capítulo anterior, primero cree un libro de trabajo y luego podemos continuar y crear una hoja.

El siguiente fragmento de código se utiliza para crear una hoja de cálculo.

//Create Blank workbook
XSSFWorkbook workbook = new XSSFWorkbook();

//Create a blank spreadsheet
XSSFSheet spreadsheet = workbook.createSheet("Sheet Name");

Filas en la hoja de cálculo

Las hojas de cálculo tienen un diseño de cuadrícula. Las filas y columnas se identifican con nombres específicos. Las columnas se identifican con alfabetos y las filas con números.

El siguiente fragmento de código se utiliza para crear una fila.

XSSFRow row = spreadsheet.createRow((short)1);

Escribir en una hoja de cálculo

Consideremos un ejemplo de datos de empleados. Aquí los datos de los empleados se dan en forma tabular.

ID de emp Nombre emp Designacion
Tp01 Gopal Gerente técnico
TP02 Manisha Lector de pruebas
Tp03 Masthan Escritor técnico
Tp04 Satish Escritor técnico
Tp05 Krishna Escritor técnico

El siguiente código se utiliza para escribir los datos anteriores en una hoja de cálculo.

import java.io.File;
import java.io.FileOutputStream;

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class Writesheet {
   public static void main(String[] args) throws Exception {

      //Create blank workbook
      XSSFWorkbook workbook = new XSSFWorkbook(); 

      //Create a blank sheet
      XSSFSheet spreadsheet = workbook.createSheet(" Employee Info ");

      //Create row object
      XSSFRow row;

      //This data needs to be written (Object[])
      Map < String, Object[] > empinfo = 
      new TreeMap < String, Object[] >();
      empinfo.put( "1", new Object[] { "EMP ID", "EMP NAME", "DESIGNATION" });
      empinfo.put( "2", new Object[] { "tp01", "Gopal", "Technical Manager" });
      empinfo.put( "3", new Object[] { "tp02", "Manisha", "Proof Reader" });
      empinfo.put( "4", new Object[] { "tp03", "Masthan", "Technical Writer" });
      empinfo.put( "5", new Object[] { "tp04", "Satish", "Technical Writer" });
      empinfo.put( "6", new Object[] { "tp05", "Krishna", "Technical Writer" });
      
      //Iterate over data and write to sheet
      Set < String > keyid = empinfo.keySet();
      int rowid = 0;

      for (String key : keyid) {
         row = spreadsheet.createRow(rowid++);
         Object [] objectArr = empinfo.get(key);
         int cellid = 0;

         for (Object obj : objectArr) {
            Cell cell = row.createCell(cellid++);
            cell.setCellValue((String)obj);
         }
      }

      //Write the workbook in file system
      FileOutputStream out = new FileOutputStream(new File("Writesheet.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("Writesheet.xlsx written successfully");
   }
}

Guarde el código Java anterior como Writesheet.java, y luego compílelo y ejecútelo desde el símbolo del sistema de la siguiente manera:

$javac Writesheet.java $java Writesheet

Se compilará y ejecutará para generar un archivo de Excel llamado Writesheet.xlsx en su directorio actual y obtendrá el siguiente resultado en el símbolo del sistema.

Writesheet.xlsx written successfully

los Writesheet.xlsx archivo tiene el siguiente aspecto.

Leer de una hoja de cálculo

Consideremos el archivo de Excel anterior llamado Writesheet.xslxcomo entrada. Observe el siguiente código; se utiliza para leer los datos de una hoja de cálculo.

import java.io.File;
import java.io.FileInputStream;

import java.util.Iterator;

import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class Readsheet {
   static XSSFRow row;
   public static void main(String[] args) throws Exception {
      FileInputStream fis = new FileInputStream(new File("WriteSheet.xlsx"));
      
      XSSFWorkbook workbook = new XSSFWorkbook(fis);
      XSSFSheet spreadsheet = workbook.getSheetAt(0);
      Iterator < Row >  rowIterator = spreadsheet.iterator();
      
      while (rowIterator.hasNext()) {
         row = (XSSFRow) rowIterator.next();
         Iterator < Cell >  cellIterator = row.cellIterator();
         
         while ( cellIterator.hasNext()) {
            Cell cell = cellIterator.next();
            
            switch (cell.getCellType()) {
               case Cell.CELL_TYPE_NUMERIC:
                  System.out.print(cell.getNumericCellValue() + " \t\t ");
                  break;
               
               case Cell.CELL_TYPE_STRING:
                  System.out.print(
                  cell.getStringCellValue() + " \t\t ");
                  break;
            }
         }
         System.out.println();
      }
      fis.close();
   }
}

Mantengamos el código anterior en Readsheet.java y luego compílelo y ejecútelo desde el símbolo del sistema de la siguiente manera:

$javac Readsheet.java $java Readsheet

Si el entorno de su sistema está configurado con la biblioteca de puntos de interés, se compilará y ejecutará para generar la siguiente salida en el símbolo del sistema.

EMP ID   EMP NAME       DESIGNATION 
 tp01     Gopal       Technical Manager 
 tp02     Manisha     Proof Reader 
 tp03     Masthan     Technical Writer 
 tp04     Satish      Technical Writer 
 tp05     Krishna     Technical Writer

Cualquier dato que ingrese en una hoja de cálculo siempre se almacena en una celda. Usamos las etiquetas de filas y columnas para identificar una celda. Este capítulo describe cómo manipular datos en celdas en una hoja de cálculo usando programación Java.

Crear una celda

Necesita crear una fila antes de crear una celda. Una fila no es más que una colección de celdas.

El siguiente fragmento de código se utiliza para crear una celda.

//create new workbook
XSSFWorkbook workbook = new XSSFWorkbook(); 

//create spreadsheet with a name
XSSFSheet spreadsheet = workbook.createSheet("new sheet");

//create first row on a created spreadsheet
XSSFRow row = spreadsheet.createRow(0);

//create first cell on created row
XSSFCell cell = row.createCell(0);

Tipos de células

El tipo de celda especifica si una celda puede contener cadenas, valores numéricos o fórmulas. Una celda de cadena no puede contener valores numéricos y una celda numérica no puede contener cadenas. A continuación se muestran los tipos de celdas, sus valores y la sintaxis de tipos.

Tipo de valor de celda Tipo de sintaxis
Valor de celda en blanco XSSFCell.CELL_TYPE_BLANK
Valor de celda booleana XSSFCell.CELL.TYPE_BOOLEAN
Valor de celda de error XSSFCell.CELL_TYPE_ERROR
Valor de celda numérico XSSFCell.CELL_TYPE_NUMERIC
Valor de celda de cadena XSSFCell.CELL_TYPE_STRING

El siguiente código se usa para crear diferentes tipos de celdas en una hoja de cálculo.

import java.io.File;
import java.io.FileOutputStream;

import java.util.Date;

import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class TypesofCells {
   public static void main(String[] args)throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("cell types");
      
      XSSFRow row = spreadsheet.createRow((short) 2);
      row.createCell(0).setCellValue("Type of Cell");
      row.createCell(1).setCellValue("cell value");
      
      row = spreadsheet.createRow((short) 3);
      row.createCell(0).setCellValue("set cell type BLANK");
      row.createCell(1);
      
      row = spreadsheet.createRow((short) 4);
      row.createCell(0).setCellValue("set cell type BOOLEAN");
      row.createCell(1).setCellValue(true);
      
      row = spreadsheet.createRow((short) 5);
      row.createCell(0).setCellValue("set cell type ERROR");
      row.createCell(1).setCellValue(XSSFCell.CELL_TYPE_ERROR );
      
      row = spreadsheet.createRow((short) 6);
      row.createCell(0).setCellValue("set cell type date");
      row.createCell(1).setCellValue(new Date());
      
      row = spreadsheet.createRow((short) 7);
      row.createCell(0).setCellValue("set cell type numeric");
      row.createCell(1).setCellValue(20 );
      
      row = spreadsheet.createRow((short) 8);
      row.createCell(0).setCellValue("set cell type string");
      row.createCell(1).setCellValue("A String");
      
      FileOutputStream out = new FileOutputStream(new File("typesofcells.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("typesofcells.xlsx written successfully");
   }
}

Guarde el código anterior en un archivo llamado TypesofCells.java, compílelo y ejecútelo desde el símbolo del sistema de la siguiente manera.

$javac TypesofCells.java $java TypesofCells

Si su sistema está configurado con la biblioteca de puntos de interés, se compilará y ejecutará para generar un archivo de Excel llamado typesofcells.xlsx en su directorio actual y muestre la siguiente salida.

typesofcells.xlsx written successfully

los typesofcells.xlsx archivo tiene el siguiente aspecto.

Estilos de celda

Aquí puede aprender cómo dar formato a las celdas y aplicar diferentes estilos, como fusionar celdas adyacentes, agregar bordes, configurar la alineación de celdas y rellenar con colores.

El siguiente código se usa para aplicar diferentes estilos a las celdas usando la programación Java.

import java.io.File;
import java.io.FileOutputStream;

import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.ss.usermodel.IndexedColors;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class CellStyle {
   public static void main(String[] args)throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("cellstyle");
      XSSFRow row = spreadsheet.createRow((short) 1);
      row.setHeight((short) 800);
      XSSFCell cell = (XSSFCell) row.createCell((short) 1);
      cell.setCellValue("test of merging");

      //MEARGING CELLS 
      //this statement for merging cells

      spreadsheet.addMergedRegion(
         new CellRangeAddress(
            1, //first row (0-based)
            1, //last row (0-based)
            1, //first column (0-based)
            4 //last column (0-based)
         )
      );
      
      //CELL Alignment
      row = spreadsheet.createRow(5); 
      cell = (XSSFCell) row.createCell(0);
      row.setHeight((short) 800);
      
      // Top Left alignment 
      XSSFCellStyle style1 = workbook.createCellStyle();
      spreadsheet.setColumnWidth(0, 8000);
      style1.setAlignment(XSSFCellStyle.ALIGN_LEFT);
      style1.setVerticalAlignment(XSSFCellStyle.VERTICAL_TOP);
      cell.setCellValue("Top Left");
      cell.setCellStyle(style1);
      row = spreadsheet.createRow(6); 
      cell = (XSSFCell) row.createCell(1);
      row.setHeight((short) 800);
      
      // Center Align Cell Contents 
      XSSFCellStyle style2 = workbook.createCellStyle();
      style2.setAlignment(XSSFCellStyle.ALIGN_CENTER);
      style2.setVerticalAlignment(XSSFCellStyle.VERTICAL_CENTER);
      cell.setCellValue("Center Aligned"); 
      cell.setCellStyle(style2);
      row = spreadsheet.createRow(7); 
      cell = (XSSFCell) row.createCell(2);
      row.setHeight((short) 800);
      
      // Bottom Right alignment 
      XSSFCellStyle style3 = workbook.createCellStyle();
      style3.setAlignment(XSSFCellStyle.ALIGN_RIGHT);
      style3.setVerticalAlignment(XSSFCellStyle.VERTICAL_BOTTOM);
      cell.setCellValue("Bottom Right");
      cell.setCellStyle(style3);
      row = spreadsheet.createRow(8);
      cell = (XSSFCell) row.createCell(3);
      
      // Justified Alignment 
      XSSFCellStyle style4 = workbook.createCellStyle();
      style4.setAlignment(XSSFCellStyle.ALIGN_JUSTIFY);
      style4.setVerticalAlignment(XSSFCellStyle.VERTICAL_JUSTIFY);
      cell.setCellValue("Contents are Justified in Alignment"); 
      cell.setCellStyle(style4);
      
      //CELL BORDER
      row = spreadsheet.createRow((short) 10);
      row.setHeight((short) 800);
      cell = (XSSFCell) row.createCell((short) 1);
      cell.setCellValue("BORDER");
      
      XSSFCellStyle style5 = workbook.createCellStyle();
      style5.setBorderBottom(XSSFCellStyle.BORDER_THICK);
      style5.setBottomBorderColor(IndexedColors.BLUE.getIndex());
      style5.setBorderLeft(XSSFCellStyle.BORDER_DOUBLE);
      style5.setLeftBorderColor(IndexedColors.GREEN.getIndex());
      style5.setBorderRight(XSSFCellStyle.BORDER_HAIR);
      style5.setRightBorderColor(IndexedColors.RED.getIndex());
      style5.setBorderTop(XSSFCellStyle.BIG_SPOTS);
      style5.setTopBorderColor(IndexedColors.CORAL.getIndex());
      cell.setCellStyle(style5);
      
      //Fill Colors
      //background color
      row = spreadsheet.createRow((short) 10 );
      cell = (XSSFCell) row.createCell((short) 1);
      
      XSSFCellStyle style6 = workbook.createCellStyle();
      style6.setFillBackgroundColor(HSSFColor.LEMON_CHIFFON.index );
      style6.setFillPattern(XSSFCellStyle.LESS_DOTS);
      style6.setAlignment(XSSFCellStyle.ALIGN_FILL);
      spreadsheet.setColumnWidth(1,8000);
      cell.setCellValue("FILL BACKGROUNG/FILL PATTERN");
      cell.setCellStyle(style6);
      
      //Foreground color
      row = spreadsheet.createRow((short) 12);
      cell = (XSSFCell) row.createCell((short) 1);
      
      XSSFCellStyle style7 = workbook.createCellStyle();
      style7.setFillForegroundColor(HSSFColor.BLUE.index);
      style7.setFillPattern( XSSFCellStyle.LESS_DOTS);
      style7.setAlignment(XSSFCellStyle.ALIGN_FILL);
      cell.setCellValue("FILL FOREGROUND/FILL PATTERN");
      cell.setCellStyle(style7);

      FileOutputStream out = new FileOutputStream(new File("cellstyle.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("cellstyle.xlsx written successfully");
   }
}

Guarde el código anterior en un archivo llamado CellStyle.java, compílelo y ejecútelo desde el símbolo del sistema de la siguiente manera.

$javac CellStyle.java $java CellStyle

Generará un archivo de Excel llamado cellstyle.xlsx en su directorio actual y muestre la siguiente salida.

cellstyle.xlsx written successfully

El archivo cellstyle.xlsx tiene el siguiente aspecto.

Este capítulo explica cómo configurar diferentes fuentes, aplicar estilos y mostrar texto en diferentes ángulos de dirección en una hoja de cálculo de Excel.

Cada sistema viene con una gran colección de fuentes como Arial, Impact, Times New Roman, etc. La colección también se puede actualizar con nuevas fuentes, si es necesario. Del mismo modo, existen varios estilos en los que se puede mostrar una fuente, por ejemplo, negrita, cursiva, subrayado, tachado, etc.

Fuentes y estilos de fuente

El siguiente código se utiliza para aplicar una fuente y un estilo en particular al contenido de una celda.

import java.io.File;
import java.io.FileOutputStream;

import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFFont;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class FontStyle {
   public static void main(String[] args)throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("Fontstyle");
      XSSFRow row = spreadsheet.createRow(2);

      //Create a new font and alter it.
      XSSFFont font = workbook.createFont();
      font.setFontHeightInPoints((short) 30);
      font.setFontName("IMPACT");
      font.setItalic(true);
      font.setColor(HSSFColor.BRIGHT_GREEN.index);

      //Set font into style
      XSSFCellStyle style = workbook.createCellStyle();
      style.setFont(font);

      // Create a cell with a value and set style to it.
      XSSFCell cell = row.createCell(1);
      cell.setCellValue("Font Style");
      cell.setCellStyle(style);
      
      FileOutputStream out = new FileOutputStream(new File("fontstyle.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("fontstyle.xlsx written successfully");
   }
}

Guardemos el código anterior en un archivo llamado FontStyle.java. Compílelo y ejecútelo desde el símbolo del sistema de la siguiente manera.

$javac FontStyle.java $java FontStyle

Genera un archivo de Excel llamado fontstyle.xlsx en su directorio actual y muestre el siguiente resultado en el símbolo del sistema.

fontstyle.xlsx written successfully

los fontstyle.xlsx archivo tiene el siguiente aspecto.

Dirección del texto

Aquí puede aprender a configurar la dirección del texto en diferentes ángulos. Por lo general, el contenido de la celda se muestra horizontalmente, de izquierda a derecha y en un ángulo de 00; sin embargo, puede utilizar el siguiente código para rotar la dirección del texto, si es necesario.

import java.io.File;
import java.io.FileOutputStream;

import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class TextDirection {
   public static void main(String[] args)throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("Text direction");
      XSSFRow row = spreadsheet.createRow(2);
      XSSFCellStyle myStyle = workbook.createCellStyle();
      myStyle.setRotation((short) 0);
      XSSFCell cell = row.createCell(1);
      cell.setCellValue("0D angle");
      cell.setCellStyle(myStyle);

      //30 degrees
      myStyle = workbook.createCellStyle();
      myStyle.setRotation((short) 30);
      cell = row.createCell(3);
      cell.setCellValue("30D angle");
      cell.setCellStyle(myStyle);

      //90 degrees
      myStyle = workbook.createCellStyle();
      myStyle.setRotation((short) 90);
      cell = row.createCell(5);
      cell.setCellValue("90D angle");
      cell.setCellStyle(myStyle);

      //120 degrees
      myStyle = workbook.createCellStyle();
      myStyle.setRotation((short) 120);
      cell = row.createCell(7);
      cell.setCellValue("120D angle");
      cell.setCellStyle(myStyle);

      //270 degrees
      myStyle = workbook.createCellStyle();
      myStyle.setRotation((short) 270);
      cell = row.createCell(9);
      cell.setCellValue("270D angle");
      cell.setCellStyle(myStyle);

      //360 degrees
      myStyle = workbook.createCellStyle();
      myStyle.setRotation((short) 360);
      cell = row.createCell(12);
      cell.setCellValue("360D angle");
      cell.setCellStyle(myStyle);
      
      FileOutputStream out = new FileOutputStream(new File("textdirection.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("textdirection.xlsx written successfully");
   }
}

Mantenga el código anterior en TextDirectin.java , compílelo y ejecútelo desde el símbolo del sistema de la siguiente manera.

$javac TextDirection.java $java TextDirection

Se compilará y ejecutará para generar un archivo de Excel llamado textdirection.xlsx en su directorio actual y muestre el siguiente resultado en el símbolo del sistema.

textdirection.xlsx written successfully

los textdirection.xlsx archivo tiene el siguiente aspecto.

Este capítulo lo lleva a través del proceso de aplicación de diferentes fórmulas en celdas usando programación Java. El propósito básico de la aplicación Excel es mantener los datos numéricos mediante la aplicación de fórmulas.

En una fórmula, pasamos valores dinámicos o ubicaciones de los valores en la hoja de Excel. Al ejecutar esta fórmula, obtiene el resultado deseado. La siguiente tabla enumera algunas fórmulas básicas que se utilizan con frecuencia en Excel.

Operación Sintaxis
Sumar varios números = SUMA (Loc1: Locn) or = SUMA (n1, n2,)
Contar = CONTAR (Loc1: Locn) or = CONTAR (n1, n2,)
Poder de dos números = POTENCIA (Loc1, Loc2) or = POTENCIA (número, potencia)
Máximo de varios números = MAX (Loc1: Locn) or = MAX (n1, n2,)
Producto = PRODUCTO (Loc1: Locn) or = PRODUCTO (n1, n2,)
Factorial = HECHO (Locn) or = HECHO (número)
Número absoluto = ABS (Locn) or = ABS (número)
Fecha de hoy = HOY ()
Convierte minúsculas = INFERIOR (Locn) or = INFERIOR (texto)
Raíz cuadrada = SQRT (locn) or = SQRT (número)

El siguiente código se usa para agregar fórmulas a una celda y ejecutarla.

import java.io.File;
import java.io.FileOutputStream;

import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class Formula {
   public static void main(String[] args)throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("formula");
      XSSFRow row = spreadsheet.createRow(1);
      XSSFCell cell = row.createCell(1);
      
      cell.setCellValue("A = ");
      cell = row.createCell(2);
      cell.setCellValue(2);
      row = spreadsheet.createRow(2);
      cell = row.createCell(1);
      cell.setCellValue("B = ");
      cell = row.createCell(2);
      cell.setCellValue(4);
      row = spreadsheet.createRow(3);
      cell = row.createCell(1);
      cell.setCellValue("Total = ");
      cell = row.createCell(2);
      
      // Create SUM formula
      cell.setCellType(XSSFCell.CELL_TYPE_FORMULA);
      cell.setCellFormula("SUM(C2:C3)");
      cell = row.createCell(3);
      cell.setCellValue("SUM(C2:C3)");
      row = spreadsheet.createRow(4);
      cell = row.createCell(1);
      cell.setCellValue("POWER =");
      cell=row.createCell(2);
      
      // Create POWER formula
      cell.setCellType(XSSFCell.CELL_TYPE_FORMULA);
      cell.setCellFormula("POWER(C2,C3)");
      cell = row.createCell(3);
      cell.setCellValue("POWER(C2,C3)");
      row = spreadsheet.createRow(5);
      cell = row.createCell(1);
      cell.setCellValue("MAX = ");
      cell = row.createCell(2);
      
      // Create MAX formula
      cell.setCellType(XSSFCell.CELL_TYPE_FORMULA);
      cell.setCellFormula("MAX(C2,C3)");
      cell = row.createCell(3);
      cell.setCellValue("MAX(C2,C3)");
      row = spreadsheet.createRow(6);
      cell = row.createCell(1);
      cell.setCellValue("FACT = ");
      cell = row.createCell(2);
      
      // Create FACT formula
      cell.setCellType(XSSFCell.CELL_TYPE_FORMULA);
      cell.setCellFormula("FACT(C3)");
      cell = row.createCell(3);
      cell.setCellValue("FACT(C3)");
      row = spreadsheet.createRow(7);
      cell = row.createCell(1);
      cell.setCellValue("SQRT = ");
      cell = row.createCell(2);
      
      // Create SQRT formula
      cell.setCellType(XSSFCell.CELL_TYPE_FORMULA);
      cell.setCellFormula("SQRT(C5)");
      cell = row.createCell(3);
      cell.setCellValue("SQRT(C5)");
      workbook.getCreationHelper().createFormulaEvaluator().evaluateAll();
      FileOutputStream out = new FileOutputStream(new File("formula.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("fromula.xlsx written successfully");
   }
}

Guarde el código anterior como Formula.java y luego compílelo y ejecútelo desde el símbolo del sistema de la siguiente manera.

$javac Formula.java $java Formula

Generará un archivo de Excel llamado formula.xlsx en su directorio actual y muestre el siguiente resultado en el símbolo del sistema.

fromula.xlsx written successfully

los formula.xlsx archivo tiene el siguiente aspecto.

Este capítulo explica cómo agregar hipervínculos al contenido de una celda. Por lo general, los hipervínculos se utilizan para acceder a cualquier URL web, correo electrónico o un archivo externo.

El siguiente código muestra cómo crear hipervínculos en celdas.

import java.io.File;
import java.io.FileOutputStream;

import org.apache.poi.common.usermodel.Hyperlink;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.ss.usermodel.CreationHelper;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFFont;
import org.apache.poi.xssf.usermodel.XSSFHyperlink;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class HyperlinkEX {
   public static void main(String[] args) throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("Hyperlinks");
      XSSFCell cell;
      CreationHelper createHelper = workbook.getCreationHelper();
      XSSFCellStyle hlinkstyle = workbook.createCellStyle();
      XSSFFont hlinkfont = workbook.createFont();
      hlinkfont.setUnderline(XSSFFont.U_SINGLE);
      hlinkfont.setColor(HSSFColor.BLUE.index);
      hlinkstyle.setFont(hlinkfont);

      //URL Link
      cell = spreadsheet.createRow(1).createCell((short) 1);
      cell.setCellValue("URL Link");
      XSSFHyperlink link = (XSSFHyperlink)createHelper.createHyperlink(Hyperlink.LINK_URL);
      link.setAddress("http://www.tutorialspoint.com/");
      cell.setHyperlink((XSSFHyperlink) link);
      cell.setCellStyle(hlinkstyle);

      //Hyperlink to a file in the current directory
      cell = spreadsheet.createRow(2).createCell((short) 1);
      cell.setCellValue("File Link");
      link = (XSSFHyperlink)createHelper.createHyperlink(Hyperlink.LINK_FILE);
      link.setAddress("cellstyle.xlsx");
      cell.setHyperlink(link);
      cell.setCellStyle(hlinkstyle);

      //e-mail link
      cell = spreadsheet.createRow(3).createCell((short) 1);
      cell.setCellValue("Email Link");
      link = (XSSFHyperlink)createHelper.createHyperlink(Hyperlink.LINK_EMAIL);
      link.setAddress("mailto:[email protected]?" + "subject = Hyperlink");
      cell.setHyperlink(link);
      cell.setCellStyle(hlinkstyle);
      
      FileOutputStream out = new FileOutputStream(new File("hyperlink.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("hyperlink.xlsx written successfully");
   }
}

Guarde el código anterior como HyperlinkEX.java. Compílelo y ejecútelo desde el símbolo del sistema de la siguiente manera.

$javac HyperlinkEX.java $java HyperlinkEX

Generará un archivo de Excel llamado hyperlink.xlsx en su directorio actual y muestre el siguiente resultado en el símbolo del sistema.

hyperlink.xlsx written successfully

los hyperlink.xlsx archivo tiene el siguiente aspecto.

Este capítulo explica cómo configurar el área de impresión en una hoja de cálculo. El área de impresión habitual es de izquierda a derecha en las hojas de cálculo de Excel. El área de impresión se puede personalizar según sus necesidades. Significa que puede imprimir un rango particular de celdas de toda la hoja de cálculo, personalizar el tamaño del papel, imprimir el contenido con las líneas de cuadrícula activadas, etc.

El siguiente código se utiliza para configurar el área de impresión en una hoja de cálculo.

import java.io.File;
import java.io.FileOutputStream;

import org.apache.poi.xssf.usermodel.XSSFPrintSetup;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class PrintArea {
   public static void main(String[] args)throws Exception {
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("Print Area");

      //set print area with indexes
      workbook.setPrintArea(
         0, //sheet index
         0, //start column
         5, //end column
         0, //start row
         5 //end row
      );
      
      //set paper size
      spreadsheet.getPrintSetup().setPaperSize(XSSFPrintSetup.A4_PAPERSIZE);
      
      //set display grid lines or not
      spreadsheet.setDisplayGridlines(true);
      
      //set print grid lines or not
      spreadsheet.setPrintGridlines(true);
      
      FileOutputStream out = new FileOutputStream(new File("printarea.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("printarea.xlsx written successfully"); 
   }
}

Guardemos el código anterior como PrintArea.java. Compílelo y ejecútelo desde el símbolo del sistema de la siguiente manera.

$javac PrintArea.java $java PrintArea

Generará un archivo llamado printarea.xlsx en su directorio actual y muestre el siguiente resultado en el símbolo del sistema.

printarea.xlsx written successfully

En el código anterior, no hemos agregado ningún valor de celda. Por lo tantoprintarea.xlsxes un archivo en blanco. Pero puede observar en la siguiente figura que la vista previa de impresión muestra el área de impresión con líneas de cuadrícula.

Este capítulo explica cómo interactúa la biblioteca de puntos de interés con una base de datos. Con la ayuda de JDBC, puede recuperar datos de una base de datos e insertar esos datos en una hoja de cálculo utilizando la biblioteca de puntos de interés. Consideremos la base de datos MySQL para operaciones SQL.

Escribir en Excel desde la base de datos

Asumamos la siguiente tabla de datos de empleados llamada emp_tbl se recuperará de la base de datos MySQL test.

ID de EMP NOMBRE EMP DEG SALARIO DEPT
1201 Gopal Gerente técnico 45000 ESO
1202 Manisha Lector de pruebas 45000 Pruebas
1203 Masthanvali Escritor técnico 45000 ESO
1204 Kiran Administrador de recursos humanos 40000 HORA
1205 Kranthi Administrador de operaciones 30000 Administración

Use el siguiente código para recuperar datos de una base de datos e insértelos en una hoja de cálculo.

import java.io.File;
import java.io.FileOutputStream;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class ExcelDatabase {
   public static void main(String[] args) throws Exception {
      Class.forName("com.mysql.jdbc.Driver");
      Connection connect = DriverManager.getConnection( 
         "jdbc:mysql://localhost:3306/test" , 
         "root" , 
         "root"
      );
      
      Statement statement = connect.createStatement();
      ResultSet resultSet = statement.executeQuery("select * from emp_tbl");
      XSSFWorkbook workbook = new XSSFWorkbook(); 
      XSSFSheet spreadsheet = workbook.createSheet("employe db");
      
      XSSFRow row = spreadsheet.createRow(1);
      XSSFCell cell;
      cell = row.createCell(1);
      cell.setCellValue("EMP ID");
      cell = row.createCell(2);
      cell.setCellValue("EMP NAME");
      cell = row.createCell(3);
      cell.setCellValue("DEG");
      cell = row.createCell(4);
      cell.setCellValue("SALARY");
      cell = row.createCell(5);
      cell.setCellValue("DEPT");
      int i = 2;

      while(resultSet.next()) {
         row = spreadsheet.createRow(i);
         cell = row.createCell(1);
         cell.setCellValue(resultSet.getInt("eid"));
         cell = row.createCell(2);
         cell.setCellValue(resultSet.getString("ename"));
         cell = row.createCell(3);
         cell.setCellValue(resultSet.getString("deg"));
         cell = row.createCell(4);
         cell.setCellValue(resultSet.getString("salary"));
         cell = row.createCell(5);
         cell.setCellValue(resultSet.getString("dept"));
         i++;
      }

      FileOutputStream out = new FileOutputStream(new File("exceldatabase.xlsx"));
      workbook.write(out);
      out.close();
      System.out.println("exceldatabase.xlsx written successfully");
   }
}

Guardemos el código anterior como ExcelDatabase.java. Compílelo y ejecútelo desde el símbolo del sistema de la siguiente manera.

$javac ExcelDatabase.java $java ExcelDatabase

Generará un archivo de Excel llamado exceldatabase.xlsx en su directorio actual y muestre el siguiente resultado en el símbolo del sistema.

exceldatabase.xlsx written successfully

los exceldatabase.xlsx archivo tiene el siguiente aspecto.

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved