基本資料型別物件包裝類

 為了方便操作基本資料型別值，將其封裝成了物件，在物件中定義了屬性和行為豐富了該資料的操作。
用於描述該物件的類就稱為基本資料型別物件包裝類。

byte--->Byte
short--->Short

int--->Integer
long--->Long
float   --->Float
double --->Double
char --->Character

boolean --->Boolean

該包裝物件主要用基本型別和字串之間的轉換。

Integer i = new Integer(5);
Integer i=new Integer("123");

System.out.println(Integer.MAX_VALUE);      //輸出int類的最大數值2147483647

System.out.println(Integer.toBinaryString(-6));        //以二進位制無符號整數形式返回字串

System.out.println("123"+1);                    //輸出結果為1231
System.out.println(Integer.parseInt("123")+1);    //輸出結果為124  有執行時異常處理

 

 基本型別--->字串
1,基本型別數值+""
2,用String類中的靜態方法valueOf(基本型別數值);
3,用Integer的靜態方法valueOf(基本型別數值);

字串--->基本型別
1,使用包裝類中的靜態方法   (返回型別)xxx parseXxx("xxx型別的字串")
int parseInt("intstring");
                        long parseLong("longstring");
       boolean parseBoolean("booleanstring");
                        ..............
        只有Character沒有parse方法 
2,如果字串被Integer進行物件的封裝。
可使用另一個非靜態的方法，intValue();

將一個Integer物件轉成基本資料型別值。
                            Integer i = new Integer("123");

                            System.out.println(i.intValue());

基本資料型別物件包裝類中的進位制轉化

十進位制-->其他進位制。
toBinaryString

toOctalString

toHexString
                toString(數值,進位制基數)

其他進位制-->十進位制。

parseInt("string",radix)
                      parseInt("1111011",2)            //123
                      parseInt("EFDEF",16)              //982511

自動裝箱:        Integer i =  4;//i = new Integer(4);        // 簡化書寫。
i = i + 6;                                        // i = new Integer(i.intValue() + 6);

                                                                                    //i.intValue() 自動拆箱

什麼時候自動裝箱
                基本資料型別賦值給引用資料型別才進行裝箱

Integer a = new Integer(128);
Integer b = new Integer(128);

System.out.println(a==b);                //false
System.out.println(a.equals(b));        //true   比較數值  複寫Object類中的equals方法

Integer x = 129;
                Integer y = 129;
System.out.println(x==y);//  false      127(包括)之前都是true 128(包括)之後都是false

System.out.println(x.equals(y));//true

                //jdk1.5以後，自動裝箱，如果裝箱的是一個位元組，那麼該資料會被共享不會重新開闢空間。

練習:
對一個字串中的數值進行從小到大的排序。  例如   "20 78 9 -7 88 36 29"
 思路：
1，排序，但是隻會基本型別的排序。
2，如何獲取到這個字串中的這些需要排序的數值？
    發現這個字串中其實都是空格來對數值進行分隔的。
    所以就想到用字串物件的切割方法將大串變成多個小串。
3，數值最終變成小字串，怎麼變成一個int數呢？
    字串-->基本型別 可以使用包裝類。

========================================================

集合類的由來：
物件用於封裝特有資料，物件多了需要儲存，如果物件的個數不確定。
就使用集合容器進行儲存。  在java中的util包中

集合特點：
1，用於儲存物件的容器。
2，集合的長度是可變的。
3，集合中不可以儲存基本資料型別值。 

集合容器因為內部的資料結構不同，有多種具體容器。
不斷的向上抽取，就形成了集合框架。

框架的頂層Collection介面：

Collection的常見方法：

1，新增。
boolean add(Object obj):
boolean addAll(Collection coll):

2，刪除。
boolean remove(object obj):
boolean removeAll(Collection coll);            //將兩個集合中的相同元素從呼叫removeAll的集合中刪除。
void clear();

3，判斷：
boolean contains(object obj):
boolean containsAll(Colllection coll);
boolean isEmpty():判斷集合中是否有元素。 

4，獲取：
int size():
Iterator iterator():取出元素的方式：迭代器。
該物件必須依賴於具體容器，因為每一個容器的資料結構都不同。
所以該迭代器物件是在容器中進行內部實現的。
對於使用容器者而言，具體的實現不重要，只要通過容器獲取到該實現的迭代器的物件即可，

也就是iterator方法。

Iterator介面就是對所有的Collection容器進行元素取出的公共介面。
其實就是抓娃娃遊戲機中的夾子！

5，其他：
boolean retainAll(Collection coll);取交集，保留和指定的集合相同的元素，而刪除不同的元素，和removeAll功能相反 。
Object[] toArray():將集合轉成陣列。 

單個集合的操作演示

public static void main(String[] args) 
{
		Collection coll = new ArrayList();
		show(coll);
}
public static void show(Collection coll){
	//1,新增元素。add.
	coll.add("abc1");
	coll.add("abc2");
	coll.add("abc3");
	System.out.println(coll);

	//2，刪除元素。remove
	coll.remove("abc2");//會改變集合的長度 	
	
        //3,判斷：
	System.out.println(coll.contains("abc3"));
      //清空集合.
      coll.clear();              
      System.out.println(coll);
}

