java類的大小

1. java的基本數據類型有幾種長度多少

Java語言提供了八種基本類型。六種數字類型（四個整數型，兩個浮點型），一種字元類型，還有一種布爾型。
1、整數：包括int,short,byte,long
2、浮點型：float,double
3、字元：char
4、布爾：boolean

擴展：

Java是一門面向對象編程語言，不僅吸收了C++語言的各種優點，還摒棄了C++里難以理解的多繼承、指針等概念，因此Java語言具有功能強大和簡單易用兩個特徵。Java語言作為靜態面向對象編程語言的代表，極好地實現了面向對象理論，允許程序員以優雅的思維方式進行復雜的編程

2. java中怎麼樣比較兩個Object的大小當然還有怎麼樣比較兩個類的大小謝謝！

如果Object要比較大小的話，你必須得實現Comparable<T>，具體誰大誰小是由你實現的compareTo方法來決定的。

3. java里的大小寫有什麼區別， 類是什麼，怎麼操作，清楚點

1.java裡面的大小寫其實是一些習慣演變而來的規則，比如類名首字母大寫(class Test)，方法名從第二個單詞開始首字母大寫(useThisMethod()),等等。。這樣別人讀你程序的時候就會更容易理解。
2.可以說類和對象是java語言的基礎，也是精髓。java是面向對象的語言說的就是這個。一個類就是現實生活當中的一種或者一類事物的抽象，可以這么比喻：類是做月餅的模子，對象就是這個模子做出來的月餅。比如對於學生，我們可以定義一個學生類，這個類裡面有各種屬性和方法。比如：
class Student
{
public String studentName; //屬性
public String studentHobby; //屬性
public void studentMethod()
{
System.out.println("我是一名學生"); //方法
}
}
//當要給這個類實例化一個對象時（用模子做一個月餅）
public class Test
{
public static void main(Sting[] args)
{
Student student = new Student(); //這里的student(小寫s的那個)，就是這個
//類的一個對象(做出來的一個月餅)
student.studentMethod(); //它可以調用類裡面定義的方法和屬性
}
}
——————————————————————————————————————
這樣講不知道你能明白多少，但是我真的講的夠詳細了，希望對你有幫助。

4. 如何查看java一個類的大小

類的各種信息的實例化後都是放置在JVM中的，這個可以通過Jconsole或者viualvm進行查看，方法就是先運行你的程序然後 使用如上工具監控你程序所在的線程，然後查看關聯對象所佔的空間， 不過一般情況下不可能直接看出來的，因為你的了可能引用了string 對象然而string對象可能被很多對象引用，這樣這塊的空間是不記錄在 你的對象中的，一般情況查看對象大小主要是擔心 內存溢出，這個一般你看對象在空間的佔比就是數量，以及對象數是否一直在增加 如果一直在增加說明這個對象有問題可能存在內存溢出的風險，比如你查詢一個很大的表放置在list中這種情況就可能存在內存溢出，不妨試一下看看查詢以後 內存是如何變化的。

5. 哪些因素可能會影響一個類的大小 java

毫無影響，java編譯時就會確定方法的偏移量。java會自動裝載，所以方法數量不是問題。
不過過多的方法和行數會對解讀造成影響，造成可讀性差。另外一些計算測試代碼覆蓋率的程序無法處理過多行的代碼。
外界處於可讀性的考慮，要求處理類的代碼不可以超過2000行，一個方法不可以超過500行。

6. java的.class文件大小

方法一：如果你是火狐瀏覽器,在火狐里輸入這個 about:cache ,裡面有緩存的文件夾地址,打開即可找到那個.class文件。
IE的話是 C:\Documents and Settings\Administrator\Local Settings\Temporary Internet Files 下就有。
方法二：你可以直接把那個.class下載過來。你可以點右鍵，使用迅雷下載全部鏈接，找.class就行。
或者比如說 <link href="/ikqb.css" rel="stylesheet" type="text/css">（applet我忘了怎麼配置了，就用它代替吧），那不是有個 「href」呢？就是在瀏覽器里的地址（比如說：http://..com/question/117735972.html），把最後那個頁面刪了，換成那個「href」的值（http://..com/question/ikqb.css），回車，就下載過來了。

7. JAVA方法求int類型大小

直接調用java api裡面的方法：
static int MAX_VALUE
保持 int 類型的最大值的常量可取的值為 231－1。
static int MIN_VALUE
保持 int 類型的最小值的常量可取的值為 －231。
static int SIZE
以二進制補碼形式表示 int 值的位數。
static Class<Integer> TYPE
表示基本類型 int 的 Class 實例。

8. 哪些因素影響一個java類的大小

基本java中一個類就是一個java文件.直接查看文件大小即可.在IDEEclipse中選中目錄中的一個類文件,直接按alt+enter就可以查看相關屬性.另可以在操作系統的文件系統中查看相關類文件大小屬性等有些類可能包含內部類.這些另算.

