This tutorial shows how to use following aggregation methods of CriteriaBuilder:

package javax.persistence.criteria;
 .....
public interface CriteriaBuilder {
 .....
   //aggregate functions:
    <N extends Number> Expression<Double> avg(Expression<N> x);
    <N extends Number> Expression<N> sum(Expression<N> x);
    Expression<Long> sumAsLong(Expression<Integer> x);
    Expression<Double> sumAsDouble(Expression<Float> x);
    <N extends Number> Expression<N> max(Expression<N> x);
    <N extends Number> Expression<N> min(Expression<N> x);
    <X extends Comparable<? super X>> Expression<X> greatest(Expression<X> x);
    <X extends Comparable<? super X>> Expression<X> least(Expression<X> x);
    Expression<Long> count(Expression<?> x);
    Expression<Long> countDistinct(Expression<?> x);
 .....
}	

The methods greatest() and least() are used for Comparables (Date, String, Number etc) whereas other methods are used for only a Number type.

Quick Example

  CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
  CriteriaQuery<Double> query = criteriaBuilder.createQuery(Double.class);
  Root<Employee> employee = query.from(Employee.class);
  query.select(criteriaBuilder.avg(employee.get(Employee_.salary)));
  TypedQuery<Double> typedQuery = entityManager.createQuery(query);
  Double average = typedQuery.getSingleResult();

Examples

Entity

@Entity
public class Employee {
  @Id
  @GeneratedValue
  private long id;
  private String name;
  private long salary;
  private LocalDate joinDate;
    .............
}

Using aggregate methods

public class ExampleMain {
  private static EntityManagerFactory entityManagerFactory =
          Persistence.createEntityManagerFactory("example-unit");

  public static void main(String[] args) {
      try {
          persistEmployees();
          findEmployeeCount();
          findEmployeeAvgSalary();
          findEmployeeMaxSalary();
          findEmployeeMinSalary();
          findEmployeeSalariesSum();
          findOldestJoinDate();
          findNewestJoinDate();
          findGreatestNameAlphabetically();
          findLeastNameAlphabetically();

      } finally {
          entityManagerFactory.close();
      }
  }

  private static void findEmployeeCount() {
      System.out.println("-- Employee COUNT --");
      EntityManager entityManager = entityManagerFactory.createEntityManager();
      CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
      CriteriaQuery<Long> query = criteriaBuilder.createQuery(Long.class);
      Root<Employee> employee = query.from(Employee.class);
      query.select(criteriaBuilder.count(employee));
      TypedQuery<Long> typedQuery = entityManager.createQuery(query);
      Long count = typedQuery.getSingleResult();
      System.out.println(count);
      entityManager.close();
  }

  private static void findEmployeeAvgSalary() {
      System.out.println("-- Employee AVG Salary --");
      EntityManager entityManager = entityManagerFactory.createEntityManager();
      CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
      CriteriaQuery<Double> query = criteriaBuilder.createQuery(Double.class);
      Root<Employee> employee = query.from(Employee.class);
      query.select(criteriaBuilder.avg(employee.get(Employee_.salary)));
      TypedQuery<Double> typedQuery = entityManager.createQuery(query);
      Double average = typedQuery.getSingleResult();
      System.out.println(average);
      entityManager.close();
  }

  private static void findEmployeeMaxSalary() {
      System.out.println("-- Employee MAX Salary --");
      EntityManager entityManager = entityManagerFactory.createEntityManager();
      CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
      CriteriaQuery<Long> query = criteriaBuilder.createQuery(Long.class);
      Root<Employee> employee = query.from(Employee.class);
      query.select(criteriaBuilder.max(employee.get(Employee_.salary)));
      TypedQuery<Long> typedQuery = entityManager.createQuery(query);
      Long max = typedQuery.getSingleResult();
      System.out.println(max);
      entityManager.close();
  }

  private static void findEmployeeMinSalary() {
      System.out.println("-- Employee MIN Salary --");
      EntityManager entityManager = entityManagerFactory.createEntityManager();
      CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
      CriteriaQuery<Long> query = criteriaBuilder.createQuery(Long.class);
      Root<Employee> employee = query.from(Employee.class);
      query.select(criteriaBuilder.min(employee.get(Employee_.salary)));
      TypedQuery<Long> typedQuery = entityManager.createQuery(query);
      Long min = typedQuery.getSingleResult();
      System.out.println(min);
      entityManager.close();
  }

