当前位置：网站首页>Lambda expression_ Stream stream_ File class

Lambda expression_ Stream stream_ File class

2022-06-30 16:49:00 【The cool city is not warm and the night is slightly cool】

1 Lambda expression

1.1 Experience Lambda expression

package com.itheima.lambda_demo;

/*
    Lambda Expression experience  :
 */
public class LambdaDemo {
    public static void main(String[] args) {
        //  Anonymous inner class method 
        goSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println(" Iron juice  ,  Let's go swimming ....");
            }
        });

        // lambda Expression 
        goSwimming(() -> System.out.println(" Iron juice  ,  Let's go swimming ...."));

    }

    public static void goSwimming(Swimming swimming) {
        swimming.swim();
    }

}

interface Swimming {
    public abstract void swim();
}

lambda Expressions can be understood as a simplification of anonymous inner classes , But the essence is different
Object oriented idea :
- The emphasis is on using objects to accomplish certain functions
Functional programming ideas :
- The emphasis is on the results , Not how

1.2 Functional interface

There is only one abstract method that needs to be overridden , Functional interface . Functional interfaces allow the existence of other non abstract methods, such as static methods , The default method , Private method .
To identify that the interface is a functional interface , You can add an annotation to the interface ： @FunctionalInterface In order to show the difference between
stay JDK in java.util.function All interfaces in the package are functional interfaces . We learned when we learned about threads Runnable It's also a functional interface

1.3 Lambda Use of expressions

Use the premise ：

There must be an interface
There is only one abstract method in the interface

Format : ( Formal parameters ) -> { Code block }

() Formal parameters ： If you have more than one parameter , Parameters are separated by commas ; If there are no parameters , Leave blank
-> ： It's made up of lines and greater than symbols in English , Fixed writing . Represents a pointing action
{} Code block ： It's what we're going to do , That's what we used to write

1.4 Lambda Case of expression

package com.itheima.lambda_test;

/*  practice 1： 1  Write an interface （ShowHandler） 2  There is an abstract method in this interface （show）, The method has no parameters and no return value  3  Testing class （ShowHandlerDemo） There's a way （useShowHandler）  The parameters of the method are ShowHandler Type of , Called inside the method ShowHandler Of show Method  */
public class LambdaTest1 {
    
    public static void main(String[] args) {
    
        useShowHandler(() -> {
    
            System.out.println(" I am a lambda expression ....");
        });
    }

    public static void useShowHandler(ShowHandler showHandler) {
    
        showHandler.show();
    }
}

interface ShowHandler {
    
    public abstract void show();
}

package com.itheima.lambda_test;

/* 1  First there is an interface （StringHandler） 2  There is an abstract method in this interface （printMessage）, The method has parameters and no return value  3  Testing class （StringHandlerDemo） There's a way （useStringHandler）,  The parameters of the method are StringHandler Type of ,  Called inside the method StringHandler Of printMessage Method  */
public class LambdaTest2 {
    
    public static void main(String[] args) {
    
        useStringHandler((String msg) -> {
    
            System.out.println(msg);
        });
    }

    public static void useStringHandler(StringHandler stringHandler){
    
        stringHandler.printMessage(" it's a nice day today  ,  It's very sunny ...");
    }
}

@FunctionalInterface
interface StringHandler {
    
    public abstract void printMessage(String msg);
}

package com.itheima.lambda_test;

import java.util.Random;

/* 1  First there is an interface （RandomNumHandler） 2  There is an abstract method in this interface （getNumber）, This method has no parameters but has a return value  3  Testing class （RandomNumHandlerDemo） There's a way （useRandomNumHandler）, The parameters of the method are RandomNumHandler Type of   Called inside the method RandomNumHandler Of getNumber Method  */
public class LambdaTest3 {
    
    public static void main(String[] args) {
    
        useRandomNumHandler(() -> {
    
            return new Random().nextInt(10) + 1;
        });
    }

    public static void useRandomNumHandler(RandomNumHandler randomNumHandler) {
    
        int number = randomNumHandler.getNumber();
        System.out.println(number);
    }
}

interface RandomNumHandler {
    
    public abstract int getNumber();
}

package com.itheima.lambda_test;

