数据结构
网络
关系数据库管理系统 (RDBMS)
操作系统
Java
MS Excel
iOS
HTML
CSS
Android
Python
C语言编程
C++
C#
MongoDB
MySQL
Javascript
PHP
物理学
化学
生物学
数学
英语
经济学
心理学
社会学
时尚研究
法学研究Java程序设置最小和最大堆大小
Java堆是用于存储对象并在Java虚拟机中将其表示为实例的特定内存区域。只要环境中运行着某些应用程序，Java堆就可以在两个线程之间共享。堆在栈内存中排序，并在对象在JVM中创建后遵循后进先出 (LIFO) 方法。
当堆内存的大小与栈相比时，垃圾收集器会自动清除多余的对象。在Java中，堆内存分为三个部分：
-
新生代堆
-
老年代堆
-
永久代堆
新生代堆 - 在特定操作期间分配到内存的新创建的对象。
-
它有两个主要部分：伊甸园区和幸存者区。幸存者区可以分为两个部分：Survivor1 和 Survivor2。
-
新创建的对象由伊甸园区函数空间处理。
-
如果伊甸园区已满，则会发生次要垃圾回收，并且活动对象将移动到幸存者区。
-
在幸存者区操作之后，整个节点将被转移到老年代堆。
老年代堆 - 当分配的年龄与新生代匹配时，它们将移动到老年代部分。它是长期存活对象的内存区域。主要垃圾回收操作在老年代部分运行以收集一些死亡对象。
永久代堆 - 可以使用永久代来存储元数据。它是类和方法包的过程。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。
不同的方法
以下是设置最小和最大堆大小的不同方法：
使用运行时类
我们编写了这个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
使用 -Xmx
如果我们想在Java中设置最大堆值，我们可以使用Java解释器的-Xmx选项。
最大堆的操作如下：
-
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
示例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());
}
}
}
输出
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
使用 -Xms
如果我们想在Java中设置最小堆值，我们可以使用Java解释器的-Xms选项。
最小堆的操作如下：
-
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
示例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("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代码来设置最小和最大堆大小的过程。希望这篇文章能帮助您理解这里提到的堆大小过程的操作方法。
更新于：2024年10月15日
浏览量：586
广告