java引用類型有哪些

『壹』 java中基本數據類型和引用數據類型有哪些

java中有8中基本數據類型和3中引用類型

1、8種基本類型
一）、4種整型
byte 1位元組 -128——127
short 2 位元組 -32,768 —— 32,767
int 4 位元組 -2,147,483,648 ——2,147,483,647（超過20億）
long 8 位元組 -9,223,372,036,854,775,808——9,223,372,036854,775,807
二）、 2種浮點類型
float 4 位元組 32位IEEE 754單精度（有效位數 6 – 7位）
double 8 位元組 64位IEEE 754雙精度（有效位數15位）
三）、1種Unicode編碼的字元單元
char 2 位元組 整個Unicode字元集
四）、1種真值類型
boolean 1 位 True或者false
2、3種引用類型
類class
介面interface
數組array

『貳』 java中引用數據類型有哪些

Java中有倆種數據類型,其中主要有8中基本數據類型和引用數據類型，除了8中基本數據類型以外都是引用數據類型,8中基本數據類型分別是byte,short,int,long,char,boolean,float,double，具體如下：
1、boolean：數據值只有true或false，適用於邏輯計算。
2、char：char型（字元型）數據在內存中佔用2個位元組。char型數據用來表示通常意義上的字元，每個字元佔2個位元組，Java字元採用Unicode編碼，它的前128位元組編碼與ASCII兼容字元的存儲范圍在\u0000~\uFFFF，在定義字元型的數據時候要注意加'
'，比如
'1'表示字元'1'而不是數值1，
3、byte：byte型（位元組型）數據在內存中佔用1個位元組，表示的存儲數據范圍為：-128~127。
4、short：short型（短整型）數據在內存中佔用2個位元組。
5、int：int型（整型）數據在內存中佔用4個位元組。
6、long：long型（長整型）數據在內存中佔用8個位元組。
7、float：float型（單精度浮點型）數據在內存中佔用4個位元組。（float精度為7-8位）
8、double：double型（雙精度浮點型）數據在內存中佔用8個位元組。
Java中所有的基本數據類型都有固定的存儲范圍和所佔內存空間的大小，而不受具體操作系統的影響，來保證Java程序的可移植性。整形數據默認為int數據類型，浮點型默認為double數據類型，如果要表示long型數據或float型數據，要在相應的數值後面加上l、L或f、F，否則會出現編譯問題。
在其他語言中如C語言中，字元型數據和整型數據是可以相互轉換的，都是以ASCII碼來存儲，可以將字元型數據當整型數據來看待。

『叄』 JAVA中值類型和引用類型的區別

（1）值類型:數據存儲在內存的堆棧中,從堆棧中可以快速地訪問這些數據,因此,值類型表示實際的數據。
(2)引用類型:對象、數組、函數。
1、值類型：包括：sbyte、short、int、long、float、double、decimal（以上值類型有符號）byte、ushort、uint、ulong（以上值類型無符號）bool、char
2、引用類型：包括：對象類型、動態類型、字元串類型。二、具體區別：
1、值類型：byteb1=1;byteb2=b1;Console.WriteLine("{0},{1}。",b1,b2);b2=
2;Console.WriteLine("{0},{1}。",b1,b2);Console.ReadKey();解釋：byteb1=1;聲明b1時，在棧內開辟一個內存空間保存b1的值1。byteb2=b1;聲明b2時，在棧內開辟一個內存空間保存b1賦給b2的值1。Console.WriteLine("{0},{1}。",b1,b2);輸出結果為1,1。b2=2;將b2在棧中保存的值1改為
2。Console.WriteLine("{0},{1}。",b1,b2);輸出結果為1,2。
2、引用類型：復制代碼。

『肆』 java中的引用數據類型是怎樣的

