JAVASE进阶day09（Stream流&File）

L。.。

已于 2024-08-11 16:35:16 修改

阅读量269

点赞数 1

文章标签： java 开发语言

于 2024-07-13 18:17:31 首次发布

本文链接：https://blog.csdn.net/qq_65095414/article/details/140393991

版权

Stream流（数组的stream流）

1.数组的Stream流

package com.lu.day09;

import java.util.Arrays;
import java.util.stream.IntStream;

public class ArrayStreamDemo {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10,1,1,1,1,1};
        //开启流->创建一个流对象
        IntStream stream = Arrays.stream(arr);
        //中间方法
        IntStream distinct = stream.distinct();
        //终止方法
        distinct.forEach(System.out::println);
        //流的链式调用
        Arrays.stream(arr).distinct().forEach(System.out::println);
    }
}

package com.lu.day09;

import com.lu.day07.setdome.Student;

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        //过滤
        Arrays.stream(arr).filter((v)->v >= 4).forEach(System.out::println);
        System.out.println("----------");
        //限制
        Arrays.stream(arr).limit(4).forEach(System.out::println);
        System.out.println("----------");
        //跳过
        Arrays.stream(arr).skip(4).forEach(System.out::println);
        System.out.println("----------");
        //取数组中4-7
        Arrays.stream(arr).skip(4).limit(3).forEach(System.out::println);
        Arrays.stream(arr).mapToObj(operand -> new Student("老头",operand)).forEach(System.out::println);
    }
}

package com.lu.day09;

import java.util.Arrays;
import java.util.stream.IntStream;

public class Test1 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        IntStream distinct = Arrays.stream(arr).distinct();
        distinct.forEach(System.out::println);
        distinct.filter(x -> x > 2).forEach(System.out::println);
        /*
        stream流使用注意
        1.流一旦终止（调用了终止方法）就不能在开启了
        2.如何区分流的中间操作和终止操作：看返回值，如果返回值是流，那么就是中间操作，否则就是终止操作
        3.流不会影响原始数据
         */
    }
}

2.lambda表达式方法引用

package com.lu.day09;

import java.util.Arrays;
import java.util.stream.IntStream;

public class Test1 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        IntStream distinct = Arrays.stream(arr).distinct();
        distinct.forEach(System.out::println);
        distinct.filter(x -> x > 2).forEach(System.out::println);
        /*
        stream流使用注意
        1.流一旦终止（调用了终止方法）就不能在开启了
        2.如何区分流的中间操作和终止操作：看返回值，如果返回值是流，那么就是中间操作，否则就是终止操作
        3.流不会影响原始数据
         */

        /*
        lambda表达式方法引用的使用前提
        1.lambda表达式方法体内只存在一条语句，并且这条语句是调用某个方法
        2.该方法与函数式接口的参数列表和放回值一致时可替换为方法引用
        本质上简化了lambda表达式的参数传递

        lambda表达式构造器方法引用使用前提：
        1.lambda表达式的方法体内只有一条语句，并且这条语句在调用某个构造器
        2.该构造器的参数列表与函数式接口的参数列表一致时可以替换为构造方法引用 类名::new
         */
    }
}

3.终止数组Stream流

package com.lu.day09;

import java.util.Arrays;
import java.util.OptionalDouble;
import java.util.OptionalInt;

public class Test2 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9};
        //sum求和
        System.out.println(Arrays.stream(arr).distinct().sum());
        OptionalInt max = Arrays.stream(arr).max();
        //max最大值
        //optionalInt时jdk1.8引入的判空类，一般搭配isPresent()先判断是否为空，如果存在则get取值
        //max求最大值
        if (max.isPresent())
            System.out.println(max.getAsInt());
        OptionalInt min = Arrays.stream(arr).min();
        //min最小值
        if (min.isPresent())
            System.out.println(min.getAsInt());
        //avg求平均值
        OptionalDouble average = Arrays.stream(arr).average();
        if (average.isPresent())
            System.out.println(average.getAsDouble());
    }
}

4.规约/折叠

规约就是对数据进行加减乘除操作

package com.lu.day09;

import java.util.Arrays;
import java.util.OptionalInt;

/**
 * reduce 归约/折叠
 */
public class Test3 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        OptionalInt reduce = Arrays.stream(arr).reduce((Integer::sum));
        System.out.println(reduce.getAsInt());
        OptionalInt reduce1 = Arrays.stream(arr).reduce((left, right) -> left * right);
        System.out.println(reduce1.getAsInt());


        //重载的reduce可以指定初始值（sum底层就是reduce）缺点reduce运算要符合结合律
        int[] arr1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int reduce2 = Arrays.stream(arr1).reduce(0, Integer::sum);
        System.out.println(reduce2);
    }
}

Stream流（集合的stream流）

1.集合stream流的基本使用

stream改不了基本数据类型内容，改不了引用数据类型大小，但是可以改引用数据类型内容

package com.lu.day09;

import java.util.ArrayList;

public class Test4 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(8);
        list.add(4);
        list.add(5);
        list.stream().filter(x -> x > 4).forEach(System.out::println);

        //distinct也需要重写equals方法和hashCode方法
        ArrayList<Computer> list1 = new ArrayList<>();
        list1.add(new Computer("联想", 10000));
        list1.add(new Computer("联想", 10000));
        list1.add(new Computer("戴尔", 20000));
        list1.add(new Computer("华硕", 30000));
        list1.stream().distinct().forEach(System.out::println);

        //将computer类型转换成String类型
        list1.stream().map(Computer::getBrand).forEach(System.out::println);
    }
}

