-----------android教育訓練、java教育訓練、java學習型技術部落格、期待與您交流！------------
集合
一、基本資料類型包裝類
| 基本資料類型 | 引用資料類型：即對象 |
| int | Integer |
| long | Long |
| short | short |
| boolean | Boolean |
| char | Character |
| float | Float |
| double | Double |
以Integer為例： 常量：static 最大值MAX_VALUE、最小值MIN_VALUE
2、基本資料類型包裝類的最常見作用： 用于基本資料類型和字元串類型之間做轉換。 1）基本資料類型轉成字元串： 基本資料類型+""; 基本資料類型.toString(基本資料類型值)： 如：Integer.toString(34);//把int類型的34變成字元串"34" 2）字元串轉成基本資料類型： static xxx a=Xxx.parseXxx(String str) （靜态調用方式） 例如：int a=Integer.parseInt("123");//必須傳入數字格式的字元串 double d=Double.parseDouble("12.32"); boolean b=Boolean.parseBoolean("true"); 可以按進制進行轉換： Integer.parseInt("110",2) 注意：一個非靜态的方法:字元串轉基本資料類型 Integer i=new Integer("123");//先封裝成對象(對象調用方式) int num= i.intValue(); 3）進制轉換： a)10進制轉換成其他進制 toBinaryString(): toHexString(); toOctalString() b)其他進制轉換成10進制 Integer.parseInt("110",2) Integer.parseInt("3c",16) 示例：
<span style="font-size:14px;">//引用資料類型
public class IntegerDemo {
public static void main(String[] args) {
//整形類型的最大值
sop("int max="+Integer. MAX_VALUE);
//将一個基本資料類型轉成字元串
sop(Double.toString (12));
//将一個字元串轉換成整數
sop("num="+(Integer. parseInt("12")+4));
//進制
sop(" 6="+Integer. toBinaryString(6));
sop("-6="+Integer. toBinaryString(-6));
sop("60="+Integer. toHexString(60));//16進制
//其他進制轉換成10進制
sop("num="+Integer. parseInt("110",2)); //按照指定的進制進制轉換
sop("3c="+Integer. parseInt("3c",16));
}
public static void sop(String str){
System. out.println(str);
}
}</span>
二、基本資料類型包裝類的新特性： 1、Integer x=new Integer(4); Integer x=4; //新特性：自動裝箱，4就變成對象==new Integer(4);其隐式的完成。 //為了簡化書寫 2、新特性的時候，健壯性要差一點；要進行是否為空（null）的判斷； 3、Integer m=128; Integer n=128; sop("m==n:"+(m==n)); //false Integer a=127; Integer b=127; sop("a==b:"+(a==b)); //true:因為a和b指向了同一個Integer對象 //因為，當數值在byte範圍内時，對于新特性，如果該數值已經存在，不會開辟新的空間； 示例：
<span style="font-size:14px;">//JDK1.5版本的新特性
public class IntegerDemo2 {
public static void main(String[] args) {
//Integer x=new Integer(4);
Integer x=4; //新特性：自動裝箱 4就變成對象了===new Integer(4);其隐式的完成
//為了簡化書寫
x=x+2; //x+2:中的x進行了自動拆箱：x.intValue()，變成 int類型的，再和2進行加減運算；
//在将和進行裝箱付給x
Integer m=128;
Integer n=128;
sop("m==n:"+(m==n)); //false
Integer a=127;
Integer b=127;
sop("a==b:"+(a==b)); //true:因為a和b指向了同一個Integer對象
//因為，當數值在byte範圍内時，對于新特性，如果該數值已經存在，不會開辟新的空間；
}
public static void method(){
Integer x= new Integer("123" );
Integer y= new Integer(123);
sop("x==y :"+(x==y)); //false 兩個不同的對象
sop("x.equals(y) :"+x.equals(y)); //true Integer複寫了Object的equals方法，用于比較數值
}
public static void sop(String str){
System. out.println(str);
}
}
</span>
集合 一、體系概述 1、為什麼出現集合類？ 資料多了需要存儲：-->對象；對象多了，也需要存儲--->數組或者集合； 即對象多了用集合存，資料多了用對象存； 2、數組和集合都是容器，有何不同？為什麼有了數組還要集合？ 1）數組雖然也可以存儲對象，但長度是固定的；集合長度是可變的； 2）數組中可以存儲基本資料類型，集合隻能存儲對象。 ************數組一定義的時候，已經指定了類型，是以，隻能存同一種類型的對象。 ************而集合是，隻要是對象就可以存儲。 集合的應用更廣泛； 3、集合的特點： 集合隻能用于存儲對象；集合長度可變；集合可以存儲不同類型的對象。
4、集合架構：不斷向上抽取出來的：Collection 參閱頂層，建立底層；
List{ ArrayList、LinkedList、Vector Collection{ set{ TreeSet、HashSet 5、為什麼會出現這麼多的容器？ 是以每一個容器對資料的存儲方式都不同； 這個存儲方式我們稱之為：資料結構； 二、共性方法
注意：對象和集合一樣都是存放的位址值 1）add( )方法的參數類型是Object,以便于接收任意類型的對象。 2）集合中存儲的都是對象的引用(位址)
3、取兩個集合元素的交集 getRetainAll( ) 注意：如果沒有交集 就為空，什麼也不存 removeAll( ):去掉相同 的元素 示例：
<span style="font-size:14px;">import java.util.*;
//集合
public class CollectionDemo {
public static void main(String[] args) {
method_2();
}
public static void method_2(){
ArrayList al1=new ArrayList();
al1.add("aaa");
al1.add("bbb");
al1.add("ccc");
al1.add("ddd");
ArrayList al2=new ArrayList();
al2.add("aaa");
al2.add("bbb");
al2.add("eee");
al2.add("fff");
sop("al1="+al1);
//取交集
al1.retainAll(al2);//al1中隻保留與al2中相同的元素
sop("al1取al2的交集="+al1);
sop("al2="+al2);
al2.removeAll(al1);
sop("al2去掉al1相同的元素="+al2);
}
public static void baseMethod(){
//建立一個集合容器，使用Collection接口的子類，ArrayList
ArrayList al=new ArrayList();
//1、添加元素
al.add("aaa");
al.add("bbb");
al.add("ccc");
al.add("ddd");
//2、擷取個數，即集合的長度
sop("al="+al);
sop("al.size="+al.size());
//3、删除
sop(al.remove("bbb"));
sop("al-"+al);
// al.clear();//清空集合元素
// sop(al );
//4、判斷
sop("al是否包含bbb:"+al.contains( "ccc"));
sop("al是否為空："+al.isEmpty());
}
public static void sop(Object obj){
System. out.println(obj);
}
}</span>
三、疊代器： 1、 Iterator it=al.interator();//對象al調用方法，傳回的是Iterator接口 這個方法傳回的是這個接口的子類對象；該子類對象怎麼建立被封裝起來了。
接口型引用隻能指向自己的子類對象，該對象是通過方法.interator()擷取的。 Iterator接口中有：next( ); hasNext( );remove( );方法 其中：next(）：傳回疊代的下一個元素 ２、什麼是疊代器？ 其實就是集合取出元素的方式： ３、集合的特點： 把取出方式定義在集合的内部，這樣取出方式就可以直接通路集合内部的元素。那麼取出方式就被定義成内部類。
而每一個容器的資料結構不同，是以取出的動作細節也不一樣。但是都有共性的内容：判斷和去除。 那麼，可以将共性内容進行抽取。
内部類實作接口的方式：
那麼，這些内部類都符合一個規則，該規則就是Iterator接口。如何擷取集合的取出對象呢？ 通過一個對外提供的方法，iterator( ).
４、對于取出這個動作不足以用一個函數來描述，它需要用多個功能來展現；當多個功能展現的時候，把多個功能封裝到一個對象當中去。 每個容器中都有一個取出對象，因為資料結構不同，每個取出動作中取出的實作方式都不一樣。 這個取出需要被描述一下，那麼是怎麼樣描述的？ 通過一個類來完成，而這個類就定義在了集合内部。取出這個類定義在集合内部，這是為什麼呢？ 因為元素在集合中，你想直接操作元素，定義内部類最友善。這個内部類完成取出動作是定義。 例子：娃娃機： 其中：機箱是 容器，夾子是疊代器（取出方式），該夾子定義在了箱子中。 示例：
<span style="font-size:14px;">//擷取元素并操作元素
import java.util.*;
public class InteratorDemo {
public static void main(String[] args) {
ArrayList al=new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
// Iterator it=al.iterator();//擷取疊代器，用于取出集合中的元素
// while(it.hasNext()){
// sop(""+it.next());
// }
//啊使用for循環節省記憶體空間
for(Iterator it=al.iterator();it.hasNext();)
sop(""+it.next());
}
public static void sop(String str){
System. out.println(str);
}
}</span>
三、List集合共性方法 1、Collection: 1)List: 元素是有序的，元素可以重複，因為該集合體系是有索引的。 a) ArrayList:底層使用的是數組結構：特點：（因為有角标）查詢速度快，增删較慢。線程不同步（JDK1.2） b) LinkedList:底層使用的是連結清單結構：特點：增删快，查詢慢。線程同步，速度慢，被ArrayLsit取代 了。 c) Vector:底層是數組資料結構：（JDK1.0） Vector出現的時候，集合架構還不存在。 ArrayList和Vector的差別：ArrayList是不同步的；而Vector是同步的。 **************數組長度是固定的，可變長度的數組： ArrayList預設的長度是10，如果超過長度，就會new 一個新的數組，以50%遞增，然後把其原數組裝進去。 而，Vector是100%延長，是以ArrayList好一些，既可以延長，有可以節約空間。 2)Set: 元素是無序的，元素不可以重複 2、List集合中特有方法：凡是可以操作角标的方法都是該體系的特有方法。 1）增： 在指定位置插入元素：add(int index,element) addAll( int index ,Collection) 2）删： remove(index): 3）改： set(index,element) 4）查： get(index): subList（from,to）:包含頭，不包含尾 listIterator( 0) 示例： package jihe; //list import java.util.*; //以ArrayList為例 public class ListDemo {
public static void main(String[] args) { method_1(); } public static void sop(String str){ System. out.println(str); } //增 public static void method_1(){ ArrayList al=new ArrayList(); //添加元素 al.add("java01"); al.add("java02"); al.add("java03"); sop("原元素="+al); ArrayList a2=new ArrayList(); //添加元素 a2.add("hello"); a2.add("world"); sop("a2="+a2); //在指定位置添加元素 al.add(0, "aaa"); al.add(1,"bbb"); sop("al="+al); al.addAll(3,a2); sop("添加a2後="+al); //删除指定位置的元素 al.remove(2); sop("删除後="+al); //3、修改元素 al.set(0,"jiahao"); sop("改變後al="+al); //通過角标擷取元素 sop("al[0]="+al.get(0)); sop("子List="+al.subList(0,3)); for(ListIterator li=al.listIterator();li.hasNext();){ sop(""+li.next()); } } } 注意：可以通過集合操作元素，也可以通過疊代器操作；那麼，就有兩種方式操作操作元素。 對元素的并發通路，容易産生安全隐患。 3、ConcurretModificationException extends RunntimeException:當方法檢測到對象的并發修改，但不允許這種修改時，抛出異常。 4、Iterator it=al.iterator();疊代器隻能進行：hasNext ();next();和remove操作。其他 的不行。怎麼辦？ 其子類ListIterator 因為有指針、角标，是以方法比其父多好多。 5、List集合特有疊代器ListIterator,是Iterator 的子類。 在疊代時，不可以通過集合對象的方法操作集合中的元素。因為會發生ConcurrentModificationException異常； 是以，在疊代時，隻能通過疊代器的方法操作元素。可是呢Iterator是有限的，隻能對元素進行判斷、取出、删除操作。如果想要使用其他的操作，比如：添加、修改等，就要使用其子接口LstIterator,該接口隻能通過List集合的listIterator()方法擷取。 6、li.hasNext()：疊代後有沒元素： li.hasPrevious（）：:疊代後有沒有元素 7、vector 枚舉是Vector特有的取出方式： 其實：枚舉和疊代是一樣的；因為枚舉的名稱和方法的名稱都過長，是以被疊代器取代了。 示例：
<span style="font-size:14px;">package jihe;
//示範Vector集合
import java.util.*;
public class VectorDemo {
public static void main(String[] args) {
method();
}
public static void sop(String str){
System. out.println(str);
}
public static void method(){
Vector v=new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
sop("v原集合："+v);
Vector v2=new Vector();
v2.add("hello");
v2.add("world");
sop("v2原集合："+v2);
//增
v.add(2, "jiahao");
v.addAll(v2);
sop("v="+v);
v.addAll(0, v2);
sop("v="+v);
//删
v.remove(0);
sop("删除v[0]:"+v);
v.removeAll(v2);
sop("删除v2="+v);
//改
v.set(0, "quan");
sop("改後="+v);
//擷取
sop("get[0]="+v.get(0));
//
Enumeration en=v.elements();
while(en.hasMoreElements()){
sop(""+en.nextElement());
}
}
}</span>
8、LinkedList 特有方法： 1)addFirst()/addLast() 2)getFirst()/getLast():擷取元素，但是不删除元素 如果元素集合為空，則抛出NoSuchElementException異常 3)removeFirst()/removeLast()：擷取元素，并删除元素 如果元素集合為空，則抛出NoSuchElementException異常 -----》新方法（JDK1.6）取代方法： offerFirst()/offerLast():添加元素 peekFirst()/peekLast();擷取但是不删除元素，如果清單為空，則傳回null,而不抛出異常。 pollFirst()/pollLast(): 擷取并移除清單的元素，如果清單為空，則傳回null,而不抛出異常。 示例： 9、LinkedList練習： 練習一：使用LinkedList模拟一個堆棧或者隊列資料結構； 堆棧：先進後出； 隊列：先進先出 封裝，基于以前存在的結構功能，封裝成我們需要的結構。
示例：
<span style="font-size:14px;">package jihe;
//使用LinkedList模拟堆棧
import java.util.*;
public class DuizhanDemo {
public static void main(String[] args) {
DuiLie dui= new DuiLie();
dui.myAdd( "java01");
dui.myAdd( "java02");
dui.myAdd( "java03");
while(!dui.isNull()){
System. out.println(dui.myGet());
}
}
}
class DuiLie{
private LinkedList link ;
DuiLie(){
link= new LinkedList();
}
public void myAdd(Object obj){
link.addFirst(obj);//link.addLast(obj);
}
public Object myGet(){
return link .removeLast();//堆棧：removeFirst();
}
public boolean isNull(){
return link .isEmpty();
}
}</span>
練習二：去除ArrayList中重複的元素：
<span style="font-size:14px;">package jihe;
//去除ArrayList中重複的元素
import java.util.*;
public class LinkedListDemo3 {
public static void main(String[] args) {
ArrayList al=new ArrayList();
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java03");
sop("原al="+al);
al= singelElement(al);
sop("al="+al);
}
public static void sop(Object obj){
System. out.println(obj);
}
public static ArrayList singelElement( ArrayList al){
ArrayList newAl=new ArrayList();
Iterator it=al.iterator();
while(it.hasNext()){
Object obj=it.next();
if(!newAl.contains(obj)){
newAl.add(obj);
}
}
return newAl;
}
}</span>
注意： 練習三：将自定義對象作為元素存到ArrayList( )集合中，并去除重複元素： 比如：存人對象，同姓名同年齡，視為同一個人，為吃飯元素： 思路： 1）對人進行描述，把資料封裝成人對象。 2）定義容器，将人存入。 3）取出。 注意：List集合判斷元素是否相等，依據的是元素的equals方法。 ArrayList知不知道判斷相同的條件？ArrayList判斷的是對象是否相同，判斷對象是否相同使用equals()方法，在使用對象的equals（）方法和另一個對象比較。比較的是位址值。 remove底層也調用了equals方法； 是以：ArrayList LinkedList的remove contains方法依賴的都是equals方法。
一、hashSet Set:元素是無序的（存入和取出的順序不一緻），元素不可以重複。 |-----HashSet:底層資料結構是hash表。 HashSet：如何保證元素的唯一性？ 是通過元素的兩個方法，hashCode和equals方法。 如果元素的HashCode值相同，才會判斷equals是否為true. 如果元素的HashCode值不相同，不會調用equals方法。
|-----TreeSet: **********Set集合的功能和Collection是一緻的。 1、HashSet:底層資料結構是hash表，表裡面存入資料的順序是按照hash值的大小存的，而不是按照存入的順序。 2、 在hash表中，當hash值重複的時候，比較兩個元素對象是否相同。如果相同，認為是同一個對象，haash表中元素不重複，是以添加失敗。 如果對象不相同，就在同一個位址值下順延存放。（hash表中，完全以hash值為主。） 示例：
<span style="font-size:14px;">import java.util.*;
public class HashSetDemo {
public static void main(String[] args) {
hashSet();
}
public static void sop(Object obj){
System. out.println(obj);
}
public static void hashSet(){
HashSet hs=new HashSet();
hs.add("java01");
hs.add("java02");
hs.add("java03");
sop(hs.add( "java02"));//false:位址值和對象都一樣，添加不成功
Iterator it=hs.iterator();
while(it.hasNext()){//是無序的
sop(""+it.next());
}
}
}</span>
3、存儲自定義對象 ******四個對象，在hash表裡有四個位置的存儲，已經存進去了，就不會判斷equals() 4、覆寫Person的hashCode方法，就建立Person對象自己的hash值，那麼怎麼建立hash值？ 你的判斷條件是什麼，那麼，我就依據 條件建立hash值。 5、我們在自定義對象的時候，通常要複寫hashCode(),equals（）方法。 示例：
<span style="font-size:14px;">package jihe;
import java.util.*;
/*
* 往HashSet中存入自定義對象
* 姓名、年齡相同視為同一個人，重複元素
*/
public class HashSetDemo {
public static void main(String[] args) {
//hashSet();
HashSet hs=new HashSet();
hs.add(new Personn("a1",32)) ;
hs.add(new Personn("a3",34)) ;
hs.add(new Personn("a4",22)) ;
hs.add(new Personn("a3",34)) ;
Iterator it=hs.iterator();
while(it.hasNext()){
Personn p=(Personn)it.next();
sop(p.getName()+"...."+p.getAge());
}
}
public static void sop(Object obj){
System. out.println(obj);
}
/*public static void hashSet(){
HashSet hs=new HashSet();
hs.add("java01");
hs.add("java02");
hs.add("java03");
sop(hs.add("java02"));//false:位址值和對象都一樣，添加不成功
Iterator it=hs.iterator();
while(it.hasNext()){//是無序的
sop(""+it.next());
}
}*/
}
class Personn{
private String name;
private int age ;
Personn(String name, int age){
this.name =name;
this.age =age;
}
public int hashCode(){
System. out.println(this .name +"...hashCode" );
return name .hashCode()+age*39;//盡量保證hash值的唯一性
}
public boolean equals(Object obj){
if(!(obj instanceof Personn))
return false ;
Personn p=(Personn)obj;
System. out.println(this .name +"..equals.." +p.name );//互相比較
return this.name .equals(p.name)&& this.age ==p.age ;//其中的equals()是字元串的方法
}
public String getName(){
return name ;
}
public int getAge(){
return age ;
}
}</span>
6、hashSet判斷和删除的依據 注意：對于判斷元素是否存在，以及删除等條件，依賴的方法是元素的hashCode值和equals方法。
ArrayList判斷、删除元素隻依賴equals,而HashSet依賴hashCode和equals方法
資料結構不同，判斷的條件也不同。
示例：
<span style="font-size:14px;">package jihe;
import java.util.*;
/*
* 往HashSet中存入自定義對象
* 姓名、年齡相同視為同一個人，重複元素
*/
public class HashSetDemo {
public static void main(String[] args) {
//hashSet();
HashSet hs=new HashSet();
hs.add(new Personn("a1",32)) ;
hs.add(new Personn("a2",34)) ;
hs.add(new Personn("a3",21)) ;
//hs.add(new Personn ("a2",34));
//
sop("a2:"+hs.contains( new Personn("a2",34)));//先比較hashCode值，再比較equals
hs.remove( new Personn("a3" ,21));
Iterator it=hs.iterator ();
while(it.hasNext()){
Personn p=(Personn)it.next();
sop(p.getName()+"...."+p.getAge());
}
}
public static void sop(Object obj){
System. out.println(obj);
}
/*public static void hashSet(){
HashSet hs=new HashSet();
hs.add("java01");
hs.add("java02");
hs.add("java03");
sop(hs.add("java02"));//false:位址值和對象都一樣，添加不成功
Iterator it=hs.iterator();
while(it.hasNext()){//是無序的
sop(""+it.next());
}
}*/
}
class Personn{
private String name;
private int age ;
Personn(String name, int age){
this.name =name;
this.age =age;
}
public int hashCode(){
System. out.println(this .name +"...hashCode" );
return name .hashCode()+age*39;//盡量保證hash值的唯一性
}
public boolean equals(Object obj){
if(!(obj instanceof Personn))
return false ;
Personn p=(Personn)obj;
System. out.println(this .name +"..equals.." +p.name );//互相比較
return this.name .equals(p.name)&& this.age ==p.age ;//其中的equals()是字元串的方法
}
public String getName(){
return name ;
}
public int getAge(){
return age ;
}
}</span>
版權聲明：本文為CSDN部落客「lanzhenyue1990」的原創文章，遵循CC 4.0 BY-SA版權協定，轉載請附上原文出處連結及本聲明。
原文連結：https://blog.csdn.net/lanzhenyue1990/article/details/49806043