【进阶篇-Day12：JAVA中stream流、File类的介绍】

于 2024-07-24 22:57:50 发布
阅读量616 收藏 5
点赞数 24
分类专栏： # Java基础 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45901519/article/details/140585171
版权

目录

1、stream流

1.1 stream流的作用

在这里插入图片描述

1.2 stream流的思想

在这里插入图片描述

注：stream流就是流水线工作，即将数据放入流水线（获取流对象），然后加工（中间方法），最后输出（终结方法）。

1.3 获取stream流对象

在这里插入图片描述

package com.itheima.stream;
import java.util.*;
import java.util.stream.Stream;

public class StreamDemo1 {
    /**
     * 获取Stream流对象演示：
     *     - 将数据放在流水线的传送带上
     *
     *     1、集合获取 Stream 流对象 (使用Collection接口中的默认方法)
     *             default Stream<E> stream()
     *             注意：Map集合获取Stream流对象，需要间接获取：
     *                     - map.entrySet().stream()
     *
     *     2、数组获取 Stream 流对象 (使用Array数组工具类中的静态方法)
     *             static <T> Stream<T> stream (T[] array)
     *
     *     3、零散的数据获取Stream 流对象 (使用Stream类中的静态方法)
     *             static <T> Stream<T> of(T... values)
     */
    public static void main(String[] args) {
        //1、集合获取 Stream 流对象
        //1.1 List集合获取 Stream 流对象
        List<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");
        list.stream().forEach(s -> {System.out.println(s);});
        //1.2 Set集合获取 Stream 流对象
        Set<String> set = new HashSet<>();
        set.add("张三丰");
        set.add("张无忌");
        set.add("张翠山");
        set.add("王二麻子");
        set.add("张良");
        set.add("谢广坤");
        set.stream().forEach(s -> System.out.println(s));
        //1.3 Map集合获取 Stream 流对象
        Map<String, Integer> map = new HashMap<>();
        map.put("张三丰", 100);
        map.put("张无忌",98);
        map.put("张翠山",29);
        map.put("王二麻子",55);
        map.put("张良",68);
        map.put("谢广坤",70);
        map.entrySet().stream().forEach(s -> System.out.println(s));

        //2、数组获取 Stream 流对象
        int[] arr1 = {11,22,33};
        double[] arr2 = {11.1,22.2,33.3};
        Arrays.stream(arr1).forEach(s -> System.out.println(s));
        Arrays.stream(arr2).forEach(s -> System.out.println(s));

        //3、零散的数据获取Stream 流对象: 零散就是这些数既没有在集合中，也没有在数组中
        Stream.of(1,2,3,4,5,6).forEach(s -> System.out.println(s));
        Stream.of("11","22","33","44").forEach(s -> System.out.println(s));
    }
}

1.4 stream流中间操作方法

在这里插入图片描述

package com.itheima.stream;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo2 {
    /**
     * Stream流的中间操作方法：
     *     - 操作后返回Stream流对象，可以继续操作
     *
     *     Stream<T> filter(Predicate<? super T> predicate) 用于对流中的数据进行过滤
     *     Stream<T> limit(long maxSize) 获取前几个元素
     *     Stream<T> skip(long n) 跳过前几个元素
     *     Stream<T> distinct() 去除流中重复的元素依赖(hashCode 和 equals方法)
     *     static <T> Stream<T> concat(Stream a, Stream b) 合并a和b两个流为一个流
     *         - 注意：如果流的对象消费过(使用过)，就不允许再消费了。
     */
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");

        //需求1：将集合中以【张】开头的数据 和 长度为3，过滤出来并打印在控制台
        list.stream().filter(v -> v.startsWith("张")).filter(v -> v.length() == 3).forEach(e -> System.out.println(e));
        System.out.println("-------------------------------------");

        //需求2：取前3个数据在控制台输出 ---> limit(long maxSize) 获取前几个元素
        list.stream().limit(3).forEach(e -> System.out.println(e));
        System.out.println("-------------------------------------");

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

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

        //需求5：取前4个数据组成一个流
        Stream<String> stream1 = list.stream().limit(4);
        System.out.println("-------------------------------------");

        //需求6：跳过2个数据组成一个流
        Stream<String> stream2 = list.stream().skip(2);
        System.out.println("-------------------------------------");

        //需求7：合并需求1和需求2得到的流，并把结果在控制台输出
        Stream<String> stream3 = Stream.concat(stream1, stream2);
//        stream3.forEach(e -> System.out.println(e));//注意：流用过之后，不可以再用了
        System.out.println("-------------------------------------");

        //需求8：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复
        stream3.distinct().forEach(e -> System.out.println(e));
        System.out.println("-------------------------------------");
    }
}

