Java读取文件夹大小的6种方法及代码

(一)单线程递归方式

创新互联建站专注于企业营销型网站、网站重做改版、横山网站定制设计、自适应品牌网站建设、html5、商城网站定制开发、集团公司官网建设、外贸营销网站建设、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为横山等各大城市提供网站开发制作服务。

 
 
  
  package com.taobao.test; 
  
  import java.io.File; 
  
  public class TotalFileSizeSequential { 
  
      public static String fileName = "C:\\Documents and Settings\\Administrator\\桌面\\monkeytalk"; 
  
      // 递归方式 计算文件的大小 
  
      private long getTotalSizeOfFilesInDir(final File file) { 
  
          if (file.isFile()) 
  
              return file.length(); 
  
          final File[] children = file.listFiles(); 
  
          long total = 0; 
  
          if (children != null) 
  
              for (final File child : children) 
  
                  total += getTotalSizeOfFilesInDir(child); 
  
          return total; 
  
      } 
  
      public static void main(final String[] args) { 
  
          final long start = System.nanoTime(); 
  
          final long total = new TotalFileSizeSequential() 
  
                  .getTotalSizeOfFilesInDir(new File(fileName)); 
  
          final long end = System.nanoTime(); 
  
          System.out.println("Total Size: " + total); 
  
          System.out.println("Time taken: " + (end - start) / 1.0e9); 
  
      } 
  
  }

(二)使用Executors.newFixedThreadPool和callable 多线程实现

 
 
  
  package com.taobao.test; 
  
  import java.io.File; 
  
  import java.util.ArrayList; 
  
  import java.util.Collections; 
  
  import java.util.List; 
  
  import java.util.concurrent.Callable; 
  
  import java.util.concurrent.ExecutionException; 
  
  import java.util.concurrent.ExecutorService; 
  
  import java.util.concurrent.Executors; 
  
  import java.util.concurrent.Future; 
  
  import java.util.concurrent.TimeUnit; 
  
  import java.util.concurrent.TimeoutException; 
  
  public class ConcurrentTotalFileSize { 
  
      public static final String fileName = "C:\\Documents and Settings\\Administrator\\桌面\\monkeytalk"; 
  
      class SubDirectoriesAndSize { 
  
          final public long size; 
  
          final public List subDirectories; 
  
          public SubDirectoriesAndSize(final long totalSize, 
  
                  final List theSubDirs) { 
  
              size = totalSize; 
  
              subDirectories = Collections.unmodifiableList(theSubDirs); 
  
          } 
  
      } 
  
      private SubDirectoriesAndSize getTotalAndSubDirs(final File file) { 
  
          long total = 0; 
  
          final List subDirectories = new ArrayList(); 
  
          if (file.isDirectory()) { 
  
              final File[] children = file.listFiles(); 
  
              if (children != null) 
  
                  for (final File child : children) { 
  
                      if (child.isFile()) 
  
                          total += child.length(); 
  
                      else 
  
                          subDirectories.add(child); 
  
                  } 
  
          } 
  
          return new SubDirectoriesAndSize(total, subDirectories); 
  
      } 
  
      private long getTotalSizeOfFilesInDir(final File file) 
  
              throws InterruptedException, ExecutionException, TimeoutException { 
  
          final ExecutorService service = Executors.newFixedThreadPool(100); 
  
          try { 
  
              long total = 0; 
  
              final List directories = new ArrayList(); 
  
              directories.add(file); 
  
              while (!directories.isEmpty()) { 
  
                  final List> partialResults = new ArrayList>(); 
  
                  for (final File directory : directories) { 
  
                      partialResults.add(service 
  
                              .submit(new Callable() { 
  
                                  public SubDirectoriesAndSize call() { 
  
                                      return getTotalAndSubDirs(directory); 
  
                                  } 
  
                              })); 
  
                  } 
  
                  directories.clear(); 
  
                  for (final Future partialResultFuture : partialResults) { 
  
                      final SubDirectoriesAndSize subDirectoriesAndSize = partialResultFuture 
  
                              .get(100, TimeUnit.SECONDS); 
  
                      directories.addAll(subDirectoriesAndSize.subDirectories); 
  
                      total += subDirectoriesAndSize.size; 
  
                  } 
  
              } 
  
              return total; 
  
          } finally { 
  
              service.shutdown(); 
  
          } 
  
      } 
  
      public static void main(final String[] args) throws InterruptedException, 
  
              ExecutionException, TimeoutException { 
  
          final long start = System.nanoTime(); 
  
          final long total = new ConcurrentTotalFileSize() 
  
                  .getTotalSizeOfFilesInDir(new File(fileName)); 
  
          final long end = System.nanoTime(); 
  
          System.out.println("Total Size: " + total); 
  
          System.out.println("Time taken: " + (end - start) / 1.0e9); 
  
      } 
  
  }

