【java基础】12-Stream流和File

1.可变参数

代码示例

public class ArgsDemo01 {
    public static void main(String[] args) {
        System.out.println(sum(10, 20));
        System.out.println(sum(10, 20, 30));
        System.out.println(sum(10, 20, 30, 40));

        System.out.println(sum(10,20,30,40,50));        
    }

//    public static int sum(int b,int... a) { //可变参数,必须放最后
//        return 0;
//    }

    public static int sum(int... a) {
        int sum = 0;
        for(int i : a) {
            sum += i;
        }
        return sum;
    }
}

要点

可变参数在什么时候用?
   当一个方法,参数类型一致,参数个数不确定 
格式是?
     例如:多个int数求和
     public int getSum(int... arr)
可变参数本质是?
    	数组
可变参数的注意事项?
    	如果有其他参数,可变参必须放后面
可变参数的应用场景:
  参数类型相同,个数不确定,
  例如:多个int数求和
可变参数的格式:
	public 返回值类型 方法名(数据类型... 参数名) {}
可变参数的理解:
		可变参数,底层是数组!!
可变参数的注意:
    1.如果还有其他参数,可变参数必须放最后!
    2.一个方法只能定义一个可变参数
可变参数的特殊写法:
	show(Object... args): 可以传任意对象,任意个数

2.创建不可变的集合

代码示例

public class MyVariableParameter4 {
    public static void main(String[] args) {
        // static <E>  List<E>  of(E…elements)  创建一个具有指定元素的List集合对象
        //static <E>  Set<E>  of(E…elements)    创建一个具有指定元素的Set集合对象
        //static <K , V>   Map<K，V>  of(E…elements) 创建一个具有指定元素的Map集合对象

        //method1();
        //method2();
        //method3();
        //method4();

    }

    private static void method4() {
        Map<String, String> map = Map.ofEntries(
                Map.entry("zhangsan", "江苏"),
                Map.entry("lisi", "北京"));
        System.out.println(map);
    }

    private static void method3() {
        Map<String, String> map = Map.of("zhangsan", "江苏", "lisi", "北京", "wangwu", "天津");
        System.out.println(map);
    }

    private static void method2() {
        //传递的参数当中，不能存在重复的元素。
        Set<String> set = Set.of("a", "b", "c", "d","a");
        System.out.println(set);
    }

    private static void method1() {
        List<String> list = List.of("a", "b", "c", "d");
        System.out.println(list);
        //list.add("Q");
        //list.remove("a");
        //list.set(0,"A");
        //System.out.println(list);

//        ArrayList<String> list2 = new ArrayList<>();
//        list2.add("aaa");
//        list2.add("aaa");
//        list2.add("aaa");
//        list2.add("aaa");

        //集合的批量添加。
        //首先是通过调用List.of方法来创建一个不可变的集合，of方法的形参就是一个可变参数。
        //再创建一个ArrayList集合，并把这个不可变的集合中所有的数据，都添加到ArrayList中。
        ArrayList<String> list3 = new ArrayList<>(List.of("a", "b", "c", "d"));
        System.out.println(list3);
    }
}

扩展： 数组转List集合
List Arrays.asList();

	String[] arr = {"a","b","c"};
        List<String> list = Arrays.asList(arr);
        System.out.println(list);
//注意
//1.返回的集合不能修改
//2.必须是引用类型数组

//数组转集合?
List Arrays.asList(数组);
//集合转数组?
toArray(T[] arr);

3.初步认识Stream流

• 原始方式示例代码

public class MyStream1 {
    public static void main(String[] args) {
        //集合的批量添加
        ArrayList<String> list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));
        //list.add()

        //遍历list1把以张开头的元素添加到list2中。
        ArrayList<String> list2 = new ArrayList<>();
        for (String s : list1) {
            if(s.startsWith("张")){
                list2.add(s);
            }
        }
        //遍历list2集合，把其中长度为3的元素，再添加到list3中。
        ArrayList<String> list3 = new ArrayList<>();
        for (String s : list2) {
            if(s.length() == 3){
                list3.add(s);
            }
        }
        for (String s : list3) {
            System.out.println(s);
        }      
    }
}