/* 1  First there is an interface （Calculator） 2  There is an abstract method in this interface （calc）, This method has both parameters and return values  3  Testing class （CalculatorDemo） There's a way （useCalculator）  The parameters of the method are Calculator Type of   Called inside the method Calculator Of calc Method  */
public class LambdaTest4 {
    
    public static void main(String[] args) {
    
        useCalculator((int a , int b) -> {
     return a + b;});
    }

    public static void useCalculator(Calculator calculator) {
    
        int calc = calculator.calc(10, 20);
        System.out.println(calc);
    }
}

@FunctionalInterface
interface Calculator {
    
    public abstract int calc(int a, int b);
}

1.5Lambda Ellipsis patterns of expressions

Omit the rule ：

Parameter types can be omitted , However, only one parameter can be omitted when there are multiple parameters
If there is only one parameter , Then brackets can be omitted
If the code block has only one statement , You can omit braces and semicolons , even to the extent that return

1.6Lambda Expressions differ from anonymous inner classes

The types required are different

Anonymous inner class ： It can be an interface , It can also be an abstract class , It can also be a concrete class
Lambda： Only functional interfaces

Use restrictions are different

If there is only one abstract method in the interface that needs to be overridden , have access to Lambda expression , You can also use anonymous inner classes
If there is more than one abstract method in the interface , Only anonymous inner classes can be used , They can't be used Lambda expression

The implementation principle is different

Anonymous inner class ： After the compilation , Produce a single class Bytecode file
Lambda expression ： After the compilation , There is no one alone class Bytecode file , The corresponding bytecode will be generated dynamically at runtime

2 Stream flow

2.1 Stream Experience

package com.itheima.stream_demo;

import java.util.ArrayList;

/*  Experience Stream The benefits of streaming   demand ： Complete the creation and traversal of the collection according to the following requirements  1  Create a collection , Store multiple string elements  " zhang wuji " , " Zhang Cuishan " , " Zhang Sanfeng " , " Xie Guangkun " , " Zhao si " , " Lennon " , " Little Shenyang " , " Zhang Liang " 2  Put all the objects in the set with " Zhang " The first element is stored in a new collection  3  hold " Zhang " The length in the first set is 3 To a new collection  4  Traversing the collection from the previous step  */
public class StreamDemo {
    
    public static void main(String[] args) {
    
        //  The traditional way to complete 
        ArrayList<String> list = new ArrayList<>();
        list.add(" zhang wuji ");
        list.add(" Zhang Cuishan ");
        list.add(" Zhang Sanfeng ");
        list.add(" Xie Guangkun ");
        list.add(" Zhao si ");
        list.add(" Lennon ");
        list.add(" Little Shenyang ");
        list.add(" Zhang Liang ");

        //  Put all the objects in the set with " Zhang " The first element is stored in a new collection 
        ArrayList<String> list2 = new ArrayList<>();
        for (String s : list) {
    
            if (s.startsWith(" Zhang ")) {
    
                list2.add(s);
            }
        }

        //  hold " Zhang " The length in the first set is 3 To a new collection 
        ArrayList<String> list3 = new ArrayList<>();
        for (String s : list2) {
    
            if (s.length() == 3) {
    
                list3.add(s);
            }
        }
        //  Traverse list3 aggregate 
        for (String s : list3) {
    
            System.out.println(s);
        }

        System.out.println("================================");

        // Stream stream 
        list.stream().filter(s -> s.startsWith(" Zhang ") && s.length() == 3).forEach(s -> 	System.out.println(s));
    }
}

2.2 Stream Three methods of flow

obtain Stream flow
- Create a pipeline , And put the data on the pipeline, ready to operate
The middle way
- Operation on the assembly line .
- After one operation , You can continue with other operations
Put an end to the method
- One Stream A stream can only have one end method
- It's the last operation on the pipeline

2.3 The first category : Access method

Single column set
have access to Collection Default method in interface stream() Generative flow
default Stream stream()
Double column set
A two column set cannot be obtained directly , An indirect generation flow is required
You can go through it first keySet perhaps entrySet Get one Set aggregate , Get more Stream flow
Array
Arrays Static methods in stream Generative flow
Put multiple data of the same type into stream Streaming
Stream Class of Method

package com.itheima.stream_demo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;

/*
    Stream One of the three methods in a stream  :   Access method 
 */
public class StreamDemo2 {
    public static void main(String[] args) {
        //  Acquisition of single column set 
        // method1();

        //  Acquisition of a two column set 
        // method2();

        //  Array get 
        // method3();

    }

