java操作內存

㈠ java執行內存一般多大

我運行了myeclipse6.5+mysql直接沾了這么多。不過要看項目的大小。打開的項目大的話，就不止這么點了。500mb都有。

㈡ 用java語言怎麼實現內存的讀寫

java都是在內存中操作的。
所有變數、所有數據都會在內存中
只是有個區別是：有些內存會被回收。即，一段時間後你就再也拿不到。
有些是永遠不回收。直到伺服器關閉。這就是你所想要的。
其實現方式有多種。
常用的是application.

㈢ Java程序運行時，操作系統內存與JVM內存的各自作用

自學,偶像...(看來不回答不行了 ....)
其實內存都是操作系統分配的, 你可以把jvm想像成一個中間層運行環境(java程序運行的支持,就是一種支持..)就得了就像那種.net framwork 那樣的東東. 不用太在意....

程序
|
jvm
|
操作系統

我樓上的都是正解:

引用樓上的話

當然。
把JVM看成是個中間層就可以，不止是內存分配，還有線程、網路連接等等，最終在底層都要靠操作系統來搞。

Java語言的設計思想，本來就是對C語言這種可以直接進行操作系統調用的語言的一種簡化。引入了一個隔離層，讓jvm來當個中介，以簡化應用開發。讓程序員集中精力於實現業務邏輯。
(修補下 准確的說是C++,不是C.....讓jvm當中介
以實現跨平台.以...)

恩，樓上說的對，jvm就是連接java程序跟操作系統的中間層，程序用到的內存都是從這里分配得到的，而jvm的內存是從系統內存得到的。

㈣ java 讀取指定內存

不行，只能用c++實現再用java調用c++

㈤ 怎麼獲取 Java 程序使用的內存