在这里插入图片描述

1.5 stream流终结操作方法

在这里插入图片描述

package com.itheima.stream;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class StreamDemo3 {
    /**
     * Stream流的终结操作方法
     *     - 流水线中的最后一道工序
     * 
     *     public void forEach(Consumer action) 对此流的每个元素执行遍历操作
     *     public long count() 返回此流中的元素数
     */
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");

        //1、forEach(Consumer action) 对此流的每个元素执行遍历操作
        list.stream().forEach(e -> System.out.println(e));

        //2、long count() 返回此流中的元素数
        System.out.println(list.stream().count());//6
        System.out.println(Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9).count());//9
    }
}

1.6 stream收集操作

注意：
Stream不会修改原始的集合，因此在流里的操作后的结果，需要用新的集合来保存。

在这里插入图片描述

package com.itheima.stream;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo4 {
    /**
     * Stream流的收集操作：
     *     public R collect (Collector c):将流中的数据收集到集合
     *
     *         Collectors
     *             public static <T> Collector toList()
     *             public static <T> Collector toSet()
     *             public static <T> Collector toMap(Function keyMapper,Function valueMapper)
     */
    public static void main(String[] args) {
        //1、toList():将流对象收集到list集合中
        List<Integer> list = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).filter(e -> e % 2 == 0).collect(Collectors.toList());
        System.out.println(list);//[2, 4, 6, 8, 10]


        //2、toSet():将流对象收集到set集合中 ---> 注意，收集时set还是会去重
        Set<Integer> set = Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10,10,10,10).filter(e -> e % 2 == 0).collect(Collectors.toSet());
        System.out.println(set);//[2, 4, 6, 8, 10]


        //3、toMap()方法比较复杂，用一个需求来介绍：
        /*
        需求：创建一个 ArrayList 集合，并添加以下字符串
             "张三,23",
             "李四,24",
             "王五,25"
             保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值
         */
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("张三,23");
        arrayList.add("李四,24");
        arrayList.add("王五,25");
        Map<String, Integer> map1 = arrayList.stream().filter(s -> Integer.parseInt(s.split(",")[1]) >= 24).collect(Collectors.toMap(
                new Function<String, String>() {
            @Override
            public String apply(String s) {//第一个匿名内部类 ---》指定key
                return s.split(",")[0];
            }
        }, new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {//第二个匿名内部类 ---》指定value
                return Integer.parseInt(s.split(",")[1]);
            }
        }));
        //上述写法可写成lambda表达式，如下：
        Map<String, Integer> map2 = arrayList.stream().filter(s -> Integer.parseInt(s.split(",")[1]) >= 24).
                collect(Collectors.toMap(s -> s.split(",")[0], s -> Integer.parseInt(s.split(",")[1])));

        System.out.println(map1);//{李四=24, 王五=25}
    }
}

1.7 stream的综合案例

在这里插入图片描述

