Java基础——Stream流、File类

最新推荐文章于 2024-07-24 22:57:50 发布
最新推荐文章于 2024-07-24 22:57:50 发布
阅读量185 收藏
点赞数
分类专栏： java小白学习笔记 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38553011/article/details/132664109
版权

一、Stream 流

        1.Stream 流配合Lambda表达式，简化集合和数组操作
        2.Stream 流思想
                1)将数据到流中（获取流对象）
                        ① 集合获取 Stream 流对象，使用 Collection 接口中的默认方法
                             default Stream<E> stream() 获取当前集合对象的 Stream 流
                             例：
                             List<String> list = new ArrayList<String>();
                             list.add("张三丰");
                             list.add("张无忌");
                             list.stream().forEach(s -> System.out.println(s))
                            //Map集合获取Stream流对象, 需要间接获取,- map.entrySet().stream()
                             Map<String, Integer> map = new HashMap<String, Integer>();
                             map.put("张三丰", 100);
                             map.put("张无忌", 35);
                             Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
                             entrySet.stream().forEach(s -> System.out.println(s));
                        ② 数组获取 Stream 流对象，使用 Arrays 数组工具类中的静态方法
                             static <T> Stream<T> stream​(T[] array)将传入的数组封装到 Stream 流对象中
                             例：
                             int[] arr = {11, 22, 33};
                             Arrays.stream(arr).forEach(s -> System.out.println(s));
                        ⑤ 零散的数据获取 Stream 流对象，使用 Stream 类中的静态方法
                             static <T> Stream<T> of​(T... values)把一堆零散的数据封装到 Stream 流对象中
                             Stream.of(1, 2, 3, 4, 5, 6).forEach(s -> System.out.println(s));

                2)中间方法 - 操作后返回Stream对象, 可以继续操作
                         //示例准备
                         ArrayList<String> list = new ArrayList<>();
                         Collections.addAll(list, "林青霞", "张曼玉", "王祖贤", "柳岩","张敏","张无忌");

                        ① Stream<T> filter(Predicate<? super T> predicate) 用于对流中的数据进行过滤
                            列： list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(
                                    s -> System.out.println(s));//张曼玉,张无忌
                        ② Stream<T> limit(long maxSize) 获取前几个元素
                             列：
                                // "林青霞", "张曼玉"
                                list.stream().limit(3).forEach(s -> System.out.println(s));
                        ③ Stream<T> skip(long n) 跳过前几个元素
                                列：
                                // "柳岩","张敏","张无忌"
                                list.stream().skip(3).forEach(s -> System.out.println(s));
                        ④ Stream<T> distinct() 去除流中重复的元素依赖 (hashCode 和 equals方法)
                                列： s3.distinct().forEach(s -> System.out.println(s));
                        ⑤ static <T> Stream<T> concat(Stream a, Stream b) 合并a和b两个流为一个流
                                例：
                                        // 取前4个数据组成一个流
                                        Stream<String> s1 = list.stream().limit(4);
                                        // 跳过2个数据组成一个流
                                        Stream<String> s2 = list.stream().skip(2);
                                        //合并s1和s2得到的流
                                        Stream<String> s3 = Stream.concat(s1, s2);

                注意事项: 流对象已经被使用过就不允许再次使用了.
                3)终结方法
                   Stream流的终结操作方法 - 流水线中的最后一道工序
                   public void forEach (Consumer action) 对此流的每个元素执行遍历操作
                   public long count () 返回此流中的元素数
        3.Stream 收集操作
                把 Stream 流操作后的结果数据转回到集合，Stream 流操作，不会修改数据源
                1)把 Stream 流操作后的结果数据转回到集合
                   R collect​(Collector collector) 开始收集Stream流，指定收集器
                2)Collectors 工具类提供了具体的收集方式
                    public static <T> Collector toList​() 把元素收集到List集合中
                    public static <T> Collector toSet​()把元素收集到Set集合中
                    public static  Collector toMap​(Function keyMapper , Function valueMapper)把元素收
                    集到Map集合中
                例：
                        //把元素收集到List集合中
                        List<Integer> list1 = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).filter(
                                s -> s % 2 == 0
                        ).collect(Collectors.toList());
                        //把元素收集到List集合中
                       Set<Integer> list2 = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10).filter(
                                s -> s % 2 == 0
                        ).collect(Collectors.toSet());
                        ArrayList<String> list = new ArrayList<>();
                        list.add("张三,23");
                        list.add("李四,24");
                        list.add("王五,25");
                        Map<String, Integer> map = list.stream().filter(new Predicate<String>() {
                                        @Override
                                        public boolean test(String s) {
                                                return Integer.parseInt(s.split(",")[1]) >= 24;
                                        }
                                }).collect(Collectors.toMap(new Function<String, String>() {
                                        @Override
                                        public String apply(String s) {
                                                return s.split(",")[0];
                                        }
                                }, new Function<String, Integer>() {
                                         @Override
                                         public Integer apply(String s) {
                                                  return Integer.parseInt(s.split(",")[1]);
                                        }
                      }));
        例：
                现在有两个 ArrayList 集合，分别存储6名男演员和6名女演员，要求完成如下的操作：
                        男演员只要名字为3个字的前两人
                        女演员只要“小”字开头的，并且不要第一个
                        把过滤后的男演员姓名和女演员姓名合并到一起
                        把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
                        演员类MyActor ，里面有一个成员变量，一个带参构造方法，以及成员变量对应的
                        get/set方法
        代码：
                public static void main(String[] args) {
                        ArrayList<String> boy = new ArrayList<>();
                        Collections.addAll(boy, "郭靖", "黄药师", "王祖贤", "乔峰","杨过","张无忌");
                        ArrayList<String> girl = new ArrayList<>();
                        Collections.addAll(girl, "黄蓉", "林超风", "小龙姐", "赵敏","周芷若","小昭");
                        //男演员只要名字为3个字的前两人
                        Stream<String> boy_1 = boy.stream().filter(s -> s.length() == 3).limit(2);
                        //女演员只要“小”字开头的，并且不要第一个
                        Stream<String> girl_1 = girl.stream().filter(s -> s.startsWith("小")).skip(1);
                        //男演员姓名和女演员姓名合并到一起
                        Stream<String> Actor = Stream.concat(boy_1, girl_1);
                        //遍历数据
                        Actor.forEach(new Consumer<String>() {
                                @Override
                                public void accept(String s) {
                                        MyActor A = new MyActor(s);
                                        System.out.println(A);
                                }
                        });
                }
                //演员类MyActor
               class MyActor{
                        private String name;
                        public MyActor() {}
                        public MyActor(String name) {
                                this.name = name;
                        }
                        public String getName() {
                                return name;
                        }
                        public void setName(String name) {
                                this.name = name;
                        }
                        public String toString() {
                                return "Actor{name = " + name + "}";
                        }
                }

