首页 > 编程开发 > Java

Java8进行多个字段分组统计的实例代码

来自：互联网
时间：2020-05-26
阅读：

Java8进行多个字段分组统计实现代码如下：

// 分组统计
Map<String, Long> countMap = records.stream().collect(Collectors.groupingBy(o -> o.getProductType() + "_" + o.getCountry(), Collectors.counting()));
 
List<Record> countRecords = countMap.keySet().stream().map(key -> {
  String[] temp = key.split("_");
  String productType = temp[0];
  String country = temp[1];
   
  Record record = new Record();
  record.set("device_type", productType);
  record.set("location", country;
  record.set("count", countMap.get(key).intValue());
  return record;
}).collect(Collectors.toList());

实例补充：

1.本实例其实可以用一句简单的sql去实现 由于我们项目数据库中时间存的是13位的时间戳 所以必须得转行成日期格式 才能进行分组 如下：

SELECT
    count(1) simpleNumber,
    SUM(penalty_amount) AS simplePenaltyAmount,
    Handling_department,
    create_time,
LEFT(FROM_UNIXTIME(LEFT(create_time,10)),7)
FROM
    t_case_simple_case
WHERE
    1 = 1
GROUP BY Handling_department,LEFT(FROM_UNIXTIME(LEFT(create_time,10)),7)

以上的就能实现多字段求和统计等功能 但我们老大考虑到查询速度和换库等问题 建议我不要用FROM_UNIXTIME（）函数，所以只能用最笨的方法一步步实现 以下是用Java8方式实现的 代码如下：

@Override
public List<StatisticalAnalysis> queryFirstCase(String startTime,String condition,String caseType) {
  List<StatisticalAnalysis> statisticalAnalyses = null;
  //简易案件
  if (caseType.equals(CaseTypeEnum.SIMPLETYPE.code())) {
    statisticalAnalyses = statisticalAnalysisDao.querySimpleData();
  }
  //一般案件
  if (caseType.equals(CaseTypeEnum.NORMALTYPE.code())) {
    statisticalAnalyses = statisticalAnalysisDao.queryNormalData();
  }
  for (StatisticalAnalysis analysis : statisticalAnalyses) {
    try {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
      String newCreateTime = sdf.format(new Date(Long.valueOf(analysis.getCreateTime())));
      analysis.setCreateTime(newCreateTime);
      SysOrg sysOrg = commonSearchDao.findByOrgId(analysis.getHandlingDepartment());
      if (sysOrg != null) {
        analysis.setHandlingDepartmentName(sysOrg.getOrgName());
      }
      if(analysis.getSimplePenaltyAmount()==null){
        analysis.setSimplePenaltyAmount(0.0);
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
  List<StatisticalAnalysis> caseTotalList = new ArrayList<>();
  //根据部门 日期进行分组 统计
  Map<String, Map<String, Long>> caseTotal = statisticalAnalyses.stream().collect(Collectors.groupingBy(StatisticalAnalysis::getCreateTime, Collectors.groupingBy(StatisticalAnalysis::getHandlingDepartmentName, Collectors.counting())));
  //根据部门 日期进行分组 求和
  Map<String, Map<String, Double>> sumCase = statisticalAnalyses.stream().collect(Collectors.groupingBy(StatisticalAnalysis::getCreateTime, Collectors.groupingBy(StatisticalAnalysis::getHandlingDepartmentName, Collectors.summingDouble(StatisticalAnalysis::getSimplePenaltyAmount))));
  //根据年份进行模糊匹配 取出对应的统计值
  for (Map.Entry<String, Map<String, Long>> entry : caseTotal.entrySet()) {
    if (entry.getKey().indexOf(startTime) > -1) {
      StatisticalAnalysis statisticalAnalysis = new StatisticalAnalysis();
      statisticalAnalysis.setCreateTime(entry.getKey());
      //将年份-去掉  组成新的数字  主要作为排序
      String key = entry.getKey().replace("-", "");
      Integer sortNum = Integer.parseInt(key);
      statisticalAnalysis.setSortNum(sortNum);
      Map<String, Long> map = entry.getValue();
      for (Map.Entry<String, Long> entr : map.entrySet()) {
        statisticalAnalysis.setHandlingDepartmentName(entr.getKey());
        statisticalAnalysis.setSimpleNumber(entr.getValue());
      }
      caseTotalList.add(statisticalAnalysis);
    }
  }
  caseTotalList.sort((a, b) -> a.getSortNum() - b.getSortNum());
  //根据年份进行模糊匹配 取出对应的求和值
  List<StatisticalAnalysis> analyses = new ArrayList<>();
  for (Map.Entry<String, Map<String, Double>> entry : sumCase.entrySet()) {
    if (entry.getKey().indexOf(startTime) > -1) {
      StatisticalAnalysis statisticalAnalysis = new StatisticalAnalysis();
      statisticalAnalysis.setCreateTime(entry.getKey());
      //将年份-去掉  组成新的数字  主要作为排序
      String key = entry.getKey().replace("-", "");
      Integer sortNum = Integer.parseInt(key);
      statisticalAnalysis.setSortNum(sortNum);
      Map<String, Double> map = entry.getValue();
      for (Map.Entry<String, Double> entr : map.entrySet()) {
        statisticalAnalysis.setHandlingDepartmentName(entr.getKey());
        statisticalAnalysis.setSimplePenaltyAmount(entr.getValue());
      }
      analyses.add(statisticalAnalysis);
    }
  }

  analyses.sort((a, b) -> a.getSortNum() - b.getSortNum());
  //将统计和求和组合成一个新的集合返回前端
  List<StatisticalAnalysis> analysisList = new ArrayList<>();
  for (StatisticalAnalysis analys : caseTotalList) {
    for (StatisticalAnalysis analys2 : analyses) {
      StatisticalAnalysis statisticalAnalysis = new StatisticalAnalysis();
      if (analys.getSortNum().intValue() == analys2.getSortNum().intValue()) {
        statisticalAnalysis.setSimpleNumber(analys.getSimpleNumber());
        statisticalAnalysis.setSimplePenaltyAmount(analys2.getSimplePenaltyAmount());
        statisticalAnalysis.setCreateTime(analys.getCreateTime());
        statisticalAnalysis.setHandlingDepartmentName(analys.getHandlingDepartmentName());
        analysisList.add(statisticalAnalysis);
      }
    }
  }
  List<StatisticalAnalysis> newAnalysisList = new ArrayList<>();
  if (analysisList.size() > 0) {
    //查询第一季度
    if (condition.equals(YearEnum.FIRST.code())) {
      for (StatisticalAnalysis analysis : analysisList) {
        StatisticalAnalysis analysis1 = new StatisticalAnalysis();
        if (analysis.getCreateTime().indexOf(startTime + "-01") > -1) {
          BeanUtils.copyProperties(analysis, analysis1);
          if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
            analysis1.setTitle(startTime+YearEnum.FIRST.desc()+"各部门简易案件");
          }else{
            analysis1.setTitle(startTime+YearEnum.FIRST.desc()+"各部门一般案件");
          }
          newAnalysisList.add(analysis1);
        }
        if (analysis.getCreateTime().indexOf(startTime + "-02") > -1) {
          BeanUtils.copyProperties(analysis, analysis1);
          if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
            analysis1.setTitle(startTime+YearEnum.FIRST.desc()+"各部门简易案件");
          }else{
            analysis1.setTitle(startTime+YearEnum.FIRST.desc()+"各部门一般案件");
          }
          newAnalysisList.add(analysis1);
        }
        if (analysis.getCreateTime().indexOf(startTime + "-03") > -1) {
          BeanUtils.copyProperties(analysis, analysis1);
          if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
            analysis1.setTitle(startTime+YearEnum.FIRST.desc()+"各部门简易案件");
          }else{
            analysis1.setTitle(startTime+YearEnum.FIRST.desc()+"各部门一般案件");
          }
          newAnalysisList.add(analysis1);
        }
      }
      return newAnalysisList;
  }
  //查询第二季度
  if (condition.equals(YearEnum.SECOND.code())) {
    for (StatisticalAnalysis analysis : analysisList) {
      StatisticalAnalysis analysis1 = new StatisticalAnalysis();
      if (analysis.getCreateTime().indexOf(startTime + "-04") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.SECOND.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.SECOND.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
      if (analysis.getCreateTime().indexOf(startTime + "-05") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.SECOND.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.SECOND.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
      if (analysis.getCreateTime().indexOf(startTime + "-06") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.SECOND.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.SECOND.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
    }
    return newAnalysisList;
  }
  //查询第三季度
  if (condition.equals(YearEnum.THREE.code())) {
    for (StatisticalAnalysis analysis : analysisList) {
      StatisticalAnalysis analysis1 = new StatisticalAnalysis();
      if (analysis.getCreateTime().indexOf(startTime + "-07") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.THREE.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.THREE.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
      if (analysis.getCreateTime().indexOf(startTime + "-08") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.THREE.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.THREE.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
      if (analysis.getCreateTime().indexOf(startTime + "-09") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.THREE.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.THREE.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
    }
    return newAnalysisList;
  }
  //查询第四季度
  if (condition.equals(YearEnum.FOUR.code())) {
    for (StatisticalAnalysis analysis : analysisList) {
      StatisticalAnalysis analysis1 = new StatisticalAnalysis();
      if (analysis.getCreateTime().indexOf(startTime + "-10") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.FOUR.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.FOUR.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
      if (analysis.getCreateTime().indexOf(startTime + "-11") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.FOUR.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.FOUR.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
      if (analysis.getCreateTime().indexOf(startTime + "-12") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.FOUR.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.FOUR.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
    }
    return newAnalysisList;
  }
  //查询上半年 取前六条数据
  if (condition.equals(YearEnum.HALF.code())) {
    for (StatisticalAnalysis analysis : analysisList) {
      StatisticalAnalysis analysis1 = new StatisticalAnalysis();
      if (analysis.getCreateTime().indexOf(startTime + "-01") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.HALF.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.HALF.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
      if (analysis.getCreateTime().indexOf(startTime + "-02") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.HALF.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.HALF.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
      if (analysis.getCreateTime().indexOf(startTime + "-03") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.HALF.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.HALF.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
      if (analysis.getCreateTime().indexOf(startTime + "-04") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.HALF.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.HALF.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
      if (analysis.getCreateTime().indexOf(startTime + "-05") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.HALF.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.HALF.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
      if (analysis.getCreateTime().indexOf(startTime + "-06") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.HALF.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.HALF.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
    }
    return newAnalysisList;
  }
  //查询下半年 后六条数据
  if (condition.equals(YearEnum.LASTHALF.code())) {
    for (StatisticalAnalysis analysis : analysisList) {
      StatisticalAnalysis analysis1 = new StatisticalAnalysis();
      if (analysis.getCreateTime().indexOf(startTime + "-07") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.LASTHALF.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.LASTHALF.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
      if (analysis.getCreateTime().indexOf(startTime + "-08") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.LASTHALF.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.LASTHALF.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
      if (analysis.getCreateTime().indexOf(startTime + "-09") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.LASTHALF.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.LASTHALF.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
      if (analysis.getCreateTime().indexOf(startTime + "-10") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.LASTHALF.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.LASTHALF.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
      if (analysis.getCreateTime().indexOf(startTime + "-11") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.LASTHALF.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.LASTHALF.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
      if (analysis.getCreateTime().indexOf(startTime + "-12") > -1) {
        BeanUtils.copyProperties(analysis, analysis1);
        if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
          analysis1.setTitle(startTime+YearEnum.LASTHALF.desc()+"各部门简易案件");
        }else{
          analysis1.setTitle(startTime+YearEnum.LASTHALF.desc()+"各部门一般案件");
        }
        newAnalysisList.add(analysis1);
      }
    }
    return newAnalysisList;
  }
  if (condition.equals(YearEnum.FULLYEAR.code())) {
    for (StatisticalAnalysis analysis : analysisList) {
      if(caseType.equals(CaseTypeEnum.SIMPLETYPE.code())){
        analysis.setTitle(startTime+YearEnum.FULLYEAR.desc()+"各部门简易案件");
      }else{
        analysis.setTitle(startTime+YearEnum.FULLYEAR.desc()+"各部门一般案件");
      }
    }
    return analysisList;
  }
}
  return null;
}
最新文章 相关文章

MapStructPlus 1.4.0 发布，体积更轻量！性能更强！

MapStruct Plus 是 MapStruct 的增强工具，在 Mapstruct 的基础上，实现了自动生成 Mapper 接口的功能，并强化了部分功能，使 Java 类型转换更加便捷、优雅。MapStructPlus官网此次

2024-03-17 01:39:15

JVM内存结构

我们都知道，我们写的Java程序需要先经过编译，生成了.class文件（字节码文件）。然而，计算机并不能直接解释.class文件里面的内容，这时候就需要一个能加载、解释.class文件并且能按.c

2024-03-15 20:58:13

Spring状态机（FSM），让订单状态流转如丝般顺滑

引言在复杂的应用程序设计中，尤其是那些涉及多个状态变迁和业务流程控制的场景，有限状态机（Finite State Machine, FSM）是一种强大而有效的建模工具。Spring框架为此提供了Sprin

2024-03-12 12:05:41

『Java 语法基础』面向对象有哪些特性

面向对象编程（OOP） 是一个将现实世界抽象为一系列对象的编程范式，这些对象通过消息传递机制来互相交流和协作。OOP 的主要特性包括四个基本概念：封装（Encapsulation）、继承（Inherit

2024-03-11 18:44:45

Spring动态定时任务之ScheduledTaskRegistrar

前言​ 在做SpringBoot项目的过程中，有时客户会提出按照指定时间执行一次业务的需求。​ 如果客户需要改动业务的执行时间，即动态地调整定时任务的执行时间，那么可以采用Spring

2024-03-11 18:39:05

分享 Java 开发中常用到的设计模式

前言不知道大家在开发的时候，有没有想过（遇到）这些问题： 大家都是按需要开发，都是一个职级的同事，为什么有些人的思路就很清晰，代码也很整洁、易懂；而自己开发，往往不知道怎么下手设

2024-03-11 18:38:21

Java 实际开发中积累的几个小技巧

目录 前言 一、枚举类的注解 二、RESTful 接口 三、类属性转换 四、Stream 流 五、判空和断言 5.1判空部分 5.2断言部分 文章小结 前言笔者目前从事一线 Java 开发今年

2024-03-11 18:37:52

Java 互联网项目如何防止集合堆内存溢出（一）

目录 前言 一、代码优化 1.1Stream 流自分页 1.2数据库分页 1.3其它思考 二、硬件配置 2.1云服务器配置 三、文章小结 前言OOM 几乎是笔者工作中遇到的线上 bug 中

2024-03-11 18:37:25

日常工作中关于 JSON 转换的经验大全（Java）

目录 前言 一、JSON 回顾 1.1结构形式 二、其它类型 -> JSON相关 2.1 JavaBean 转 JsonObject 2.2 JavaBean 转 Json 字符串 2.3 List 转 JsonArray 2.4 List 转Jso

2024-03-11 18:36:19

从零开始学Spring Boot系列-集成mybatis

在Spring Boot的应用开发中，MyBatis是一个非常流行的持久层框架，它支持定制化SQL、存储过程以及高级映射。在本篇文章中，我们将学习如何在Spring Boot项目中集成MyBatis，以便通

2024-03-11 00:05:13

Jpackage-制作无需预装Java环境的Jar可执行程序

JAR 包要在预装 JRE 环境的系统上执行。如果没有预先安装 JRE 环境，又想直接运行 Java 程序，该怎么办呢？这篇文章我们会先学习如何将 Java 程序打包成一个可执行的 Java JAR 文

2024-03-08 22:43:01

Java 8 Supplier函数式接口介绍及代码样例

介绍供应商接口（Supplier Interface）是 Java 8 引入的 java.util.function 包的一部分，用于在 Java 中实现函数式编程。它表示一个函数，该函数不接收任何参数，但会产生一个类型为

2024-03-08 22:31:58

Java核心之细说泛型

泛型是什么？等你使用java逐渐深入以后会了解或逐步使用到Java泛型。Java 中的泛型是 JDK 5 中引入的功能之一。"Java 泛型 "是一个技术术语，表示一组与定义和使用泛型类型和方

2024-03-08 22:30:26

从零开始搭建Springboot开发环境(Java8+Git+Maven+MySQL+Idea)之一步到位

说明所谓万事开头难，对于初学Java和Springboot框架的小伙伴往往会花不少时间在开发环境搭建上面。究其原因其实还是不熟悉，作为在IT界摸爬滚打数年的老司机，对于各种开发环境搭

2024-03-07 01:02:41

接口 vs. 抽象类：揭开 Java 世界中的神秘面纱

小编带您揭开Java世界中的神秘面纱：接口与抽象类。面向对象编程中，接口与抽象类是常用的概念，但它们的区别与应用场景常让人困惑。通过本文，您将了解到接口与抽象类的定义、特点

2024-03-05 23:25:48

解密MyBatis操作过程：深入探讨ORM框架的关键原理

ORM（Object-Relational Mapping）是一种将对象模型和关系数据库之间的映射的技术，它让我们可以通过面向对象的方式操作数据库，避免了繁琐的SQL语句编写，提高了开发效率。MyBatis是

2024-03-05 23:25:29

Java Lambda 表达式与传统编程范式的比较：函数式编程的优势与劣势

Java Lambda 表达式简介Java Lambda表达式是Java 8引入的函数式编程特性，与传统编程范式相比，具有独特的优势和劣势。通过Lambda表达式，Java可以更简洁地实现函数式编程，提高代

2024-03-05 23:25:10

Lambda表达式在Java中的奇妙之旅：函数式编程的实践指南！

php小编西瓜带你探索Lambda表达式在Java中的奇妙之旅！本文将为您提供函数式编程的实践指南，深入剖析Lambda表达式在Java中的应用场景和优势，帮助您更好地理解和运用这一强大的

2024-03-05 23:24:50

Java JNDI 性能优化技巧：如何提高 Java JNDI 的性能和效率

1. 使用连接池Java JNDI（Java Naming and Directory Interface）是Java中用于访问命名和目录服务的API。在实际开发中，优化Java JNDI性能是非常重要的，可以提高系统的效率和响应

2024-03-05 23:24:31

Java JNDI 与 Spring 集成的秘诀：揭秘 Java JNDI 与 Spring 框架的无缝协作

Java JNDI 与 spring 集成的优势php小编西瓜带你揭秘Java JNDI与Spring框架的无缝协作。Java Naming and Directory Interface（JNDI）是Java平台提供的一种API，可用于访问各种命

2024-03-05 23:24:12

深度探究MyBatis的一对多查询配置：灵活运用关联查询

MyBatis是一个优秀的持久层框架，它不仅简化了数据库操作，还提供了强大的查询功能。在实际开发中，经常会涉及到多表关联查询的情况，而MyBatis通过配置一对多查询可以轻松实现这种

2024-03-05 23:23:51

深入解析MyBatis一对多查询配置：提升SQL语句执行效率

MyBatis是一款非常流行的持久层框架，其灵活的SQL映射和强大的查询功能使得开发人员可以轻松地处理复杂的数据操作。在实际开发中，经常会遇到一对多查询的场景，即一个主体对象对

2024-03-05 23:23:34

一文讲明白Java中线程与进程、并发与并行、同步与异步

写在开头ok，everybody，在过去的两周内，我们大体上讲完了Java的集合，在最后我们探讨了关于HashMap线程不安全的原因，又提出了ConcurrentHashMap这个线程安全的集合解决方案，那么在

2024-03-05 23:09:48

从零开始学Spring Boot系列-前言

在数字化和信息化的时代，Java作为一种成熟、稳定且广泛应用的编程语言，已经成为构建企业级应用的首选。而在Java生态系统中，Spring框架无疑是其中最为耀眼的一颗明星。它提供了

2024-03-03 22:52:19

在 Spring Boot 3.x 中使用 SpringDoc 2 / Swagger V3

SpringDoc V1 只支持到 Spring Boot 2.xspringdoc-openapi v1.7.0 is the latest Open Source release supporting Spring Boot 2.x and 1.x.Spring Boot 3.x 要用 SpringDo

2024-03-01 20:25:28

Java HashMap 详解

HashMapHashMap 继承自 AbstractMap，实现了 Map 接口，基于哈希表实现，元素以键值对的方式存储，允许键和值为 null。因为 key 不允许重复，因此只能有一个键为 null。HashMap 不能

2024-03-01 00:00:17

Java异常处理的20个最佳实践：告别系统崩溃

引言在Java编程中，异常处理是一个至关重要的环节，它不仅涉及到程序的稳定性和安全性，还关系到用户体验和系统资源的合理利用。合理的异常处理能够使得程序在面对不可预知错误时

2024-02-29 23:57:29

阿里面试：Java开发中，应如何避免OOM

Java内存管理：避免OOM的10个实用小技巧引言在Java开发中，OutOfMemoryError（OOM）错误一直是令开发者头疼的问题，也是Java面试中出现核心频率很高的问题。
那么我们究竟怎么样才能

2024-02-29 23:56:58

从零开始学Spring Boot系列-返回json数据

欢迎来到从零开始学Spring Boot的旅程！在Spring Boot中，返回JSON数据是很常见的需求，特别是当我们构建RESTful API时。我们对上一篇的Hello World进行简单的修改。 添加依赖

2024-02-29 14:29:20

Java面向对象之内部类的几类使用场景

介绍Java内部类是一种特殊的类，它定义在另一个类的内部。内部类提供了许多有用的特性，包括访问外部类的私有成员、隐藏实现细节以及实现回调接口等。以下是Java内部类的一些常

2024-02-28 16:28:06

热点内容

IDEA 2020.3最新永久激活码(免费激活到 2099 年,亲测有效)
2021-02-06
IDEA2020.2.2激活与IntelliJ IDEA2020注册码及IntelliJ全家桶激活码的详细教程(有你足
2020-09-18
解决IDEA 2020.3 lombok失效问题
2020-12-12
springboot yml定义属性,下文中${} 引用说明
2020-05-05
java怎么判断两个集合之间是否有交集
2020-11-20
Java8使用stream实现list中对象属性的合并（去重并求和）
2021-01-09
mybatis-plus 版本不兼容问题的解决
2020-09-25
基于redis setIfAbsent的使用说明
2021-02-06
关于IDEA中spring-cloud-starter-alibaba-nacos-discovery 无法引入问题
2021-03-07
java简短表白代码是什么
2020-09-27
返回顶部
顶部