java中有兩種數據類型：基本類型和引用類型。
基本類型有8個：
整數類型 byte、short、int、long
浮點數類型 float、double
字元型 char
布爾類型 boolean
引用類型包括三種：
類 Class
介面 Interface
數組 Array
基本類型是通過諸如 int a = 5; long b = 6L;的形式來定義的，稱為自動變數，自動變數存放的是字面值，不是類的實例，它存放在內存的堆棧中，數據大小和生存期必須是確定的，存取速度比較快，在堆棧中的字面值可以共享，也就是說我們定義一個int a = 5;然後又定義了一個int b = 5;這時a與b在內存中指向的是同一個字面常量。
引用類型一般是通過new關鍵字來創建，比如Integer num = new Integer(3);它存放在內存的堆中，可以在運行時動態的分配內存大小，生存期也不必事先告訴編譯器，當引用類型變數不被使用時，Java內部的垃圾回收器GC會自動回收走。引用變數中存放的不是變數的內容，而是存放變數內容的地址。
在參數傳遞時，基本類型都是傳值，也就是傳遞的都是原變數的值得拷貝，改變這個值不會改變原變數，而引用類型傳遞的是地址，也就是參數與原變數指向的是同一個地址，所以如果改變參數的值，原變數的值也會改變。這點要注意。
在java中，8種基本類型在java中都有對應的封裝類型，也就是引用類型：
整數類型 Byte、Short、Integer、Long
浮點數類型 Float、Double
字元型 Character
布爾類型 Boolean
有時候我們會看到這樣的語句 Integer num = 3;Boolean b = true;這樣定義也能行得通，其實這裡面有一個自動裝箱的問題，即java自動把3這個字面常量封裝成了Integer對象，同理也有自動拆箱。
還有些需要注意的比較特殊的地方：
1.Integer類型
Integer i1 = 3;
Integer i2 = 3;
此時i1 == i2 返回的是true
Integer i1 = 128;
Integer i2 = 128;
此時i1 == i2返回的是false，
這時因為Integer的數值在-128～127之間時，即在int的范圍內，默認是按照基本類型int來存放的，仍舊存在堆棧中，如果超出了int的范圍，就按照對象的方式來存放和比較了。

2、String類型
String類型我們有時候也會直接這樣定義：
String s = "abc";
這里的"abc"稱為字元串常量，也是存在堆棧中的，s中存放的就是指向這個堆棧地址的引用，如果再定義一個
String s1 = "abc";
這時，s與s1存放的是同一個地址的引用，即s與s1指向的是同一個字元串常量，
s == s1的值是true，
但是如果有
String s2 = new String("abc");
這時s == s2則為false，因為使用new之後，每次生成的對象都不是同一個，即使存儲的內容相同。
上面的s == s1，s == s2其實比較的都是地址，並不是裡面的內容。如果要比較內容，可以使用equals()方法。

其他的就不多說了，打起來太慢了，可以自己去看一下java編程思想。

『伍』 java三個引用類型

四種引用類型
所以在 JDK.1.2 之後，Java 對引用的概念進行了擴充，將引用分為了：強引用（Strong Reference）、軟引用（Soft Reference）、弱引用（Weak Reference）、虛引用（Phantom Reference）4 種，這 4 種引用的強度依次減弱。

一，強引用
Java中默認聲明的就是強引用，比如：

Object obj = new Object(); //只要obj還指向Object對象，Object對象就不會被回收
obj = null; //手動置null
只要強引用存在，垃圾回收器將永遠不會回收被引用的對象，哪怕內存不足時，JVM也會直接拋出OutOfMemoryError，不會去回收。如果想中斷強引用與對象之間的聯系，可以顯示的將強引用賦值為null，這樣一來，JVM就可以適時的回收對象了

二，軟引用
軟引用是用來描述一些非必需但仍有用的對象。在內存足夠的時候，軟引用對象不會被回收，只有在內存不足時，系統則會回收軟引用對象，如果回收了軟引用對象之後仍然沒有足夠的內存，才會拋出內存溢出異常。這種特性常常被用來實現緩存技術，比如網頁緩存，圖片緩存等。
在 JDK1.2 之後，用java.lang.ref.SoftReference類來表示軟引用。

下面以一個例子來進一步說明強引用和軟引用的區別：
在運行下面的Java代碼之前，需要先配置參數 -Xms2M -Xmx3M，將 JVM 的初始內存設為2M，最大可用內存為 3M。

首先先來測試一下強引用，在限制了 JVM 內存的前提下，下面的代碼運行正常

public class TestOOM {

public static void main(String[] args) {
testStrongReference();
}
private static void testStrongReference() {
// 當 new byte為 1M 時，程序運行正常
byte[] buff = new byte[1024 * 1024 * 1];
}
}
但是如果我們將

