Jaxb

http://www.programacion.com/java/tutorial/jaxb/

Convertir tipo File a InputStream y viceversa

Para convertir de file a inputstream:

InputStream is = new FileInputStream (file);

Para convertir de inputstream a file:

byte[] data = IOUtils.toByteArray(inputStream);
File temportal = new File("/tmp/" + nombreFichero);
org.apache.commons.io.FileUtils.writeByteArrayToFile(temportal, data);

Crear Excel desde Java

Introducción
POI consiste en APIs para manipular varios formatos de ficheros basados en el formato de Documento Compuesto OLE 2 de Microsoft, utilizando Java puro. En concreto, se pueden leer y escribir ficheros MS Excel utilizando Java.

Voy a poner un ejemplo que yo tuve que hacer:

public class Prueba(){

public String actionExportarExcel(){
ExportarUtils exportar= ExportarUtils.getInstance();
Vector v= new Vector();
// cabecera del excel
v.addElement("Cabecera1, cabecera2,....");
v.addElement(dato1, dato2,dato3,........);

// Generar el fichero
try {
exportar.crearExcel(v, "Titulo", "nombreFichero.xls");
} catch (Exception e) {
log.debug(e.getMessage());
}
return null;
}
}//fin de clase

//Clase para la preparacion del fichero Excel

import java.io.FileOutputStream;
import java.io.InputStream;
import java.util.StringTokenizer;
import java.util.Vector;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFFont;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;