(三)使用Executors.newFixedThreadPool和callable 多线程的另外一种实现

 
 
  
  package com.taobao.test; 
  
   
  
  import java.io.File; 
  
  import java.util.ArrayList; 
  
  import java.util.List; 
  
  import java.util.concurrent.Callable; 
  
  import java.util.concurrent.ExecutionException; 
  
  import java.util.concurrent.ExecutorService; 
  
  import java.util.concurrent.Executors; 
  
  import java.util.concurrent.Future; 
  
  import java.util.concurrent.TimeUnit; 
  
  import java.util.concurrent.TimeoutException; 
  
  public class NaivelyConcurrentTotalFileSize { 
  
      public static String fileName = "C:\\Documents and Settings\\Administrator\\桌面\\monkeytalk"; 
  
      private long getTotalSizeOfFilesInDir(final ExecutorService service, 
  
              final File file) throws InterruptedException, ExecutionException, 
  
              TimeoutException { 
  
          if (file.isFile()) 
  
              return file.length(); 
  
          long total = 0; 
  
          final File[] children = file.listFiles(); 
  
          if (children != null) { 
  
              final List> partialTotalFutures = new ArrayList>(); 
  
              for (final File child : children) { 
  
                  partialTotalFutures.add(service.submit(new Callable() { 
  
                      public Long call() throws InterruptedException, 
  
                              ExecutionException, TimeoutException { 
  
                          return getTotalSizeOfFilesInDir(service, child); 
  
                      } 
  
                  })); 
  
              } 
  
              for (final Future partialTotalFuture : partialTotalFutures) 
  
                  total += partialTotalFuture.get(100, TimeUnit.SECONDS); 
  
          } 
  
          return total; 
  
      } 
  
      private long getTotalSizeOfFile(final String fileName) 
  
              throws InterruptedException, ExecutionException, TimeoutException { 
  
          final ExecutorService service = Executors.newFixedThreadPool(100); 
  
          try { 
  
              return getTotalSizeOfFilesInDir(service, new File(fileName)); 
  
          } finally { 
  
              service.shutdown(); 
  
          } 
  
      } 
  
      public static void main(final String[] args) throws InterruptedException, 
  
              ExecutionException, TimeoutException { 
  
          final long start = System.nanoTime(); 
  
          final long total = new NaivelyConcurrentTotalFileSize() 
  
                  .getTotalSizeOfFile(fileName); 
  
          final long end = System.nanoTime(); 
  
          System.out.println("Total Size: " + total); 
  
          System.out.println("Time taken: " + (end - start) / 1.0e9); 
  
      } 
  
  }

#p#

(四)使用CountDownLatch和AtomicLong实现多线程下的并发控制

 
 
  
  package com.taobao.test; 
  
  import java.io.File; 
  
  import java.util.concurrent.CountDownLatch; 
  
  import java.util.concurrent.ExecutorService; 
  
  import java.util.concurrent.Executors; 
  
  import java.util.concurrent.TimeUnit; 
  
  import java.util.concurrent.atomic.AtomicLong; 
  
  public class ConcurrentTotalFileSizeWLatch { 
  
      private ExecutorService service; 
  
      final private AtomicLong pendingFileVisits = new AtomicLong(); 
  
      final private AtomicLong totalSize = new AtomicLong(); 
  
      final private CountDownLatch latch = new CountDownLatch(1); 
  
      public static String fileName = "C:\\Documents and Settings\\Administrator\\桌面\\monkeytalk"; 
  
      private void updateTotalSizeOfFilesInDir(final File file) { 
  
          long fileSize = 0; 
  
          if (file.isFile()) 
  
              fileSize = file.length(); 
  
          else { 
  
              final File[] children = file.listFiles(); 
  
              if (children != null) { 
  
                  for (final File child : children) { 
  
                      if (child.isFile()) 
  
                          fileSize += child.length(); 
  
                      else { 
  
                          pendingFileVisits.incrementAndGet(); 
  
                          service.execute(new Runnable() { 
  
                              public void run() { 
  
                                  updateTotalSizeOfFilesInDir(child); 
  
                              } 
  
                          }); 
  
                      } 
  
                  } 
  
              } 
  
          } 
  
          totalSize.addAndGet(fileSize); 
  
          if (pendingFileVisits.decrementAndGet() == 0) 
  
              latch.countDown(); 
  
      } 
  
      private long getTotalSizeOfFile(final String fileName) 
  
              throws InterruptedException { 
  
          service = Executors.newFixedThreadPool(100); 
  
          pendingFileVisits.incrementAndGet(); 
  
          try { 
  
              updateTotalSizeOfFilesInDir(new File(fileName)); 
  
              latch.await(100, TimeUnit.SECONDS); 
  
              return totalSize.longValue(); 
  
          } finally { 
  
              service.shutdown(); 
  
          } 
  
      } 
  
      public static void main(final String[] args) throws InterruptedException { 
  
          final long start = System.nanoTime(); 
  
          final long total = new ConcurrentTotalFileSizeWLatch() 
  
                  .getTotalSizeOfFile(fileName); 
  
          final long end = System.nanoTime(); 
  
          System.out.println("Total Size: " + total); 
  
          System.out.println("Time taken: " + (end - start) / 1.0e9); 
  
      } 
  
  }