• 使用Stream流示例代码

public class StreamDemo {
    public static void main(String[] args) {
        //集合的批量添加
        ArrayList<String> list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));

        //Stream流
        list1.stream().filter(s->s.startsWith("张"))
                .filter(s->s.length() == 3)
                .forEach(s-> System.out.println(s));
    }
}

要点

stream流(jdk8,函数式编程思想(关注做什么,不关注以什么方式做,格式可以简化))
    	Lambda 简化 匿名内部类
        stream 流,简化集合和数组的遍历(不用循环也可以遍历元素)

4.Stream流-思想特点

5.Stream流-获取方法

代码示例

public class StreamDemo {
    public static void main(String[] args) {
        //Collection体系的集合可以使用默认方法stream()生成流
        List<String> list = new ArrayList<String>();
        Stream<String> listStream = list.stream();

        Set<String> set = new HashSet<String>();
        Stream<String> setStream = set.stream();

        //Map体系的集合间接的生成流
        Map<String,Integer> map = new HashMap<String, Integer>();
        Stream<String> keyStream = map.keySet().stream();
        Stream<Integer> valueStream = map.values().stream();
        Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();

        //数组可以通过Arrays中的静态方法stream生成流
        String[] strArray = {"hello","world","java"};
        Stream<String> strArrayStream = Arrays.stream(strArray);
      
      	//同种数据类型的多个数据可以通过Stream接口的静态方法of(T... values)生成流
        Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
        Stream<Integer> intStream = Stream.of(10, 20, 30);
    }
}

要点

List集合 如何生成Stream流??
	List<String> list = new ArrayList<String>();
Set 如何生成Stream流??
	Set<String> set = new HashSet<String>();
Map 如何生成Stream流??
	Map<String,Integer> map = new HashMap<String, Integer>();
数组 如何生成Stream流??
	String[] strArray = {"hello","world","java"};
零散数据如何生成流?
	Stream.of("hello","world","java");

6.流的生成方式

7.中间方法-filter

代码示例

public class MyStream3 {
    public static void main(String[] args) {
//        Stream<T> filter(Predicate predicate)：过滤
//        Predicate接口中的方法	boolean test(T t)：对给定的参数进行判断，返回一个布尔值

        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");

        //filter方法获取流中的 每一个数据.
        //而test方法中的s,就依次表示流中的每一个数据.
        //我们只要在test方法中对s进行判断就可以了.
        //如果判断的结果为true,则当前的数据留下
        //如果判断的结果为false,则当前数据就不要.
//        list.stream().filter(
//                new Predicate<String>() {
//                    @Override
//                    public boolean test(String s) {
//                        boolean result = s.startsWith("张");
//                        return result;
//                    }
//                }
//        ).forEach(s-> System.out.println(s));

        //因为Predicate接口中只有一个抽象方法test
        //所以我们可以使用lambda表达式来简化
//        list.stream().filter(
//                (String s)->{
//                    boolean result = s.startsWith("张");
//                        return result;
//                }
//        ).forEach(s-> System.out.println(s));

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

    }
}	

要点

流的使用注意:
	任何流只能用一次!!!
        
流的中间方法的理解: 例如: Stream<T> filter() 返回了一个新的流对象,可以继续. 调用方法
    终结方法的理解: 例如: void forEach(): 返回 void ,不能继续通过"."调用了 

8.其他常用中间方法

代码示例

public class StreamDemo02 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        //需求1：取前3个数据在控制台输出
        list.stream().limit(3).forEach(s-> System.out.println(s));
        System.out.println("--------");

        //需求2：跳过3个元素，把剩下的元素在控制台输出
        list.stream().skip(3).forEach(s-> System.out.println(s));
        System.out.println("--------");

        //需求3：跳过2个元素，把剩下的元素中前2个在控制台输出
        list.stream().skip(2).limit(2).forEach(s-> System.out.println(s));
    }
}

9.Stream流-终结方法

代码示例

public class MyStream5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");

        //method1(list);
        