package com.itheima.stream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo5 {
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        list1.add("林菲菲");
        list1.add("李飞飞");
        list1.add("林格格");
        list1.add("黄方面");
        list1.add("林黛玉十");
        list1.add("林黛玉");
        List<String> list2 = new ArrayList<>();
        list2.add("马大炮");
        list2.add("猪八戒");
        list2.add("唐僧");
        list2.add("孙悟空");
        list2.add("狗蛋蛋");
        list2.add("范杰杰");

        Stream<String> stream1 = list1.stream().filter(v -> v.startsWith("林")).skip(1);
        Stream<String> stream2 = list2.stream().filter(v -> v.length() == 3).limit(2);
        List<String> collect = Stream.concat(stream1, stream2).collect(Collectors.toList());//把两个流合并为一个使用concat方法

        Map<String, Actor> map = new HashMap<>();
        for (String s : collect) {
            Actor a = new Actor(s);
            map.put(s, a);
        }
        System.out.println(map);//{林黛玉十=Actor{name='林黛玉十'}, 林格格=Actor{name='林格格'}, 猪八戒=Actor{name='猪八戒'}, 林黛玉=Actor{name='林黛玉'}, 马大炮=Actor{name='马大炮'}}
    }
}

未完待续。。。。。。

2、File类

在这里插入图片描述

2.1 File类创建文件对象

在这里插入图片描述

package com.itheima.file;
import java.io.File;
import java.io.IOException;

public class FileDemo1 {
    /**
     * File类介绍 ： 文件或文件夹对象
     *
     * 构造方法 ：
     *         1、public File(String pathname):根据传入的字符串路径封装File对象
     *         2、public File(String pathname,String child):根据传入的父级路径和子级路径来封装File对象
     *         3、public File(File parent, String child):根据传入的父级路径(File类型)和子级路径来封装File对象
     */
    public static void main(String[] args) throws IOException {
        //1、File(String pathname):根据传入的字符串路径封装File对象
        File f1 = new File("E:\\A.txt");//读取文件对象
        f1.createNewFile();
        File f2 = new File("E:\\test");//读取文件夹
        System.out.println(f2.exists());//存在返回true，不存在返回false

        //2、File(String pathname,String child):根据传入的父级路径和子级路径来封装File对象
        File f3 = new File("E:\\", "test");//父路径+子路径，封装File对象
        System.out.println(f3.exists());//true

        //3、File(File parent, String child):根据传入的父级路径(File类型)和子级路径来封装File对象
        File f4 = new File(new File("E:\\"), "test");
        System.out.println(f4.exists());//true
    }
}

注意：文件夹路径有相对路径和绝对路径两种写法
在这里插入图片描述

package com.itheima.file;
import java.io.File;
import java.io.IOException;

public class FileDemo2 {
    /**
     * 路径的写法：
     *     1、相对路径：相对于当前项目
     *     2、绝对路径：从盘符根目录开始，一直到某个具体的文件或文件夹
     */

    public static void main(String[] args) throws IOException {
        //1、相对路径
        File f1 = new File("A.txt");
        f1.createNewFile();

        //2、绝对路径
        File f2 = new File("E:\\test\\A.txt");
    }
 }

2.2 File类的常用方法

在这里插入图片描述

package com.itheima.file;
import java.io.File;
import java.time.LocalDateTime;
import java.util.Date;

