Java 程序设置最小和最大堆大小
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 代码设置最小和最大堆大小的过程。希望本文能帮助您了解这里提到的堆大小过程的运作方式。
相关文章
有用资源
java 参考教程 - 该教程包含有关 java 的更多信息:https://www.cainiaomax.com/java/

