Stream API：Java 8 中的数据流式处理指南

最新推荐文章于 2024-10-01 09:29:45 发布
最新推荐文章于 2024-10-01 09:29:45 发布
阅读量893 收藏 28
点赞数 14
分类专栏： 闲杂知识分享 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53117341/article/details/141910560
版权

Stream API：Java 8 中的数据流式处理指南

Hello , 大家好 , 本篇文章给大家讲解的是 Java 8 中的 Stream 流 .
在 Java 8 中 , 引入了 Streams API，它允许以声明式方式处理数据集合。Stream API 提供了一种高级迭代器，可以用来执行序列化操作，如筛选、转换、聚合等。它支持并行操作，可以利用多核处理器来加速数据处理。
在日常开发过程中 , 使用 stream 流能够显著提升开发效率 , 极大提升生产力 , 非常推荐使用 .
在这里插入图片描述

一 . 体验 Stream 流

需求 : 按照下面的要求完成集合的创建和遍历

  1. 创建一个集合 , 存储多个字符串元素
  2. 把集合中所有以 “张” 开头的元素存储到一个新的集合
  3. 把 “张” 开头的集合中的长度为 3 的元素存储到另外一个新的集合中
  4. 遍历上一步得到的集合

那我们使用原始的方式 , 代码就是这个样子

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张四丰");
        list.add("张五");
        list.add("李四");
        list.add("王二麻子");

        List<String> result = new ArrayList<>();
        // 1. 遍历 list 集合
        for (String s : list) {
            // 2. 判断元素是否以 "张" 开头
            if (s.startsWith("张")) {
                // 3. 判断元素长度是否是 3
                if (s.length() == 3) {
                    // 4. 将元素添加到 result 集合中
                    result.add(s);
                }
            }
        }
        System.out.println(result);
    }
}

如果我们使用的是 Stream 流的形式 , 那代码就会被简化成这个样子

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张四丰");
        list.add("张五");
        list.add("李四");
        list.add("王二麻子");

        // Stream 流的写法
        List<String> result = new ArrayList<>();
        list.stream()
                .filter(name -> name.startsWith("张"))
                .filter(name -> name.length() == 3)
                .forEach(name -> System.out.println(name));
    }
}

那我们通过这个案例就可以看出 Stream 流的作用就是针对集合进行功能简化开发 , 并且 Stream 流的使用通常需要搭配 Lambda 表达式来使用 .

那 Stream 流我们就可以理解成流水线的过程 , 一步一步地筛选掉不满足条件的数据 .

那我们也可以得到 Stream 流的三类方法

  1. 获取 Stream 流 : 创建一条流水线 , 并把数据放到流水线上准备进行操作
  2. 中间方法 : 流水线上的操作 , 一次操作结束之后还可以继续进行其他操作
  3. 终结方法 : 一个 Stream 流只能有一个终结方法 , 是流水线上最后一道操作

二 . 获取 Stream 流对象

获取 Stream 流就是创建一条流水线 , 并把数据放到流水线上准备进行操作 .

2.1 单列集合

单列集合就是我们之前学习过的 Collection (List、Set …)

我们可以使用 Collection 接口中的默认方法 stream() 生成流

import java.util.ArrayList;
import java.util.stream.Stream;

public class Demo2 {
    public static void main(String[] args) {
        method01();
    }

    private static void method01() {
        // 单列集合
        ArrayList<String> list = new ArrayList<>();
        list.add("甄嬛");
        list.add("沈眉庄");
        list.add("安陵容");

        // 获取 Stream 对象
        // 直接调用 stream 方法即可
        Stream<String> stream = list.stream();
        // 打印 stream 流中的内容
        stream.forEach(s -> System.out.println(s));
    }
}

而我们一般情况下不会将 stream 流拆分开来写

import java.util.ArrayList;
import java.util.stream.Stream;

public class Demo2 {
    public static void main(String[] args) {
        method01();
    }

    private static void method01() {
        // 单列集合
        ArrayList<String> list = new ArrayList<>();
        list.add("甄嬛");
        list.add("沈眉庄");
        list.add("安陵容");

        // 获取 Stream 对象
        // 直接调用 stream 方法即可
        list.stream().forEach(s -> System.out.println(s));
    }
}

我们看一下运行结果

2.2 哈希表集合

哈希表集合需要间接的生成流 , 可以先通过 keySet 或者 entrySet 获取一个 Set 集合 , 再获取 Stream 流

import java.util.ArrayList;
import java.util.HashMap;
import java.util.stream.Stream;