2.集合用stream流排序

package com.lu.day09;

import java.util.ArrayList;

public class Test4 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(8);
        list.add(4);
        list.add(5);
        list.stream().filter(x -> x > 4).forEach(System.out::println);

        //distinct也需要重写equals方法和hashCode方法
        ArrayList<Computer> list1 = new ArrayList<>();
        list1.add(new Computer("联想", 10000));
        list1.add(new Computer("联想", 10000));
        list1.add(new Computer("戴尔", 20000));
        list1.add(new Computer("华硕", 30000));
        list1.stream().distinct().forEach(System.out::println);

        //将computer类型转换成String类型
        list1.stream()
                .map(Computer::getPrice)
                .distinct()
                .forEach(System.out::println);

        list1.stream().sorted((o1, o2) -> o2.getPrice() - o1.getPrice()).forEach(System.out::println);
        /*
        三种集合的排序方式
        list1.stream().sorted()
        Object.sort();
        Collections.sort();
         */
    }
}

3.collect

package com.lu.day09;

import java.util.*;
import java.util.stream.Collectors;

/**
 * collect收集操作
 */
public class Test5 {
    public static void main(String[] args) {
        ArrayList<Computer> list = new ArrayList<>();
        list.add(new Computer("荣耀", 10000));
        list.add(new Computer("荣耀", 10000));
        list.add(new Computer("荣耀", 10000));
        list.add(new Computer("联想", 10000));
        list.add(new Computer("戴尔", 20000));
        list.add(new Computer("华硕", 30000));
        //collect方法并不是一个函数式接口 ->搭配Collectors工具类使用->toList()/toSet()/toMap()
        List<Integer> collect = list.stream().map(Computer::getPrice).collect(Collectors.toList());
        Set<Integer> collect1 = list.stream().map(Computer::getPrice).collect(Collectors.toSet());
        System.out.println(collect);
        System.out.println(collect1);

        //toMap
//        Map<String, Integer> collect2 = list.stream().collect(Collectors.toMap(Computer::getBrand, Computer::getPrice));
//        System.out.println(collect2);

        //重载toMap有三个参数
        //第三个参数：如果key重复，则用新值覆盖旧值
        Map<String, Integer> collect3 = list.stream().collect(Collectors.toMap(Computer::getBrand, Computer::getPrice, (oldValue, newValue) -> newValue));
        System.out.println(collect3);

    }
}

package com.lu.day09;

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

/**
 * 分组
 */
public class Test6 {
    public static void main(String[] args) {
        ArrayList<Computer> list = new ArrayList<>();
        list.add(new Computer("荣耀", 10000));
        list.add(new Computer("荣耀", 10000));
        list.add(new Computer("荣耀", 10000));
        list.add(new Computer("联想", 10000));
        list.add(new Computer("戴尔", 20000));
        list.add(new Computer("华硕", 30000));
        //根据品牌分组groupingBy
        Map<String, List<Computer>> collect = list.stream().collect(Collectors.groupingBy(Computer::getBrand));
        System.out.println(collect);
    }
}

stream流可以一定程度上的代替sql

groupingby可以根据返回值灵活的定义分组的名字以及分的组数（原因是因为他的底层是一个数组）

4.IntStream.range(1, 10000000)

生成一个1到一千万的数组

5.集合和数组用stream多线程计算求和

package com.lu.day12.sum;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.LongStream;

public class SumThread {
    public static void main(String[] args) {
        //并行流就是多线程计算
        //数组的并行流，stream流可以开启并行流进行多线程计算parallel()
        long[] array = LongStream.range(1, 1000000000).toArray();
        System.out.println(Arrays.stream(array).parallel().sum());
        //集合的并行流
        ArrayList<Object> objects = new ArrayList<>();
        objects.parallelStream();
    }
}

类与类之间的关系组合

一个类里面属性是另一个类

file

1.为什么要学习File?

2.概念

java.io 包中唯一代表磁盘文件本身的对象，也就是说，如果希望在程序中操作文件和目录，则都可以通过 File 类来完成,本质是对文件(夹)路径的一个抽象

3.类中具体方法的使用

package com.lu.day09.file;

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

public class Test01 {
    public static void main(String[] args) {
        /*
        \是特殊字符要转义
        windows\\
        mac linux/
        jdk1.5 之后目录分隔符都用/
         */
        File file = new File("D:/a.txt");

        try {
            //创建新文件
            System.out.println(file.createNewFile());
            //获取文件名
            System.out.println(file.getName());
            //判断文件/文件夹是否存在
            System.out.println(file.exists());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

package com.lu.day09.file;

import java.io.File;

public class FileTest {
    public static void main(String[] args) {
        File file = new File("D:/");
        //创建目录/文件夹 mkdir = make directory
        //System.out.println(file.mkdir());
        //创建多级目录
        //file.mkdirs();
        //删除文件
        //System.out.println(file.delete());
        String[] list = file.list();
        //遍历所有文件
        if (list != null) {
            for (String s : list) {
                System.out.println(s);
            }
        }
    }
}

4.据对路径相对路径

package com.lu.day09.file;

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

/**
 * 以相对路径创建文件->把文件创建在项目中
 */
public class FileTest1 {
    public static void main(String[] args) {
        //从工作路径中补全相对路径
        File file = new File("resource/a.txt");
        try {
            System.out.println(file.createNewFile());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        System.out.println(file.delete());
    }
}