byte[] buff = new byte[1024 * 1024 * 1];
替換為創建一個大小為 2M 的位元組數組

byte[] buff = new byte[1024 * 1024 * 2];
則內存不夠使用，程序直接報錯，強引用並不會被回收

接著來看一下軟引用會有什麼不一樣，在下面的示例中連續創建了 10 個大小為 1M 的位元組數組，並賦值給了軟引用，然後循環遍歷將這些對象列印出來。

public class TestOOM {
private static List<Object> list = new ArrayList<>();
public static void main(String[] args) {
testSoftReference();
}
private static void testSoftReference() {
for (int i = 0; i < 10; i++) {
byte[] buff = new byte[1024 * 1024];
SoftReference<byte[]> sr = new SoftReference<>(buff);
list.add(sr);
}

System.gc(); //主動通知垃圾回收

for(int i=0; i < list.size(); i++){
Object obj = ((SoftReference) list.get(i)).get();
System.out.println(obj);
}

}

}
列印結果：

我們發現無論循環創建多少個軟引用對象，列印結果總是只有最後一個對象被保留，其他的obj全都被置空回收了。
這里就說明了在內存不足的情況下，軟引用將會被自動回收。
值得注意的一點 , 即使有 byte[] buff 引用指向對象, 且 buff 是一個strong reference, 但是 SoftReference sr 指向的對象仍然被回收了，這是因為Java的編譯器發現了在之後的代碼中, buff 已經沒有被使用了, 所以自動進行了優化。
如果我們將上面示例稍微修改一下：

private static void testSoftReference() {
byte[] buff = null;

for (int i = 0; i < 10; i++) {
buff = new byte[1024 * 1024];
SoftReference<byte[]> sr = new SoftReference<>(buff);
list.add(sr);
}

System.gc(); //主動通知垃圾回收

for(int i=0; i < list.size(); i++){
Object obj = ((SoftReference) list.get(i)).get();
System.out.println(obj);
}

System.out.println("buff: " + buff.toString());
}

則 buff 會因為強引用的存在，而無法被垃圾回收，從而拋出OOM的錯誤。

如果一個對象惟一剩下的引用是軟引用，那麼該對象是軟可及的（softly reachable）。垃圾收集器並不像其收集弱可及的對象一樣盡量地收集軟可及的對象，相反，它只在真正 「需要」 內存時才收集軟可及的對象。

三，弱引用
弱引用的引用強度比軟引用要更弱一些，無論內存是否足夠，只要 JVM 開始進行垃圾回收，那些被弱引用關聯的對象都會被回收。在 JDK1.2 之後，用 java.lang.ref.WeakReference 來表示弱引用。
我們以與軟引用同樣的方式來測試一下弱引用：

private static void testWeakReference() {
for (int i = 0; i < 10; i++) {
byte[] buff = new byte[1024 * 1024];
WeakReference<byte[]> sr = new WeakReference<>(buff);
list.add(sr);
}

System.gc(); //主動通知垃圾回收

for(int i=0; i < list.size(); i++){
Object obj = ((WeakReference) list.get(i)).get();
System.out.println(obj);
}
}
列印結果：

可以發現所有被弱引用關聯的對象都被垃圾回收了。

四，虛引用
虛引用是最弱的一種引用關系，如果一個對象僅持有虛引用，那麼它就和沒有任何引用一樣，它隨時可能會被回收，在 JDK1.2 之後，用 PhantomReference 類來表示，通過查看這個類的源碼，發現它只有一個構造函數和一個 get() 方法，而且它的 get() 方法僅僅是返回一個null，也就是說將永遠無法通過虛引用來獲取對象，虛引用必須要和 ReferenceQueue 引用隊列一起使用。

public class PhantomReference<T> extends Reference<T> {
/**
* Returns this reference object's referent. Because the referent of a
* phantom reference is always inaccessible, this method always returns
* <code>null</code>.
*
* @return <code>null</code>
*/
public T get() {
return null;
}
public PhantomReference(T referent, ReferenceQueue<? super T> q) {
super(referent, q);
}
}
那麼傳入它的構造方法中的 ReferenceQueue 又是如何使用的呢？

