Java 程序设置最小和最大堆大小

javaobject oriented programmingprogramming更新于 2024/3/27 19:24:17

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

当将堆内存的大小与堆栈进行比较时,垃圾收集器会自动清除多余的对象。 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

对于 Min-Heap 操作,leftChild 和 rightChild 都必须大于所有父级。

在此语法中,我们应用了堆逻辑来构建 Java 代码以设置最小和最大堆大小。以下是我们拥有的两个可能函数 -

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

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

要遵循的方法

  • 方法 1 - Java 程序显示堆内存统计信息

  • 方法 2 - Java 程序使用 -Xmx 将最大堆大小设置为最大值

  • 方法 3 - Java 程序使用 -Xms 设置最小或初始堆大小

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("分配的最大内存"+ " " + r.maxMemory() / mb);
    System.out.println("初始内存存在"+ " " + r.totalMemory() / mb);
    System.out.println("可用内存"+ " " + r.freeMemory() / mb);
    System.out.println("进程消耗的内存"+ " " + (r.totalMemory() - r.freeMemory()) / mb);
   }
}

输出

分配的最大内存 1073.741824
初始内存 270.532608
可用内存 268.466176
进程消耗的内存 2.066432

Java 程序使用 -Xmx 将最大堆大小设置为最大值

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

Max Heap 上的操作如下 -

  • getMax() - 它返回根元素作为最大值。此操作的时间复杂度为 O(1)。

  • extractMax() - 从 MaxHeap 中删除最大元素。此操作的时间复杂度为 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("此处分配的最大内存" + " " + r.maxMemory() / mb);
    System.out.println("此处可用的初始内存" + " " + r.totalMemory() / mb);
    System.out.println("当前可用的内存" + " " + r.freeMemory() / mb);
    System.out.println("进程消耗的内存"+ " "+ (r.totalMemory() - r.freeMemory()) / mb);
   }
}

输出

此处分配的最大内存 107.3741824
此处可用的初始内存 27.0532608
当前可用的内存 26.8466176
进程消耗的内存 0.2066432

示例 2 A

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());
      }
   }
}

输出

原始数组在这里:16 10 97 7 10 2001 31 10 22
操作后的最大堆:9722 31107 1016 010
操作后提取最大堆:9731 221610 101070

使用 -Xms 设置最小或初始堆大小的 Java 程序

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

平均堆上的操作如下 -

  • getMin() - 它返回根元素作为最小值。此操作的时间复杂度为 O(1)。

  • extractMin() - 从 MinHeap 中删除最小元素。此操作的时间复杂度为 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("我们拥有的最大内存"+ " " + r.maxMemory() / mb);
    System.out.println("初始内存已给出"+ " " + r.totalMemory() / mb);
    System.out.println("此处有可用内存" + " " + r.freeMemory() / mb);
    System.out.println("进程消耗的内存"+ " "+ (r.totalMemory() - r.freeMemory()) / mb);
   }
}

输出

我们手头上的最大内存为 107.3741824
初始内存为 27.0532608
此处可用的空闲内存为 26.8466176
进程消耗的内存为 0.2066432

示例 3 A

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("原始数组集在这里,看一下:");
    for(int i=0;i<arrA.length;i++){
    System.out.print(" " + arrA[i]);
    }
    minHeapoperation m = new minHeapoperation (arrA.length);
    System.out.print("\nMin-Heap 在这里,伙计:");
    m.createHeap(arrA);
    m.display();
    System.out.print("操作后提取最小堆:");
    for(int i=0;i<arrA.length;i++){
    System.out.print(" " + m.extractMin());
    }
   }
}

输出

原始数组集在这里,看一下:16 10 1997 7 10 2001 10 31 2022
Min-Heap 在这里,伙计:7 10 10 16 10 2001 1997 31 2022
操作后提取最小堆:7 10 10 10 16 31 1997 2001 2022

结论

在今天的这篇文章中,我们通过遵循语法和算法,了解了使用一些可能的 java 代码设置最小和最大堆大小的过程。希望本文能帮助您了解这里提到的堆大小过程的运作方式。


相关文章


有用资源