public class Demo2 {
    public static void main(String[] args) {
        method02();
    }

    private static void method02() {
        // 双列集合
        HashMap<String, Integer> map = new HashMap<>();
        map.put("甄嬛", 18);
        map.put("沈眉庄", 19);
        map.put("安陵容", 20);

        // 获取 Stream 流
        // 双列集合不能直接获取 Stream 流
        // 先获取到所有的键, 再把这个 Set 集合中所有的键放到 Stream 流中
        map.keySet().stream().forEach(s -> System.out.println(s));// 打印出所有的键

        // 先获取到所有的键值对对象, 再把这个 Set 集合中所有的键值对对象都放到 Stream 流中
        map.entrySet().stream().forEach(s -> System.out.println(s));// 打印出所有的键值对对象
    }
}

运行一下 , 看一下效果

2.3 数组

数组可以通过 Arrays 中的静态方法 stream 生成流

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

public class Demo2 {
    public static void main(String[] args) {
        method03();
    }

    private static void method03() {
        // 数组
        int[] arr = {1, 2, 3, 4, 5};

        // 获取 Stream 流
        Arrays.stream(arr).forEach(s -> System.out.println(s));
    }
}

2.4 同种数据类型的多个元素

比如 :

  • 1 , 2 , 3 , 4 , 5 …
  • “aaa” , “bbb” , “ccc” , “ddd” …

我们需要使用 Stream.of(T… values) 生成流

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

public class Demo2 {
    public static void main(String[] args) {
        method04();
    }

    private static void method04() {
        // 同种数据类型的多个数据
        // 将同一类型的数据放到 of 中即可
        Stream.of(1, 2, 3, 4, 5, 6, 7, 8).forEach(s -> System.out.println(s));
    }
}

2.5 小结

单列集合 : 集合对象.stream()

双列集合 : 不能直接获取 , 需要间接获取

  • 获取键的集合 : 集合对象.keySet().stream();
  • 获取键值对的集合 : 集合对象.entrySet().stream();

数组 : Arrays.stream(数组名称)

同种数据类型的多个数据 : Stream.of(多个数据);

三 . 中间方法

中间方法指的就是流水线上的操作 . 一次操作完毕之后 , 还可以继续进行其他的操作 .

3.1 filter 方法

filter 方法用于对流中的数据进行过滤 . 对给定的参数进行判断 , 返回一个布尔值

3.1.1 匿名内部类

这种方式需要我们传入一个 Predicate 匿名内部类对象

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class Demo2 {
    public static void main(String[] args) {
        method05();
    }

    // 需求 : 筛选出姓张的用户
    private static void method05() {
        List<String> list = new ArrayList<>();
        list.add("张凯丽");
        list.add("张韶涵");
        list.add("张学友");
        list.add("李四");

        // 获取 Stream 流
        // 使用 filter 可以设置筛选条件
        // 这个方法需要我们传入一个 Predicate 匿名内部类对象
        list.stream().filter(
                // filter 方法获取流中的每一个数据
                // 而 test 方法中的 s, 就一次表示流中的每一个数据
                // 我们只需要在 test 方法中对 s 进行判断即可
                new Predicate<String>() {
                    @Override
                    public boolean test(String s) {
                        boolean result = s.startsWith("张");
                        return result;
                    }
                }
        ).forEach(s -> System.out.println(s));
    }
}

3.1.2 lambda 表达式

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class Demo2 {
    public static void main(String[] args) {
        method06();
    }

    // 需求 : 筛选出姓张的用户
    private static void method06() {
        List<String> list = new ArrayList<>();
        list.add("张凯丽");
        list.add("张韶涵");
        list.add("张学友");
        list.add("李四");

        // 获取 Stream 流
        // 使用 filter 可以设置筛选条件
        list.stream().filter(
                (String s) -> {
                    boolean result = s.startsWith("张");
                    return result;
                }
        ).forEach(s -> System.out.println(s));
    }

}

那我们还可以对这个 lambda 表达式进一步简化

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class Demo2 {
    public static void main(String[] args) {
        method06();
    }

    // 需求 : 筛选出姓张的用户
    private static void method06() {
        List<String> list = new ArrayList<>();
        list.add("张凯丽");
        list.add("张韶涵");
        list.add("张学友");
        list.add("李四");

        // 获取 Stream 流
        // 使用 filter 可以设置筛选条件
        list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));
    }
}

3.2 limit 方法