    private static void method3() {
        int[] arr = {1, 2, 3, 4, 5, 6};
        Arrays.stream(arr).forEach(s -> System.out.println(s));
    }

    private static void method2() {
        HashMap<String, String> hm = new HashMap<>();
        hm.put("it001", " Cao Zhi ");
        hm.put("it002", " Cao Pi ");
        hm.put("it003", " Cao Xiong ");
        hm.put("it004", " Cao Chong ");
        hm.put("it005", " Cao ang ");

        //  obtain map Key set of set  ,  Output printing is in progress 
        hm.keySet().stream().forEach(s -> System.out.println(s + "---" + hm.get(s)));
        //  obtain map A collection of entry object  ,  Print on output 
        hm.entrySet().stream().forEach(s -> System.out.println(s));
    }

    private static void method1() {
        //  have access to Collection Default method in interface stream() Generative flow 
        ArrayList<String> list = new ArrayList<>();
        list.add(" Delireba ");
        list.add(" Gulinaza ");
        list.add(" Marzaha ");
        list.add(" Ouyang Nana ");
        list.stream().forEach(s -> System.out.println(s));
    }
}

2.4 The second category : The middle way

package com.itheima.stream_demo;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Predicate;
import java.util.stream.Stream;

/*
    Stream One of the three methods in a stream  :   The middle way 

    1 Stream<T> filter(Predicate predicate)： Used to filter data in the stream , You will get every data in the stream 
        Predicate Methods in interfaces  : boolean test(T t)： Judge the given parameters , Returns a Boolean value 
    2 Stream<T> limit(long maxSize)： Intercept the data of the specified number of parameters 
    3 Stream<T> skip(long n)： Skip data with specified number of parameters 
    4 static <T> Stream<T> concat(Stream a, Stream b)： Merge a and b Two streams into one 
    5 Stream<T> distinct()： Remove the repeating elements from the stream . rely on (hashCode and equals Method )
    6 Stream<T> sorted () :  Sort the elements in the flow according to the natural sorting rules 
    7 Stream<T> sorted (Comparator<? super T> comparator) :  Sort the elements in the flow according to the custom comparer rules 

 */
public class StreamDemo3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add(" zhang wuji ");
        list.add(" Zhang Cuishan ");
        list.add(" Zhang Sanfeng ");
        list.add(" Xie Guangkun ");
        list.add(" Zhao si ");
        list.add(" Lennon ");
        list.add(" Little Shenyang ");
        list.add(" Zhang Liang ");
        list.add(" Zhang Liang ");
        list.add(" Zhang Liang ");
        list.add(" Zhang Liang ");

        // Stream<T> limit(long maxSize)： Intercept the data of the specified number of parameters 
        // list.stream().limit(3).forEach(s -> System.out.println(s));

        // Stream<T> skip(long n)： Skip data with specified number of parameters 
        // list.stream().skip(3).forEach(s-> System.out.println(s));

        // Stream<T> distinct()： Remove the repeating elements from the stream . rely on (hashCode and equals Method )
        // list.stream().distinct().forEach(s->{System.out.println(s);});
        
    }

    // // Stream<T> sorted (Comparator<? super T> comparator) :  Sort the elements in the flow according to the custom comparer rules 
    private static void method3(ArrayList<String> list) {
        list.stream().sorted(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        }).forEach(s->{
            System.out.println(s);
        });
    }

    // Stream<T> sorted () :  Sort the elements in the flow according to the natural sorting rules 
    private static void method3() {
        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(3);
        list2.add(1);
        list2.add(2);
        list2.stream().sorted().forEach(s->{
            System.out.println(s);
        });
    }

    // // static <T> Stream<T> concat(Stream a, Stream b)： Merge a and b Two streams into one 
    private static void method2(ArrayList<String> list) {
        ArrayList<String> list2 = new ArrayList<>();
        list2.add(" Delireba ");
        list2.add(" Gulinaza ");
        list2.add(" Ouyang Nana ");
        list2.add(" Marzaha ");

        Stream.concat(list.stream(), list2.stream()).forEach(s -> {
            System.out.println(s);
        });
    }

    // Stream<T> filter(Predicate predicate)： Used to filter data in the stream 
    private static void method1(ArrayList<String> list) {
        // filter Method gets every data in the stream 
        // s It represents every data in the stream 
        //  If the return value is true ,  So the data is left behind 
        //  If the return value is false ,  So it means that the data is filtered out 
//        list.stream().filter(new Predicate<String>() {
//            @Override
//            public boolean test(String s) {
//                boolean result = s.startsWith(" Zhang ");
//                return result;
//            }
//        }).forEach(s -> System.out.println(s));

        list.stream().filter(s ->
                s.startsWith(" Zhang ")
        ).forEach(s -> System.out.println(s));
    }
}