//        long count()：返回此流中的元素数
        long count = list.stream().count();
        System.out.println(count);
    }

    private static void method1(ArrayList<String> list) {
        //  void forEach(Consumer action)：对此流的每个元素执行操作
        //  Consumer接口中的方法void accept(T t)：对给定的参数执行此操作
        //在forEach方法的底层,会循环获取到流中的每一个数据.
        //并循环调用accept方法,并把每一个数据传递给accept方法
        //s就依次表示了流中的每一个数据.
        //所以,我们只要在accept方法中,写上处理的业务逻辑就可以了.
        list.stream().forEach(
                new Consumer<String>() {
                    @Override
                    public void accept(String s) {
                        System.out.println(s);
                    }
                }
        );
      
        System.out.println("====================");
        //lambda表达式的简化格式
        //是因为Consumer接口中,只有一个accept方法
        list.stream().forEach(
                (String s)->{
                    System.out.println(s);
                }
        );
        System.out.println("====================");
        //lambda表达式还是可以进一步简化的.
        list.stream().forEach(s->System.out.println(s));
    }
}

另:Stream流 并不存储元素， 只是按需计算，不能通过流修改原始的集合。

10.收集方法-toList和toSet

代码示例

// toList和toSet方法演示 
public class MyStream7 {
    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            list1.add(i);
        }

        list1.add(10);
        list1.add(10);
        list1.add(10);
        list1.add(10);
        list1.add(10);

        //filter负责过滤数据的.
        //collect负责收集数据.
                //获取流中剩余的数据,但是他不负责创建容器,也不负责把数据添加到容器中.
        //Collectors.toList() : 在底层会创建一个List集合.并把所有的数据添加到List集合中.
        List<Integer> list = list1.stream().filter(number -> number % 2 == 0)
                .collect(Collectors.toList());

        System.out.println(list);

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

11.收集方法-toMap

代码示例

// toList和toSet方法演示 
public class MyStream7 {
    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            list1.add(i);
        }

        list1.add(10);
        list1.add(10);
        list1.add(10);
        list1.add(10);
        list1.add(10);

        //filter负责过滤数据的.
        //collect负责收集数据.
                //获取流中剩余的数据,但是他不负责创建容器,也不负责把数据添加到容器中.
        //Collectors.toList() : 在底层会创建一个List集合.并把所有的数据添加到List集合中.
        List<Integer> list = list1.stream().filter(number -> number % 2 == 0)
                .collect(Collectors.toList());

        System.out.println(list);

    Set<Integer> set = list1.stream().filter(number -> number % 2 == 0)
            .collect(Collectors.toSet());
    System.out.println(set);
}
}
/**
Stream流的收集方法 toMap方法演示
创建一个ArrayList集合，并添加以下字符串。字符串中前面是姓名，后面是年龄
"zhangsan,23"
"lisi,24"
"wangwu,25"
保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值
*/
public class MyStream8 {
	public static void main(String[] args) {
      	ArrayList<String> list = new ArrayList<>();
        list.add("zhangsan,23");
        list.add("lisi,24");
        list.add("wangwu,25");

        Map<String, Integer> map = list.stream().filter(
                s -> {
                    String[] split = s.split(",");
                    int age = Integer.parseInt(split[1]);
                    return age >= 24;
                }

         //   collect方法只能获取到流中剩余的每一个数据.
         //在底层不能创建容器,也不能把数据添加到容器当中

         //Collectors.toMap 创建一个map集合并将数据添加到集合当中

          // s 依次表示流中的每一个数据

          //第一个lambda表达式就是如何获取到Map中的键
          //第二个lambda表达式就是如何获取Map中的值
        ).collect(Collectors.toMap(
                s -> s.split(",")[0],
                s -> Integer.parseInt(s.split(",")[1]) ));

        System.out.println(map);
	}
}

12.File和IO的概述

要点

	io: 持久化存储

    I: input
    O:output
    输入 输出
    对硬盘进行输入, 写入硬盘
    对硬盘进行输出, 读取硬盘
        
