当前位置：极客笔记 > Java > Java 精选笔记 > Java 设置最小和最大堆大小

Java 设置最小和最大堆大小

Java 设置最小和最大堆大小

Java堆是一个特定的内存区域，用于存储对象并将其表示为Java虚拟机中的实例。只要环境被一些正在运行的应用程序占用，Java堆就可以在两个线程之间共享。堆在堆栈内存中排序，并在对象在JVM中创建后遵循后进先出（LIFO）的方法。

当堆内存的大小与堆栈进行比较时，多余的对象将由GarbageCollector自动清除。Java中的堆内存被分成三部分−

  • 新堆生成

  • 旧堆生成

  • 永久堆生成

新堆生成 −在特定操作过程中，新创建的对象分配在内存中。

  • 它有两个主要部分 – Eden和Survivor。第二部分可以分为两部分，即Survivor1和Survivor2。

  • 新创建的对象由Eden函数空间处理。

  • 如果Eden已满，将进行小的垃圾收集，并将存活的对象移动到Survivor部分。

  • 在Survivor中进行操作后，整个节点将转移到旧堆生成。

旧堆生成 −当分配的年龄与新一代匹配时，它们将被移动到旧一代部分。它是长期存活对象的一个内存社区。主要的垃圾收集操作在旧一代部分上运行，以收集一些死对象

永久堆生成 −为了存储元数据，我们可以使用永久生成。它是类和方法包的过程。Java虚拟机还有一个完整的目录用于永久生成。该空间中的垃圾由完全垃圾收集操作的一部分清除。

在Java中设置最小和最大堆大小的算法

  • 第1步−开始

  • 第2步−声明一个数组。

  • 第3步−从索引1开始排序。

  • 第4步−不要从0开始排序。

  • 第5步−如果可用，则左孩子为[2 * i]。

  • 第6步−如果可用，则右孩子为[2 * i + 1]。

  • 第7步−如果可用，则父节点为[i / 2]。

  • 第8步−终止

语法

Heapify(array, size, i)
  set i as largest
  leftChild = 2i + 1
  rightChild = 2i + 2

  if leftChild > array[largest]
set leftChildIndex as largest
  if rightChild > array[largest]
set rightChildIndex as largest

  swap array[i] and array[largest]

MaxHeap(array, size)
  loop from the first index of non-leaf node down to zero
call heapify

For Min-Heap operation, leftChild and rightChild both will must be larger than the parent for all.

在这个语法中，我们应用了堆逻辑来构建一个Java代码来设置最小和最大堆大小。这里有两个可能的函数：

  • wrapper.java.initmemory – 最小堆大小。默认值为256 MB。

  • wrapper.java.maxmemory – 最大堆大小。默认值为1024 MB。

所采用的方法

  • 方法1 – Java程序显示堆内存统计数据。

  • 方法2 – 使用-Xmx设置最大堆大小。

  • 方法3 – 使用-Xms设置最小或初始堆大小。

方法1：Java程序显示堆内存统计数据

在这里，我们编写了Java程序，通过它我们可以显示堆内存统计数据。请看以下示例：

示例1

import java.io.*;
import java.lang.*;
import java.util.*;
public class heapMemorybytp {
   public static void main(String[] args){
      double mb = 1000000;
      Runtime r = Runtime.getRuntime();
      System.out.println("Max memory alloted"+ " " + r.maxMemory() / mb);
      System.out.println("Initial memory present"+ " " + r.totalMemory() / mb);
      System.out.println("Free memory available"+ " " + r.freeMemory() / mb);
      System.out.println("Consume memory by the process"+ " "+ (r.totalMemory() - r.freeMemory()) / mb);
   }
}

输出

Max memory alloted 1073.741824
Initial memory present 270.532608
Free memory available 268.466176
Consume memory by the process 2.066432

方法2：使用-Xmx设置Java程序的最大堆大小

如果我们想在Java中设置最大堆值，我们可以使用-Xmx选项来设置Java解释器。

最大堆的操作如下：

  • getMax() – 将返回最大堆的根元素。这个操作的时间复杂度是O(1)。

  • extractMax() – 从最大堆中删除最大元素。这个操作的时间复杂度是O(Log n)，因为在删除根元素后需要调用heapify()方法来维护堆的属性。

  • insert() – 插入一个新的键需要O(Log n)的时间。我们将新的键添加到树的末尾。如果新的键小于其父节点，则我们不需要进行任何操作。否则，我们需要向上遍历以修复被破坏的堆属性。

示例2

import java.io.*;
import java.lang.*;
import java.util.*;
public class heaptheMemorybytp {
   public static void main(String[] args){
      double mb = 10000000;
      Runtime r = Runtime.getRuntime();
      System.out.println("Max memory alloted here" + " " + r.maxMemory() / mb);
      System.out.println("Initial memory we have here available" + " " + r.totalMemory() / mb);
      System.out.println("Free memory we have now" + " " + r.freeMemory() / mb);
      System.out.println("Consumed memory by the process"+ " "+ (r.totalMemory() - r.freeMemory()) / mb);
   }
}

