Home   Java   Novidades do Java NIO2 a API de acesso a arquivos

Novidades do Java NIO2 a API de acesso a arquivos
Java NIO2

Novidades do Java NIO2 a API de acesso a arquivos


Olá amigos,

Hoje falaremos do pacote Java NIO2. Essa é a nova API java para acesso a arquivos que foi disponibilizada com a versão 7 do Java. Este é um assunto importante para quem deseja utilizar uma boa forma de acesso a arquivos e excencial para quem deseja tirar a certificação Java Programmer II.

Objetivos da certificação:

  • Java File I / O (NIO.2)
    1. Trabalhar com caminhos de arquivos e diretórios com a classe Path
    2. Verificar, apagar, copiar ou mover um arquivo ou pasta com a classe Arquivos
    3. Ler e alterar atributos de arquivos e diretórios, usando BasicFileAttributes, DosFileAttributes e interfaces de PosixFileAttributes
    4. Acessar recursivamente uma árvore de diretórios usando as interfaces DirectoryStream e FileVisitor
    5. Encontrar um arquivo com a interface PathMatcher
    6. Monitorar um diretório para mudanças com a interface WatchService


    Vamos aos exemplos:

    1. Exemplo básico da utilização da Classe Path

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    
     
    import java.io.IOException;
    import java.nio.file.Path;
    import java.nio.file.Paths;
     
    public class JavaNIO2 {
     
    	public static void main(String[] args) {
     
    		Path path = Paths.get("D:/javanio/br/com/feltex/jse");
     
    		System.out.format("toString: %s%n", path.toString());
    		System.out.format("getFileName: %s%n", path.getFileName());
    		System.out.format("getName(0):", path.getName(0));
    		System.out.format("getNameCount: %d%n", path.getNameCount());
    		System.out.format("subpath(0,2): %s%n", path.subpath(0, 2));
    		System.out.format("getParent: %s%n", path.getParent());
    		System.out.format("getRoot: %s%n", path.getRoot());
    		try {
    			// Verifica se existe o path informado.
    			// Caso não exista é lançada uma exceção "NoSuchFileException:"
    			path.toRealPath();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
     
    	}
     
    }

    Resultado esperado:

    toString: D:\javanio\br\com\feltex\jse
    getFileName: jse
    getName(0):getNameCount: 5
    subpath(0,2): javanio\br
    getParent: D:\javanio\br\com\feltex
    getRoot: D:\
    

    2. Utilização da classe PathMatcher que realiza uma busca recursiva em um diretório

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    
     
    // Uso de importação estática
    import static java.nio.file.FileVisitResult.CONTINUE;
     
    import java.io.IOException;
    import java.nio.file.FileSystems;
    import java.nio.file.FileVisitResult;
    import java.nio.file.Files;
    import java.nio.file.Path;
    import java.nio.file.PathMatcher;
    import java.nio.file.Paths;
    import java.nio.file.SimpleFileVisitor;
    import java.nio.file.attribute.BasicFileAttributes;
     
    public class MyPathMatcher {
     
    	public static class Finder extends SimpleFileVisitor<Path> {
     
    		private final PathMatcher matcher;
    		private int totalOcorrencias = 0;
     
    		Finder(String pattern) {
    			matcher = FileSystems.getDefault()
    					.getPathMatcher("glob:" + pattern);
    		}
     
    		// Compara o "glob" padrão contra o nome do arquivo ou diretório.
    		void find(Path file) {
    			Path name = file.getFileName();
    			if (name != null && matcher.matches(name)) {
    				totalOcorrencias++;
    				System.out.println(file);
    			}
    		}
     
    		// Exibe o número de ocorrências encontradas
    		void done() {
    			System.out.println("Localizados: " + totalOcorrencias);
    		}
     
    		// Invoca o método padrão de correspondência em cada arquivo.
    		public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
    			find(file);
     
    			// Esta constante é uma importação estática
    			return CONTINUE;
    		}
     
    		// Invoca o método padrão de correspondência em cada diretório.
    		public FileVisitResult preVisitDirectory(Path dir,
    				BasicFileAttributes attrs) {
    			find(dir);
    			return CONTINUE;
    		}
     
    		public FileVisitResult visitFileFailed(Path file, IOException exc) {
    			System.err.println(exc);
    			return CONTINUE;
    		}
    	}	
     
    	public static void main(String[] args) throws IOException {
     
    		String meuPath = "D:/Temp";
    		String padrao = "*.txt";
     
     
    		Path startingDir = Paths.get(meuPath);	
     
    		Finder finder = new Finder(padrao);
    		Files.walkFileTree(startingDir, finder);
    		finder.done();
    	}
    }

    Resultado esperado:

       D:\Temp\X\java\license.txt
       D:\Temp\X\psqlodbc_09_03_0210\README.txt
    Localizados: 2
    

    Conclusão


    As classes apresentadas nos ajudam bastante a trabalhar com acesso a arquivos. Em especial a classe Path que tem é a indicação para usarmos nos acessos a arquivos em substituição à classe File.
    Não deixe de acessar os links indicados abaixo e conhecer melhor essa API do Java. Abraços e vida que segue.

    Links relacionados

    Recomendo que leia:Manipulação de Arquivos em java

    Leia também: Como criar um arquivo

    Você irá gostar: Java NIO2

    Não se esqueça de curtir este post nas rede sociais. Dê a sua contribuição social e ajude o autor:

    Deixe uma resposta

    Get Best Services from Our Business.