public class ExportarUtils {
private ExportarUtils() {
}

public static ExportarUtils getInstance() {
if (singleton == null) {
singleton=new ExportarUtils();
}
return singleton;
}

public static void createCell(HSSFRow row, short i, String value, HSSFCellStyle style) {
HSSFCell cell = row.createCell(i);
value = value+" ";
cell.setCellValue(value);
// si no hay estilo, no se aplica
if (style != null)
cell.setCellStyle(style);
}

public void crearExcel(Vector v, String namesheet, String filename)
throws Exception {
try {
workbook = new HSSFWorkbook();
HSSFSheet sheet=workbook.createSheet("Nueva Hoja");
int filas = v.size();
for (int i = 0; i < filas; i++) {
String fila = (String) v.elementAt(i);
StringTokenizer st = new StringTokenizer(fila, ",");
HSSFRow row = sheet.createRow((short) i);
int j = 0;
while (st.hasMoreTokens()) {
String token = st.nextToken();
// para la cabecera, la primera fila, aplicamos un estilo (negrita y color de fondo azul)
if (i == 0) {
HSSFCellStyle style = workbook.createCellStyle();
//style.setFillForegroundColor(IndexedColors.BLUE_GREY.getIndex()); );

style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
HSSFFont font = workbook.createFont();
font.setFontHeightInPoints((short)10);
font.setFontName("Courier New");
font.setItalic(true);
// font.setStrikeout(true);
font.setBoldweight(HSSFFont.BOLDWEIGHT_BOLD);
//font.setColor(Short.parseShort("#ffffff"));
style.setFont(font);
createCell(row, (short)j, token, style);
} else
createCell(row, (short)j, token, null);

j = j + 1;

}

}

// Asignar automaticamente el tamaño de las celdas en funcion del contenido
//for (int i = 0; i < filas; i++) {
sheet.setDefaultColumnWidth((short) 55);
// }

// Escribir el fichero.
FileOutputStream fileOut = new FileOutputStream(filename);
workbook.write(fileOut);
fileOut.close();

} catch (Exception e)
{
e.printStackTrace();
}
}


Aui en este enlace bien mejor explicado POI

Problema con File

Necesitaba saber si un fichero es correcto o no y para ello utilicé :

File fichero = new File(rutaFichero);
if(fichero.exists()){

}

Pues esto siempre me decía que no existía ese fichero cuando si existía perfectamente.Entonces vi que había una opción de createNewFile() lo utilicé en vez del exists() y esto si me funcionaba, y me dijeron que esto podía ser porque File crea una referencia pero puede ser que todavía no se ha relacionado con el fichero físico y por eso me daba siempre false al comprobarlo con exists().

Una vez hecho esto del createNewFile ya si podemos hacerle el exists().

INNER CLASS

Una clase embebida es una clase que se define dentro de otra.

Se puede definir una clase embebida de la siguiente forma:
class Externa {
. . .
class Interna {
. . .
}

Una diferencia importante es que un objeto de la clase embebida está relacionado siempre con un objeto de la clase que la envuelve, de tal forma que las instancias de la clase embebida deben ser creadas por una instancia de la clase que la envuelve. Desde el exterior estas referencias pueden manejarse, pero calificandolas completamente, es decir nombrando la clase externa y luego la interna. Además una instancia de la clase embebida tiene acceso a todos los datos miembros de la clase que la envuelve sin usar ningún calificador de acceso especial (como si le pertenecieran).

Interface

Los Interfaces son unas clases completamente abstractas que contiene sólo una colección de métodos abstractos y propiedades constantes.

Algunas especificaciones para interfaces:

Puede contener solo variables estáticas.

Las interfaces pueden extender otras interfaces.En este caso la clase que implemente una interface que extiende de otra interface tiene que implementar todos los métodos de ambas interfaces.

Una clase puede implementar cualquier número de interfaces.

Una interfaz es implícitamente abstracta. 

No es necesario utilizar la palabra clave abstracta al declarar una interfaz.

Cada método en una interfaz también es implícitamente abstracto, por lo que la palabra clave abstracta no es necesaria. Esto era antes de Java 8, con esta versión una inteface puede tener un método default o static y con cuerpo.

Los métodos en una interfaz son implícitamente públicos.

Las variables declaradas en una interfaz no son variables de instancia. En cambio, son implícitamente public, final, y static, y deben inicializarse.  

Los métodos son abstratos, default o static pero no ambos.

Una clase puede heredar de una sola superclase, pero puede implementar múltiples interfaces.

Normas de Nomenclatura

Esto hace que los programas sean más fáciles de leer y estándar

• Clases--> Los nombres de clases deben ser palabras completas, en mayúsculas y minúsculas, con la primera letra de cada palabra en mayúscula. Los nombres de clases deben ser simples y descriptivos, utilizando palabras completas y acrónimos o abreviaturas (a no ser que la abreviatura sea ampliamente conocida, como URL o HTML). Por ejemplo: class Coche ,class EmpresaProductora.
• Interfaces--> Siguen las mismas reglas que las clases. Por ejemplo: interface AlmacenarCoche, class Almacen.
• Métodos-->Los métodos deberían ser verbos, en mayúsculas y minúsculas, con la primera letra en minúscula, y la primera letra de cada una de las palabras internas en mayúscula. Por ejemplo: correr(), numeroRuedas(), pintarCoche().
• Variables--> Todas los nombres de variables de instancia o de clase deben estar constituidos por palabras con la primera letra de la primera palabra en minúscula y la primera letra de las palabras internas en mayúscula.Los nombres de variables deben ser cortos y significativos. La elección de un nombre de variable debe ser mnemotécnico, es decir, pensado para que un lector casual al verla comprenda su uso. Se deben evitar las variables de una sola letra, excepto en variables temporales de corto uso. Nombres comunes para este tipo de variables son: i, j, k, m y n para enteros; c, d y e para caracteres.Por ejemplo: int i; char *cp, float miVariable.
  
• Constantes-->Los nombres de variables declaradas como constantes de clase y constantes ANSI, deberías escribirse siempre en mayúsculas, con las palabras internas separadas por el signo de subrayado ("_"). Las constantes ANSI se deben evitar en lo posible, para facilitar la depuración del código. Por ejemplo int MIN_WIDTH = 4;