首先
創建一個Bean用來存貯要得到的信
public class MonitorInfoBean {
/** 可使用內存. */
private long totalMemory;
/** 剩餘內存. */
private long freeMemory;
/** 最大可使用內存. */
private long maxMemory;
/** 操作系統. */
private String osName;
/** 總的物理內存. */
private long totalMemorySize;
/** 剩餘的物理內存. */
private long freePhysicalMemorySize;
/** 已使用的物理內存. */
private long usedMemory;
/** 線程總數. */
private int totalThread;
/** cpu使用率. */
private double cpuRatio;
public long getFreeMemory() {
return freeMemory;
}
public void setFreeMemory(long freeMemory) {
this.freeMemory = freeMemory;
}
public long getFreePhysicalMemorySize() {
return freePhysicalMemorySize;
}
public void setFreePhysicalMemorySize(long freePhysicalMemorySize) {
this.freePhysicalMemorySize = freePhysicalMemorySize;
}
public long getMaxMemory() {
return maxMemory;
}
public void setMaxMemory(long maxMemory) {
this.maxMemory = maxMemory;
}
public String getOsName() {
return osName;
}
public void setOsName(String osName) {
this.osName = osName;
}
public long getTotalMemory() {
return totalMemory;
}
public void setTotalMemory(long totalMemory) {
this.totalMemory = totalMemory;
}
public long getTotalMemorySize() {
return totalMemorySize;
}
public void setTotalMemorySize(long totalMemorySize) {
this.totalMemorySize = totalMemorySize;
}
public int getTotalThread() {
return totalThread;
}
public void setTotalThread(int totalThread) {
this.totalThread = totalThread;
}
public long getUsedMemory() {
return usedMemory;
}
public void setUsedMemory(long usedMemory) {
this.usedMemory = usedMemory;
}
public double getCpuRatio() {
return cpuRatio;
}
public void setCpuRatio(double cpuRatio) {
this.cpuRatio = cpuRatio;
}
}
之後，建立bean的介面
public interface IMonitorService {
public MonitorInfoBean getMonitorInfoBean() throws Exception;
}
然後，就是最關鍵的，得到cpu的利用率，已用內存，可用內存，最大內存等信息。
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import sun.management.ManagementFactory;
import com.sun.management.OperatingSystemMXBean;
import java.io.*;
import java.util.StringTokenizer;
/**
* 獲取系統信息的業務邏輯實現類.
* @author GuoHuang
*/
public class MonitorServiceImpl implements IMonitorService {
private static final int CPUTIME = 30;
private static final int PERCENT = 100;
private static final int FAULTLENGTH = 10;
private static final File versionFile = new File("/proc/version");
private static String linuxVersion = null;
/**
* 獲得當前的監控對象.
* @return 返回構造好的監控對象
* @throws Exception
* @author GuoHuang
*/
public MonitorInfoBean getMonitorInfoBean() throws Exception {
int kb = 1024;
// 可使用內存
long totalMemory = Runtime.getRuntime().totalMemory() / kb;
// 剩餘內存
long freeMemory = Runtime.getRuntime().freeMemory() / kb;
// 最大可使用內存
long maxMemory = Runtime.getRuntime().maxMemory() / kb;
OperatingSystemMXBean osmxb = (OperatingSystemMXBean) ManagementFactory
.getOperatingSystemMXBean();
// 操作系統
String osName = System.getProperty("os.name");
// 總的物理內存
long totalMemorySize = osmxb.getTotalPhysicalMemorySize() / kb;
// 剩餘的物理內存
long freePhysicalMemorySize = osmxb.getFreePhysicalMemorySize() / kb;
// 已使用的物理內存
long usedMemory = (osmxb.getTotalPhysicalMemorySize() - osmxb
.getFreePhysicalMemorySize())
/ kb;
// 獲得線程總數
ThreadGroup parentThread;
for (parentThread = Thread.currentThread().getThreadGroup(); parentThread
.getParent() != null; parentThread = parentThread.getParent())
;
int totalThread = parentThread.activeCount();
double cpuRatio = 0;
if (osName.toLowerCase().startsWith("windows")) {
cpuRatio = this.getCpuRatioForWindows();
}
else {
cpuRatio = this.getCpuRateForLinux();
}
// 構造返回對象
MonitorInfoBean infoBean = new MonitorInfoBean();
infoBean.setFreeMemory(freeMemory);
infoBean.setFreePhysicalMemorySize(freePhysicalMemorySize);
infoBean.setMaxMemory(maxMemory);
infoBean.setOsName(osName);
infoBean.setTotalMemory(totalMemory);
infoBean.setTotalMemorySize(totalMemorySize);
infoBean.setTotalThread(totalThread);
infoBean.setUsedMemory(usedMemory);
infoBean.setCpuRatio(cpuRatio);
return infoBean;
}
private static double getCpuRateForLinux(){
InputStream is = null;
InputStreamReader isr = null;
BufferedReader brStat = null;
StringTokenizer tokenStat = null;
try{
System.out.println("Get usage rate of CUP , linux version: "+linuxVersion);
Process process = Runtime.getRuntime().exec("top -b -n 1");
is = process.getInputStream();
isr = new InputStreamReader(is);
brStat = new BufferedReader(isr);
if(linuxVersion.equals("2.4")){
brStat.readLine();
brStat.readLine();
brStat.readLine();
brStat.readLine();
tokenStat = new StringTokenizer(brStat.readLine());
tokenStat.nextToken();
tokenStat.nextToken();
String user = tokenStat.nextToken();
tokenStat.nextToken();
String system = tokenStat.nextToken();
tokenStat.nextToken();
String nice = tokenStat.nextToken();
System.out.println(user+" , "+system+" , "+nice);
user = user.substring(0,user.indexOf("%"));
system = system.substring(0,system.indexOf("%"));
nice = nice.substring(0,nice.indexOf("%"));
float userUsage = new Float(user).floatValue();
float systemUsage = new Float(system).floatValue();
float niceUsage = new Float(nice).floatValue();
return (userUsage+systemUsage+niceUsage)/100;
}else{
brStat.readLine();
brStat.readLine();
tokenStat = new StringTokenizer(brStat.readLine());
tokenStat.nextToken();
tokenStat.nextToken();
tokenStat.nextToken();
tokenStat.nextToken();
tokenStat.nextToken();
tokenStat.nextToken();
tokenStat.nextToken();
String cpuUsage = tokenStat.nextToken();
System.out.println("CPU idle : "+cpuUsage);
Float usage = new Float(cpuUsage.substring(0,cpuUsage.indexOf("%")));
return (1-usage.floatValue()/100);
}
} catch(IOException ioe){
System.out.println(ioe.getMessage());
freeResource(is, isr, brStat);
return 1;
} finally{
freeResource(is, isr, brStat);
}
}

㈥ java可不可以直接操作內存中的數

當然可以！~！！在為存入資料庫或者 文件中的時候 JAVA 的讀寫都是在操作內存

㈦ 怎樣用Java獲取內存中的數據

可以考慮使用內存映射文件：java.nio.MappedByteBuffer，主要適合放入較大的數據進入系統內存
可以考慮使用：java.nio.ByteBuffer.allocateDirect()方法進行分配，可以將一些不適合放入堆里的數據放入系統內存
還可以採用java本地調用的方式，實現對系統自身內存的掌控與調度，這種方式可以讓你靈活的訪問系統的內存。
java的堆放入的對象尺度是有限制的，這里建議參考BigMemory 的實現機制以及內存管理機制
如果自己管理內存的話，建議參考其他語言對內存管理的方式。
你可以把數據放入線性數據結構中（這些數據是在系統內存中，而非jvm管理的內存里），這樣就不存在分代問題，可以由你的應用在適當的時候清理系統的內存。這樣，你的內存模型-釋放機制就與jvm的內存管理機制處於一個互不幹擾的異行線上。

㈧ Java讀取大量數據進入內存

你需要了解jvm的運行機制，這種堆溢出的情況下，需要加大jvm的最大內存限制。
具體可參考：http://www.cnblogs.com/zcshan/archive/2011/03/10/jvm.html

㈨ Java怎麼直接在內存中讀寫對象

JAVA對象是在堆中存儲的，它在內存中的地址被存儲在一個或多個變數當中，類似於C中的指針，通過這些變數來操作對象，對象理論上是不能獨立存在的，可以有多個變數存有它的地址，但不能沒有變數存它的地址，一旦沒有變數存有它的地址，就沒法對它進行操作，對於程序運行來說，它就成了內存垃圾，正常情況下會被JAVA垃圾收集器給清除（少數異常情況可能回收不掉）

㈩ java 怎麼把數據存到內存中

這里你採納與否沒關系，給你說說編程與內存的關系。
你定義的任何變數，常量，類，方法等等，其實都在內存中，沒有所謂的把數據存內存中，這概念，你可以想一下電腦重啟或關機後，內存中的所有數據，都會丟失，除非你保存到磁碟中去。
在內存中的數據有兩塊，第一、緩沖，一般寫數據到磁碟的時候開辟出來的內存空間；第二、緩存，一般是從磁碟讀數據到內存中開辟出來的內存空間。會這么使用，原因很簡單，磁碟讀寫數據速度與內存不一致（磁碟的存取效率遠遠小於內存的存取效率），為了提高數據的存取效率，才會這么乾的。
一般而言，java中的所謂數據，大部分都是類，從自動引用計數的概念來分析，你想把對象長久的放在內存中，不會被垃圾回收機制釋放，注意制葯有一個對象在使用／引用你的數據，這條數據就會存在內存中。所以，想servlet中的全局配置參數，隨時可以取到還是唯一一份，你可以參考一下。
另外內存使用分堆與棧，堆在面向對象編程中存儲對象的，棧是方法或函數執行的時候臨時開辟的存儲空間，方法或函數執行完畢就會釋放。
希望我的回復能幫助到你，採納與否沒關系。有更好的答案，我就隱藏我的回復。