输出

Max memory alloted here 107.3741824
Initial memory we have here available 27.0532608
Free memory we have now 26.8466176
Consumed memory by the process 0.2066432

示例2A

public class maxHeapoperation {
   public int capacity;
   public int [] mH;
   public int currentSize;
   public maxHeapoperation(int capacity){
      this.capacity=capacity;
      mH = new int [capacity+1];
      currentSize =0;
   }
   public void createHeap(int [] arrA){
      if(arrA.length>0){
         for(int i=0;i<arrA.length;i++){
            insert(arrA[i]);
         }
      }
   }
   public void display(){
      for(int i=1;i<mH.length;i++){
         System.out.print(" " + mH[i]);
      }
      System.out.println("");
   }
   public void insert(int x) {
      if(currentSize==capacity){
         System.out.println("heap is full");
         return;
      }
      currentSize++;
      int idx = currentSize;
      mH[idx] = x;
      bubbleUp(idx);
   }
   public void bubbleUp(int pos) {
      int parentIdx = pos/2;
      int currentIdx = pos;
      while (currentIdx > 0 && mH[parentIdx] < mH[currentIdx]) {
         swap(currentIdx,parentIdx);
         currentIdx = parentIdx;
         parentIdx = parentIdx/2;
      }
   }
   public int extractMax() {
      int max = mH[1];
      mH[1] = mH[currentSize];
      mH[currentSize] = 0;
      sinkDown(1);
      currentSize--;
      return max;
   }

   public void sinkDown(int k) {
      int greatest = k;
      int leftChildIdx = 2 * k;
      int rightChildIdx = 2 * k+1;
      if (leftChildIdx < heapSize() && mH[greatest] < mH[leftChildIdx]) {
         greatest = leftChildIdx;
      }
      if (rightChildIdx < heapSize() && mH[greatest] < mH[rightChildIdx]) {
         greatest = rightChildIdx;
      }
      if (greatest != k) {
         swap(k, greatest);
         sinkDown(greatest);
      }
   }
   public void swap(int a, int b) {
      int temp = mH[a];
      mH[a] = mH[b];
      mH[b] = temp;
   }
   public boolean isEmpty() {
      return currentSize == 0;
   }
   public int heapSize(){
      return currentSize;
   }
   public static void main(String args[]){
      int arrA [] = {16,10,97,7,10,2001,31,10,22};
      System.out.print("Original Array Is Here: ");
      for(int i=0;i<arrA.length;i++){
         System.out.print("" + arrA[i]);
      }
      maxHeapoperation m = new maxHeapoperation(arrA.length);
      System.out.print("\nMax-Heap After Operation : ");
      m.createHeap(arrA);
      m.display();
      System.out.print("Extract Max Hep After Operation:");
      for(int i=0;i<arrA.length;i++){
         System.out.print("" + m.extractMax());
      }
   }
}

输出

Original Array Is Here: 16 10  97  7  10 2001  31  10 22
Max-Heap After Operation : 9722 31107 1016 010
Extract Max Hep After Operation:9731  221610  101070

方法3：通过使用-Xms来设置Java程序的最小或初始堆大小

如果我们想要在Java中设置最小堆值，我们可以使用-Xms选项来设置Java解释器。

平均堆的操作如下−

  • getMin() – 返回最小元素作为最小值。这个操作的时间复杂度是 O(1)。

  • extractMin() – 从最小堆中移除最小元素。这个操作的时间复杂度是O(Log n)，因为在移除根节点后，需要维护堆的性质（通过调用heapify()函数）。

  • insert() – 插入一个新的键需要O(Log n)的时间。我们将新键添加到树的末尾。如果新键大于其父节点，则我们不需要做任何操作。否则，我们需要向上遍历以修复违反的堆性质。

示例3

import java.io.*;
import java.lang.*;
import java.util.*;
public class heaptheMemorybytp {
   public static void main(String[] args){
      double mb = 10000000;
      Runtime r = Runtime.getRuntime();
      System.out.println("Max memory we have in hand"+ " " + r.maxMemory() / mb);
      System.out.println("Initial memory has given"+ " " + r.totalMemory() / mb);
      System.out.println("Free memory is available here" + " " + r.freeMemory() / mb);
      System.out.println("Consume memory by the process"+ " "+ (r.totalMemory() - r.freeMemory()) / mb);
   }
}

输出

Max memory we have in hand 107.3741824
Initial memory has given 27.0532608
Free memory is available here 26.8466176
Consume memory by the process 0.2066432

示例3A