1.IO流的理解(数据在不同的设备之间流动,例如:内存,硬盘,)
2. File 类 的对象相当于包装了一个路径,这个路径可以是文件,也可以是目录.
3. 通过File类可以对文件和目录进行操作(跨平台)(创建,删除,获取,判断等)

13.File的构造方法

• File类介绍
  • 它是文件和目录路径名的抽象表示
  • 文件和目录是可以通过File封装成对象的
  • 对于File而言,其封装的并不是一个真正存在的文件,仅仅是一个路径名而已.它可以是存在的,也可以是不存在的.将来是要通过具体的操作把这个路径的内容转换为具体存在的
• File类的构造方法

方法名	说明
File(String pathname)	通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
File(String parent, String child)	从父路径名字符串和子路径名字符串创建新的 File实例
File(File parent, String child)	从父抽象路径名和子路径名字符串创建新的 File实例

• 代码示例

public class FileDemo01 {
    public static void main(String[] args) {
        //File(String pathname): 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
        File f1 = new File("E:\\bibabo\\java.txt");
        System.out.println(f1);

        //File(String parent, String child): 从父路径名字符串和子路径名字符串创建新的 File实例
        File f2 = new File("E:\\bibabo","java.txt");
        System.out.println(f2);

        //File(File parent, String child): 从父抽象路径名和子路径名字符串创建新的 File实例
        File f3 = new File("E:\\bibabo");
        File f4 = new File(f3,"java.txt");
        System.out.println(f4);
    }
}

14.绝对路径和相对路径

绝对路径： 从盘符开始

相对路径： 相对当前项目下的路径

要点

1. 绝对路径
    A. 说明: 它是一个完整的路径，从盘符开始
    B. 例如: D:\\bibabo\\a.txt

2. 相对路径
    A. 说明: 它是一个简化的路径, 需要一个参照物, IDEA中相对路径是当前项目下! (Project下,不是module下)
    B. 例如: a.txt

15. File的创建功能

代码示例

 public class FileDemo02 {
    public static void main(String[] args) throws IOException {
        //需求1：我要在E:\\bibabo目录下创建一个文件java.txt
        File f1 = new File("E:\\bibabo\\java.txt");
        System.out.println(f1.createNewFile());
        System.out.println("--------");

        //需求2：我要在E:\\bibabo目录下创建一个目录JavaSE
        File f2 = new File("E:\\bibabo\\JavaSE");
        System.out.println(f2.mkdir());
        System.out.println("--------");

        //需求3：我要在E:\\bibabo目录下创建一个多级目录JavaWEB\\HTML
        File f3 = new File("E:\\bibabo\\JavaWEB\\HTML");
//        System.out.println(f3.mkdir());
        System.out.println(f3.mkdirs());
        System.out.println("--------");

        //需求4：我要在E:\\bibabo目录下创建一个文件javase.txt
        File f4 = new File("E:\\bibabo\\javase.txt");
//        System.out.println(f4.mkdir());
        System.out.println(f4.createNewFile());
    }
}

要点

创建文件和文件夹的步骤:
1.构造File对象
2.调用方法()
		创建文件
    		createNewFile()
		创建文件夹
    		mkdirs()
注意事项
     创建的是文件还是目录要看方法,不要看名称   createNewFile("c:\新建文件夹")
	 创建目录和文件时必须确保父目录存在( mkdirs()可以创建多级目录 )

16.File的删除方法

代码示例

public class FileDemo03 {
    public static void main(String[] args) throws IOException {
//        File f1 = new File("E:\\bibabo\\java.txt");
        //需求1：在当前模块目录下创建java.txt文件
        File f1 = new File("myFile\\java.txt");
//        System.out.println(f1.createNewFile());

        //需求2：删除当前模块目录下的java.txt文件
        System.out.println(f1.delete());
        System.out.println("--------");

        //需求3：在当前模块目录下创建bibabo目录
        File f2 = new File("myFile\\bibabo");
//        System.out.println(f2.mkdir());

        //需求4：删除当前模块目录下的bibabo目录
        System.out.println(f2.delete());
        System.out.println("--------");
        
    }
}

要点

步骤:
1.先构造File对象
2.再调用删除方法(delete())

