Google Guava IO 操作

红太狼 2021-12-09 16:53 507阅读 0赞

关于IO操作Guava给我们提供了很多工具类，大大提高了我们开发效率．下面我们将对Guava IO 提供的相关工具类做一个简单的介绍．涉及到的工具类主要有：ByteStreams,CharStreams,Resources,Closeables,Flushables,Files,MoreFiles.

# 一 ByteStreams #

ByteStreams里面提供用于处理字节数组和I / O流的实用程序方法。

## 1.1 ByteStreams常用方法 ##

public final class ByteStreams {
        
        /**
         * 拷贝从from到to
         */
        @CanIgnoreReturnValue
        public static long copy(InputStream from, OutputStream to) throws IOException;
    
        /**
         * 拷贝从from到to
         */
        @CanIgnoreReturnValue
        public static long copy(ReadableByteChannel from, WritableByteChannel to) throws IOException;
    
    
        /**
         * InputStream里面的数据读到byte数组里面去
         */
        public static byte[] toByteArray(InputStream in) throws IOException;
    
        /**
         *
         * 从给定的InputStream读取并丢弃数据，直到到达流的末尾。返回读取的总字节数。不关闭流
         */
        @CanIgnoreReturnValue
        @Beta
        public static long exhaust(InputStream in) throws IOException;
    
        /**
         * byte数组里面的数据导入到ByteArrayDataInput里面去
         */
        @Beta
        public static ByteArrayDataInput newDataInput(byte[] bytes);
    
        /**
         * byte数组里面的数据导入到ByteArrayDataInput里面去
         */
        @Beta
        public static ByteArrayDataInput newDataInput(byte[] bytes, int start);
    
        /**
         * ByteArrayInputStream里面的数据导入到ByteArrayDataInput里面去
         */
        @Beta
        public static ByteArrayDataInput newDataInput(ByteArrayInputStream byteArrayInputStream);
    
    
        /** 返回ByteArrayDataOutput,默认size = 32 */
        @Beta
        public static ByteArrayDataOutput newDataOutput() {
            return newDataOutput(new ByteArrayOutputStream());
        }
    
        /**
         * 返回ByteArrayDataOutput,给定了初始数组大小size
         */
        @Beta
        public static ByteArrayDataOutput newDataOutput(int size);
    
        /**
         * 返回ByteArrayDataOutput，并且把ByteArrayOutputStream里面的数据导入进去
         */
        @Beta
        public static ByteArrayDataOutput newDataOutput(ByteArrayOutputStream byteArrayOutputSteam);
    
    
        /**
         * 返回一个空的OutputStream，里面什么数据也没有
         */
        @Beta
        public static OutputStream nullOutputStream();
    
        /**
         * 重新包装下InputStream，限制可读的字节数
         */
        @Beta
        public static InputStream limit(InputStream in, long limit);
    
        /**
         * InputStream里面的数据读到byte数组里面去。如果读到数据的长度和给定的数组长度不相同抛EOFException异常
         */
        @Beta
        public static void readFully(InputStream in, byte[] b) throws IOException;
    
        /**
         * InputStream里面的数据读到byte数组里面去，如果读到数据的长度和给定的len长度不相同抛EOFException异常
         */
        @Beta
        public static void readFully(InputStream in, byte[] b, int off, int len) throws IOException;
    
        /**
         * InputStream里面丢弃n个字节的数据
         */
        @Beta
        public static void skipFully(InputStream in, long n) throws IOException;
    
    
    
        /**
         * 把InputStream里面的数据用ByteProcessor来处理
         */
        @Beta
        @CanIgnoreReturnValue // some processors won't return a useful result
        public static <T> T readBytes(InputStream input, ByteProcessor<T> processor);
    
        /**
         * 把InputStream里面的数据读到byte数组里面去
         */
        @Beta
        @CanIgnoreReturnValue
        // Sometimes you don't care how many bytes you actually read, I guess.
        // (You know that it's either going to read len bytes or stop at EOF.)
        public static int read(InputStream in, byte[] b, int off, int len);
    
    }

## 1.2 ByteStreams简单使用 ##

