Se você é um desenvolvedor de aplicativos Java que trabalha com o Excel a partir de seus aplicativos Java, estaria interessado em fornecer a funcionalidade de manipular dados do Excel em seu aplicativo. O Excel permite formatar o estilo de célula, definir o tipo de célula como diferentes tipos de dados, encher uma célula com cores diferentes e assim por diante. O Apache POI serve como sua ponte entre Java e Excel, oferecendo ferramentas para manipular o Excel XLSX Arquivos programaticamente. Nesta série de blogs, revelaremos a manipulação da arte do Excel usando o Apache Poi em Java. Vamos mergulhar e descobrir a sinergia de código e planilhas!

Índice

Durante o blog, passaremos por amostras de código e explicações do mesmo para o seguinte:

  1. Criação de células no arquivo Excel
  2. Crie células de data no Excel
  3. Trabalhando com diferentes tipos de células
  4. Definindo a aparência da célula

Trabalhando com células no arquivo Excel em java

Criando células no arquivo Excel

//Create Cells
XSSFWorkbook wb = new XSSFWorkbook();
XSSFCreationHelper createHelper = wb.getCreationHelper();
XSSFSheet sheet = wb.createSheet("new sheet");
// Create a row and put some cells in it. Rows are 0 based.
Row row = sheet.createRow(0);
// Create a cell and put a value in it.
Cell cell = row.createCell(0);
cell.setCellValue(1);
row.createCell(1).setCellValue(1.2);
row.createCell(2).setCellValue(createHelper.createRichTextString("This is a string"));
row.createCell(3).setCellValue(true);
// Write the output to a file
try (FileOutputStream fileOut = new FileOutputStream("workbook.xlsx")) {
    wb.write(fileOut);
}

O trecho de código Java acima demonstra o uso da API APACH POI para trabalhar com células em uma pasta de trabalho do Excel. O código cria uma nova pasta de trabalho do Excel (\ **xssfworkbook** \), inicializa uma folha dentro da pasta de trabalho e, em seguida, preenche células com vários tipos de dados. Primeiro, o código cria uma nova folha chamada " nova folha “. Em seguida, gera uma linha no índice 0 na folha e passa a preencher as células dentro dessa linha. A primeira célula (índice 0) recebe um valor inteiro de 1 usando o método \ **setCellValue** \. Por outro lado, a segunda célula (índice 1) é definida como um valor decimal de 1,2 diretamente dentro do método \ **createCell** \. A terceira célula (índice 2) contém um valor de string “Esta é uma string” criada usando o método \ **CreaterichTextString** \ do método \ **xssfcreationHelper** \ . Por fim, a quarta célula (índice 3) é preenchida com o valor booleano "verdadeiro". Depois que os valores da célula forem definidos, o código grava a pasta de trabalho resultante em um arquivo do Excel chamado "Work.xlsx" usando um \ fileOutputStream `.

Criando o tipo de data da célula

XSSFWorkbook wb = new XSSFWorkbook();
//Workbook wb = new XSSFWorkbook();
CreationHelper createHelper = wb.getCreationHelper();
org.apache.poi.ss.usermodel.Sheet sheet = wb.createSheet("new sheet");
// Create a row and put some cells in it. Rows are 0 based.
Row row = sheet.createRow(0);
// Create a cell and put a date value in it.  The first cell is not styled
// as a date.
Cell cell = row.createCell(0);
cell.setCellValue(new Date());
// we style the second cell as a date (and time).  It is important to
// create a new cell style from the workbook otherwise you can end up
// modifying the built in style and effecting not only this cell but other cells.
CellStyle cellStyle = wb.createCellStyle();
cellStyle.setDataFormat(
    createHelper.createDataFormat().getFormat("m/d/yy h:mm"));
cell = row.createCell(1);
cell.setCellValue(new Date());
cell.setCellStyle(cellStyle);
//you can also set date as java.util.Calendar
cell = row.createCell(2);
cell.setCellValue(Calendar.getInstance());
cell.setCellStyle(cellStyle);
// Write the output to a file
try (FileOutputStream fileOut = new FileOutputStream("workbook.xlsx")) {
    wb.write(fileOut);
}