public class FileDemo3 {
    /**
     * File类常见方法：
     *     1、判断相关
     *             public boolean isDirectory():判断是否是文件夹
     *             public boolean isFile():判断是否是文件
     *             public boolean exists():判断是否存在
     *
     *     2、获取相关
     *             public long length():返回文件的大小（字节数量）
     *                     - 为文件对象时，返回正确的字节数量
     *                     - 为文件夹对象时，返回错误的字节数量
     *             public String getAbsolutePath():返回文件的绝对路径
     *             public String getPath():返回文件使用时的路径
     *             public String getName():返回文件的名称，带后缀
     *             public long lastModified():返回文件的最后修改时间（时间毫秒值）
     */
    public static void main(String[] args) {
        //1、判断相关
        File f1 = new File("E:\\A.txt");
        //isDirectory():判断是否是文件夹
        System.out.println(f1.isDirectory());
        //isFile():判断是否是文件
        System.out.println(f1.isFile());
        //exists():判断是否存在
        System.out.println(f1.exists());

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

        //2、获取相关
        File f2 = new File("E:\\GNN");
        //length():返回文件的大小（字节数量）
        System.out.println(f1.length());//为文件对象时，返回正确的字节数量
        System.out.println(f2.length());//为文件夹对象时，返回错误的字节数量
        //getAbsolutePath():返回文件的绝对路径
        System.out.println(f1.getAbsoluteFile());//E:\A.txt
        System.out.println(f2.getAbsoluteFile());//E:\GNN
        //getPath():返回文件使用时的路径
        System.out.println(f1.getPath());//E:\A.txt
        System.out.println(f2.getPath());//E:\GNN
        //getName():返回文件的名称，带后缀
        System.out.println(f1.getName());//A.txt
        System.out.println(f2.getName());//GNN
        //lastModified():返回文件的最后修改时间（时间毫秒值）
        System.out.println(f1.lastModified());//1721657586035
        System.out.println(f2.lastModified());//1601530884989
        System.out.println(new Date(f2.lastModified()));//Thu Oct 01 13:41:24 CST 2020

    }
}

在这里插入图片描述

package com.itheima.file;
import java.io.File;
import java.util.Scanner;

public class FileDemo4 {
    public static void main(String[] args) {
        File dir = getDir();
        System.out.println(dir);
    }

    public static File getDir(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入文件路径：");
        while (true) {
            String dir = sc.nextLine();
            File f = new File(dir);
            if (!f.exists()) {
                System.out.println("你输入的文件路径不存在，请重新输入！");
            } else if (f.isFile()) {
                System.out.println("你输入的是一个文件，请重新输入！");
            } else {
                return f;
            }
        }
    }
}

2.3 File类的创建和删除方法

在这里插入图片描述

package com.itheima.file;

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

public class FileDemo5 {
    /**
     * File类的创建方法和删除方法：
     *     public boolean createNewFile():创建文件
     *     public boolean mkdir():创建单极文件夹
     *     public boolean mkdirs():创建多极文件夹
     *     public boolean delete():删除文件或文件夹
     *             - delete 方法删除文件夹时，只能删除空的文件夹
     */
    public static void main(String[] args) throws IOException {
        //1、createNewFile():创建文件
        File f1 = new File("A.txt");
        System.out.println(f1.createNewFile());//不存在则创建文件并返回true，存在则返回false

        //2、mkdir():创建单极文件夹
        File f2 = new File("aaa");
        System.out.println(f2.mkdir());//不存在则创建文件夹并返回true，存在则返回false

        //3、mkdirs():创建多极文件夹
        File f3 = new File("bbb\\ccc\\ddd");
        System.out.println(f3.mkdirs());不存在则创建文件夹并返回true，存在则返回false

        //4、delete():删除文件或文件夹
        System.out.println(f1.delete());//存在则删除并返回true，否则返回false
    }
}

2.4 File类的遍历方法

在这里插入图片描述

注意：
在这里插入图片描述

package com.itheima.file;

import java.io.File;

public class FileDemo6 {
    /**
     * File类的遍历方法：
     *         public File[] listFiles():获取当前目录下所有的 ”一级文件对象“ 返回File数组
     */
    public static void main(String[] args) {
        File f1 = new File("C:\\Users\\MSZ\\Desktop\\java_test\\dev\\day12-code");
        File[] files = f1.listFiles();
        for (File file : files) {
            System.out.println(file);
        }
    }
}

练习一：

需求：键盘录入一个文件夹路径，找出这个文件夹下所有的 .java 文件

package com.itheima.file;
import java.io.File;
import java.util.Scanner;

public class FileDemo7 {
    /**
     * 需求：键盘录入一个文件夹路径，找出这个文件夹下所有的 .java 文件
     */
    public static void main(String[] args) {
        //1、获取文件夹路径
        File dir = getDir();

        //2、找出文件夹下的.java文件
        for (File file : dir.listFiles()) {
            if (file.isFile() && file.getName().endsWith(".java")){
                System.out.println(file);
            }
        }
    }