二、File 类

        File类代表操作系统的文件对象（文件、文件夹）
        构造方法 :
        1. public File (String pathname) : 根据传入的字符串路径封装File对象
                File f = new File("D:\\A.txt");
        2. public File (String parent, String child) : 根据传入的父级路径和子级路径来封装File对象
                File f = new File("D:\\", "test");
        3. public File (File parent, String child) : 根据传入的父级路径(File类型)和子级路径来封装File
             对象
                File f = new File(new File("D:\\"), "test");
                File 对象可以定位文件和文件夹
                File 封装的对象仅仅是一个路径名，这个路径可以是存在的，也可以是不存在的
        路径的写法 :
        1. 绝对路径: 从盘符根目录开始，一直到某个具体的文件或文件夹
        2. 相对路径: 相对于当前项目
        例：
                public static void main(String[] args) throws IOException {
                        File f = new File("src/com/itheima/day12\\A.txt");
                        f.createNewFile();
                }
        常见方法 :
        1. 判断相关
                public boolean isDirectory() : 判断是否是文件夹
                public boolean isFile() : 判断是否是文件
                public boolean exists() : 判断是否存在
                例：
                File f1 = new File("D:\\A.txt");
                System.out.println(f1.isDirectory()); // false
                System.out.println(f1.isFile()); // true
                System.out.println(f1.exists()); // true

         2. 获取相关
                public long length() : 返回文件的大小(字节数量)
                        * 文件对象操作, 返回正确的字节个数
                        * 文件夹对象操作, 返回的是错误的字节个数
                public String getAbsolutePath() : 返回文件的绝对路径
                public String getPath() : 返回定义文件时使用的路径
                public String getName() : 返回文件的名称，带后缀
                public long lastModified() : 返回文件的最后修改时间（时间毫秒值）
                例：
                System.out.println(f1.length());
                System.out.println(f1.getAbsolutePath());
                System.out.println(f1.getPath());
                System.out.println(f1.getName());
                System.out.println(new Date(f1.lastModified()));
        3.创建方法和删除方法
                public boolean createNewFile() :创建文件
                public boolean mkdir() : 创建单级文件夹
                public boolean mkdirs() : 创建多级文件夹
                public boolean delete() : 删除文件或文件夹（慎用）
                        - delete 方法删除文件夹, 只能删除空的文件夹.
                 例：
                public static void main(String[] args) throws IOException {
                        File f1 = new File("src\\com\\itheima\\day12\\B.txt");
                        System.out.println(f1.createNewFile());
                        File f2 = new File("src\\com\\itheima\\day12\\aaa");
                        System.out.println(f2.mkdirs());
                        File f3 = new File("src\\com\\itheima\\day12\\C.txt");
                        System.out.println(f3.mkdirs());
                        System.out.println(f1.delete());
                        System.out.println(f2.delete());
                }
        4.遍历方法
                public File[] listFiles() 获取当前目录下所有的 "一级文件对象" 返回 File 数组
                ① 当调用者File表示的路径不存在时，返回null
                ② 当调用者File表示的路径是文件时，返回null
                ③ 当调用者File表示的路径是一个空文件夹时，返回一个长度为0的数组
                ④ 当调用者File表示的路径是需要权限才能访问的文件夹时，返回null
                例：
                public static void main(String[] args) {
                        File f = new File("D:\\test");
                        File[] files = f.listFiles();
                        for (File file : files) {
                                System.out.println(file);
                        }
                }