9. 如何准確計算Java對象的大小

首先，我們先寫一段大家可能不怎麼寫或者認為不可能的代碼：一個類中，幾個類型都是private類型，沒有public方法，如何對這些屬性進行讀寫操作，看似不可能哦，為什麼，這違背了面向對象的封裝，其實在必要的時候，留一道後門可以使得語言的生產力更加強大，對象的序列化不會因為沒有public方法就無法保存成功吧，OK，我們簡單寫段代碼開個頭，逐步引入到怎麼樣去測試對象的大小，一下代碼非常簡單，相信不用我解釋什麼：
import java.lang.reflect.Field;
class NodeTest1 {
private int a = 13;
private int b = 21;
}

public class Test001 {
public static void main(String []args) {
NodeTest1 node = new NodeTest1();
Field []fields = NodeTest1.class.getDeclaredFields();
for(Field field : fields) {
field.setAccessible(true);
try {
int i = field.getInt(node);
field.setInt(node, i * 2);
System.out.println(field.getInt(node));
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}

代碼最基本的意思就是：實例化一個NodeTest1這個類的實例，然後取出兩個屬性，分別乘以2，然後再輸出，相信大家會認為這怎麼可能，NodeTest1根本沒有public方法，代碼就在這里，將代碼拷貝回去運行下就OK了，OK，現在不說這些了，運行結果為：
26
42
為什麼可以取到，是每個屬性都留了一道門，主要是為了自己或者外部接入的方便，相信看代碼自己仔細的朋友，應該知道門就在：field.setAccessible(true);代表這個域的訪問被打開，好比是一道後門打開了，呵呵，上面的方法如果不設置這個，就直接報錯。
看似和對象大小沒啥關系，不過這只是拋磚引玉，因為我們首先要拿到對象的屬性，才能知道對象的大小，對象如果沒有提供public方法我們也要知道它有哪些屬性，所以我們後面多半會用到這段類似的代碼哦！
對象測量大小的方法關鍵為java提供的（1.5過後才有）：java.lang.instrument.Instrumentation，它提供了豐富的對結構的等各方面的跟蹤和對象大小的測量的API（本文只闡述對象大小的測量方法），於是乎我心喜了，不過比較惡心的是它是實例化類：sun.instrument.IntrumentationImpl是sun開頭的，這個鬼東西有點不好搞，翻開源碼構造方法是private類型，沒有任何getInstance的方法，寫這個類幹嘛？看來這個只能被JVM自己給初始化了，那麼怎麼將它自己初始化的東西取出來用呢，唯一能想到的就是agent代理，那麼我們先拋開代理，首先來寫一個簡單的對象測量方法：
步驟1：（先創建一個用於測試對象大小的處理類）
import java.lang.instrument.Instrumentation;
public class MySizeOf {
private static Instrumentation inst;
/**
*這個方法必須寫，在agent調用時會被啟用
*/
public static void premain(String agentArgs, Instrumentation instP) {
inst = instP;
}

/**
* 直接計算當前對象佔用空間大小，包括：當前類及超類的基本類型實例欄位大小
* 引用類型實例欄位引用大小、實例基本類型數組總佔用空間、實例引用類型數組引用本身佔用空間大小
* 但是不包括超類繼承下來的和當前類聲明的實例引用欄位的對象本身的大小、實例引用數組引用的對象本身的大小
* 用來測量java對象的大小（這里先理解這個大小是正確的，後面再深化）
*/
public static long sizeOf(Object o) {
if(inst == null) {
throw new IllegalStateException("Can not access instrumentation environment.\n" +
"Please check if jar file containing SizeOfAgent class is \n" +
"specified in the java's \"-javaagent\" command line argument.");
}
return inst.getObjectSize(o);
}
}

步驟2：上面我們寫好了agent的代碼，此時我們要將上面這個類編譯後打包為一個jar文件，並且在其包內部的META-INF/MANIFEST.MF文件中增加一行：Premain-Class: MySizeOf代表執行代理的全名，這里的類名稱是沒有package的，如果你有package，那麼就寫全名，我們這里假設打包完的jar包名稱為agent.jar(打包過程這里簡單闡述，就不細說了)，OK，繼續向下走：
步驟3：編寫測試類，測試類中寫：
public class TestSize {
public static void main(String []args) {
System.out.println(MySizeOf.sizeOf(new Integer(1)));
System.out.println(MySizeOf.sizeOf(new String("a")));
System.out.println(MySizeOf.sizeOf(new char[1]));
}
}

下一步准備運行，運行前我們准備初步估算下結果是什麼，目前我是在32bit模式下運行jvm（注意，不同位數的JVM參數設置不一樣，對象大小也不一樣大）。
(1) 首先看Integer對象，在32bit模式下，class區域佔用4byte，mark區域佔用最少4byte，所以最少8byte頭部，Integer內部有一個int類型的數據，佔4個byte，所以此時為8+4=12，java默認要求按照8byte對象對其，所以對其到16byte，所以我們理論結果第一個應該是16；
(2) 再看String，長度為1，String對象內部本身有4個非靜態屬性（靜態屬性我們不計算空間，因為所有對象都是共享一塊空間的），4個非靜態屬性中，有offset、count、hash為int類型，分別佔用4個byte，char value[]為一個指針，指針的大小在bit模式下或64bit開啟指針壓縮下默認為4byte，所以屬性佔用了16byte，String本身有8byte頭部，所以佔用了24byte；其次，一個String包含了子對象char數組，數組對象和普通對象的區別是需要用一個欄位來保存數組的長度，所以頭部變成12byte，java中一個char採用UTF-16編碼，佔用2個byte，所以是14byte，對其到16byte，24+16=40byte；
(3) 第三個在第二個基礎上已經分析，就是16byte大小；
也就是理論結果是：16、40、16；
步驟4：現在開始運行代碼：運行代碼前需要保證classpath把剛才的agent.jar包含進去：
D:>javac TestSize.java
D:>java -javaagent:agent.jar TestSize
16
24
16
第一個和第三個結果一致了，不過奇怪了，第二個怎麼是24，不是40，怎麼和理論結果偏差這么大，再回到理論結果中，有一個24曾經出現過，24是指String而不包含char數組的空間大小，那麼這么算還真是對的，可見，java默認提供的方法只能測量對象當前的大小，如果要測量這個對象實際的大小（也就是包含了子對象，那麼就需要自己寫演算法來計算了，最簡單的方法就是遞歸，不過遞歸一項是我不喜歡用的，無意中在一個地方看到有人用棧寫了一個代碼寫得還不錯，自己稍微改了下，就是下面這種了）。
import java.lang.instrument.Instrumentation;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.IdentityHashMap;
import java.util.Map;
import java.util.Stack;

public class MySizeOf {

static Instrumentation inst;

public static void premain(String agentArgs, Instrumentation instP) {
inst = instP;
}

public static long sizeOf(Object o) {
if(inst == null) {
throw new IllegalStateException("Can not access instrumentation environment.\n" +
"Please check if jar file containing SizeOfAgent class is \n" +
"specified in the java's \"-javaagent\" command line argument.");
}
return inst.getObjectSize(o);
}

/**
* 遞歸計算當前對象佔用空間總大小，包括當前類和超類的實例欄位大小以及實例欄位引用對象大小
*/
public static long fullSizeOf(Object obj) {//深入檢索對象，並計算大小
Map<Object, Object> visited = new IdentityHashMap<Object, Object>();
Stack<Object> stack = new Stack<Object>();
long result = internalSizeOf(obj, stack, visited);
while (!stack.isEmpty()) {//通過棧進行遍歷
result += internalSizeOf(stack.pop(), stack, visited);
}
visited.clear();
return result;
}
//判定哪些是需要跳過的
private static boolean skipObject(Object obj, Map<Object, Object> visited) {
if (obj instanceof String) {
if (obj == ((String) obj).intern()) {
return true;
}
}
return (obj == null) || visited.containsKey(obj);
}

private static long internalSizeOf(Object obj, Stack<Object> stack, Map<Object, Object> visited) {
if (skipObject(obj, visited)) {//跳過常量池對象、跳過已經訪問過的對象
return 0;
}
visited.put(obj, null);//將當前對象放入棧中
long result = 0;
result += sizeOf(obj);
Class <?>clazz = obj.getClass();
if (clazz.isArray()) {//如果數組
if(clazz.getName().length() != 2) {// skip primitive type array
int length = Array.getLength(obj);
for (int i = 0; i < length; i++) {
stack.add(Array.get(obj, i));
}
}
return result;
}
return getNodeSize(clazz , result , obj , stack);
}

//這個方法獲取非數組對象自身的大小，並且可以向父類進行向上搜索
private static long getNodeSize(Class <?>clazz , long result , Object obj , Stack<Object> stack) {
while (clazz != null) {
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
if (!Modifier.isStatic(field.getModifiers())) {//這里拋開靜態屬性
if (field.getType().isPrimitive()) {//這里拋開基本關鍵字（因為基本關鍵字在調用java默認提供的方法就已經計算過了）
continue;
}else {
field.setAccessible(true);
try {
Object objectToAdd = field.get(obj);
if (objectToAdd != null) {
stack.add(objectToAdd);//將對象放入棧中，一遍彈出後繼續檢索
}
} catch (IllegalAccessException ex) {
assert false;
}
}
}
}
clazz = clazz.getSuperclass();//找父類class，直到沒有父類
}
return result;
}
}