  private static void findEmployeeSalariesSum() {
      System.out.println("-- Employee SUM Salary --");
      EntityManager em = entityManagerFactory.createEntityManager();
      CriteriaBuilder criteriaBuilder = em.getCriteriaBuilder();
      CriteriaQuery<BigDecimal> query = criteriaBuilder.createQuery(BigDecimal.class);
      Root<Employee> employee = query.from(Employee.class);
      query.select(criteriaBuilder.sum(employee.get(Employee_.salary).as(BigDecimal.class)));
      TypedQuery<BigDecimal> typedQuery = em.createQuery(query);
      BigDecimal sum = typedQuery.getSingleResult();
      System.out.println(sum);
      em.close();
  }

  private static void findOldestJoinDate() {
      System.out.println("-- oldest join date --");
      EntityManager entityManager = entityManagerFactory.createEntityManager();
      CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
      CriteriaQuery<LocalDate> query = criteriaBuilder.createQuery(LocalDate.class);
      Root<Employee> employee = query.from(Employee.class);
      query.select(criteriaBuilder.least(employee.get(Employee_.joinDate)));
      TypedQuery<LocalDate> typedQuery = entityManager.createQuery(query);
      LocalDate least = typedQuery.getSingleResult();
      System.out.println(least);
      entityManager.close();
  }

  private static void findNewestJoinDate() {
      System.out.println("-- newest join date --");
      EntityManager entityManager = entityManagerFactory.createEntityManager();
      CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
      CriteriaQuery<LocalDate> query = criteriaBuilder.createQuery(LocalDate.class);
      Root<Employee> employee = query.from(Employee.class);
      query.select(criteriaBuilder.greatest(employee.get(Employee_.joinDate)));
      TypedQuery<LocalDate> typedQuery = entityManager.createQuery(query);
      LocalDate greatest = typedQuery.getSingleResult();
      System.out.println(greatest);
      entityManager.close();
  }


  private static void findGreatestNameAlphabetically() {
      System.out.println("-- greatest name alphabetically --");
      EntityManager entityManager = entityManagerFactory.createEntityManager();
      CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
      CriteriaQuery<String> query = criteriaBuilder.createQuery(String.class);
      Root<Employee> employee = query.from(Employee.class);
      query.select(criteriaBuilder.greatest(employee.get(Employee_.name)));
      TypedQuery<String> typedQuery = entityManager.createQuery(query);
      String greatest = typedQuery.getSingleResult();
      System.out.println(greatest);
      entityManager.close();
  }

  private static void findLeastNameAlphabetically() {
      System.out.println("-- least name alphabetically --");
      EntityManager entityManager = entityManagerFactory.createEntityManager();
      CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
      CriteriaQuery<String> query = criteriaBuilder.createQuery(String.class);
      Root<Employee> employee = query.from(Employee.class);
      query.select(criteriaBuilder.least(employee.get(Employee_.name)));
      TypedQuery<String> typedQuery = entityManager.createQuery(query);
      String least = typedQuery.getSingleResult();
      System.out.println(least);
      entityManager.close();
  }

  public static void persistEmployees() {
      Employee employee1 = Employee.create("Diana", 3000, LocalDate.of(1999, 6, 1));
      Employee employee2 = Employee.create("Rose", 4000, LocalDate.of(2005, 2, 1));
      Employee employee3 = Employee.create("Denise", 1500, LocalDate.of(2011, 1, 1));
      Employee employee4 = Employee.create("Mike", 2000, LocalDate.of(2007, 8, 1));
      EntityManager em = entityManagerFactory.createEntityManager();
      em.getTransaction().begin();
      em.persist(employee1);
      em.persist(employee2);
      em.persist(employee3);
      em.persist(employee4);
      em.getTransaction().commit();
      em.close();
      System.out.println("-- all employees --");
      System.out.println(employee1);
      System.out.println(employee2);
      System.out.println(employee3);
      System.out.println(employee4);
  }
}

-- all employees --
Employee{id=1, name='Diana', salary=3000, joinDate=1999-06-01}
Employee{id=2, name='Rose', salary=4000, joinDate=2005-02-01}
Employee{id=3, name='Denise', salary=1500, joinDate=2011-01-01}
Employee{id=4, name='Mike', salary=2000, joinDate=2007-08-01}
-- Employee COUNT --
4
-- Employee AVG Salary --
2625.0
-- Employee MAX Salary --
4000
-- Employee MIN Salary --
1500
-- Employee SUM Salary --
10500.0
-- oldest join date --
1999-06-01
-- newest join date --
2011-01-01
-- greatest name alphabetically --
Rose
-- least name alphabetically --
Denise

Example Project

Dependencies and Technologies Used:

• hibernate-core 5.3.7.Final: Hibernate's core ORM functionality.
  Implements javax.persistence:javax.persistence-api version 2.2
• hibernate-jpamodelgen 5.3.7.Final: Annotation Processor to generate JPA 2 static metamodel classes.
• h2 1.4.197: H2 Database Engine.
• JDK 1.8
• Maven 3.5.4