(五)使用BlockingQueue和AtomicLong的实现

 
 
  
  package com.taobao.test; 
  
  import java.io.File; 
  
  import java.util.concurrent.ArrayBlockingQueue; 
  
  import java.util.concurrent.BlockingQueue; 
  
  import java.util.concurrent.ExecutorService; 
  
  import java.util.concurrent.Executors; 
  
  import java.util.concurrent.TimeUnit; 
  
  import java.util.concurrent.atomic.AtomicLong; 
  
  public class ConcurrentTotalFileSizeWQueue { 
  
      public static String fileName = "C:\\Documents and Settings\\Administrator\\桌面\\monkeytalk"; 
  
   
  
      private ExecutorService service; 
  
      final private BlockingQueue fileSizes = new ArrayBlockingQueue( 
  
              500); 
  
      final AtomicLong pendingFileVisits = new AtomicLong(); 
  
      private void startExploreDir(final File file) { 
  
          pendingFileVisits.incrementAndGet(); 
  
          service.execute(new Runnable() { 
  
              public void run() { 
  
                  exploreDir(file); 
  
              } 
  
          }); 
  
      } 
  
      private void exploreDir(final File file) { 
  
          long fileSize = 0; 
  
          if (file.isFile()) 
  
              fileSize = file.length(); 
  
          else { 
  
              final File[] children = file.listFiles(); 
  
              if (children != null) 
  
                  for (final File child : children) { 
  
                      if (child.isFile()) 
  
                          fileSize += child.length(); 
  
                      else { 
  
                          startExploreDir(child); 
  
                      } 
  
                  } 
  
          } 
  
          try { 
  
              fileSizes.put(fileSize); 
  
          } catch (Exception ex) { 
  
              throw new RuntimeException(ex); 
  
          } 
  
          pendingFileVisits.decrementAndGet(); 
  
      } 
  
      private long getTotalSizeOfFile(final String fileName) 
  
              throws InterruptedException { 
  
          service = Executors.newFixedThreadPool(100); 
  
          try { 
  
              startExploreDir(new File(fileName)); 
  
              long totalSize = 0; 
  
              while (pendingFileVisits.get() > 0 || fileSizes.size() > 0) { 
  
                  final Long size = fileSizes.poll(10, TimeUnit.SECONDS); 
  
                  totalSize += size; 
  
              } 
  
              return totalSize; 
  
          } finally { 
  
              service.shutdown(); 
  
          } 
  
      } 
  
      public static void main(final String[] args) throws InterruptedException { 
  
          final long start = System.nanoTime(); 
  
          final long total = new ConcurrentTotalFileSizeWQueue() 
  
                  .getTotalSizeOfFile(fileName); 
  
          final long end = System.nanoTime(); 
  
          System.out.println("Total Size: " + total); 
  
          System.out.println("Time taken: " + (end - start) / 1.0e9); 
  
      } 
  
  }

(六)使用jdk7的ForkJoin来实现

 
 
  
  package com.taobao.test; 
  
  import java.io.File; 
  
  import java.util.ArrayList; 
  
  import java.util.List; 
  
  import java.util.concurrent.ForkJoinPool; 
  
  import java.util.concurrent.ForkJoinTask; 
  
  import java.util.concurrent.RecursiveTask; 
  
  public class FileSize { 
  
      private final static ForkJoinPool forkJoinPool = new ForkJoinPool(); 
  
      public static String fileName = "C:\\Documents and Settings\\Administrator\\桌面\\monkeytalk"; 
  
   
  
      private static class FileSizeFinder extends RecursiveTask { 
  
          final File file; 
  
          public FileSizeFinder(final File theFile) { 
  
              file = theFile; 
  
          } 
  
          @Override 
  
          public Long compute() { 
  
              long size = 0; 
  
              if (file.isFile()) { 
  
                  size = file.length(); 
  
              } else { 
  
                  final File[] children = file.listFiles(); 
  
                  if (children != null) { 
  
                      List> tasks = new ArrayList>(); 
  
                      for (final File child : children) { 
  
                          if (child.isFile()) { 
  
                              size += child.length(); 
  
                          } else { 
  
                              tasks.add(new FileSizeFinder(child)); 
  
                          } 
  
                      } 
  
                      for (final ForkJoinTask task : invokeAll(tasks)) { 
  
                          size += task.join(); 
  
                      } 
  
                  } 
  
              } 
  
              return size; 
  
          } 
  
      } 
  
      public static void main(final String[] args) { 
  
          final long start = System.nanoTime(); 
  
          final long total = forkJoinPool.invoke(new FileSizeFinder(new File("/home"))); 
  
          final long end = System.nanoTime(); 
  
          System.out.println("Total Size: " + total); 
  
          System.out.println("Time taken: " + (end - start) / 1.0e9); 
  
      } 
  
  }

当前名称：Java读取文件夹大小的6种方法及代码
文章转载：http://www.csdahua.cn/qtweb/news21/184171.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：快上网

成都快上网为您推荐相关内容