File类练习,阻塞队列

最新推荐文章于 2024-09-21 10:38:43 发布

华..

最新推荐文章于 2024-09-21 10:38:43 发布

阅读量40

点赞数

分类专栏： Java小白学习之路文章标签： java jvm 开发语言 java-ee 数据结构

本文链接：https://blog.csdn.net/m0_53400772/article/details/130206476

版权

Java小白学习之路专栏收录该内容

25 篇文章 0 订阅

订阅专栏

1.遍历目录,获取所有Java文件

使用FileFilter接口,实现文件过滤功能,public boolean accept(File path)：方法参数就是listFiles()方法获取到的文件或者目录的路径。如果方法返回true，表示需要此路径，否则此路径将被忽略。

public static void main(String[] args){
    File dir = new File("d:\\demo");
    File[] files = dir.listFiles(new FileFilter() {
    @Override
    public boolean accept(File pathname) {
        //判断如果获取到的是目录，直接放行
        if(pathname.isDirectory())
        return true;
        //获取路径中的文件名，判断是否java结尾，是就返回true
        return pathname.getName().toLowerCase().endsWith("java");
      }
    });
    for(File file : files){
    	System.out.println(file);
    }
}

2.使用递归的方法遍历目录.

分析：目录遍历，无法判断多少级目录，所以在遍历需要进行判断，如果遍历到的还是目录，就要使用递归，遍历所有目录。

public class Demo {
    public static void main(String[] args) {
        File file = new File("d:\\ideawork\\doit40");
       show(file);
    }
    public static void show(File file){
        File[] files = file.listFiles();
        for (File file1 : files) {
            if (file1.isFile()){
                //如果是文件,直接打印
                System.out.println(file1);
            }else{
                //如果是文件夹,递归调用
                show(file1);
            }
        }
    }
}

阻塞队列

阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作是：在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。

ArrayBlockingQueue：是一个用数组实现的有界阻塞队列，此队列按照先进先出（FIFO）的原则对元素进行排序。支持公平锁和非公平锁。【注：每一个线程在获取锁的时候可能都会排队等待，如果在等待时间上，先获取锁的线程的请求一定先被满足，那么这个锁就是公平的。反之，这个锁就是不公平的。公平的获取锁，也就是当前等待时间最长的线程先获取锁】
LinkedBlockingQueue：一个由链表结构组成的有界队列，此队列的长度为Integer.MAX_VALUE。此队列按照先进先出的顺序进行排序。
SynchronousQueue：一个不存储元素的阻塞队列，每一个put操作必须等待take操作，否则不能添加元素。支持公平锁和非公平锁。

常用方法

public void put(E e)将指定的元素插入此队列的尾部，如果该队列已满，则等待可用的空间。
public E take() 获取并移除此队列的头部，在元素变得可用之前一直等待。

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

//        BlockingQueue<Integer>  blockingQueue = new ArrayBlockingQueue<>(5);
//        BlockingQueue<Integer>  blockingQueue = new LinkedBlockingQueue<>();
        BlockingQueue<Integer>  blockingQueue = new SynchronousQueue<>();



        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    try {
                        blockingQueue.put(i);
                        System.out.println("存入数据-->"+i);

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){

                    try {
                        Thread.sleep(1000);
                        System.out.println("取出数据-->"+blockingQueue.take());

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        }).start();
    }
}