2.5 The third category : Put an end to the method

package com.itheima.stream_demo;

import java.util.ArrayList;
import java.util.function.Consumer;

/*
    Stream One of the three methods in a stream  :   Put an end to the method 
    1 void forEach(Consumer action)： Perform operations on each element of this flow 
        Consumer Methods in interfaces  void accept(T t)： Do this for a given parameter 
    2 long count()： Returns the number of elements in this stream 

 */
public class StreamDemo4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add(" zhang wuji ");
        list.add(" Zhang Cuishan ");
        list.add(" Zhang Sanfeng ");
        list.add(" Xie Guangkun ");

        // long count()： Returns the number of elements in this stream 
        long count = list.stream().count();
        System.out.println(count);
    }
    // void forEach(Consumer action)： Perform operations on each element of this flow 
    private static void method1(ArrayList<String> list) {
        //  hold list The elements in the collection are placed in stream Streaming 
        // forEach Method iterates through the data in the stream 
        //  And cycle through accept Method  ,  Send the data to s
        //  therefore s It represents every data in the stream 
        //  All we have to do is accept Method to do business logic processing on the data 
        list.stream().forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        System.out.println("=====================");

        list.stream().forEach( (String s) -> {
            System.out.println(s);
        });

        System.out.println("=====================");

        list.stream().forEach(  s -> { System.out.println(s); });
    }

}

2.6 Stream Collection method in stream

package com.itheima.stream_demo;

import java.util.ArrayList;

/*
    Stream Stream collection operation  :  The first part 

     demand ： Filter the elements and iterate through the collection 
         Define a set , And add some integers 1,2,3,4,5,6,7,8,9,10
         Delete the odd number from the set , Keep only even numbers .
         Traverse the set to get 2,4,6,8,10

     Conclusion ： stay Stream The collection cannot be modified directly in the stream , Data in data sources such as arrays .
 */
public class StreamDemo5 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();

        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }

        list.stream().filter(num -> num % 2 == 0).forEach(num -> System.out.println(num));

        System.out.println("=============");

        //  Conclusion ： stay Stream The collection cannot be modified directly in the stream , Data in array .
        System.out.println(list);
    }
}

Conclusion ： stay Stream The collection cannot be modified directly in the stream , Data in array

package com.itheima.stream_demo;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/*

    Stream Stream collection operation  :  The second part 

     Use Stream After the stream mode operation is completed , I want to put the data in the stream , What to do ？

    Stream Stream collection methods 
    R collect(Collector collector) :  This method is only responsible for collecting data in the stream  ,  The action of creating a collection and adding data depends on parameters Collectors.toL

     Tool class Collectors Specific collection methods are provided 
    public static <T> Collector toList()： Collect elements into List Collection 
    public static <T> Collector toSet()： Collect elements into Set Collection 
    public static  Collector toMap(Function keyMapper,Function valueMapper)： Collect elements into Map Collection 


     demand  :
         Define a set , And add some integers 1,2,3,4,5,6,7,8,9,10
         Delete the odd number from the set , Keep only even numbers .
         Traverse the set to get 2,4,6,8,10
 */
public class StreamDemo6 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
        list.add(10);
        list.add(10);
        list.add(10);
        list.add(10);
        list.add(10);

        // collect Only responsible for collecting data in the stream 
        // Collectors.toList() Will be responsible for creating list aggregate  , And add the data to the collection  ,  Returns the collection object 
        List<Integer> list2 = list.stream().filter(num -> num % 2 == 0 ).collect(Collectors.toList());
        System.out.println(list2);

        Set<Integer> set = list.stream().filter(num -> num % 2 == 0 ).collect(Collectors.toSet());
        System.out.println(set);

    }
}

package com.itheima.stream_demo;