// ByteStreams.copy()方法,数据拷贝
        @Test
        public void copy() {
            URL url = Resources.getResource("application.yml");
            File f = new File(url.getFile());    // 声明File对象
    
            InputStream inputStream = null;
            try {
                inputStream = new FileInputStream(f);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
            if (inputStream == null) {
                return;
            }
    
            try {
                OutputStream outputStream = new FileOutputStream("/home/tuacy/github/google-guava-study/src/main/resources" + File.separator + "abc.txt");
                // 把InputStream里面的内容写入到OutputStream里面去
                ByteStreams.copy(inputStream, outputStream);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        // ByteStreams.toByteArray()方法，把InputStream里面的数据读到数组里面去
        @Test
        public void toByteArray() {
            URL url = Resources.getResource("application.yml");
            File f = new File(url.getFile());    // 声明File对象
            // InputStream
            InputStream inputStream = null;
            try {
                inputStream = new FileInputStream(f);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
            if (inputStream == null) {
                return;
            }
            try {
                // InputStream里面的内容读到byte数组里面去
                byte[] byteArrary = ByteStreams.toByteArray(inputStream);
                System.out.println(new String(byteArrary));
            } catch (IOException e) {
                e.printStackTrace();
            }
    
        }
    
        // ByteStreams.read() 把
        @Test
        public void read() {
            URL url = Resources.getResource("application.yml");
            File f = new File(url.getFile());    // 声明File对象
            // InputStream
            InputStream inputStream = null;
            try {
                inputStream = new FileInputStream(f);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
            if (inputStream == null) {
                return;
            }
            try {
                byte[] byteArray = new byte[1024];
                int readLength = ByteStreams.read(inputStream, byteArray, 0, 1024);
                System.out.println("读取都的数据长度 = " + readLength);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

# 二 CharStreams #

CharStreams  
提供用于处理字符流的实用方法．

## 2.1 CharStreams常用方法 ##

public final class CharStreams {
    
        /**
         * 数据复制
         */
        @CanIgnoreReturnValue
        public static long copy(Readable from, Appendable to) throws IOException;
        
        
    
        /**
         * Readable里面的数据转换为String
         */
        public static String toString(Readable r) throws IOException;
        
    
        /**
         * Readable里面的数据按行读出来放到List<String>里面去。读文件的时候经常用到
         */
        @Beta
        public static List<String> readLines(Readable r) throws IOException;
    
        /**
         * 一行一行的读数据，一行一行的交给processor去处理
         */
        @Beta
        @CanIgnoreReturnValue // some processors won't return a useful result
        public static <T> T readLines(Readable readable, LineProcessor<T> processor) throws IOException;
    
        /**
         * 从给定的Readable读取并丢弃数据，直到到达流的末尾,相当于清空数据
         */
        @Beta
        @CanIgnoreReturnValue
        public static long exhaust(Readable readable) throws IOException;
    
        /**
         * 从reader里面丢弃指定的字节
         */
        @Beta
        public static void skipFully(Reader reader, long n) throws IOException;
    
        /**
         * 返回一个空的Writer，里面什么数据也没得
         */
        @Beta
        public static Writer nullWriter();
    
        /**
         * 返回一个Writer，并且把target里面的数据导入进去
         */
        @Beta
        public static Writer asWriter(Appendable target);
    
    }

## 2.2 CharStreams简单使用 ##

// CharStreams.copy() 字符流拷贝
        @Test
        public void copy() {
            URL url = Resources.getResource("application.yml");
            File f = new File(url.getFile());    // 声明File对象
            try {
                BufferedReader in = new BufferedReader(new FileReader(f));
                StringBuilder stringBuilder = new StringBuilder();
                CharStreams.copy(in, stringBuilder);
                System.out.println(stringBuilder.toString());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        // CharStreams.readLines() 一行，一行的读取数据
        @Test
        public void readLines() {
            URL url = Resources.getResource("application.yml");
            File f = new File(url.getFile());    // 声明File对象
            try {
                BufferedReader in = new BufferedReader(new FileReader(f));
                List<String> lineList = CharStreams.readLines(in);
                for (String lineItem : lineList) {
                    System.out.println(lineItem);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        // CharStreams.readLines(),并且交给LineProcessor处理
        @Test
        public void readLines2() {
            URL url = Resources.getResource("application.yml");
            File f = new File(url.getFile());    // 声明File对象
            try {
                BufferedReader in = new BufferedReader(new FileReader(f));
                List<String> lineList = CharStreams.readLines(in, new LineProcessor<List<String>>() {
                    List<String> resultList = Lists.newArrayList();
                    @Override
                    public boolean processLine(String line) throws IOException {
                        resultList.add(line);
                        return true;
                    }
    
                    @Override
                    public List<String> getResult() {
                        return resultList;
                    }
                });
                // 打印结果
                for (String lineItem : lineList) {
                    System.out.println(lineItem);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

# 三 Resources #

提供用于处理类路径中的资源的实用程序方法。

## 3.1 Resources常用方法 ##

public final class Resources  {
    
        private Resources() {}
    
        /**
         * URL对应的数据，读到ByteSource里面
         */
        public static ByteSource asByteSource(URL url);
    
        /**
         * URL对应的数据，读到CharSource里面
         */
        public static CharSource asCharSource(URL url, Charset charset);
    
        /**
         * URL对应的数据读到byte数组里面去
         */
        public static byte[] toByteArray(URL url) throws IOException;
    
        /**
         * URL对应数据读到String里面去
         */
        public static String toString(URL url, Charset charset) throws IOException;
    
        /**
         * URL对应数据一行一行读，一行一行给callback处理
         */
        @CanIgnoreReturnValue // some processors won't return a useful result
        public static <T> T readLines(URL url, Charset charset, LineProcessor<T> callback)
                throws IOException;
    
        /**
         * URL数据一行一行读出来放到List<String>里面去
         */
        public static List<String> readLines(URL url, Charset charset) throws IOException;
    
        /**
         * URL里面数据拷贝到OutputStream里面去
         */
        public static void copy(URL from, OutputStream to) throws IOException;
    
        /**
         * 返回resourceName对应的java资源的URL
         */
        @CanIgnoreReturnValue // being used to check if a resource exists
        // TODO(cgdecker): maybe add a better way to check if a resource exists
        // e.g. Optional<URL> tryGetResource or boolean resourceExists
        public static URL getResource(String resourceName);
    
        /**
         * 同上，contextClass用来指定从contextClass所在路径出发，去查找resourceName对应资源文件
         */
        public static URL getResource(Class<?> contextClass, String resourceName);
    
    }

## 3.2 Resources简单使用 ##

// Resources.getResource()
        @Test
        public void getResource() {
            System.out.println(Resources.getResource("application.yml"));
            // 起始路径不一样
            System.out.println(Resources.getResource(ResourcesTest.class, "ResourcesTest.class"));
        }
    
        // Resources.readLines()
        @Test
        public void readLines() {
    
            // 我们把application.yml文件的内容读取出来
            URL url = Resources.getResource("application.yml");
            try {
                // Resources.readLines
                List<String> lineList = Resources.readLines(url, Charsets.UTF_8);
                for (String lineItem : lineList) {
                    System.out.println(lineItem);
                }
                // Resources.readLines +
                List<String> lineList2 = Resources.readLines(url, Charsets.UTF_8, new LineProcessor<List<String>>() {
                    List<String> lines = Lists.newArrayList();
                    @Override
                    public boolean processLine(String line) throws IOException {
                        lines.add(line);
                        return true;
                    }
    
                    @Override
                    public List<String> getResult() {
                        return lines;
                    }
                });
                for (String lineItem : lineList2) {
                    System.out.println(lineItem);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
    
        }

# 四　Closeables #

Closeables对象的实用方法。让我们调用一些close方法更加的方便一点．

## 4.1 Closeables常用方法 ##

public final class Closeables{
    
        /**
         * 调用可关闭对象Closeable的close方法．
         *
         * swallowIOException=true，不会抛出异常，false会抛出异常
         */
        public static void close(@Nullable Closeable closeable, boolean swallowIOException)
                throws IOException;
    
        /**
         * InputStream关闭
         */
        public static void closeQuietly(@Nullable InputStream inputStream);
    
        /**
         * Reader关闭
         */
        public static void closeQuietly(@Nullable Reader reader);
    
    }

# 五　Flushables #

Flushables对象的一些使用方法，让我们调用flush方法更加的方便一点．

## Flushables常用方法 ##

public final class Flushables {
    
        /**
         * 把可以flush的Flushable对象，调用flush方法
         * swallowIOException：true 不会抛出IOException异常，false会抛出IOException异常
         */
        public static void flush(Flushable flushable, boolean swallowIOException) throws IOException;
    
        /**
         * flush(flushable, true);
         */
        public static void flushQuietly(Flushable flushable);
    
    }

# 六　Files #

Files类提供使用文件相关的一些实用程序方法．

## 6.1 Files常用方法 ##

public final class Files {
    
        /**
         * 把文件信息读到BufferedReader里面去
         */
        @Beta
        public static BufferedReader newReader(File file, Charset charset) throws FileNotFoundException;
    
        /**
         * 把文件信息和BufferedWriter关联起来
         */
        @Beta
        public static BufferedWriter newWriter(File file, Charset charset) throws FileNotFoundException;
    
        /**
         * 把文件信息读到ByteSource里面去
         */
        public static ByteSource asByteSource(File file);
    
    
        /**
         * 把文件里面的内容以append追加方式（覆盖方式可以省略）读到ByteSink里面去
         */
        public static ByteSink asByteSink(File file, FileWriteMode... modes);
    
        /**
         * 把文件里面的内容读到CharSource里面去
         */
        public static CharSource asCharSource(File file, Charset charset);
    
        /**
         * 把文件里面的内容读到CharSink里面去
         */
        public static CharSink asCharSink(File file, Charset charset, FileWriteMode... modes);
    
        /**
         * 把文件里面的内容读到byte数组里面去
         */
        @Beta
        public static byte[] toByteArray(File file) throws IOException;
    
        /**
         * 把文件里面的内容读到String里面去
         */
        @Beta
        @Deprecated
        public static String toString(File file, Charset charset) throws IOException;
    
        /**
         * byte数组里面的内容写到文件里面去
         */
        @Beta
        public static void write(byte[] from, File to) throws IOException;
    
        /**
         * CharSequence内容写到文件里面去
         */
        @Beta
        @Deprecated
        public static void write(CharSequence from, File to, Charset charset) throws IOException;
    
        /**
         * 把文件里面的内容拷贝到OutputStream里面去(个人认为和读出来的意思是一样的)
         */
        @Beta
        public static void copy(File from, OutputStream to) throws IOException;
    
        /**
         * 把一个人家的内容拷贝到另一个文件里面去
         */
        @Beta
        public static void copy(File from, File to) throws IOException;
    
    
        /**
         * 判断两个文件的内容是否相同
         */
        @Beta
        public static boolean equal(File file1, File file2) throws IOException;
    
        /**
         * 创建一个临时文件（由java.io.tmpdir指定的操作系统缓存的临时目录下）
         */
        @Beta
        public static File createTempDir();
    
        /**
         * 创建一个空文件或更新上次更新的时间戳，与同名的unix命令相
         */
        @Beta
        @SuppressWarnings("GoodTime") // reading system time without TimeSource
        public static void touch(File file) throws IOException;
    
        /**
         * 必要时为文件创建父目录（文件路径里面有父路径）
         */
        @Beta
        public static void createParentDirs(File file) throws IOException;
    
        /**
         * 把文件从一个路径移动到另一个路径
         */
        @Beta
        public static void move(File from, File to) throws IOException;
    
        /**
         * 读取文件的第一行数据
         */
        @Beta
        @Deprecated
        public
        static String readFirstLine(File file, Charset charset) throws IOException;
    
        /**
         * 一行，一行的把文件读取出来
         */
        @Beta
        public static List<String> readLines(File file, Charset charset) throws IOException;
    
        /**
         * 一行，一行的把文件读取出来，然后交给LineProcessor去处理
         */
        @Beta
        @Deprecated
        @CanIgnoreReturnValue // some processors won't return a useful result
        public
        static <T> T readLines(File file, Charset charset, LineProcessor<T> callback) throws IOException;
    
        /**
         * 读取文件并且把读出来的内容交给ByteProcessor去处理
         */
        @Beta
        @Deprecated
        @CanIgnoreReturnValue // some processors won't return a useful result
        public
        static <T> T readBytes(File file, ByteProcessor<T> processor) throws IOException;
    
        /**
         * 对文件做hash操作
         */
        @Beta
        @Deprecated
        public
        static HashCode hash(File file, HashFunction hashFunction) throws IOException；
    
        /**
         *　把文件的内容读到MappedByteBuffer里面去
         * java nio中引入了一种基于MappedByteBuffer操作大文件的方式，其读写性能极高
         */
        @Beta
        public static MappedByteBuffer map(File file) throws IOException;
    
        /**
         * 把文件的内容读到MappedByteBuffer里面去
         */
        @Beta
        public static MappedByteBuffer map(File file, MapMode mode) throws IOException;
    
        /**
         * 把文件的内容读到MappedByteBuffer里面去
         */
        @Beta
        public static MappedByteBuffer map(File file, MapMode mode, long size) throws IOException;
    
        /**
         * 规范文件路径，并不总是与文件系统一致，请仔细测试
         */
        @Beta
        public static String simplifyPath(String pathname);
    
        /**
         * 返回给定路径所表示文件的扩展名
         */
        @Beta
        public static String getFileExtension(String fullName);
    
        /**
         * 返回去除了扩展名的文件名
         */
        @Beta
        public static String getNameWithoutExtension(String file);
    
        /**
         * 返回文件和目录树的raverser实例。返回的遍历器从File开始，将返回它遇到的所有文件和目录。
         */
        @Beta
        public static Traverser<File> fileTraverser() {
            return Traverser.forTree(FILE_TREE);
        }
    
        /**
         * 返回一个Predicate对象，用于判断文件是否是目录文件
         */
        @Beta
        public static Predicate<File> isDirectory();
    
        /**
         * 返回一个Predicate，用于判断是否是文件
         */
        @Beta
        public static Predicate<File> isFile();
    }

## 6.2 Files简单使用 ##

// Files.newReader() 把文件的内容读到BufferedReader里面去
        @Test
        public void newReader() {
            //　这里，需要换成你电脑存在的地址
            File file = new File("/home/tuacy/github/google-guava-study/src/main/resources" + File.separator + "application.yml");
            try {
                BufferedReader bufferedReader = Files.newReader(file, Charsets.UTF_8);
                List<String> lineList = CharStreams.readLines(bufferedReader);
                for (String lineItem : lineList) {
                    System.out.println(lineItem);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        // Files.newWriter
        @Test
        public void newWriter() {
            File file = new File("/home/tuacy/github/google-guava-study/src/main/resources" + File.separator + "filewirite.txt");
            try {
                BufferedWriter bufferedWriter = Files.newWriter(file, Charsets.UTF_8);
                bufferedWriter.write("hello word!!!");
    //            bufferedWriter.flush();
                Flushables.flushQuietly(bufferedWriter);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        // Files.asByteSink
        @Test
        public void asByteSink() {
            File file = new File("/home/tuacy/github/google-guava-study/src/main/resources" + File.separator + "filewirite.txt");
            try {
                ByteSink byteSink = Files.asByteSink(file, FileWriteMode.APPEND);
                OutputStream outputStream = byteSink.openStream();
                outputStream.write("hello word!!!".getBytes(Charsets.UTF_8));
    //            bufferedWriter.flush();
                Flushables.flushQuietly(outputStream);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        // 对文件做hash操作
        @Test
        public void hash() {
            File file = new File("/home/tuacy/github/google-guava-study/src/main/resources" + File.separator + "filewirite.txt");
            try {
                HashCode hashCode = Files.asByteSource(file).hash(Hashing.sha256());
                System.out.println(hashCode.toString());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        // Files.fileTraverser() 用于遍历文件
        @Test
        public void fileTraverser() {
            Traverser<File> traverser = Files.fileTraverser();
            File file = new File("/home/tuacy/github/google-guava-study/src/main/resources");
            Iterable<File> list = traverser.breadthFirst(file);
            list.forEach(new Consumer<File>() {
    
                @Override
                public void accept(File file) {
                    System.out.println(file.getName());
                }
            });
        }

# 七　MoreFiles #

MoreFiles类是Files类的一个补充类,MoreFiles里面的方法也是操作文件相关的方法,不过MoreFiles针对的是Path类,关于Path类和File的的区别和用法可以自己去百度下,两者都是操作文件的对象.

## 7.1 MoreFiles常用方法 ##

public final class MoreFiles {
    
        /**
         * 文件内容读到ByteSource里面去
         */
        public static ByteSource asByteSource(Path path, OpenOption... options);
        
    
        /**
         * 文件内容关联ByteSink,这样可以通过ByteSink把内容写到文件里面去
         */
        public static ByteSink asByteSink(Path path, OpenOption... options);
        
    
        /**
         * 文件内容读到CharSource里面去u
         */
        public static CharSource asCharSource(Path path, Charset charset, OpenOption... options);
    
        /**
         * 文件关联CharSink,这样可以通过CharSink把内容写到文件里面去
         */
        public static CharSink asCharSink(Path path, Charset charset, OpenOption... options);
    
        /**
         * 获取指定目录下的文件
         */
        public static ImmutableList<Path> listFiles(Path dir) throws IOException;
    
        /**
         * 返回Traverser,用于遍历文件
         */
        public static Traverser<Path> fileTraverser();
        
    
        /**
         * 返回一个表示目录文件的Predicate, 
         */
        public static Predicate<Path> isDirectory(LinkOption... options);
        
    
        /**
         * 返回Predicate,用于判断文件是不是一个正常的文件
         */
        public static Predicate<Path> isRegularFile(LinkOption... options);
    
        /**
         * 两个path对应的文件内容是否相同
         */
        public static boolean equal(Path path1, Path path2) throws IOException;
    
        /**
         * 创建一个空文件或更新上次更新的时间戳
         */
        @SuppressWarnings("GoodTime") // reading system time without TimeSource
        public static void touch(Path path) throws IOException;
    
        /**
         * 创建父目录
         */
        public static void createParentDirectories(Path path, FileAttribute<?>... attrs)
                throws IOException;
    
        /**
         * 返回给定路径所表示文件的扩展名
         */
        public static String getFileExtension(Path path);
    
        /**
         * 返回去除了扩展名的文件名
         */
        public static String getNameWithoutExtension(Path path);
    
        /**
         * 删除整个目录
         */
        public static void deleteRecursively(Path path, RecursiveDeleteOption... options)
                throws IOException;
    
        /**
         * 删除目录下面的文件
         */
        public static void deleteDirectoryContents(Path path, RecursiveDeleteOption... options)
                throws IOException;
    
    }

## 7.2 MoreFiles简单使用 ##

// MoreFiles.asCharSource()
        @Test
        public void asCharSource() {
            Path path = Paths.get("/home/tuacy/github/google-guava-study/src/main/resources/abc.txt");
            CharSource charSource = MoreFiles.asCharSource(path, Charsets.UTF_8);
            try {
                BufferedReader bufferedReader = charSource.openBufferedStream();
                List<String> lines = CharStreams.readLines(bufferedReader);
                for (String lineItem : lines) {
                    System.out.println(lineItem);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        // MoreFiles.deleteDirectoryContents() 删除目录里面的文件
        // MoreFiles.deleteRecursively() 删除目录已经目录里面的文件
        @Test
        public void deleteDirectoryContents() {
    
            Path path = Paths.get("/home/tuacy/github/google-guava-study/src/main/resources/abc");
            try {
                MoreFiles.deleteDirectoryContents(path, RecursiveDeleteOption.ALLOW_INSECURE);
                MoreFiles.deleteDirectoryContents(path, RecursiveDeleteOption.ALLOW_INSECURE);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        @Test
        public void createParentDirectories() {
    
            Path path = Paths.get("/home/tuacy/github/google-guava-study/src/main/resources/abc/123/789/abc.txt");
            try {
                MoreFiles.createParentDirectories(path);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        @Test
        public void isDirectory() {
            Path path = Paths.get("/home/tuacy/github/google-guava-study/src/main/resources");
            Predicate<Path> predicate = MoreFiles.isDirectory();
            System.out.println("是否目录 = " + predicate.apply(path));
    
        }

--------------------

关于Guava I/O 部分的内容,我们就先讲这些主要是一些工具类的使用,熟悉ByteStreams,CharStreams,Resources,Closeables,Flushables,Files,MoreFiles这些个工具类里面方法的使用. 充分的把他们用到我们实际开发当中去．相关实例代码可以在 [https://github.com/tuacy/google-guava-study][https_github.com_tuacy_google-guava-study] 测试包下com.tuacy.guava.study.io包里面找到.

[https_github.com_tuacy_google-guava-study]: https://github.com/tuacy/google-guava-study