javaHispano - Portada

1: Switch permite tomar tipos Strings como argumentos:

public stringsEnCase(Trade t) {
 
            String status = t.getStatus();
 
            switch(status) {
 
            caseNEW:
 
                  newTrade(t);
 
                  break;
 
            caseEXECUTE:
 
                  executeTrade(t);
 
                  break;
 
            casePENDING:
 
                  pendingTrade(t);
 
                  break;
 
 
 
            default:
 
                  break;
 
            }
 
      }

2: Gestión automática de recursos

 public voidnewTry() {
 
            try(FileOutputStream fos = newFileOutputStream("movies.txt");
 
                        DataOutputStream dos = newDataOutputStream(fos)) {
 
                  dos.writeUTF("Java 7 yeah");
 
            } catch(IOException e) {
 
                  // log the exception
 
            }
 
      }

3: Literales numéricos con barra baja

int million  =  1_000_000

4: Mejorado el manejo de excepciones

 public voidnewMultiCatch() {
 
            try{
 
                  methodThatThrowsThreeExceptions();
 
            } catch(ExceptionOne | ExceptionTwo | ExceptionThree e) {
 
                  // log and deal with all Exceptions
 
            }
 
      }

5: Nuevas apis de fichero

package java7;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class PruebasDeFichero {

	public void pruebas() {

		Path pathOrigen = Paths.get("c:\\Temp\\tempOrigen");

		System.out.println("Número de nodos:" + pathOrigen.getNameCount());

		System.out.println("Nombre de fichero:" + pathOrigen.getFileName());

		System.out.println("Raíz:" + pathOrigen.getRoot());

		System.out.println("Padre:" + pathOrigen.getParent());

		OutputStream fis;
		try {
			fis = new FileOutputStream(new File(
					"c:\\Temp\\temp2\\holaMundo2.txt"));

			Files.copy(pathOrigen, fis);
			Path pathOrigenDestino = Paths.get("c:\\Temp\\tempDestino");
			Files.move(pathOrigen, pathOrigenDestino);

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		try {
			Files.delete(pathOrigen);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		try {
			Files.deleteIfExists(pathOrigen);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}

6: Escucha activa de eventos sobre ficheros

/**
 
 * This initiates the police
 
 */
 
private voidinit() {
 
      path= Paths.get("C:\Temp\temp\");
 
      try{
 
            watchService= FileSystems.getDefault().newWatchService();
 
            path.register(watchService, ENTRY_CREATE, ENTRY_DELETE,
 
                        ENTRY_MODIFY);
 
      } catch(IOException e) {
 
            System.out.println("IOException"+ e.getMessage());
 
      }
 
}
 
/**
 
 * The police will start making rounds
 
 */
 
private voiddoRounds() {
 
      WatchKey key = null;
 
      while(true) {
 
            try{
 
                  key = watchService.take();
 
                  for(WatchEvent event : key.pollEvents()) {
 
                        Kind kind = event.kind();
 
System.out.println("Event on "+ event.context().toString() + " is " + kind);
 
                  }
 
            } catch(InterruptedException e) {
 
System.out.println("InterruptedException: "+e.getMessage());
 
            }
 
            booleanreset = key.reset();
 
            if(!reset)
 
                  break;
 
      }
 
}

7: Tareas recursivas

package forkJoinDemoEjemploAsíncrono;
 
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.RecursiveTask;
 
public class ProcesadorDeDirectorios extends RecursiveTask>
{
   private static final long serialVersionUID = 1L;
   //El path que será procesado
   private final String      path;
   //Extensión de ficheros en cuestión
   private final String      extension;
 
   //Constructor
   public FolderProcessor(String path, String extension)
   {
      this.path = path;
      this.extension = extension;
   }
 
   //Implementación del método compute, que debe devolver un listado de Strings, pues aśi fue parametrizado RecursiveTask
   @Override
   protected List compute()
   {
      //La lista de los nombres de los ficheros almacenados en el directorio
      List list = new ArrayList();
      //Tareas que almacenan las subtareas que van a procesar los subdirectorios almacenados
      //en el directorio padre
      List tasks = new ArrayList();
      //Obtiene el contenido del directorio
      File file = new File(path);
      File content[] = file.listFiles();
      //Para cada elemento del directorio, si hay un subdirectorio, cra un objeto FolderProcessor
      if (content != null)
      {
         for (int i = 0; i < content.length; i++)
         {
            if (content[i].isDirectory())
            {
               FolderProcessor task = new FolderProcessor(content[i].getAbsolutePath(), extension);
               task.fork();
               tasks.add(task);
            }
            //Otherwise, compare the extension of the file with the extension you are looking for using the checkFile() method
            //En otro caso, compara la extensión del fichero con la que se busca (definida
            //en el método checkfile()
            else
            {
               if (checkFile(content[i].getName()))
               {
                  list.add(content[i].getAbsolutePath());
               }
            }
         }
      }
      //Si el listado de tareas de FolderProcesar supera los 50 elementos, se muestra un mensaje
      //por consola
      if (tasks.size() > 50)
      {
         System.out.printf("%s: %d Tareas ejecutadas.\n", file.getAbsolutePath(), tasks.size());
      }
      //Añade a la lista de ficheros los resultados returnados por las subtareas ejecutadas en 
      //esta tarea
      addResultsFromTasks(list, tasks);
      //Retorna el listado de strings.
      return list;
   }
 
   //Para cada tarea almacenada en la lista de tareas, llama al método join() que esperará
   //a la finalización y retornará entonces el resultado de las tareas.
   private void addResultsFromTasks(List list, List tasks)
   {
      for (FolderProcessor item : tasks)
      {
         list.addAll(item.join());
      }
   }
 
   //Compara si el nombre del fichero pasado como parámetro tiene como extensión la que buscamos
   private boolean checkFile(String name)
   {
      return name.endsWith(extension);
   }
}

package forkJoinDemoAsyncExample;
 
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.TimeUnit;
 
public class Main
{
   public static void main(String[] args)
   {
      //Crea el pool fork join usando el constructor por defecto.
      ForkJoinPool pool = new ForkJoinPool();
      //Crea tres tareas FolderProcessor. Inicializa cada una de ellas con un path
      //de directorio diferente
      FolderProcessor system = new FolderProcessor("C:\\Windows", "log");
      FolderProcessor apps = new FolderProcessor("C:\\Program Files", "log");
      FolderProcessor documents = new FolderProcessor("C:\\Documents And Settings", "log");
      //Ejecuta las tres tareas en el pool mediante el método execute.
      pool.execute(system);
      pool.execute(apps);
      pool.execute(documents);
      //Escribe a la consola información sobre el estado del pool cada segunda, hasta que
      //las tres tareas han finalizado su ejecución
      do
      {
         System.out.printf("******************************************\n");
         System.out.printf("Main: Paralelismo: %d\n", pool.getParallelism());
         System.out.printf("Main: Hilos activos: %d\n", pool.getActiveThreadCount());
         System.out.printf("Main: Contados de tareas: %d\n", pool.getQueuedTaskCount());
         System.out.printf("******************************************\n");
         try
         {
            TimeUnit.SECONDS.sleep(1);
         } catch (InterruptedException e)
         {
            e.printStackTrace();
         }
      } while ((!system.isDone()) || (!apps.isDone()) || (!documents.isDone()));
      //Para el pool de fork join 
      pool.shutdown();
      //Escribe el número de resultados generados por cada tarea a la consola
      List results;
      results = system.join();
      System.out.printf("System: %d ficheros encontrados.\n", results.size());
      results = apps.join();
      System.out.printf("Apps: %d ficheros encontrados.\n", results.size());
      results = documents.join();
      System.out.printf("Documents: %d ficheros encontrados.\n", results.size());
   }
}

Muchas gracias,

Un saludo