五，引用隊列（ReferenceQueue）
引用隊列可以與軟引用、弱引用以及虛引用一起配合使用，當垃圾回收器准備回收一個對象時，如果發現它還有引用，那麼就會在回收對象之前，把這個引用加入到與之關聯的引用隊列中去。程序可以通過判斷引用隊列中是否已經加入了引用，來判斷被引用的對象是否將要被垃圾回收，這樣就可以在對象被回收之前採取一些必要的措施。

『陸』 Java里什麼是引用類型

最簡答來說除了8中基本類型以外剩下的都是引用類型

Java 提供兩種不同的類型：引用類型和原始類型（或內置類型）。Int是java的原始數據類型，Integer是java為int提供的封裝類。Java為每個原始類型提供了封裝類。
原始類型封裝類
boolean -->Boolean
char --->Character
byte -->Byte
short -->Short
int -->Integer
long -->Long
float -->Float
double -->Double
引用類型和原始類型的行為完全不同，並且它們具有不同的語義。引用類型和原始類型具有不同的特徵和用法，它們包括：大小和速度問題，這種類型以哪種類型的數據結構存儲，當引用類型和原始類型用作某個類的實例數據時所指定的預設值。對象引用實例變數的預設值為 null，而原始類型實例變數的預設值與它們的類型有關。同時為了面向對象操作的一致性，這些基本類型都有相應的封裝類型：Integer、Short、Long、Byte、Float、Double、Character等。
因為封裝類型是對象，所以可以進行相應的很多對象能力函數操作，這樣就可以提供很多基本類型難以完成的工作的完成和實現。
你可以通過以下方式來聲明該類型。

int a，a為int類型的變數
char a，a為char類型的

String對象

1. 首先String不屬於8種基本數據類型，String是一個對象。

因為對象的默認值是null，所以String的默認值也是null；但它又是一種特殊的對象，有其它對象沒有的一些特性。

2. new String()和new String(「」)都是申明一個新的空字元串，是空串不是null；

3. String str=」punkll」；

String str=new String (「punkll」);的區別：

在這里，我們不談堆，也不談棧，只先簡單引入常量池這個簡單的概念。

常量池(constant pool)指的是在編譯期被確定，並被保存在已編譯的.class文件中的一些數據。它包括了關於類、方法、介面等中的常量，也包括字元串常量。

看例1：

String s0=」punkll」;

String s1=」punkll」;

String s2=」punk」 + 「ll」;

System.out.println( s0==s1 );

System.out.println( s0==s2 );

結果為：

true

true

首先，我們要知結果為道Java會確保一個字元串常量只有一個拷貝。

因為例子中的s0和s1中的」punkll」都是字元串常量，它們在編譯期就被確定了，所以s0==s1為true；而」punk」和」ll」也都是字元串常量，當一個字元串由多個字元串常量連接而成時，它自己肯定也是字元串常量，所以s2也同樣在編譯期就被解析為一個字元串常量，所以s2也是常量池中」punkll」的一個引用。

所以我們得出s0==s1==s2;

用new String() 創建的字元串不是常量，不能在編譯期就確定，所以new String() 創建的字元串不放入常量池中，它們有自己的地址空間。

看例2：

String s0=」punkll」;

String s1=new String(」punkll」);

String s2=」punk」 + new String(「ll」);

System.out.println( s0==s1 );

System.out.println( s0==s2 );

System.out.println( s1==s2 );

結果為：

false

false

false

例2中s0還是常量池中」punkll」的應用，s1因為無法在編譯期確定，所以是運行時創建的新對象」punkll」的引用，s2因為有後半部分new String(「ll」)所以也無法在編譯期確定，所以也是一個新創建對象」punkll」的應用;明白了這些也就知道為何得出此結果了。

『柒』 引用類型的運用

什麼是引用類型

下面說說java中引用數據類型：

引用數據類型分3種：類，介面，數組；

一、類Class引用

可以是我們創建的，這里我不多講，主要是講解幾個java庫中的類

Object ：Object是一個很重要的類，Object是類層次結構的根類，每個類都使用Object作為超類，所有對象（包括數組）都實現這個類的方法。用Object可以定義所有的類

              如：

              Object object= new Integer(1); 來定義一個Interger類

              Integer i=(Integer) object;    在來把這個Object強制轉換成Interger類