qq_38553011
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础之Stream流、File类
weixin_40119218的博客
04-09 358
Stream流 Stream流的获取 Stream流常用API
java文件流类结构图_Java 流(Stream)、文件(File)和IO | 菜鸟教程
weixin_39625987的博客
02-13 228
Java 流(Stream)、文件(File)和IOJava.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。...
Java 流(Stream)、文件(File)和IO详解
学习编程的小羊的博客
06-21 533
本文详细介绍了Java中的流(Stream)、文件(File)和IO操作，涵盖了基本概念、常用操作和示例代码。掌握这些知识对于处理数据、文件读写以及流式数据处理非常重要。希望这篇文章对你理解和应用Java的流、文件和IO有所帮助。如果你有任何问题或建议，欢迎在评论区讨论。
Java-Runoob：Java Stream、File、IO
weixin_30578677的博客
03-28 211
ylbtech-Java-Runoob：Java Stream、File、IO 1.返回顶部 1、 Java 流(Stream)、文件(File)和IO Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。 Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。 ...
Java进阶5 Stream流、File类
chenjiap的博客
03-29 540
Stream流的介绍及使用，File类的使用，递归删除文件，查询文件。
java-file stream
xzbaimildcat的专栏
10-05 408
the hierarchy of the file stream in java
java——IO流技术.pdf
04-03
Java中的IO流主要位于`java.io`包中，该包包含了用于处理各种类型数据的流类。其中最重要的是五个类和三个接口： - **File**: 文件类，用于处理文件和目录的操作。 - **InputStream**: 字节输入流，用于从数据源...
JAVA-SE入门学习——第九讲IO流
06-08
JAVA-SE入门学习——第九讲IO流 在 Java 中，IO 流（Input/Output Stream）是一种基本的输入/输出机制，它允许程序读取和写入各种类型的数据。IO 流是 Java 编程语言的核心组件之一，它提供了一种通用的方式来处理...
java面试——深圳-银盛支付-Java中级.zip
09-26
1. **面向对象编程**：这是Java的基础，包括类、对象、封装、继承、多态等概念。理解如何设计和实现面向对象的解决方案是中级开发者必备的能力。 2. **异常处理**：理解Java中的异常类型，如何使用try-catch-...
java面试——深圳-乐信-Java高级.zip
09-26
在Java高级面试中，面试官通常会关注候选人在核心Java、多线程、集合框架、JVM内存管理、设计模式、数据库操作、网络编程、异常处理、IO流、Spring框架及其实现原理等方面的知识掌握程度。以下是根据这些关键点展开...
java基础的ppt文件学习
04-05
8. **输入/输出流**：介绍I/O流的基本概念，File类的使用，字节流和字符流的区别，以及BufferedReader和PrintWriter等常用流的用法。 9. **多线程**：线程的创建方式（通过实现Runnable接口或继承Thread类），线程...
【java基础】12-Stream流和File
Nusret的博客
03-22 807
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
Java流（Stream）
若没有记忆
01-06 343
根据流的方向可以分为：输入流和输出流。用户可以从输入流中读取数据，但不可以写它，相反，对于输出流只能写而不能读。其实，输入/输出是相对于内存来说的。 根据流的操作对象的类型可分为：字节流和字符流。在Java中字节流统一由InputStream和OutputStream来做处理，而字符流则由Reader和Writer来做处理。 InputStream、OutputStream、Reader、
Java流（Stream）、文件(File)和IO
qq_40285302的博客
03-25 246
Java 的控制台输入由 System.in 完成。 为了获得一个绑定到控制台的字符流，你可以把 System.in 包装在一个 BufferedReader 对象中来创建一个字符流。 下面是创建 BufferedReader 的基本语法： [java] view plain copy BufferedReader br = new BufferedReader(new InputStre...
Java 流(Stream)、文件(File)和IO
笔记
03-12 516
Java中的流(Stream)提供了一个统一的接口来处理输入和输出数据，文件(File)提供了一种简单的方式来操作磁盘上的文件，而I/O则允许我们在Java程序中读写数据。Java 提供了多个输入流和输出流的实现，其中最常用的是 InputStream 和 OutputStream。字节流是Java中处理二进制数据的流，通常用于读取和写入文件。本文将详细解释Java中流、文件和I/O的概念，包括如何创建、读取和写入文件，如何使用流处理输入和输出数据，以及如何使用I/O来进行网络编程。
java学习笔记（三） FileStream
llin-黎辰
07-22 1677
文件的读取主要是用java.io.FileInputStream java.io.FileInputStream 那么接下来我分为读文件和写文件两部分来介绍FileStream，也就是文件流 -----------------------------------------FileInputStream---------------------------------------------
JavaSE进阶-Stream&File
aaa934946088的博客
07-30 187
Stream流 【重点】 File类 【重点】
【进阶篇-Day12：JAVA中stream流、File类的介绍】
最新发布
Ma Sizhou
07-24 973
Stream不会修改原始的集合，因此在流里的操作后的结果，需要用新的集合来保存。需求：键盘录入一个文件夹路径，找出这个文件夹下所有的 .java 文件。注意：文件夹路径有相对路径和绝对路径两种写法。注：stream流就是流水线工作，即。
Java 常用方法实例 Stream,File,IO
望天吼
01-20 261
Java 常用方法实例 Stream,File,IO
Java基础：File类与IO流详解
Java第八章主要探讨了Java编程中的核心输入输出流（Input/Output Stream）概念以及其在实际开发中的应用。本章首先介绍了File类，这是Java中用于处理磁盘上文件和目录的重要工具。File类是一个抽象类，定义了一系列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值