import java.util.ArrayList;
import java.util.Map;
import java.util.stream.Collectors;

/*
    Stream Stream collection operation  :  The third part 

    1  Create a ArrayList aggregate , And add the following string . The string is preceded by the name , And then there's age 
        "zhangsan,23"
        "lisi,24"
        "wangwu,25"
    2  The retention age is greater than or equal to 24 A man of years old , And collect the results to Map Collection , The name is the key , Age is the value of 

     Collection methods  :
    public static  Collector toMap(Function keyMapper  ,   Function valueMapper)： Collect elements into Map Collection 
 */
public class StreamDemo7 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("zhangsan,23");
        list.add("lisi,24");
        list.add("wangwu,25");

        // collect  Only responsible for collecting data 
        // Collectors.toMap Responsible for creating collection objects at the bottom  ,  Additive elements 
        // toMap Methods s It represents every element in the set 
        //  The first parameter  :  How to get map Key in set 
        //  The second parameter  :  How to get map Values in the set 
        Map<String, String> map = list.stream().filter(s -> Integer.parseInt(s.split(",")[1]) > 23).collect(
                Collectors.toMap(
                        (String s) -> {
                            return s.split(",")[0];
                        }
                        ,
                        (String s) -> {
                            return s.split(",")[1];
                        }
                )
        );
        System.out.println(map);
    }
}

3 File class

Absolute path ： Start with the drive
Relative paths ： Relative to the path under the current project

3.1 File Class

java.io.File Class is an abstract representation of file and directory pathnames , Mainly used for the creation of files and directories 、 Search and delete operations

3.2 Construction method

package com.itheima.file_demo;

import java.io.File;

/*
    File： It's an abstract representation of file and directory pathnames 
    	   Both files and paths are represented by paths 
         Files and directories can be accessed through File Encapsulated as an object 
        File The encapsulated object is just a pathname . It can exist , It can also be nonexistent .（ Be careful ： The path is unique ）
     Construction method  :
        1 File(String pathname)    Create a new... By converting the given pathname string to an abstract pathname  File example 
        2 File(String parent, String child)    Create a new... From the parent pathname string and the child pathname string  File example 
        3 File(File parent, String child)  Create a new... From the parent abstract pathname and child pathname strings  File example 
        
         Be careful ： The parent path needs to be a directory path 
 */
public class FileDemo1 {
    public static void main(String[] args) {
//        1 File(String pathname)  Create a new... By converting the given pathname string to an abstract pathname  File example 
        File f1 = new File("D:\\abc.txt");
        System.out.println(f1);
//        2 File(String parent, String child)  Create a new... From the parent pathname string and the child pathname string  File example 
        File f2 = new File("D:\\aaa", "bbb.txt");
        System.out.println(f2);

//        3 File(File parent, String child)    Create a new... From the parent abstract pathname and child pathname strings  File example 
        File f3 = new File(new File("D:\\aaa"), "bbb.txt");
        System.out.println(f3);
    }
}

3.3 File Class creation

package com.itheima.file_demo;


import java.io.File;
import java.io.IOException;

/*
    File Class creation  :
        1 public boolean createNewFile()    :  Create a new empty file 
        2 public boolean mkdir()   :  Create a single level folder 
        3 public boolean mkdirs() :  Create a multi-level folder 
 */
public class FileDemo2 {
    public static void main(String[] args) throws IOException {
        File f1 = new File("D:\\a.txt");
        // 1 public boolean createNewFile()     :  Create a new empty file 
        System.out.println(f1.createNewFile());

        File f2 = new File("day10_demo\\aaa");
        //  2 public boolean mkdir()   :  Create a single level folder 
        System.out.println(f2.mkdir());

        File f3 = new File("day10_demo\\bbb\\ccc");
        // 3 public boolean mkdirs() :  Create a multi-level folder 
        System.out.println(f3.mkdirs());
    }
}

3.4 File Class delete function

package com.itheima.file_demo;

import java.io.File;
import java.io.IOException;

/*
    File Class deletion function  :
        public boolean delete()     Delete the file or directory represented by this abstract pathname 

         Be careful  : 
            1 delete Method directly delete the recycle bin .
            2  If you delete a file , Delete directly .
            3  If you delete a folder , You need to delete the contents of the folder first , Only then can the folder be deleted 
 */