limit 方法是用来截取指定参数个数的数据

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class Demo2 {
    public static void main(String[] args) {
        method07();
    }

    private static void method07() {
        List<String> list = new ArrayList<>();
        list.add("张凯丽");
        list.add("张韶涵");
        list.add("张学友");
        list.add("张靓颖");
        list.add("张碧晨");
        list.add("张信哲");
        list.add("李四");
        list.add("王五");
        list.add("赵六");

        // 截取指定参数个数的数据
        list.stream().limit(2).forEach(s -> System.out.println(s));
    }
}

3.3 skip 方法

skip 方法是跳过指定参数个数的数据

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class Demo2 {
    public static void main(String[] args) {
        method07();
    }

    private static void method07() {
        List<String> list = new ArrayList<>();
        list.add("张凯丽");
        list.add("张韶涵");
        list.add("张学友");
        list.add("张靓颖");
        list.add("张碧晨");
        list.add("张信哲");
        list.add("李四");
        list.add("王五");
        list.add("赵六");

        // 跳过指定参数个数的数据
        // 去除前面的, 保留后面的
        list.stream().skip(2).forEach(s -> System.out.println(s));
    }
}

3.4 concat 方法

concat 方法是合并 a 和 b 两个流为一个流

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class Demo2 {
    public static void main(String[] args) {
        method07();
    }

    private static void method07() {
        List<String> list = new ArrayList<>();
        list.add("张凯丽");
        list.add("张韶涵");
        list.add("张学友");
        list.add("张靓颖");
        list.add("张碧晨");
        list.add("张信哲");
        list.add("李四");
        list.add("王五");
        list.add("赵六");

        List<String> list2 = new ArrayList<>();
        list2.add("张三丰");
        list2.add("张无忌");
        
        // 合并两个流为一个流
        Stream<String> stream1 = list.stream();
        Stream<String> stream2 = list2.stream();
        Stream<String> concat = Stream.concat(stream1, stream2);
        concat.forEach(s -> System.out.println(s));

    }
}

那我们还可以进行简写

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class Demo2 {
    public static void main(String[] args) {
        method07();
    }

    private static void method07() {
        List<String> list = new ArrayList<>();
        list.add("张凯丽");
        list.add("张韶涵");
        list.add("张学友");
        list.add("张靓颖");
        list.add("张碧晨");
        list.add("张信哲");
        list.add("李四");
        list.add("王五");
        list.add("赵六");

        // 截取指定参数个数的数据
        // 保留前面的, 去除后面的
        // list.stream().limit(2).forEach(s -> System.out.println(s));

        // 跳过指定参数个数的数据
        // 去除前面的, 保留后面的
        // list.stream().skip(2).forEach(s -> System.out.println(s));

        List<String> list2 = new ArrayList<>();
        list2.add("张三丰");
        list2.add("张无忌");
        // 合并两个流为一个流
        Stream.concat(list.stream(), list2.stream()).forEach(s -> System.out.println(s));
    }

3.5 distinct 方法

distinct 方法用来去除流中重复的元素 , 底层依赖 hashCode 方法和 equals 方法

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class Demo2 {
    public static void main(String[] args) {
        method08();
    }

    private static void method08() {
        List<String> list = new ArrayList<>();
        list.add("张凯丽");
        list.add("张韶涵");
        list.add("张学友");
        list.add("张靓颖");
        // 设置一些重复数据
        list.add("张三");
        list.add("张三");
        list.add("张三");
        list.add("张三");

        // 去除流中重复的元素
        // 底层依赖 hashCode 和 equals 实现的
        list.stream().distinct().forEach(s -> System.out.println(s));
    }
}

四 . 终结方法

一个 Stream 流只能有一个终结方法

常见的终结操作方法如下 :

  • forEach : 对流中的每个元素进行操作
  • count : 返回流中的元素数量

4.1 forEach 方法

forEach 最基础的方法的形参是一个 Consumer 匿名内部类

我们还可以使用 lambda 表达式来进行缩写

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class Demo2 {
    public static void main(String[] args) {
        method09();
    }

    private static void method09() {
        List<String> list = new ArrayList<>();
        list.add("张凯丽");
        list.add("张韶涵");
        list.add("张学友");
        list.add("张靓颖");
        list.add("李四");
        list.add("王五");
        list.add("赵六");

        list.stream().forEach(new Consumer<String>() {
            // 在 forEach 方法的底层, 会循环获取到流中的每个数据, 并循环调用 accept 方法, 将每一个数据传递给 accept 方法
            // s 就依次表示了流中的每一个数据
            @Override
            public void accept(String s) {
                // 对数据的处理可以直接写到 accept 方法中
                System.out.println(s);
            }
        });

        // lambda 表达式简写
        list.stream().forEach(
                (String s) -> {
                    System.out.println(s);
                }
        );

        // lambda 表达式更进一步简写
        list.stream().forEach(s -> System.out.println(s));
    }
}

4.2 count 方法

count 方法用于返回流中的元素个数

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class Demo2 {
    public static void main(String[] args) {
        method10();
    }

    private static void method10() {
        List<String> list = new ArrayList<>();
        list.add("张凯丽");
        list.add("张韶涵");
        list.add("张学友");
        list.add("张靓颖");
        list.add("李四");
        list.add("王五");
        list.add("赵六");

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

五 . 收集操作

需求 : 过滤元素并遍历集合

我们定义一个集合 , 并且添加一些整数 1、2、3、4、5、6、7、8、9、10 .

将集合中的奇数删除 , 只保留偶数 .

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class Demo2 {
    public static void main(String[] args) {
        method11();
    }

    // 我们定义一个集合, 并且添加一些整数 1、2、3、4、5、6、7、8、9、10 .
    // 将集合中的奇数删除, 只保留偶数 .
    private static void method11() {
        List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));

        // 基本写法
        list.stream().filter(
                // 参数为 Integer 类型
                (Integer i) -> {
                    // 在这个位置设置条件
                    return i % 2 == 0;
                }
        );

        // 简化写法
        list.stream().filter(num -> num % 2 == 0).forEach(num -> System.out.println(num));
    }
}

但是我们此时打印一下原来的集合

结论 : 在 Stream 流中无法直接修改集合、数组等数据源中的数据 .

但是如果我们使用 Stream 流的方式操作完毕之后 , 那我还想把流中的数据保存起来 , 该怎么办呢 ?

我们需要使用 Collectors 这个工具类

  • toList() : 把元素收集到 List 集合中
  • toSet() : 把元素收集到 Set 集合中
  • toMap() : 把元素收集到 Map 集合中
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Demo2 {
    public static void main(String[] args) {
        method12();
    }

    private static void method12() {
        // 10 这个数据是重复的
        List<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10));

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

        // Collectors.toSet() 在底层会创建一个 Set 集合, 并且把所有的数据添加到 Set 集合中
        Set<Integer> list3 = list1.stream().filter(num -> num % 2 == 0).collect(Collectors.toSet());
        System.out.println(list3);
    }
}