String ：String類代表字元串，Java 程序中的所有字元串字面值（如"abc"）都作為此類的實例來實現。檢查序列的單個字元、比較字元串、搜索字元串、提取子字元串、創建字元串副本、在該副本中、所有的字元都被轉換為大寫或小寫形式。

Date ：Date表示特定的瞬間，精確到毫秒。Date的類一般現在都被Calendar 和GregorianCalendar所有代替

Void ：Void 類是一個不可實例化的佔位符類，它保持一個對代表 Java 關鍵字 void 的 Class 對象的引用。

同時也有對應的Class如：Integer  Long  Boolean  Byte  Character  Double  Float  Short

二、介面interface引用

可以是我們創建的，這里我不多講，主要是講解幾個java庫中的介面interface

List<E>：列表 ，此介面的用戶可以對列表中每個元素的插入位置進行精確地控制。用戶可以根據元素的整數索引 （在列表中的位置）訪問元素，並搜索列表中的元素。List 介面提供了兩種搜索指定對象的方法。從性能的觀點來看，應該小心使用這些方法。在很多實現中，它們將執行高開銷的線性搜索。 List 介面提供了兩  種在列表的任意位置高效插入和移除多個元素的方法。

add() : 在列表的插入指定元素。

remove()：移除列表中指定位置的元素。

get(int index)：返回列表中指定位置的元素。

Map<K,V>：

K - 此映射所維護的鍵的類型

V - 映射值的類型 將鍵映射到值的對象。一個映射不能包含重復的鍵；每個鍵最多隻能映射到一個值。

put(K key,V value)：將指定的值與此映射中的指定鍵關聯（可選操作）。如果此映射以前包含一個該鍵的映射關系，則用指定值替換舊值（當且僅當，返回 true 時，才能說映射 m 包含鍵 k 的映射關系）。  remove(Object key)如果存在一個鍵的映射關系，則將其從此映射中移除（可選操作）。更確切地講，如果此 映射包含從滿足(key==null ? k==null :key.equals(k))的鍵 k 到值 v 的映射關系，則移除該映射關系。（該映射最多隻能包含一個這樣的映射關系.） get(Object key)：返回指定鍵所映射的值；如果此映射不包含該鍵的映射關系，則返回 null。

這里我們主要是用String List Map Object 是最常用Number ArrayList<E> Arrays等

三、數組引用

數組：存儲在一個連續的內存塊中的相同數據類型（引用數據類型）的元素集合。

數組中的每一個數據稱之為數組元素，數組中的元素以索引來表示其存放的位置，索引（下標）從0開始。

數組的定義

第一種方式：類型[] 數組名; 如 int[] nums;

第二種方式：類型數組名[]; 如 int nums[];

大多數Java程序員喜歡使用第一種風格,因為它把數據類型int[],和變數名num分開了.

數組的初始化

Java中數組必先初始化後才能使用.

初始化就是給數組元素分配內存，並為每個元素賦初始值。

初始化數組的兩種方式：

- 靜態初始化:

語法格式:類型[] 數組名 = new 數組類型[]{元素1,元素2,元素3,...元素n};

簡化語法：類型[] 數組名 = {元素1,元素2,元素3...元素n};

- 動態初始化:

如果我們事先不知道數組里存儲哪些數據，只知道需要存儲數據的個數，此時可以使用動態初始化方式。

動態初始化：初始化時由我們指定數組的長度，系統自動為數組元素分配初始值。

格式：類型[] 數組名 = new 數組類型[數組長度];

注意:無論，以哪種方式初始化數組，一旦初始化完成，數組的長度就固定了，不能改變，除非重新初始化。也就是說數組是定長的。

為什麼Java里有基本數據類型和引用數據類型？

引用類型在堆里，基本類型在棧里。

棧空間小且連續，往往會被放在緩存。引用類型cache miss率高且要多一次解引用。

『捌』 Java引用類型有哪幾種

除了基本類型以外的都是引用
基本類型有int char boolean long .....等等，都是小寫開頭，而類的話都是大寫開頭的
類的引用都是引用的某個對象的地址

『玖』 java中引用數據類型有哪些

String StringBuffer 等除了基本類型，枚舉類外的所有的類 都是引用類型。
以及所有的自定義類型。