[BAEL-9555] - Created a core-java-modules folder

2019-05-05 17:22:09 +05:30
parent 8b63b0d90a
commit 3bae5e5334
1480 changed files with 25600 additions and 5594 deletions
@@ -0,0 +1,84 @@
+package com.baeldung.bufferedreader;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.stream.Collectors;
+
+public class BufferedReaderExample {
+
+    public String readAllLines(BufferedReader reader) throws IOException {
+        StringBuilder content = new StringBuilder();
+        String line;
+
+        while ((line = reader.readLine()) != null) {
+            content.append(line);
+            content.append(System.lineSeparator());
+        }
+
+        return content.toString();
+    }
+
+    public String readAllLinesWithStream(BufferedReader reader) {
+        return reader
+                .lines()
+                    .collect(Collectors.joining(System.lineSeparator()));
+    }
+
+    public String readAllCharsOneByOne(BufferedReader reader) throws IOException {
+        StringBuilder content = new StringBuilder();
+
+        int value;
+        while ((value = reader.read()) != -1) {
+            content.append((char) value);
+        }
+
+        return content.toString();
+    }
+
+    public String readMultipleChars(BufferedReader reader) throws IOException {
+        int length = 5;
+        char[] chars = new char[length];
+        int charsRead = reader.read(chars, 0, length);
+
+        String result;
+        if (charsRead != -1) {
+            result = new String(chars, 0,  charsRead);
+        } else {
+            result = "";
+        }
+
+        return result;
+    }
+
+    public String readFile() {
+        BufferedReader reader = null;
+        try {
+            reader = new BufferedReader(new FileReader("src/main/resources/input.txt"));
+            String content = readAllLines(reader);
+            return content;
+        } catch (IOException e) {
+            e.printStackTrace();
+            return null;
+        } finally {
+            try {
+                if (reader != null) {
+                    reader.close();
+                }
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    public String readFileTryWithResources() {
+        try (BufferedReader reader = new BufferedReader(new FileReader("src/main/resources/input.txt"))) {
+            String content = readAllLines(reader);
+            return content;
+        } catch (IOException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+}
@@ -0,0 +1,22 @@
+package com.baeldung.csv;
+
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class WriteCsvFileExample {
+
+    public String convertToCSV(String[] data) {
+        return Stream.of(data)
+            .map(this::escapeSpecialCharacters)
+            .collect(Collectors.joining(","));
+    }
+
+    public String escapeSpecialCharacters(String data) {
+        String escapedData = data.replaceAll("\\R", " ");
+        if (data.contains(",") || data.contains("\"") || data.contains("'")) {
+            data = data.replace("\"", "\"\"");
+            escapedData = "\"" + data + "\"";
+        }
+        return escapedData;
+    }
+}
@@ -0,0 +1,42 @@
+package com.baeldung.dirmonitoring;
+
+import org.apache.commons.io.monitor.FileAlterationListener;
+import org.apache.commons.io.monitor.FileAlterationListenerAdaptor;
+import org.apache.commons.io.monitor.FileAlterationMonitor;
+import org.apache.commons.io.monitor.FileAlterationObserver;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+
+public class DirectoryMonitoringExample {
+
+    private static final Logger LOG = LoggerFactory.getLogger(DirectoryMonitoringExample.class);
+
+    private static final int POLL_INTERVAL = 500;
+
+    public static void main(String[] args) throws Exception {
+        FileAlterationObserver observer = new FileAlterationObserver(System.getProperty("user.home"));
+        FileAlterationMonitor monitor = new FileAlterationMonitor(POLL_INTERVAL);
+        FileAlterationListener listener = new FileAlterationListenerAdaptor() {
+            @Override
+            public void onFileCreate(File file) {
+                LOG.debug("File: " + file.getName() + " created");
+            }
+
+            @Override
+            public void onFileDelete(File file) {
+                LOG.debug("File: " + file.getName() + " deleted");
+            }
+
+            @Override
+            public void onFileChange(File file) {
+                LOG.debug("File: " + file.getName() + " changed");
+            }
+        };
+        observer.addListener(listener);
+        monitor.addObserver(observer);
+        monitor.start();
+
+    }
+}
@@ -0,0 +1,90 @@
+package com.baeldung.download;
+
+import org.apache.commons.io.FileUtils;
+import org.asynchttpclient.*;
+
+import java.io.*;
+import java.net.*;
+import java.nio.channels.Channels;
+import java.nio.channels.FileChannel;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
+import java.util.concurrent.ExecutionException;
+
+public class FileDownload {
+
+    public static void downloadWithJavaIO(String url, String localFilename) {
+
+        try (BufferedInputStream in = new BufferedInputStream(new URL(url).openStream()); FileOutputStream fileOutputStream = new FileOutputStream(localFilename)) {
+
+            byte dataBuffer[] = new byte[1024];
+            int bytesRead;
+            while ((bytesRead = in.read(dataBuffer, 0, 1024)) != -1) {
+                fileOutputStream.write(dataBuffer, 0, bytesRead);
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void downloadWithJava7IO(String url, String localFilename) {
+
+        try (InputStream in = new URL(url).openStream()) {
+            Files.copy(in, Paths.get(localFilename), StandardCopyOption.REPLACE_EXISTING);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void downloadWithJavaNIO(String fileURL, String localFilename) throws IOException {
+
+        URL url = new URL(fileURL);
+        try (ReadableByteChannel readableByteChannel = Channels.newChannel(url.openStream()); 
+            FileOutputStream fileOutputStream = new FileOutputStream(localFilename); FileChannel fileChannel = fileOutputStream.getChannel()) {
+
+            fileChannel.transferFrom(readableByteChannel, 0, Long.MAX_VALUE);
+            fileOutputStream.close();
+        }
+    }
+
+    public static void downloadWithApacheCommons(String url, String localFilename) {
+
+        int CONNECT_TIMEOUT = 10000;
+        int READ_TIMEOUT = 10000;
+        try {
+            FileUtils.copyURLToFile(new URL(url), new File(localFilename), CONNECT_TIMEOUT, READ_TIMEOUT);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    public static void downloadWithAHC(String url, String localFilename) throws ExecutionException, InterruptedException, IOException {
+
+        FileOutputStream stream = new FileOutputStream(localFilename);
+        AsyncHttpClient client = Dsl.asyncHttpClient();
+
+        client.prepareGet(url)
+            .execute(new AsyncCompletionHandler<FileOutputStream>() {
+
+                @Override
+                public State onBodyPartReceived(HttpResponseBodyPart bodyPart) throws Exception {
+                    stream.getChannel()
+                        .write(bodyPart.getBodyByteBuffer());
+                    return State.CONTINUE;
+                }
+
+                @Override
+                public FileOutputStream onCompleted(Response response) throws Exception {
+                    return stream;
+                }
+            })
+            .get();
+
+        stream.getChannel().close();
+        client.close();
+    }
+
+}
@@ -0,0 +1,62 @@
+package com.baeldung.download;
+
+import java.io.*;
+import java.net.*;
+
+public class ResumableDownload {
+
+    public static long downloadFile(String downloadUrl, String saveAsFileName) throws IOException, URISyntaxException {
+
+        File outputFile = new File(saveAsFileName);
+        URLConnection downloadFileConnection = new URI(downloadUrl).toURL()
+            .openConnection();
+        return transferDataAndGetBytesDownloaded(downloadFileConnection, outputFile);
+    }
+
+    private static long transferDataAndGetBytesDownloaded(URLConnection downloadFileConnection, File outputFile) throws IOException {
+
+        long bytesDownloaded = 0;
+        try (InputStream is = downloadFileConnection.getInputStream(); OutputStream os = new FileOutputStream(outputFile, true)) {
+
+            byte[] buffer = new byte[1024];
+
+            int bytesCount;
+            while ((bytesCount = is.read(buffer)) > 0) {
+                os.write(buffer, 0, bytesCount);
+                bytesDownloaded += bytesCount;
+            }
+        }
+        return bytesDownloaded;
+    }
+
+    public static long downloadFileWithResume(String downloadUrl, String saveAsFileName) throws IOException, URISyntaxException {
+        File outputFile = new File(saveAsFileName);
+
+        URLConnection downloadFileConnection = addFileResumeFunctionality(downloadUrl, outputFile);
+        return transferDataAndGetBytesDownloaded(downloadFileConnection, outputFile);
+    }
+
+    private static URLConnection addFileResumeFunctionality(String downloadUrl, File outputFile) throws IOException, URISyntaxException, ProtocolException, ProtocolException {
+        long existingFileSize = 0L;
+        URLConnection downloadFileConnection = new URI(downloadUrl).toURL()
+            .openConnection();
+
+        if (outputFile.exists() && downloadFileConnection instanceof HttpURLConnection) {
+            HttpURLConnection httpFileConnection = (HttpURLConnection) downloadFileConnection;
+
+            HttpURLConnection tmpFileConn = (HttpURLConnection) new URI(downloadUrl).toURL()
+                .openConnection();
+            tmpFileConn.setRequestMethod("HEAD");
+            long fileLength = tmpFileConn.getContentLengthLong();
+            existingFileSize = outputFile.length();
+
+            if (existingFileSize < fileLength) {
+                httpFileConnection.setRequestProperty("Range", "bytes=" + existingFileSize + "-" + fileLength);
+            } else {
+                throw new IOException("File Download already completed.");
+            }
+        }
+        return downloadFileConnection;
+    }
+
+}
@@ -0,0 +1,23 @@
+package com.baeldung.extension;
+
+import com.google.common.io.Files;
+import org.apache.commons.io.FilenameUtils;
+
+import java.util.Optional;
+
+public class Extension {
+    //Instead of file name we can also specify full path of a file eg. /baeldung/com/demo/abc.java
+    public String getExtensionByApacheCommonLib(String filename) {
+        return FilenameUtils.getExtension(filename);
+    }
+
+    public Optional<String> getExtensionByStringHandling(String filename) {
+        return Optional.ofNullable(filename)
+                       .filter(f -> f.contains("."))
+                      .map(f -> f.substring(filename.lastIndexOf(".") + 1));
+    }
+
+    public String getExtensionByGuava(String filename) {
+        return Files.getFileExtension(filename);
+    }
+}
@@ -0,0 +1,24 @@
+package com.baeldung.fileparser;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+
+public class BufferedReaderExample {
+
+    protected static ArrayList<String> generateArrayListFromFile(String filename) throws IOException {
+
+        ArrayList<String> result = new ArrayList<>();
+
+        try (BufferedReader br = new BufferedReader(new FileReader(filename))) {
+
+            while (br.ready()) {
+                result.add(br.readLine());
+            }
+            return result;
+        }
+
+    }
+
+}
@@ -0,0 +1,31 @@
+package com.baeldung.fileparser;
+
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+
+public class FileReaderExample {
+
+    protected static ArrayList<String> generateArrayListFromFile(String filename) throws IOException {
+
+        ArrayList<String> result = new ArrayList<>();
+
+        try (FileReader f = new FileReader(filename)) {
+            StringBuffer sb = new StringBuffer();
+            while (f.ready()) {
+                char c = (char) f.read();
+                if (c == '\n') {
+                    result.add(sb.toString());
+                    sb = new StringBuffer();
+                } else {
+                    sb.append(c);
+                }
+            }
+            if (sb.length() > 0) {
+                result.add(sb.toString());
+            }
+        }
+        
+        return result;
+    }
+}
@@ -0,0 +1,18 @@
+package com.baeldung.fileparser;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+
+public class FilesReadLinesExample {
+
+    protected static ArrayList<String> generateArrayListFromFile(String filename) throws IOException {
+        
+        List<String> result = Files.readAllLines(Paths.get(filename));
+        
+        return (ArrayList<String>) result;
+    }
+
+}
@@ -0,0 +1,24 @@
+package com.baeldung.fileparser;
+
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Scanner;
+
+public class ScannerIntExample {
+
+    protected static ArrayList<Integer> generateArrayListFromFile(String filename) throws IOException {
+        
+        ArrayList<Integer> result = new ArrayList<>();
+
+        try (Scanner s = new Scanner(new FileReader(filename))) {
+
+            while (s.hasNext()) {
+                result.add(s.nextInt());
+            }
+            return result;
+        }
+
+    }
+
+}
@@ -0,0 +1,24 @@
+package com.baeldung.fileparser;
+
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Scanner;
+
+public class ScannerStringExample {
+
+    protected static ArrayList<String> generateArrayListFromFile(String filename) throws IOException {
+        
+        ArrayList<String> result = new ArrayList<>();
+
+        try (Scanner s = new Scanner(new FileReader(filename))) {
+
+            while (s.hasNext()) {
+                result.add(s.nextLine());
+            }
+            return result;
+        }
+
+    }
+
+}
@@ -0,0 +1,64 @@
+package com.baeldung.files;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.DirectoryStream;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class ListFiles {
+    public static final int DEPTH = 1;
+
+    public Set<String> listFilesUsingJavaIO(String dir) {
+        return Stream.of(new File(dir).listFiles())
+            .filter(file -> !file.isDirectory())
+            .map(File::getName)
+            .collect(Collectors.toSet());
+    }
+
+    public Set<String> listFilesUsingFileWalk(String dir, int depth) throws IOException {
+        try (Stream<Path> stream = Files.walk(Paths.get(dir), depth)) {
+            return stream.filter(file -> !Files.isDirectory(file))
+                .map(Path::getFileName)
+                .map(Path::toString)
+                .collect(Collectors.toSet());
+        }
+    }
+
+    public Set<String> listFilesUsingFileWalkAndVisitor(String dir) throws IOException {
+        Set<String> fileList = new HashSet<>();
+        Files.walkFileTree(Paths.get(dir), new SimpleFileVisitor<Path>() {
+            @Override
+            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
+                if (!Files.isDirectory(file)) {
+                    fileList.add(file.getFileName()
+                        .toString());
+                }
+                return FileVisitResult.CONTINUE;
+            }
+        });
+        return fileList;
+    }
+
+    public Set<String> listFilesUsingDirectoryStream(String dir) throws IOException {
+        Set<String> fileList = new HashSet<>();
+        try (DirectoryStream<Path> stream = Files.newDirectoryStream(Paths.get(dir))) {
+            for (Path path : stream) {
+                if (!Files.isDirectory(path)) {
+                    fileList.add(path.getFileName()
+                        .toString());
+                }
+            }
+        }
+        return fileList;
+    }
+
+}
@@ -0,0 +1,42 @@
+package com.baeldung.filesystem.jndi;
+
+import java.io.File;
+import java.util.Hashtable;
+
+import javax.naming.Context;
+import javax.naming.InitialContext;
+import javax.naming.NamingException;
+
+public class LookupFSJNDI {
+    private InitialContext ctx = null;
+
+    public LookupFSJNDI() throws NamingException {
+        super();
+        init();
+    }
+
+    private void init() throws NamingException {
+        Hashtable<String, String> env = new Hashtable<String, String>();
+
+        env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.fscontext.RefFSContextFactory");
+        // URI to namespace (actual directory)
+        env.put(Context.PROVIDER_URL, "file:./src/test/resources");
+
+        ctx = new InitialContext(env);
+    }
+
+    public InitialContext getCtx() {
+        return ctx;
+    }
+
+    public File getFile(String fileName) {
+        File file;
+        try {
+            file = (File) getCtx().lookup(fileName);
+        } catch (NamingException e) {
+            file = null;
+        }
+        return file;
+    }
+
+}
@@ -0,0 +1,50 @@
+package com.baeldung.java.nio.selector;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.channels.SocketChannel;
+
+public class EchoClient {
+    private static SocketChannel client;
+    private static ByteBuffer buffer;
+    private static EchoClient instance;
+
+    public static EchoClient start() {
+        if (instance == null)
+            instance = new EchoClient();
+
+        return instance;
+    }
+
+    public static void stop() throws IOException {
+        client.close();
+        buffer = null;
+    }
+
+    private EchoClient() {
+        try {
+            client = SocketChannel.open(new InetSocketAddress("localhost", 5454));
+            buffer = ByteBuffer.allocate(256);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public String sendMessage(String msg) {
+        buffer = ByteBuffer.wrap(msg.getBytes());
+        String response = null;
+        try {
+            client.write(buffer);
+            buffer.clear();
+            client.read(buffer);
+            response = new String(buffer.array()).trim();
+            System.out.println("response=" + response);
+            buffer.clear();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return response;
+
+    }
+}
@@ -0,0 +1,75 @@
+package com.baeldung.java.nio.selector;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.Selector;
+import java.nio.channels.ServerSocketChannel;
+import java.nio.channels.SocketChannel;
+import java.util.Iterator;
+import java.util.Set;
+
+public class EchoServer {
+
+    private static final String POISON_PILL = "POISON_PILL";
+
+    public static void main(String[] args) throws IOException {
+        Selector selector = Selector.open();
+        ServerSocketChannel serverSocket = ServerSocketChannel.open();
+        serverSocket.bind(new InetSocketAddress("localhost", 5454));
+        serverSocket.configureBlocking(false);
+        serverSocket.register(selector, SelectionKey.OP_ACCEPT);
+        ByteBuffer buffer = ByteBuffer.allocate(256);
+
+        while (true) {
+            selector.select();
+            Set<SelectionKey> selectedKeys = selector.selectedKeys();
+            Iterator<SelectionKey> iter = selectedKeys.iterator();
+            while (iter.hasNext()) {
+
+                SelectionKey key = iter.next();
+
+                if (key.isAcceptable()) {
+                    register(selector, serverSocket);
+                }
+
+                if (key.isReadable()) {
+                    answerWithEcho(buffer, key);
+                }
+                iter.remove();
+            }
+        }
+    }
+
+    private static void answerWithEcho(ByteBuffer buffer, SelectionKey key) throws IOException {
+        SocketChannel client = (SocketChannel) key.channel();
+        client.read(buffer);
+        if (new String(buffer.array()).trim().equals(POISON_PILL)) {
+            client.close();
+            System.out.println("Not accepting client messages anymore");
+        }
+
+        buffer.flip();
+        client.write(buffer);
+        buffer.clear();
+    }
+
+    private static void register(Selector selector, ServerSocketChannel serverSocket) throws IOException {
+        SocketChannel client = serverSocket.accept();
+        client.configureBlocking(false);
+        client.register(selector, SelectionKey.OP_READ);
+    }
+
+    public static Process start() throws IOException, InterruptedException {
+        String javaHome = System.getProperty("java.home");
+        String javaBin = javaHome + File.separator + "bin" + File.separator + "java";
+        String classpath = System.getProperty("java.class.path");
+        String className = EchoServer.class.getCanonicalName();
+
+        ProcessBuilder builder = new ProcessBuilder(javaBin, "-cp", classpath, className);
+
+        return builder.start();
+    }
+}
@@ -0,0 +1,2 @@
+###Relevant Articles:
+- [Introduction to the Java NIO Selector](http://www.baeldung.com/java-nio-selector)
@@ -0,0 +1,56 @@
+package com.baeldung.java.nio2.visitor;
+
+import java.io.IOException;
+import java.nio.file.*;
+import java.nio.file.attribute.BasicFileAttributes;
+
+import static java.nio.file.FileVisitResult.CONTINUE;
+import static java.nio.file.FileVisitResult.TERMINATE;
+
+public class FileSearchExample implements FileVisitor<Path> {
+    private final String fileName;
+    private final Path startDir;
+
+    public FileSearchExample(String fileName, Path startingDir) {
+        this.fileName = fileName;
+        startDir = startingDir;
+    }
+
+    @Override
+    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
+        return CONTINUE;
+    }
+
+    @Override
+    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
+        String fileName = file.getFileName().toString();
+        if (this.fileName.equals(fileName)) {
+            System.out.println("File found: " + file.toString());
+            return TERMINATE;
+        }
+        return CONTINUE;
+    }
+
+    @Override
+    public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
+        System.out.println("Failed to access file: " + file.toString());
+        return CONTINUE;
+    }
+
+    @Override
+    public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
+        boolean finishedSearch = Files.isSameFile(dir, startDir);
+        if (finishedSearch) {
+            System.out.println("File:" + fileName + " not found");
+            return TERMINATE;
+        }
+        return CONTINUE;
+    }
+
+    public static void main(String[] args) throws IOException {
+        Path startingDir = Paths.get("C:/Users/new/Desktop");
+        FileSearchExample crawler = new FileSearchExample("hibernate.txt", startingDir);
+        Files.walkFileTree(startingDir, crawler);
+    }
+
+}
@@ -0,0 +1,30 @@
+package com.baeldung.java.nio2.visitor;
+
+import java.io.IOException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.FileVisitor;
+import java.nio.file.Path;
+import java.nio.file.attribute.BasicFileAttributes;
+
+public class FileVisitorImpl implements FileVisitor<Path> {
+
+    @Override
+    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
+        return null;
+    }
+
+    @Override
+    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
+        return null;
+    }
+
+    @Override
+    public FileVisitResult visitFileFailed(Path file, IOException exc) {
+        return null;
+    }
+
+    @Override
+    public FileVisitResult postVisitDirectory(Path dir, IOException exc) {
+        return null;
+    }
+}
@@ -0,0 +1,29 @@
+package com.baeldung.java.nio2.watcher;
+
+import java.io.IOException;
+import java.nio.file.FileSystems;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardWatchEventKinds;
+import java.nio.file.WatchEvent;
+import java.nio.file.WatchKey;
+import java.nio.file.WatchService;
+
+public class DirectoryWatcherExample {
+
+    public static void main(String[] args) throws IOException, InterruptedException {
+        WatchService watchService = FileSystems.getDefault().newWatchService();
+        Path path = Paths.get(System.getProperty("user.home"));
+        path.register(watchService, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_DELETE, StandardWatchEventKinds.ENTRY_MODIFY);
+        WatchKey key;
+        while ((key = watchService.take()) != null) {
+            for (WatchEvent<?> event : key.pollEvents()) {
+                System.out.println("Event kind:" + event.kind() + ". File affected: " + event.context() + ".");
+            }
+            key.reset();
+        }
+
+        watchService.close();
+    }
+
+}
@@ -0,0 +1,48 @@
+package com.baeldung.stream;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.channels.FileChannel;
+import java.nio.file.Files;
+
+import org.apache.commons.io.FileUtils;
+
+public class FileCopy {
+
+    public static void copyFileUsingStream(File source, File dest) throws IOException {
+        InputStream is = null;
+        OutputStream os = null;
+        is = new FileInputStream(source);
+        os = new FileOutputStream(dest);
+        byte[] buffer = new byte[1024];
+        int length;
+        while ((length = is.read(buffer)) > 0) {
+            os.write(buffer, 0, length);
+        }
+        is.close();
+        os.close();
+    }
+
+    public static void copyFileUsingChannel(File source, File dest) throws IOException {
+        FileChannel sourceChannel = null;
+        FileChannel destChannel = null;
+        sourceChannel = new FileInputStream(source).getChannel();
+        destChannel = new FileOutputStream(dest).getChannel();
+        destChannel.transferFrom(sourceChannel, 0, sourceChannel.size());
+        sourceChannel.close();
+        destChannel.close();
+    }
+
+    public static void copyFileUsingApacheCommonsIO(File source, File dest) throws IOException {
+        FileUtils.copyFile(source, dest);
+    }
+
+    public static void copyFileUsingJavaFiles(File source, File dest) throws IOException {
+        Files.copy(source.toPath(), dest.toPath());
+    }
+
+}
@@ -0,0 +1,48 @@
+package com.baeldung.stream;
+
+import java.io.BufferedOutputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+
+public class OutputStreamExamples {
+
+    public void fileOutputStreamByteSequence(String file, String data) throws IOException {
+        byte[] bytes = data.getBytes();
+        try (OutputStream out = new FileOutputStream(file)) {
+            out.write(bytes);
+        }
+    }
+
+    public void fileOutputStreamByteSubSequence(String file, String data) throws IOException {
+        byte[] bytes = data.getBytes();
+        try (OutputStream out = new FileOutputStream(file)) {
+            out.write(bytes, 6, 5);
+        }
+    }
+
+    public void fileOutputStreamByteSingle(String file, String data) throws IOException {
+        byte[] bytes = data.getBytes();
+        try (OutputStream out = new FileOutputStream(file)) {
+            out.write(bytes[6]);
+        }
+    }
+
+    public void bufferedOutputStream(String file, String... data) throws IOException {
+        try (BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(file))) {
+            for (String s : data) {
+                out.write(s.getBytes());
+                out.write(" ".getBytes());
+            }
+        }
+    }
+
+    public void outputStreamWriter(String file, String data) throws IOException {
+        try (OutputStream out = new FileOutputStream(file); Writer writer = new OutputStreamWriter(out, "UTF-8")) {
+            writer.write(data);
+        }
+    }
+
+}
@@ -0,0 +1,54 @@
+package com.baeldung.symlink;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.DirectoryStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import static java.nio.file.StandardOpenOption.*;
+import java.util.stream.IntStream;
+
+public class SymLinkExample {
+
+    public void createSymbolicLink(Path link, Path target) throws IOException {
+        if (Files.exists(link)) {
+            Files.delete(link);
+        }
+        Files.createSymbolicLink(link, target);
+    }
+
+    public void createHardLink(Path link, Path target) throws IOException {
+        if (Files.exists(link)) {
+            Files.delete(link);
+        }
+        Files.createLink(link, target);
+    }
+
+    public Path createTextFile() throws IOException {
+        byte[] content = IntStream.range(0, 10000)
+            .mapToObj(i -> i + System.lineSeparator())
+            .reduce("", String::concat)
+            .getBytes(StandardCharsets.UTF_8);
+        Path filePath = Paths.get(".", "target_link.txt");
+        Files.write(filePath, content, CREATE, TRUNCATE_EXISTING);
+        return filePath;
+    }
+
+    public void printLinkFiles(Path path) throws IOException {
+        try (DirectoryStream<Path> stream = Files.newDirectoryStream(path)) {
+            for (Path file : stream) {
+                if (Files.isDirectory(file)) {
+                    printLinkFiles(file);
+                } else if (Files.isSymbolicLink(file)) {
+                    System.out.format("File link '%s' with target '%s'%n", file, Files.readSymbolicLink(file));
+                }
+            }
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+        new SymLinkExample().printLinkFiles(Paths.get("."));
+    }
+
+}
@@ -0,0 +1,46 @@
+package com.baeldung.unzip;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+public class UnzipFile {
+    public static void main(final String[] args) throws IOException {
+        final String fileZip = "src/main/resources/unzipTest/compressed.zip";
+        final File destDir = new File("src/main/resources/unzipTest");
+        final byte[] buffer = new byte[1024];
+        final ZipInputStream zis = new ZipInputStream(new FileInputStream(fileZip));
+        ZipEntry zipEntry = zis.getNextEntry();
+        while (zipEntry != null) {
+            final File newFile = newFile(destDir, zipEntry);
+            final FileOutputStream fos = new FileOutputStream(newFile);
+            int len;
+            while ((len = zis.read(buffer)) > 0) {
+                fos.write(buffer, 0, len);
+            }
+            fos.close();
+            zipEntry = zis.getNextEntry();
+        }
+        zis.closeEntry();
+        zis.close();
+    }
+    
+    /**
+     * @see https://snyk.io/research/zip-slip-vulnerability
+     */
+    public static File newFile(File destinationDir, ZipEntry zipEntry) throws IOException {
+        File destFile = new File(destinationDir, zipEntry.getName());
+        
+        String destDirPath = destinationDir.getCanonicalPath();
+        String destFilePath = destFile.getCanonicalPath();
+        
+        if (!destFilePath.startsWith(destDirPath + File.separator)) {
+            throw new IOException("Entry is outside of the target dir: " + zipEntry.getName());
+        }
+        
+        return destFile;
+    }
+}
@@ -0,0 +1,16 @@
+package com.baeldung.util;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.StringWriter;
+
+import org.apache.commons.io.IOUtils;
+
+public class StreamUtils {
+
+    public static String getStringFromInputStream(InputStream input) throws IOException {
+        StringWriter writer = new StringWriter();
+        IOUtils.copy(input, writer, "UTF-8");
+        return writer.toString();
+    }
+}
@@ -0,0 +1,50 @@
+package com.baeldung.zip;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+public class ZipDirectory {
+    public static void main(final String[] args) throws IOException {
+        final String sourceFile = "src/main/resources/zipTest";
+        final FileOutputStream fos = new FileOutputStream("src/main/resources/dirCompressed.zip");
+        final ZipOutputStream zipOut = new ZipOutputStream(fos);
+        final File fileToZip = new File(sourceFile);
+
+        zipFile(fileToZip, fileToZip.getName(), zipOut);
+        zipOut.close();
+        fos.close();
+    }
+
+    private static void zipFile(final File fileToZip, final String fileName, final ZipOutputStream zipOut) throws IOException {
+        if (fileToZip.isHidden()) {
+            return;
+        }
+        if (fileToZip.isDirectory()) {
+            if (fileName.endsWith("/")) {
+                zipOut.putNextEntry(new ZipEntry(fileName));
+                zipOut.closeEntry();
+            } else {
+                zipOut.putNextEntry(new ZipEntry(fileName + "/"));
+                zipOut.closeEntry();
+            }
+            final File[] children = fileToZip.listFiles();
+            for (final File childFile : children) {
+                zipFile(childFile, fileName + "/" + childFile.getName(), zipOut);
+            }
+            return;
+        }
+        final FileInputStream fis = new FileInputStream(fileToZip);
+        final ZipEntry zipEntry = new ZipEntry(fileName);
+        zipOut.putNextEntry(zipEntry);
+        final byte[] bytes = new byte[1024];
+        int length;
+        while ((length = fis.read(bytes)) >= 0) {
+            zipOut.write(bytes, 0, length);
+        }
+        fis.close();
+    }
+}
@@ -0,0 +1,28 @@
+package com.baeldung.zip;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+public class ZipFile {
+    public static void main(final String[] args) throws IOException {
+        final String sourceFile = "src/main/resources/zipTest/test1.txt";
+        final FileOutputStream fos = new FileOutputStream("src/main/resources/compressed.zip");
+        final ZipOutputStream zipOut = new ZipOutputStream(fos);
+        final File fileToZip = new File(sourceFile);
+        final FileInputStream fis = new FileInputStream(fileToZip);
+        final ZipEntry zipEntry = new ZipEntry(fileToZip.getName());
+        zipOut.putNextEntry(zipEntry);
+        final byte[] bytes = new byte[1024];
+        int length;
+        while ((length = fis.read(bytes)) >= 0) {
+            zipOut.write(bytes, 0, length);
+        }
+        zipOut.close();
+        fis.close();
+        fos.close();
+    }
+}
@@ -0,0 +1,33 @@
+package com.baeldung.zip;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+public class ZipMultipleFiles {
+    public static void main(final String[] args) throws IOException {
+        final List<String> srcFiles = Arrays.asList("src/main/resources/zipTest/test1.txt", "src/main/resources/zipTest/test2.txt");
+        final FileOutputStream fos = new FileOutputStream("src/main/resources/multiCompressed.zip");
+        final ZipOutputStream zipOut = new ZipOutputStream(fos);
+        for (final String srcFile : srcFiles) {
+            final File fileToZip = new File(srcFile);
+            final FileInputStream fis = new FileInputStream(fileToZip);
+            final ZipEntry zipEntry = new ZipEntry(fileToZip.getName());
+            zipOut.putNextEntry(zipEntry);
+
+            final byte[] bytes = new byte[1024];
+            int length;
+            while ((length = fis.read(bytes)) >= 0) {
+                zipOut.write(bytes, 0, length);
+            }
+            fis.close();
+        }
+        zipOut.close();
+        fos.close();
+    }
+}
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
+        http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd" version="2.1">
+
+    <!-- JDO tutorial "unit" -->
+    <persistence-unit name="Tutorial">
+        <exclude-unlisted-classes/>
+		<properties>
+			<property name="javax.jdo.PersistenceManagerFactoryClass" value="org.datanucleus.api.jdo.JDOPersistenceManagerFactory"/>		
+		    <property name="javax.jdo.option.ConnectionURL" value="jdbc:h2:mem:mypersistence"/>
+		    <property name="javax.jdo.option.ConnectionDriverName" value="org.h2.Driver"/>
+		    <property name="javax.jdo.option.ConnectionUserName" value="sa"/>
+		    <property name="javax.jdo.option.ConnectionPassword" value=""/>
+		    <property name="datanucleus.schema.autoCreateAll" value="true"/>
+		</properties>
+    </persistence-unit>
+</persistence>
+
--- a/Show More
+++ b/Show More