public class minHeapoperation {
   public int capacity;
   public int [] mH;
   public int currentSize;
   public minHeapoperation (int capacity){
      this.capacity=capacity;
      mH = new int [capacity+1];
      currentSize =0;
   }
   public void createHeap(int [] arrA){
      if(arrA.length>0){
         for(int i=0;i<arrA.length;i++){
            insert(arrA[i]);
         }
      }
   }
   public void display(){
      for(int i=1;i<mH.length;i++){
         System.out.print(" " + mH[i]);
      }
      System.out.println("");
   }
   public void insert(int x) {
      if(currentSize==capacity){
         System.out.println("Heap is full. I Am Really Sorry Buddy!");
         return;
      }
      currentSize++;
      int idx = currentSize;
      mH[idx] = x;
      bubbleUp(idx);
   }

   public void bubbleUp(int pos) {
      int parentIdx = pos/2;
      int currentIdx = pos;
      while (currentIdx > 0 && mH[parentIdx] > mH[currentIdx]) {

         swap(currentIdx,parentIdx);
         currentIdx = parentIdx;
         parentIdx = parentIdx/2;
      }
   }

   public int extractMin() {
      int min = mH[1];
      mH[1] = mH[currentSize];
      mH[currentSize] = 0;
      sinkDown(1);
      currentSize--;
      return min;
   }

   public void sinkDown(int k) {
      int smallest = k;
      int leftChildIdx = 2 * k;
      int rightChildIdx = 2 * k+1;
      if (leftChildIdx < heapSize() && mH[smallest] > mH[leftChildIdx]) {
         smallest = leftChildIdx;
      }
      if (rightChildIdx < heapSize() && mH[smallest] > mH[rightChildIdx]) {
         smallest = rightChildIdx;
      }
      if (smallest != k) {

         swap(k, smallest);
         sinkDown(smallest);
      }
   }

   public void swap(int a, int b) {
      int temp = mH[a];
      mH[a] = mH[b];
      mH[b] = temp;
   }
   public boolean isEmpty() {
      return currentSize == 0;
   }

   public int heapSize(){
      return currentSize;
   }

   public static void main(String args[]){
      int arrA [] = {16,10,1997,7,10,2001,10,31,2022};
      System.out.print("Original Array Set Is Here, Have A Look : ");
      for(int i=0;i<arrA.length;i++){
         System.out.print("  " + arrA[i]);
      }
      minHeapoperation m = new minHeapoperation (arrA.length);
      System.out.print("\nMin-Heap Is Here Buddy : ");
      m.createHeap(arrA);
      m.display();
      System.out.print("Extract Min Heap After The Operation:");
      for(int i=0;i<arrA.length;i++){
         System.out.print("  " + m.extractMin());
     }
   }
}

输出

Original Array Set Is Here, Have A Look :16  10  1997  7  10  2001  10  31  2022
Min-Heap Is Here Buddy :  7 10 10 16 10 2001 1997 31 2022
Extract Min Heap After The Operation:  7  10  10  10  16  31  1997  2001  2022

结论

在这篇文章中，我们学习了使用一些可能的Java代码来设置最小和最大堆大小的过程，通过遵循语法和算法。希望本文能帮助您理解这里提到的堆大小处理的操作方法。

Camera课程

Camera API2 教程

API2 教程
Camera 性能教程

Perf 教程
Camera Native Framework 教程

Native FW 教程
Camera QCOM ISP 教程

ISP 教程
Camera QCOM Sensor 教程

Sensor 教程

Python教程

Python 教程

Python 教程
NumPy 教程

NumPy 教程
Django 教程

Django 教程

Java教程

Java 教程

Java 教程

Web教程

JavaScript 教程

JavaScript 教程
jQuery 教程

jQuery 教程
CSS 教程

CSS 教程
PHP 教程

PHP 教程
Laravel 教程

Laravel 教程
TypeScript 教程

TypeScript 教程
WordPress 教程

WordPress 教程

数据库教程

SQL 教程

SQL 教程
SQLite 教程

SQLite 教程
MySQL 教程

MySQL 教程
PL/SQL 教程

PL/SQL 教程
MongoDB 教程

MongoDB 教程

图形图像教程

OpenCV 教程

OpenCV 教程

办公软件教程

Excel 教程

Excel 教程

Linux教程

Linux命令全集

Linux命令全集
Linux内核API

Linux内核API
LVGL 教程

LVGL 教程

计算机教程

操作系统 教程

操作系统 教程
计算机网络 教程

计算机网络 教程
C语言 教程

C语言 教程
C++ 教程

C++ 教程
Swift 教程

Swift 教程

大数据教程

Hadoop 教程

Hadoop 教程
Spark 教程

Spark 教程
Scala 教程

Scala 教程

开发工具教程

Git 教程

Git 教程
Jenkins 教程

Jenkins 教程
ChatGPT 教程

ChatGPT 教程
IntelliJ 教程

IntelliJ 教程

Java 精选教程