    public static File getDir(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输文件夹路径：");
        while (true) {
            String path = sc.nextLine();
            File f = new File(path);
            if (f.isFile()){
                System.out.println("您输入的是一个文件，请重新输入！");
            } else if (!f.exists()) {
                System.out.println("您输入的问价夹不存在，请重新输入！");
            }else {
                return f;
            }
        }
    }
}

上述方法如果遇到多级文件夹下还有.java文件，那就获取不到了，于是我们可以使用递归来解决这个问题：

package com.itheima.file;
import java.io.File;
import java.util.Scanner;

public class FileDemo7 {
    /**
     * 需求：键盘录入一个文件夹路径，找出这个文件夹下所有的 .java 文件
     */
    public static void main(String[] args) {
        File dir = getDir();
        printJavaFile(dir);
    }

    public static void printJavaFile(File dir){
        //1、获取当前路径下的文件夹和文件的对象
        File[] files = dir.listFiles();

        //2、遍历数组对象
        for (File file : files) {
            //3、如果.java文件则打印
            if (file.isFile() && file.getName().endsWith(".java")){
                System.out.println(file);
            } else if (file.isDirectory()) {
                //4、如果是文件夹，则递归调用自身继续找.java文件
                if (file.listFiles() != null){
                    printJavaFile(file);
                }
            }
        }
    }

    public static File getDir(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输文件夹路径：");
        while (true) {
            String path = sc.nextLine();
            File f = new File(path);
            if (f.isFile()){
                System.out.println("您输入的是一个文件，请重新输入！");
            } else if (!f.exists()) {
                System.out.println("您输入的问价夹不存在，请重新输入！");
            }else {
                return f;
            }
        }
    }
}

练习二：

在这里插入图片描述

package com.itheima.file;
import java.io.File;
import java.util.Collections;

public class FileDem8 {
    /**
     * 需求：设计一个方法，删除文件夹（delete()只能删除空文件夹）
     */
    public static void main(String[] args) {
        File f = new File("C:\\Users\\MSZ\\Desktop\\java_test\\dev\\test111");
        deleteDir(f);
    }

    public static void deleteDir(File file){
        //获取文件夹下所有的文件对象
        File[] files = file.listFiles();
        for (File f : files) {
            if (f.isFile()){
                //如果是文件则直接删除
                f.delete();
            }else {
                //非空文件夹，递归删除
                if (f.listFiles() != null){
                    deleteDir(f);
                }
            }
        }
        //循环结束了，表明已经是空文件夹了,则删除此文件夹
        file.delete();
    }
}

练习三：

在这里插入图片描述

package com.itheima.file;
import java.io.File;

public class FileDem9 {
    /**
     * 需求：键盘录入一个二五年间加路径，统计文件夹的大小
     *         -length()方法只能获取文件的大小，不能获取文件夹的大小
     */
    public static void main(String[] args) {
        long dirSize = getDirSize(new File("C:\\Users\\MSZ\\Desktop\\java_test\\dev\\code"));
        System.out.println(dirSize);
    }

    public static long getDirSize(File file){
        long length = 0L;
        File[] files = file.listFiles();
        for (File f : files) {
            if (f.isFile()){
                //是文件，则获取文件的大小
                length += f.length();
            }else {
                //是文件夹，则递归获取里面的文件大小
                if (f.listFiles() != null){
                    length += getDirSize(f);
                }
            }
        }
        return length;
    }
}

练习四：

在这里插入图片描述

package com.itheima.file;
import java.io.File;
import java.util.HashMap;
import java.util.Map;

public class FileDem10 {
    /**
     * 需求：键盘录入一个文件夹路径，统计文件夹中每种文件的个数并打印（考虑子文件夹）
     * 打印格式如下：
     *           txt:3个
     *           doc:4个
     *           jpg:6个
     */