雙集合操作演示

public static void main(String[] args) {
	Collection coll = new ArrayList();	
	Collection c1 = new ArrayList();
	Collection c2 = new ArrayList();
	show(c1,c2);	
	}
public static void show(Collection c1,Collection c2){
		
		//給c1新增元素。
		c1.add("abc1");
		c1.add("abc2");
		c1.add("abc3");
		c1.add("abc4");
		
		//給c2新增元素。
		c2.add("abc1");
		c2.add("abc2");
		c2.add("abc3");
		c2.add("abc4");
		c2.add("abc5");
		
		System.out.println("c1:"+c1);
		System.out.println("c2:"+c2);
		
		//演示addAll
		
//		c1.addAll(c2);//將c2中的元素新增到c1中。
		
		
		//演示removeAll
		boolean b = c1.removeAll(c2);//將兩個集合中的相同元素從呼叫removeAll的集合中刪除。
		System.out.println("removeAll:"+b);
		
		//演示containsAll
		boolean b = c1.containsAll(c2);
		System.out.println("containsAll:"+b);
		
		//演示retainAll
		boolean b = c1.retainAll(c2);//取交集，保留和指定的集合相同的元素，而刪除不同的元素。
								//和removeAll功能相反 。
		System.out.println("retainAll:"+b);
		System.out.println("c1:"+c1);
		
		
	}

Iterator迭代器的使用

//使用Collection中的iterator()方法。 呼叫集合中的迭代器方法，獲取集合中的迭代器物件。
    Iterator it = coll.iterator();		
    while(it.hasNext()){
        System.out.println(it.next());
    }
    //兩種迴圈的使用 for迴圈更好 因為在迭代結束後,仍可以使用迭代器,while的使用後迭代器不重置
    for(Iterator it = coll.iterator(); it.hasNext(); ){
	System.out.println(it.next());
    }

Collection
|--List：有序(存入和取出的順序一致),元素都有索引(角標)，元素可以重複。

|--Set：元素不能重複,無序。

import java.util.ArrayList;
import java.util.List;

public class ListDemo {
	public static void main(String[] args) 
        {
		List list = new ArrayList();
		show(list);
	}

	public static void show(List list) {
		
		//新增元素
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");
		System.out.println(list);
		
		//插入元素。   void add(index,element);        void add(index,collection);
		list.add(1,"abc9");
		
		//刪除元素。    Object remove(index):
		System.out.println("remove:"+list.remove(2));
		
		//修改元素。    Object set(index,element);
		System.out.println("set:"+list.set(1, "abc8"));
		
		//獲取元素。
                //Object get(index);int indexOf(object);int lastIndexOf(object);List subList(from,to);
		System.out.println("get:"+list.get(0));
		
		//獲取子列表。前閉後開
		System.out.println("sublist:"+list.subList(1, 2));
		
		System.out.println(list);
	}

}

list集合是可以完成對元素的增刪改查。

List:
|--Vector:內部是陣列資料結構，是同步的。增刪，查詢都很慢！
|--ArrayList:內部是陣列資料結構，是不同步的。替代了Vector。查詢的速度快。

|--LinkedList:內部是連結串列資料結構，是不同步的。增刪元素的速度很快。

List中使用Iterator修改時的錯誤

Iterator it = list.iterator();
while(it.hasNext()){
	Object obj = it.next();//java.util.ConcurrentModificationException
	//在迭代器過程中，不要使用集合操作元素，容易出現異常。
        //可以使用Iterator介面的子介面ListIterator來完成在迭代中對元素進行更多的操作。 

	if(obj.equals("abc2")){
		list.add("abc9");
		}
	else
        	System.out.println("next:"+obj);
	}
    System.out.println(list);

正確用法

ListIterator it = list.listIterator();
//獲取列表迭代器物件  它可以實現在迭代過程中完成對元素的增刪改查。
//注意：只有list集合具備該迭代功能.	
while(it.hasNext()){
    Object obj = it.next();
    if(obj.equals("abc2")){
	it.set("abc9");
    }
    System.out.println("hasNext:"+it.hasNext());
}

iterator和listiterator的區別

一．相同點

都是迭代器，當需要對集合中元素進行遍歷不需要干涉其遍歷過程時，這兩種迭代器都可以使用。

二．不同點

1.使用範圍不同，Iterator可以應用於所有的集合，Set、List和Map和這些集合的子型別。而ListIterator只能用於List及其子型別。

2.ListIterator有add方法，可以向List中新增物件，而Iterator不能。

3.ListIterator和Iterator都有hasNext()和next()方法，可以實現順序向後遍歷，但是ListIterator有hasPrevious()和previous()方法，可以實現逆向（順序向前）遍歷。Iterator不可以。

4.ListIterator可以定位當前索引的位置，nextIndex()和previousIndex()可以實現。Iterator沒有此功能。

5.都可實現刪除操作，但是ListIterator可以實現物件的修改，set()方法可以實現。Iterator僅能遍歷，不能修改。