delete方法可以删除文件和目录
	要删除的目录必须是空目录
	删除不走回收站
   
是文件或目录不要看名字,看类型! ( aaa.txt 可能是文件夹 )

17.File的获取和判断方法

判断功能
  public boolean  exists()    //判断当前的 文件 或者 文件夹 是否存在
1. public boolean isDirectory()  //判断是否是文件夹
2. public boolean isFile()    //判断是否是文件

获取功能
1. public String getAbsolutePath()  //获取绝对路径
2. public String getName()  //获取 文件名加文件后缀  或者 文件夹的名称

代码示例

public class FileDemo04 {
    public static void main(String[] args) {
        //创建一个File对象
        File f = new File("myFile\\java.txt");

//        public boolean isDirectory()：测试此抽象路径名表示的File是否为目录
//        public boolean isFile()：测试此抽象路径名表示的File是否为文件
//        public boolean exists()：测试此抽象路径名表示的File是否存在
        System.out.println(f.isDirectory());
        System.out.println(f.isFile());
        System.out.println(f.exists());

//        public String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串
//        public String getPath()：将此抽象路径名转换为路径名字符串
//        public String getName()：返回由此抽象路径名表示的文件或目录的名称
        System.out.println(f.getAbsolutePath());
        System.out.println(f.getPath());
        System.out.println(f.getName());
        System.out.println("--------");

    }
}

要点

1.判断功能(是否存在?是文件?是目录?) 
    		1. public boolean exists()    //判断当前的 文件 或者 文件夹 是否存在    
             2. public boolean isFile()    //判断是否是文件
             3. public boolean isDirectory()  //判断是否是文件夹
    	注意,如果路径不存在,是文件,是目录均返回false
    
2.获取功能(短名称,长名称,文件大小,最后修改时间)
    	1. public String getAbsolutePath()  //获取绝对路径 带盘符,长名称     
        2. public String getName()  //获取 文件名或文件夹名,带后缀,短名称
===================================================================
  注意事项(文件夹长度是0,不存在的文件长度也是0)
    long length() 返回由此抽象路径名表示的文件的长度。 
    long lastModified() 返回此抽象路径名表示的文件上次修改的时间。 
========================================================
 测试代码:
		File file = new File("C:\\Users\\Administrator\\Desktop\\笔记.doc");

        System.out.println("字节数:" + file.length());//字节数:6946179
        //获取文件或文件夹最后修改时间
        long time = file.lastModified();
        Date date = new Date(time);

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(sdf.format(date));



=============================================================================
扩展: 
	String	getCanonicalPath() : 获取长的规范的路径名称
    
    // getAbsolutePath() 和 getCanonicalPath()的不同
	public static void test2() throws Exception{
        File file = new File("..\\src\\test1.txt");
        System.out.println(file.getAbsolutePath());// D:\workspace\test\..\src\test1.txt
        System.out.println(file.getCanonicalPath());// D:\workspace\src\test1.txt
    }
	得到的结果:
		D:\workspace\test\..\src\test1.txt
		D:\workspace\src\test1.txt

18.File的listFiles方法

示例代码

//      public File[] listFiles()：返回此抽象路径名表示的目录中的文件和目录的File对象数组
        File f2 = new File("E:\\bibabo");
        File[] fileArray = f2.listFiles();
        for(File file : fileArray) {
//            System.out.println(file);
//            System.out.println(file.getName());
            if(file.isFile()) {
                System.out.println(file.getName());
            }
        }

要点

步骤:
    1.先构造File对象
    2.再调用File[] listFiles()

遍历我的电脑

public class Demo2ListFiles {
    public static void main(String[] args) {
        //File dir = new File("C:\\");
        File[] files = File.listRoots();
        for (File file : files) {
            //System.out.println(file);
            printDir(file);
        }
        //printDir(dir);
    }

    //写一个方法,遍历一级目录
    public static void printDir(File dir) {
        File[] files = dir.listFiles();

        if (files == null) return;

        for (File file : files) {
            if (file.isFile()) {
                System.out.println(file);
            } else {
                //file是目录
                printDir(file);
            }
        }
    }
}