public class FileDemo3 {

    public static void main(String[] args) throws IOException {
        File f1 = new File("D:\\a.txt");
        // 1 public boolean createNewFile()     :  Create a new empty file 
        System.out.println(f1.delete());

        File f2 = new File("day10_demo\\aaa");
        //  2 public boolean mkdir()   :  Create a single level folder 
        System.out.println(f2.delete());

        File f3 = new File("day10_demo\\bbb");
        // 3 public boolean mkdirs() :  Create a multi-level folder 
        System.out.println(f3.delete());
    }
}

3.5 File Class judgment and acquisition function

package com.itheima.file_demo;

import java.io.File;

/*
    File Class judgment and acquisition function 
        public boolean isDirectory()    Test the... Represented by this abstract pathname File Is it a directory 
        public boolean isFile()     Test the... Represented by this abstract pathname File Is it a document 
        public boolean exists()     Test the... Represented by this abstract pathname File Whether there is 
        public String getAbsolutePath()     Returns the absolute pathname string of this abstract pathname 
        public String getPath()     Convert this abstract pathname to a pathname string 
        public String getName()     Returns the name of the file or directory represented by this abstract pathname 
 */
public class FileDemo4 {
    public static void main(String[] args) {
        File f1 = new File("day10_demo\\aaa");
        File f2 = new File("day10_demo\\a.txt");

//        public boolean isDirectory()  Test the... Represented by this abstract pathname File Is it a directory 
        System.out.println(f1.isDirectory());
        System.out.println(f2.isDirectory());

//        public boolean isFile()   Test the... Represented by this abstract pathname File Is it a document 
        System.out.println(f1.isFile());
        System.out.println(f2.isFile());

//        public boolean exists()   Test the... Represented by this abstract pathname File Whether there is 
        System.out.println(f1.exists());

//        public String getAbsolutePath()   Returns the absolute pathname string of this abstract pathname 
        System.out.println(f1.getAbsolutePath());

//        public String getPath()   Convert this abstract pathname to a pathname string 
        System.out.println(f1.getPath());

//        public String getName()   Returns the name of the file or directory represented by this abstract pathname 
        System.out.println(f2.getName());
    }
}

3.6 File Class to get advanced functions

package com.itheima.file_demo;

import java.io.File;

/*
    File Class to get advanced functions 
        public File[] listFiles()   Returns the number of files and directories in the directory represented by this abstract pathname File An array of objects 

    listFiles Method precautions ：
        1  When the caller does not exist , return null
        2  When the caller is a file , return null
        3  When the caller is an empty folder , Returns a length of 0 Array of 
        4  When the caller is a folder with content , Put the paths of all files and folders in File Array returns 
        5  When the caller is a folder with hidden files , Put the paths of all files and folders in File Array returns , Contains hidden content 
 */
public class FileDemo5 {
    public static void main(String[] args) {
        File file = new File("day10_demo\\bbb\\ccc");

        //  Returns the number of files and directories in the directory represented by this abstract pathname File An array of objects 
        File[] files = file.listFiles();

        //  Traverse File Class array 
        for (File f : files) {
            //  Get the text of each file 
            System.out.println(f.getName());
        }
    }
}

practice :

package com.itheima.file_demo;

import java.io.File;
import java.util.HashMap;

/*
     Exercise 2  ： Count the number of each file in a folder and print .

    The print format is as follows ：
      txt:3 individual 
      doc:4 individual 
      jpg:6 individual 
      …
 */
public class FileTest2 {
    public static void main(String[] args) {
        File file = new File("day10_demo\\ Count the number of files folder ");

        getFileCount(file);
    }

    public static void getFileCount(File f) {

        HashMap<String, Integer> hm = new HashMap<>();

        //  Is the folder getting all the sub files 
        if (f.isDirectory()) {
            File[] files = f.listFiles();
            //  Traversal array 
            for (File file : files) {
                String fileName = file.getName();
                String name = fileName.split("\\.")[1];
                if (hm.containsKey(name)) {
                    hm.put(name, hm.get(name));
                } else {
                    hm.put(name, 1);
                }
            }
        }

        System.out.println(hm);
    }
}

原网站

版权声明
本文为[The cool city is not warm and the night is slightly cool]所创，转载请带上原文链接，感谢
https://yzsam.com/2022/181/202206301436042915.html