Este snippet de código Java mostra o uso da API APACE API para trabalhar com células do tipo data em uma pasta de trabalho do Excel. O código começa criando uma nova pasta de trabalho do Excel (\ **xssfworkbook** \). A primeira célula (índice 0) visa manter um valor de data. A \ **Data** \ Objeto que representa a data e hora atual é definido como o valor da célula usando o método \ **setCellValue** \. Esta célula não é explicitamente estilizada como uma data. Para a segunda célula (índice 1), um novo estilo de célula (\ CellStyle \) é criado usando o método \ createCellStyle \ da pasta de trabalho. Esse estilo é configurado para ter um formato específico de data e hora usando o método \ setDataFormat \. O processo (m/d/yy h: mm “) ` processo cria um formato de data personalizado com um padrão de formato de “m/d/yy h: mm”. A segunda célula recebe o valor atual de data e hora e o estilo de célula recém -criado é aplicado a ele usando o método \ setCellStyle \. A terceira célula (índice 2) demonstra um método alternativo para preencher as células do tipo data usando \ java.util.calendar \. Semelhante à segunda célula, o estilo de célula personalizado também é aplicado a esta célula.

Trabalhando com diferentes tipos de células

XSSFWorkbook wb = new XSSFWorkbook();
XSSFSheet sheet = wb.createSheet("new sheet");
Row row = sheet.createRow(2);
row.createCell(0).setCellValue(1.1);
row.createCell(1).setCellValue(new Date());
row.createCell(2).setCellValue(Calendar.getInstance());
row.createCell(3).setCellValue("a string");
row.createCell(4).setCellValue(true);
row.createCell(5).setCellType(CellType.ERROR);		// Write the output to a file
try (FileOutputStream fileOut = new FileOutputStream("workbook.xlsx")) {
    wb.write(fileOut);
}

Nesta amostra de código, diferentes estilos de células são aplicados às células em um arquivo do Excel usando a API APACH POI, conforme explicado nas etapas a seguir.

  1. Uma linha é criada no índice 2 na folha usando \ **Createrow** (2) \. As células são então preenchidas nessa linha com os seguintes dados.
  2. A primeira célula (índice 0) recebe um valor decimal de 1.1 usando o método \ **setCellValue** \.
  3. Na segunda célula (índice 1), a data e hora atuais são inseridas usando um objeto \ date \ através do método \ **setCellValue** \.
  4. A terceira célula (índice 2) contém a data e a hora de uma instância \ calendário \, definida usando o método \ **setCellValue** \.
  5. A quarta célula (índice 3) mantém o texto “uma string”.
  6. A quinta célula (índice 4) é designada para um valor booleano “verdadeiro”.
  7. Avançando, um tipo de célula específico é atribuído à sexta célula (índice 5), invocando o método \ **setCellType** \. Esta célula está configurada como uma célula de erro usando a enumeração \ **Celltype.error** \, o que indica que ele exibirá um valor de erro. Finalmente, a pasta de trabalho modificada é gravada em um arquivo chamado “Work.xlsx” usando um \ **fileOutputStream** \. Em resumo, este exemplo de código demonstra como estabelecer uma pasta de trabalho do Excel, aplicar diferentes estilos de células para acomodar vários tipos de dados e, finalmente, salvar a pasta de trabalho modificada em um arquivo. Esta ilustração prática mostra os recursos da Biblioteca Apache POI para trabalhar com arquivos do Excel em Java.

Configurando a aparência da célula

XSSFWorkbook wb = new XSSFWorkbook();
XSSFSheet sheet = wb.createSheet("new sheet");
// Create a row and put some cells in it. Rows are 0 based.
Row row = sheet.createRow(1);
// Aqua background
CellStyle style = wb.createCellStyle();
style.setFillBackgroundColor(IndexedColors.AQUA.getIndex());
style.setFillPattern(FillPatternType.BIG_SPOTS);
Cell cell = row.createCell(1);
cell.setCellValue("X");
cell.setCellStyle(style);
// Orange "foreground", foreground being the fill foreground not the font color.
style = wb.createCellStyle();
style.setFillForegroundColor(IndexedColors.ORANGE.getIndex());
style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
cell = row.createCell(2);
cell.setCellValue("X");
cell.setCellStyle(style);
// Write the output to a file
try (FileOutputStream fileOut = new FileOutputStream("workbook.xlsx")) {
    wb.write(fileOut);
}
wb.close();

Este snippet de código demonstra como manipular a aparência das células em um arquivo do Excel usando a biblioteca Apache Poi em Java. Isso é alcançado usando as seguintes etapas.

  1. Uma linha é criada no índice 1 na folha usando \ Createrow (1) \. As seguintes alterações são feitas nas células nesta linha.
  2. Para a primeira célula (índice 1), um estilo de célula personalizado é criado usando \ wb.createCellStyle () \. Este estilo é configurado com uma cor de fundo aqua usando \ setFillbackgroundColor \ e \ indexedColors.aqua.getIndex () \. O padrão para o plano de fundo é definido como “grandes pontos” usando \ setFillPattern (FillPatterNtype.big_spots) \. Uma célula é criada nesta linha no índice 1 e preenchida com o valor “X”. O estilo criado anteriormente é aplicado a esta célula usando \ setCellStyle \.
  3. Para a segunda célula (índice 2), um novo estilo de célula é criado. Este estilo foi projetado com uma cor de primeiro plano laranja usando \ setFillForeRoundColor \ e \ indexedColors.orange.getIndex () \. O padrão de preenchimento é definido como “em primeiro plano sólido” usando \ setFillPattern (FillPatterNtype.solid_foreground) \. Outra célula é criada no índice 2 na mesma linha e preenchida com o valor “X”. O estilo recém -gerado é então atribuído a esta célula usando \ setCellStyle \. Depois de configurar as aparências de células, a pasta de trabalho modificada é gravada em um arquivo chamado “Workbook.xlsx” usando um \ FileOutputStream \. Em resumo, este exemplo de código mostra como usar a biblioteca Apache POI para manipular as aparências celulares em um arquivo do Excel. As técnicas demonstradas envolvem a criação de estilos de células personalizados para controlar as cores de fundo e primeiro plano, além de padrões de preenchimento, proporcionando flexibilidade para personalizar visualmente as planilhas do Excel usando Java.

Conclusão

Em todos os exemplos Java acima para a Biblioteca Apache POI, demonstramos como trabalhar com o conteúdo do arquivo do Excel no seu aplicativo Java. As amostras de código mostraram como criar células em um arquivo do Excel, definir a aparência deles, definir o estilo de célula como diferentes tipos de dados, como string, numérico, decimal etc. e como defina o tipo de célula até o tipo de data. Adicionaremos mais exemplos para trabalhar com arquivos do Excel usando o Apache Poi para Java, então fique atento.

veja também