我们看一下运行结果

对于 Java8 中的 Stream 流的介绍就到这里 , 如果对你有帮助的话 , 还请一键三连支持~
在这里插入图片描述

加勒比海涛
关注
专栏目录
Java编程语言中的数据结构与算法：深入理解与实践指南.zip
09-15
- 大数据处理：使用流式处理（Stream API）和并行计算，提升大数据操作的效率。 5. 进阶话题： - 图形算法：如Dijkstra最短路径算法、Floyd-Warshall所有最短路径算法等。 - 字符串匹配：KMP算法、Boyer-Moore...
Java8 Stream：2万字20个实例，玩转集合的筛选、归约、分组、聚合
好好学java
11-13 4492
点击上方好好学java，选择星标公众号重磅资讯、干货，第一时间送达 今日推荐：硬刚一周，3W字总结，一年的经验告诉你如何准备校招！ 个人原创100W+访问量博客：点击前往，查...
Java8-Stream流处理
Juses_331的博客
07-31 2428
Java8中的Stream是对与集合对象有所加强的新特性，专注于集合对象进行各种非常便利，高效的聚合操作，同时提供串行与并行两种模式的汇聚操作，使用了fork/join并行方式来拆分任务、加速处理过程。注意，这里的stream与原先的文件I/O流没有必然关系，是在Java8中的新内容。Stream有时类似于一个迭代器，但是相比原来的Iterator串行命令式的执行过程，stream通过并行方式去便利
Java8Stream（高效处理集合数据）
小谷同学的博客
05-19 1121
java8stream是处理数据集合，遍历数据集的高级迭代器，有助于提高我们写代码的效率！
Java8 Stream流处理 详细使用讲解
羽觞醉月11的博客
01-14 4439
一、stream概要与使用场景 首先，Java8中的stream与InputStream和OutputStream是完全不同的概念，stream是用于对集合迭代器的增强，使之能够完成更高效的聚合操作（过滤、排序、统计分组）或大批量数据操作，使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。 此外，stream与lambda表达式结合后编码效率大大提高，并且可读性更强。 首先来看一个例子： 创建一个学生列表，填入不同的数据进行模拟，实际的业务中肯定要比这
Java8使用Streams处理数据
Scnu_wang的博客
05-02 3431
–使用流操作来表达复杂的数据处理查询。 没有收藏会怎么办？几乎每个Java应用程序都会生成并处理集合。它们是许多编程任务的基础：它们允许您分组和处理数据。例如，您可能需要创建一个集合来表示客户在银行的交易。然后，您可能想要处理整个集合，以了解客户花费了多少钱。尽管它们的重要性，但处理集合在Java方面远非完美。 首先，集合上的典型处理模式类似于SQL的操作，例如“查找”（例如，找到具有最高价值的
掌握Java 8 Stream API的艺术：详解流式编程
学而时习之，不亦说乎？温故而知新，可以为师矣！
10-14 772
本文将深入讲解Java 8中引入的Stream API，这是一种强大的函数式编程工具，用于处理集合数据。我们将从基础概念开始，逐步深入到高级应用，包括过滤、映射、归约等各种操作。通过清晰的例子和详尽的解释，读者将全面了解Stream API的使用方法、优势和实际应用。无论您是初学者还是有经验的开发者，这篇博客都将成为您学习和掌握Java 8 Stream API的绝佳指南。
Java8 Stream API 详细使用指南
热门推荐
LoveSummer
07-02 1万+
Java 8 引入的一个重要的特性无疑是 Stream API。Stream 翻译过来是“流”，突然想到的是大数据处理有个流式计算的概念，数据通过管道经过一个个处理器（Handler）进行筛选，聚合，而且流都具有向量性，强调的是对数据的计算处理，而集合强调的是数据集。Stream可以看做是一个可操作的数据集序列，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。有点类似于数据库中的增删改查操作。十分高效而且易于使用。从不同的数据源创建流有很多方式。 被创建的流并不能改变数据源。
Java Stream流指南：优雅处理集合数据
buhuisuanfa的博客
02-28 2909
1.Stream流的作用：结合了Lambda表达式，简化集合、数组的操作获取Stream流对象使用中间方法处理数据使用终结方法处理数据3.如何获取Stream流对象单列集合：Collection中默认的stream方法双列集合：不能直接获取，需要先转为单列集合去获取数据：Arrays工具类中的stream静态方法零散数据：Stream接口中的of静态方法4.常见方法中间方法：filter、limit、skip、distinct、concat、map。
Java8 Stream API 使用指南
u013452337的博客
08-30 225
1. 概述 Java 8 引入的一个重要的特性无疑是 Stream API。Stream 翻译过来是“流”，突然想到的是大数据处理有个流式计算的概念，数据通过管道经过一个个处理器（Handler）进行筛选，聚合，而且流都具有向量性，强调的是对数据的计算处理，而集合强调的是数据集。Stream可以看做是一个可操作的数据集序列，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据...
【流式处理对比】：Google Guava与Java 8协同工作指南（性能优化秘籍）
[【流式处理对比】：Google Guava与Java 8协同工作指南（性能优化秘籍）](https://res.cloudinary.com/practicaldev/image/fetch/s--VU-f44qm--/c_imagga_scale,f_auto,fl_progressive,h_420,q_auto,w_1000/...
字符串转数组：Java流式处理与传统方法的对决
[字符串转数组：Java流式处理与传统方法的对决](https://img-blog.csdnimg.cn/bc97b2fd98934bfb84c42f0671dbca18.png) # 1. 字符串转数组的概念与重要性 在现代编程实践中，对数据的操作无处不在。尤其是字符串的...
XML与RESTful API构建指南：Java中使用XML开发服务的最佳实践
![java 各种xml解析常用库介绍与使用]...XML广泛用于Web服务，如RESTful API中数据交换格式，因其具有良好的跨平台性和人类可读性。 ## 1.2 RESTful API概述 代表性
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 737
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 668
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
spring-boot 整合 mybatis
m0_72168501的博客
09-29 486
spring boot 整合 mybatis
Java内存布局
最新发布
阿呆的专栏
10-01 764
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 314
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
Java8 Stream全解析：实例演示与高效应用
Stream自Java 8版本以来，作为一种全新的编程范式，为处理数据集合提供了强大的工具。它允许开发者以声明式的方式对集合进行操作，使得代码更加简洁高效。 首先，Stream是一个接口，其核心理念是提供了一种处理集合...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

加勒比海涛

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值