    static int count = 0;//统计没有后缀名的文件
    static Map<String, Integer> map = new HashMap<>();//存放结果
    
    public static void main(String[] args) {
        Map<String, Integer> fileNum = getFileNum(new File("C:\\Users\\MSZ\\Desktop\\java_test\\dev\\code"));
        fileNum.forEach((k, v) -> System.out.println(k + ":" + v + "个"));
        System.out.println("没有后缀的文件：" + count);
    }

    public static Map<String, Integer> getFileNum(File file){
        //获取当前目录下所有的 ”一级文件对象“ 返回File数组
        File[] files = file.listFiles();
        for (File f : files) {
            if (f.isFile()){
                //如果是文件，则对应类型的值+1
                String name = f.getName();
                if (name.contains(".")){//文件有后缀
                    String[] split = name.split("\\.");
                    String key = split[split.length - 1];
                    if (map.containsKey(key)){
                        map.put(key, map.get(key) + 1);
                    }else {
                        map.put(key, 1);
                    }
                }else {//文件没有后缀,单独统计
                    count++;
                }
            }else {
                //如果是文件夹，则递归获取
                if (f.listFiles() != null){
                    getFileNum(f);
                }
            }
        }
        return map;
    }
}
Ma Sizhou
关注
  • 24
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVASE进阶day09（Stream流&File）
qq_65095414的博客
07-13 249
一个类里面属性是另一个类。
【进阶篇-Day4：使用JAVA编写石头迷阵游戏】
06-22
在本进阶篇中，我们将探讨如何使用Java编程语言来创建一个石头迷阵游戏。Java是一种广泛使用的面向对象的编程语言，它具有丰富的类库和强大的功能，非常适合开发各种类型的游戏。在这个项目中，我们将利用Java的图形...
Day12-Java进阶-Stream流 & File类
weixin_68063226的博客
04-23 490
*需求: 键盘录入一个文件夹路径，如果输入错误就给出提示，并继续录入，直到正确为止*/System.out.println("请输入一个文件夹路径: ");if (!System.out.println("您输入的文件夹不存在, 请重新输入: ");System.out.println("您输入的是一个文件路径, 请重新输入: ");
13天Java进阶笔记-day10-方法引用、Lambda表达式、stream流
qq_36178962的博客
06-11 198
当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，有几种状态呢？在API中这个枚举中给出了六种线程状态：这里先列出各个线程状态发生的条件，下面将会对每种状态进行详细解析我们看到状态中有一个状态叫做计时等待，可以通过Thread类的方法来进行演示. 让当前线程进入到睡眠状态，到毫秒后自动醒来继续执行 这时我们发现主线程执行到sleep方法会休眠1秒后再继续执行。Object类的方法 : 让当前线程进入到等待状态 此方法必须锁对象调用. : 唤醒当前锁对象上
13天Java进阶笔记-day9-方法引用、Lambda表达式、stream流
qq_36178962的博客
06-11 224
当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，有几种状态呢？在API中这个枚举中给出了六种线程状态：这里先列出各个线程状态发生的条件，下面将会对每种状态进行详细解析我们看到状态中有一个状态叫做计时等待，可以通过Thread类的方法来进行演示. 让当前线程进入到睡眠状态，到毫秒后自动醒来继续执行 这时我们发现主线程执行到sleep方法会休眠1秒后再继续执行。Object类的方法 : 让当前线程进入到等待状态 此方法必须锁对象调用. : 唤醒当前锁对象上
【02】Java进阶：12-File类、递归、IO概述、字节流、字符流、
忘尘丶莫负的博客
02-03 218
day12【File类、递归、IO流、字节流、字符流】 今日内容 File类 递归 IO流 字节流 字符流 教学目标 能够说出File对象的创建方式 能够使用File类常用方法 能够辨别相对路径和绝对路径 能够遍历文件夹 能够解释递归的含义 能够使用递归的方式计算5的阶乘 能够说出使用递归会内存溢出隐患的原因 能够说出IO流的分类和功能 能够使用字节输出流写出数据到文件 能够使用字节输入流读取数据到程序 能够理解读取数据read(byte[])方法的原理 能够使用字节流完成文件
java - java进阶（三）Stream、File、IO流
siyu1216的博客
09-03 95
Java进阶三，Stream，File，IO流
Day13-Java进阶-IO字节流&字符流及其练习题
weixin_68063226的博客
04-23 397
*FileReader: 用于读取纯文本文件，解决中文乱码问题构造方法:1. public FileReader(String fileName) 字符输入流关联文件，路径以字符串形式给出2. public FileReader(File file) 字符输入流关联文件，路径以File对象形式给出成员方法:public int read() : 读取单个字符public int read(char[] cbuf) : 读取一个字符数组, 返回读取到的有效字符个数*/
【系统学习】【Java基础】2-Java进阶知识总结-2-递归-异常-流-File
HMTeen
10-25 127
都是讲的方法，常用常新。
JAVA进阶篇DAY12
weixin_47143359的博客
11-10 60
正常情况下，Stream流操作，不会修改数据源，如果想要Stream操作后的数据，就可以使用Stream收集操作。示例中的stream流是一旦被方法调用，就到下一个阶段，无法再被重新调用。
练习前端-HTML标签进阶篇-day02-03
08-19
练习前端-HTML标签进阶篇-day02-03
汇丰Java-Day1：培训中的Java文件
02-12
在“汇丰Java-Day1：培训中的Java文件”这一主题中，我们主要关注的是Java编程语言的基础知识，这是第一天的培训内容。Java是一种广泛应用的、面向对象的编程语言，由Sun Microsystems（现为Oracle公司）于1995年...
HSBC-Java-Day2：HSBC Java培训第二天
02-12
在文件I/O操作中，我们了解了Java的File类以及InputStream和OutputStream流，它们用于读写文件。我们还学习了缓冲流（BufferedReader和BufferedWriter）以提高读写效率，并学习了对象序列化和反序列化，这是持久化...
tdd-java-day1:Java测试驱动开发研讨会的培训练习
05-10
克隆后，请执行： git submodule initgit submodule update一些有用的链接： 图书讨论小组网志 截屏 如果您还有其他有价值的资源值得在这里提及，请随时提出请求。
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1136
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 406
redis+spring面试题
Java-Lambda
lizhiwei21的博客
07-21 444
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 773
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
编写一个程序，将系统时间以“year-month-day hour:minute:second”格式保存在 time.txt 文件中
06-11
好的，以下是一个 C 语言程序，可以将系统时间以“year-month-day hour:minute:second”格式保存在 time.txt 文件中： ```c #include <stdio.h> #include <time.h> int main(void) { time_t now; struct tm *local_time; char time_str[20]; FILE *fp; // 获取当前系统时间 now = time(NULL); local_time = localtime(&now); // 格式化时间字符串 strftime(time_str, sizeof(time_str), "%Y-%m-%d %H:%M:%S", local_time); // 打开文件并写入时间字符串 fp = fopen("time.txt", "w"); if (fp == NULL) { printf("Failed to open file!\n"); return 1; } fprintf(fp, "%s\n", time_str); fclose(fp); printf("Time has been saved to time.txt.\n"); return 0; } ``` 这个程序中用到了以下几个函数： - `time` 函数：获取当前系统时间，返回自 1970 年 1 月 1 日 00:00:00 UTC 起至今的秒数； - `localtime` 函数：将秒数转换为本地时间，返回一个 `struct tm` 结构体指针； - `strftime` 函数：将时间格式化为字符串； - `fopen` 函数：打开文件，返回一个文件指针； - `fprintf` 函数：向文件中写入格式化的字符串； - `fclose` 函数：关闭文件。 以上函数的详细使用方法可以参考相关的 C 语言手册。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值