第四周

1.抽象

1.抽象類
	概念: 如果一個類中,有抽象方法的話,那么這個類必須定義為抽象類
    格式: abstract  class 類名{}
    注意: 抽象類中不一定有抽象方法呢,也可以是非抽象方法!
    舉例:
         我們在開發中,應該將"概括性的事物"抽象化
         不應該在事物中給出具體的體現
         而是僅僅宣告出來(就是沒有方法體的方法)
         讓具體的事物進行重寫
2.抽象方法: 和之前定義成員方法一樣,只是沒有方法體而已,沒有{}
         權限修飾符 abstract 回傳值型別 方法名(引數串列);
3.抽象類的本質:
         強制子類必須做的事情
         重寫抽象類的所有重寫方法
4.抽象類的特點:
         抽象類不能實體化
         不能創建物件

5.抽象類的注意事項:
         抽象類不能實體化,那么需用具體的子類實體化
         如果抽象類的子類是抽象類,那么也不能實體化,但是一定存在最具體的子類,否則沒有意義
         抽象類的實體化---通過抽象類多型,父類參考指向子類物件,有最具體的子類
                 Fu fu = new Zi() ;Fu--->是一個抽象型別別
6.抽象類的成員特點:
         1)成員變數
             既可以是變數,也可以自定義常量:被final修飾
         2)成員方法
             可以是抽象方法,也可以是非抽象方法
     	 3)構造方法:子類繼承父類,存在繼承關系,分層初始化
     		 先讓父類初始化,然后子類再進行初始化
		 4)注意事項: 子類的方法必須訪問權限足夠大,要么跟父類保持一致,否則報錯

2.介面

1.概念
		介面是一種規范,就是能夠實作介面中的額外的功能
		當前這個事物區域這個功能,就是體現事物能夠實作的擴展的額外功能
        介面---比抽象類還抽象的一種型別

2.格式
		關鍵字:interface 介面名{  介面名和類名的命名規范是一致的,"大駝峰命名法"
          }
3.介面的特點
        介面中的方法:只能是抽象方法,不能有方法體;
        介面特點:不能實體化(不能創建物件)

        介面的實體化:是通過介面多型
        介面的子實作類和介面的關系--->implements 實作關系
               interface 介面名{}
               class 子實作類名 implements 介面1,介面2...{}
               介面名 物件名 = new 子實作類名() ;
               
        如果當前介面子實作類是一個抽象類,一定會存在抽象類的子類,
        否則介面多型,子實作類new不了,所以當前抽象類一定有具體的子類
4.介面中的成員特點:
     	1)成員變數只能是常量,存在默認修飾符 public static final :可以省略不寫
        2)介面中的構造方法:沒有構造方法,只是提供一些抽象方法,讓子實作類實作這些方法
        3)介面中的成員方法:只能是抽象方法(一般都是抽象方法)
        	存在默認修飾符:public abstract :可以省略不寫

3.權限修飾符

private: 最小的
default: 默認修飾符
protected: 受保護的
public: 使用最最多的,訪問權限足夠大

權限修飾					在同一個包下的當前類中   同一個包下的子類中/無關類中    在不同包下子類中       
  private                      √
  默認修飾符                     √                         √
  protected:受保護的             √                         √                         √
  public :最大的                 √                         √                         √                  

其他的修飾符:
     static:結合自定義去使用
         定義自定義常量結合final
                 public static final 資料型別 變數名 = 初始化資料;
          static還可以在工具類中---->工具類中的構造方法私有化,里面的方法都加入static,類名訪問

     abstract--->修飾類-->抽象類
             還可以在成員方法中定義:抽象類中 =--->public abstract 回傳值型別 方法名(引數串列) ;
             abstract在介面中定義的抽象方法---abstract可以省略

     final結合static一塊使用的:
     public static final 資料型別 變數名 = 初始化資料;

4.抽象面試題

1.如果一個類中沒有抽象方法,那么把這個類定義為抽象類的意義何在?
        屬于"設計層面"----->設計某個類以及子類的結構
        就是不想讓直接 它new物件;肯定最終是有具體的子類存在

   舉例:
        jdk提供提供的日歷類---->Calendar 抽象類,不能new
        提供了靜態方法,回傳值就是它自己本身
        public static Calendar getInstance(){
                呼叫其他成員方法---->里面的本質就是 new 具體的子類物件();
        }
        
2:abstract不能和哪些關鍵字使用?
            abstract的應用場景:修飾類或者成員方法
            修飾成員方法注意:
               1)abstract不能和private關鍵字使用,因為被private修飾的只能在當前類訪問
                 而加入abstract需要讓子類實作這個方法;已經超出了當前訪問的范圍,所以沖突
               2)abstract不能和final一塊使用,因為被final修飾的成員方法不能被重寫的
                 而abstract修飾的抽象方法需要讓子類強制重寫的,所以沖突
               3)abstract不能和static一塊使用,因為被static修飾的方法,跟類相關的,隨著類的加載而加載
                 而抽象方法需要被子類重寫的,最終需要使用物件來抽象類多型:Fu fu   = new Zi() ;
                 和static一塊使用抽象方法在父類中又沒有方法體,加載進行記憶體,沒意義

3:介面和抽象類有什么區別?
        1)成員的區別
        	介面的成員:
                    成員變數:只能常量,存在默認的修飾符public static final,可以省略不寫
                    實際開發中,自定義一個常量,就定義一個介面,里面寫常量即可

                    成員方法:一般說的抽象方法,可以是default默認方法或者靜態方法,
                                必須有方法體
                               抽象方法,存在默認修飾符:public abstract 可以省略不寫
                    構造方法:
                            沒有
            
            抽象類的成員:
                      成員變數:可以是常量(被final修飾),也可以是變數
                      成員方法:既可以是抽象方法,也可以是非抽象方法,
                            抽象方法中的abstract不能省略!
                      構造方法 :存在有參構造/無參構造都可以
                            因為還是繼承關系,肯定分層初始化的
        2)關系的區別
            類與類的關系:extends
                    類:可能抽象類/具體類
                       繼承關系只支持單繼承,不支持多繼承,可以多層繼承
            類與介面的關系:implements 實作關系
                     一個類繼承另一個 類的同時可以實作多個介面
            介面與介面的關系:extends :繼承關系
                 可以單繼承,可以多繼承,也可以多層繼承
                 
        3)設計理念的區別
            抽象類: 
            	最終肯定具體的子類,是繼承關系
                繼承關系---體現的是一種"is a"的關系 抽象類多型
                    Animal(抽象類) a = new Dog() ;//狗是動物
                    a = new Cat() ;//貓是動物
            介面:
                   子實作類實作介面---> 實作關系
                描述的是事物本身不具備的功能,是通過后臺學習培養出來的工
                將這些功能----"額外的擴展功能"
                        核心思想---體現的是"like a "關系
                        
4.形式引數如果是一個具體類,實際引數如何傳遞
		實際引數需要當前類的具體物件
		或者匿名物件也可以
		
5.如果方法的形式引數是參考型別
    1)具體類:實際引數傳遞應該創建當前具體類物件
    2)抽象類,實際引數需要傳遞應該創建當前抽象類的子類物件(抽象類多型)
    3)介面:
    4)陣列:實際引數需要傳遞陣列物件

5.帶包的編譯運行

1.手動方式
		1)創建com檔案夾
				下面子檔案qf
		2)使用javac 先對HelloWorld的源檔案先進行編譯--->產生類名.class檔案 (位元組碼檔案)
		3)將2)位元組碼檔案放在qf子檔案夾下
		4)帶包名來運行
				java  包名.位元組碼檔案的前綴類名
					
2.自動方式:
        1)javac -d . java檔案---->它會自動的產生包名的結果com下面有個qf子檔案夾以及編譯后的位元組碼檔案在里面
        2)只需要帶包來運行即可
                java  包名.位元組碼檔案的前綴類名

6.內部類

1.概念:一個類A中定義一個類B,將類B就稱為類A的內部類
     	類A就是類B的外部類

2.特點:
     1)成員內部類---在外部類的成員位置定義的類
     2)區域內部類---在外部類的成員方法中定義的類
     
3.注意: 成員內部類中的成員訪問外部類的成員變數包括私有
		可以使用private修飾,保證資料的安全性
		
4.如何直接訪問成員內部類的成員方法
     	將外部類的成員內部類---當做是外部類的成員
     直接訪問的方式:
     	前提條件:當前的成員內部類是非靜態的
               外部類名.內部類名  物件名 = new 外部類物件.內部類物件
5.區域內部類特點:
		區域內部類也依然訪問外部類的成員變數,包括私有

6.面試題:
     1)區域內部類訪問區域變數的時候,能訪問碼?區域變數有什么要求?
             jdk7或者jdk7以前,區域變數必須顯示加入final修飾,否則訪問報錯
             而jdk8已經jvm優化了,此時這個num2就是常量
         
     2)使用反編譯工具查看內部類的結構--->發現其實已經加入了final,為什么?
             區域變數的生命周期是隨著的方法的呼叫而存在,隨著方法的呼叫結束而消失
             而當前這個方法結束之后,num2區域變數也應該就不存在了
             但是我們還在使用內部類物件訪問它里面這個成員方法
             而物件不會立即被GC立即回收,等待空閑的時候回收沒有更多參考的物件
             所以此時這些變數應該都是常駐記憶體,使用final定義----->常量

7.object類

1.Object類:
     每個類都有Object作為超類--->父類的意思
     所有的類都默認繼承自Object

2.常用方法:
	 1)public final Class getClass() (重要):獲取當前正在運行的Class類物件(位元組碼檔案物件)
	 2)public int hashCode():常用類都已經重寫了
          理解: "一個地址值",不是實際意義的地址值,它是經過底層的哈希演算法(hash)算出來的
     3)public String toString()
         回傳物件的字串表示形式,
         結果應該是一個簡明扼要的表達，容易讓人閱讀，建議所有子類覆寫此方法，'
    	 不需要我們自定義---使用的idea提供的toString
         自動生成: alt+ins---->toString()
	 4)public boolean equals(Object obj):比較物件是否相等
             參考該型別比較的是地址值是否相同
     5)protected Object clone()throws CloneNotSupportedException
     		創建并回傳此物件的副本
			本質就是復制物件---"淺克隆"
		Object里面的clone方法
           protected native Object clone() throws CloneNotSupportedException;
           本地方法---->非Java語言實作的,通過系統資源呼叫的
           如果此物件的類不實作介面Cloneable ，沒有成員方法就是標記介面
           如果某個物件的類實作這個介面的話,那么就說明這個類可以使用Object的clone來進行物件的復制
           		則拋出CloneNotSupportedException 

3.==和equals的區別
       1)==:如果連接都是兩個基本資料型別:比如int 比較的是資料值是否相等
       2)如果連接的是參考型別,那么比較的是地址值是否相同
			 equals()是Object類的方法
             原始碼
                 public boolean equals(Object obj) {
                           return (this == obj);
                     }
             如果我們不重寫Object的equals方法,
             默認比較的是兩個參考型別的地址值是否相同,
             如果重寫了equals方法而且同時重寫了hashCode()比較的是成員資訊是否相同
	  3)幾乎所有類都會覆寫
             論何時覆寫該方法equals()，通常需要覆寫hashCode方法
      4)工具生成: alt+ins--->eauals and hashCode

8.回傳值

回傳值問題
    方法的回傳值要么是基本資料型別,要么就是參考資料型別
    方法的回傳值是基本型別:是什么型別的時候,使用對應的型別接收即可

回傳值是參考型別:
   如果是具體類,需要回傳的當前類的具體物件
   如果是抽象類,需要回傳的是當前抽象類的子類物件
   如果是介面,需要回傳的是介面的子實作類物件

9.匿名內部類

    1.見名知意:沒有名字的類
    2.一般情況很少使用具體類的匿名內部類,因為具體類本身就可以new物件
    3.應用場景:
    	就是抽象類和介面中使用最多,其中介面使用最多的
    4.固定格式
        一個類中的某個區域位置使用
              new 類名(一般情況下:都是抽象類)或者介面名(){
					重寫抽象類或者介面的抽象方法(){
                     }};
	5.本質:就是繼承了該抽象類或者實作了該介面的子類物件
	4.注意事項
         1)形參問題:
               方法的形式引數如果是一個抽象類,呼叫方法的時候實際引數應該傳遞的當前抽象類的子類物件
			   方法的形式引數如果是一個介面型別,呼叫方法的時候,需要傳遞介面的子實作類物件
		2)回傳值問題
     		   方法的回傳值如果是一個介面,需要介面的子實作類物件

10.鍵盤錄入細節

    1)先錄入的String,在錄入i1nt,沒問題
    2)先錄入int,在錄入String,有問題
    	因為"回車符號"---->就是換行---->當空字符進去了,所以第二個數還沒有錄入的就完了
    解決方案:
        1)String nextLine() 錄入一行資料,--->官方用法
        使用另一種方法:public String next() 錄入的指定的字串內容(通用格式)
        2)就要使用nextLine()方法錄入STring,在錄入String之前,重新創建一個新的鍵盤錄入物件,也可以!
            String型別使用時最多的-->所以以后如果有int型別的錄入---->
                 可以都是用String資料接收(nextLine())--->
                 然后將String-->Integer->int(前提---->錄入的"數字字串")

11.String類(重點)

	1.String類:
        Java程式中的所有字串文字（例如"abc" ）都被實作為此類的實體
        特點: 字串是不變的,它們的值在創建后不能被更改;
            String str = "abc"; //創建字串物件的標準格式(建議)
            直接是在常量中查看是否存在這個字串常量,如果存在,就會查找常量池的地址值,否則,常量池中開辟空間

	2.String的構造方法
         1)String() :空參構造
         2)String(byte[] bytes) :有參構造,里面是位元組陣列(將byte[]--String)
                 解碼程序(將看不懂的內容--->字符--->平臺默認字符集現在"utf-8",所以不用帶字符集!)
         3)String(byte[] bytes, int offset, int length) :將一部分位元組陣列--->字串
                 引數1:位元組陣列
                 引數2:指定的位置開始
                 引數3:指定的長度
         4)String(char[] value) :將字符陣列---->字串
         5)String(char[] value, int offset, int count) :將一部分字符陣列--->字串
                 引數1:字符陣列物件
                 引數2:從指定位置開始
                 引數3:記錄數多少個
         6)String(String original) :構造的字串物件,引數為字串常量值
         
	3.""空字符序列和null的區別
         "":說明有內容,空的,依然可以使用String型別里面的所有功能
         null:空物件,不能在使用String的方法,在使用,就空指標例外NullPointerException

	4.String常用的判斷功能
        public boolean startsWith(String xxx) :以指定的字串開頭
        public boolean endsWith(String xxx):指定的字串結尾
        public boolean equals(Object obj):判斷字串的內容是否相同
        public boolean equalsIgoreCase(String str):不區分大小寫比較內容是否相同
        public boolean isEmpty():判斷字串是否空字符序列
        public boolean contains(String str):是否包含指定的字串
    
	5.String常用的獲取功能
        char charAt(int index):回傳指定索引出的字符
        String[] spilt(String regex) :使用指定的分割符號拆分字串,回傳的字串陣列
        String concat(String str):拼接功能,和指定字串拼接為新的字串內容
        String subString(int beginIndex):從指定的位置開始截取,默認截取到末尾;
        String subString(int beginIndex,int endIndex):從指定位置開始截取到指定位置結束
                        (不包含endIndex位置,包含在endIndex-1位置)
                        
	6.String類的轉換功能:
        public char[] toCharArray():將字串轉換為字符陣列
        public byte[] getBytes():將字串轉換成位元組陣列---使用平臺默認字符集編碼
        String的構造方法---String(byte[] bytes):使用平臺默認字符集解碼
        public String toLowerCase():將字串轉換成小寫
        public String toUpperCase():將字串轉換成大寫
	萬能方法:將任何資料型別轉換成String
        public static String valueOf(int/double/float/char[]/Object i)\
        
	7.String類的其他功能
        public String replace(char oldChar,char newChar):將指定的字符使用新字符進行替換
        public String replace(String oldStr,String newStr):替換指定字串
        public String trim():去除兩端空格
		public int compareTo(String anotherString):按照字典順序比較

12.String面試題

1.陣列中有沒有length(),String類中有沒有length(),集合中有沒有length()方法?
        陣列中沒有length(),叫length屬性
        String類有的length():獲取字串長度
        		獲取功能之一:int length()
		集合中沒有,是sise():獲取集合的元素數
2.
        String s = "hello";
        String s = new String("hello") ;
        有什么區別?分別創建了幾個物件呢?

        實際開發中:將常量賦值給字串和new String("常量")有區別,實際開發中使用的是前者
            1)將常量賦值給字串:常量賦值的 形式,直接在常量中找,是否存在常量
            	如果存在,就直接回傳常量池地址
              	如果不存在,那么現在常量池中開辟空間,然后再去把常量池地址賦值給變數s,從而有地址指向
            2)new String("常量"):
                    new 物件,---需要在堆記憶體空開辟空間(堆記憶體空間地址值)而里面有一個字串常量"hello"
                    然后在常量池中找,如果有,直接回傳常量池地址值,如果沒有,開辟常量池的空間地址
              不推薦,因為它的記憶體消耗很大
              
4.String和StringBuffer的區別?
     String是一個特殊的參考型別,形參的改變不會實際引數,效果和基本型別一致
     String是常量,一旦被賦值,其值不能被更改

     StringBuffer:是執行緒安全的一個類,支持可變的字符序列,
     參考型別除過String之外,形參改變直接影響實際引數

3.StringBuffer和StringBuilder有什么區別?
    共同點:就是具有相互兼容的API(StringBuffer能用的StringBuilder也可以)
            都是支持可變的字符序列,不斷在字串緩沖區進行追加字符
    不同點:   	
           	StringBuffer是執行緒安全的類,同步操作,執行效率低
           	StringBuilder是執行緒不安全的類,不同步的操作,執行效率高
           	
    單執行緒環境下都使用StringBuilder去替換StringBuffer,因為執行效率高
          	單執行緒環境:只考慮執行效率,不考慮安全
          	多執行緒環境:首先要考慮安全,然后在說效率

13.StringBuffer

	1.概念
		  字串緩沖區--->里面都存盤的可變的字符序列,但是它的型別StringBuffer型別
	2.構造方法
          StringBuffer() 空參構造
          StringBuffer(String str):有參構造
                         "hello"     --->容量大小--->16+5=21
                         中文很特殊--->超過某個容量值,系統會重寫分配
     	  StringBuffer(int capacity):指定容量大小
	3.獲取功能:
          int length():獲取字串緩沖區的長度(里面實際的字符序列的長度)
          public int capacity():獲取緩沖區的容量大小
               字串緩沖區默認16個初始容器里(英文字符)
               如果里面有字符序列,構造方法就是前兩個使用居多
               第一個是最常用的,空參構造方法--->創建字串緩沖區物件
	3.添加功能
          public StringBuffer append(任何型別資料) :追加功能 (常用的)
          回傳值是字串緩沖區本身,在緩沖區中的默認的字符序列后面依次追加

          public StringBuffer insert(int offset,char c/String str):
          回傳值是字串緩沖區本身,在指定的位置插入指定的字符或者字串
	4.反轉功能:
          StringBuffer reverse() 回傳字串緩沖區本身
          		截取功能和String型別的截取功能一樣
          String subString(int beginIndex):從指定位置默認截取到末尾--->String
          String subString(int beginIndex,int endIndex):
                從指定開始截取到指定位置結束endIndex-1出,回傳的新的字串

14.Integer

	1.引入
		jdk5以后的新特性:自動拆裝箱功能,每一個基本型別都自動裝箱為對應的包裝型別別
            byte --- Byte
            short--- Short
            int --- Integer
            long --- Long
            float--- Float
            double --- Double
            char  --- Character
            boolean --- Boolean
	2.Integer類的有些成員變數
         public static final int MAX_VALUE ;自定義常量
         public static final int MIN_VALUE ;
	3.靜態方法
         public static String toBinaryString(int i):將十進制資料--->二進制資料的字串形式
         public static String toOctalString(int i):將十進制資料--->八進制字串形式
         public static String toHexString(int i):將十進制資料---->十六進制資料的字串形式
	4.Integer類的作用
         Integer的構造方法
         Integer作為中間橋梁,,可以實作int型別和String型別的相互轉換
         同理,其他的基本型別和String型別的相互轉換--使用基本型別對應的包裝型別別
         (實際開發中,int和long,double使用最多)
         Integer的內部快取區特點IntegerCache
	5.Integer的構造方法
         Integer(int value)--->可以將基本型別資料--->Integer
         Integer(String s)throws NumberFormatException :將String--->Integer
                形式引數必須為"數字字串",否則如果不是數字字串--->
                        NumberFormatException出現數字格式化例外
	6.自動拆裝箱:
        基本型別會提示為對應的包裝型別--->稱為"裝箱"
        而包裝型別別會自動降為基本型別--->稱為"拆箱"
	7.Character:char型別保證型別
		構造方法:
     		Character(char value) 包含 char型別的值
     		
	8.Integer內部快取區的IntegerCache的作用
        將某個int的值直接賦值給Integer型別--->
        呼叫底層的方法public static Integer valueOf(int i)
                里面涉及到靜態的私有的成員內部類:IntegerCache
                如果當前我們的i的值是緩沖區的范圍內:low:-128  high=127,是直接在緩沖區中取資料
                否則,如果超出這個內部快取區的范圍的話,就執行else下面的代碼
                i3和i4:分別創建自己的物件,開辟堆記憶體空間!所以,地址值不同

15.Date

	1.概念
		java.util.Date:表示日期物件,精確到毫秒
	2.格式
        創建日期的時候Date--->使用的空參構造方法
            Date()
            public Date(long date)
                 是字串日期的文本格式
                 String "2008-5-12" <--->java.util.Date 相互轉換
	3.轉換的類:
		DateFormat:日期格式化類:他是抽象類,不能new物件
            public final String format(Date date):格式化 Date-->String
            public Date parse(String source) throws ParseException:決議
        使用它的子類
                SimpleDateFormat
        構造方法:public SimpleDateFormat(String pattern):
                引數是指定的一種模式
                年           yyyy
                月           MM
                日期         dd
                小時         hh
                分鐘         mm
                秒數         ss

16.System

1.System類包含幾個有用的類欄位和方法,它不能被實體化
 	欄位:(成員變數)
         public static final InputStream int ; 標準輸入流
         public static final PrintStream out ; 標準輸出流
         public static final PrintStream err ;標準的錯誤輸出流
         public static void gc()手動運行垃圾回收器
                 開啟垃圾回收器
                 jvm需要呼叫實際本質方法是Object類的方法protected void finalize() throws Throwable
         public static long currentTimeMillis() 回傳當前時間（以毫秒為單位)
                     這個方法:通過一個段規模比較的程式
         public static void arraycopy(Object src,    原物件(陣列)
                                 int srcPos,         原物件中的某個索引值
                                 Object dest,        目標物件(陣列)
                                 int destPos,        目標物件的指定的索引值
                                 int length)         復制多少個長度,從指定原陣列中復制元素到目標陣列中

17.集合

1.集合和陣列的區別
    1)長度區別
        陣列的長度是固定的
        集合的長度是可變的
    2)存盤資料型別的區別
        陣列存盤的資料型別既可以是基本資料型別,也可以是參考資料型別
        集合存盤的資料型別只能是參考資料型別
    3)存盤元素的區別
        陣列存盤的元素必須為同一種型別的元素
        集合存盤的元素(沒有泛型),可以存盤任意參考型別的元素
        
2.Collection集合
    1)常用方法:
        Object[] toArray():集合轉換成物件陣列
        boolean remove(Object o):洗掉集合中指定的元素
        void clear():洗掉所有元素(暴力洗掉)
        boolean contains(Object o):是否包含指定的元素

    2)集合的高級功能:(了解)
        帶All的功能
        boolean addAll(Collection c)添加一個集合中的所有元素
        boolean containsAll(Collection c):包括一個集合中元素
                    包含一個集合中所有元素
        boolean removeAll(Collection c):洗掉集合中的包含的元素
                    洗掉的元素一個只要包含,都存在,那么就洗掉了

             boolean retainAll(Collection     c):獲取兩個集合中交集元素,
             回傳值boolean表達的意思什么?

             A集合對B集合求交集,1)如果沒有交集元素,那么A集合內容就是[](-->存盤交集的元素 沒有交集)
             如果有交集,交集的元素是存在A集合中,回傳值是看A集合中的元素內容是否發生變化
             如果有變化--->true
             如果沒有變化--->false
    3)泛型
        1)概念: 就是集合物件的在創建的時候,就已經明確了存盤的型別的限定!(模擬我們的陣列的創建的格式一樣)
        2)泛型的好處:
                提高了程式安全性,不會出現型別轉換問題!
                避免了強轉型別轉換的格式
                將運行時期例外提前到了編時譯期(編譯通過不了,不能運行!)--- (使用迭代器的方式進行遍歷)
	4)Collection<E>集合遍歷的方式
        Object[] toArray() : 將集合轉換成物件陣列
        Iterator iterator():Collection集合的迭代器
        for(資料型別 變數名: 集合物件){
                使用變數名即可
        }
    5)迭代器
        Collection 的成員方法
             Iterator<E> iterator() :迭代器(理解原理)
             使用Collection集合的迭代器遍歷里面的字串元素
                    while(it.hasNext()){//是否有可以遍歷的元素,如果成立,不斷獲取
                                //Integer i = it.next() ;
                                String s = it.next();
                                System.out.println(s+"----"+s.length());
                            }
        迭代器Iterator(介面)的原理
            就是實作迭代器中的方法,boolean hasNext(){}    判斷是否有更多的元素可以遍歷
                                E next():獲取下一個可以遍歷的元素
            通過ArrayList集合的內部類Itr實作
            類似于游標指標,當通過判斷有由下一個可以遍歷的元素,游標指標通過next()向下一個位置元素移動
            直到當cursor如果達到了最大的集合的元素數,那么就不會再繼續移動了,后面沒有元素
            否則,就出現NoSuchElementException:沒有元素的例外

3.List
    1)概念: List集合是Collection的子介面
    2)特點:
        List集合可以允許元素重復,并且存盤和取出一致
	3)遍歷方式
        Object[] toArray() : 將集合轉換成物件陣列
        Iterator iterator():Collection集合的迭代器
        特有功能:E get(int index):通過索引獲取元素內容+int size()方法普通回圈實作
        特有功能:串列迭代器  ListIterator listiterator():
            ①增強for回圈變數List集合
                     for(String s:list){
                         System.out.println(s);
                     }
            ②普通for回圈便利List集合
                for(int x = 0 ; x <list.size() ; x ++){
                    String s = list.get(x);
                    System.out.println(s);
                }
    4)List的專有遍歷方式:
    第四種遍歷方式
    		(前面三種:Collection的Iterator迭代器/傳統方式Object[] toArray()/get(int index)+size()相結合)
        串列迭代器
             ListIterator<E> listIterator()
             ListIterator介面
             正向遍歷
                     boolean hasNext():判斷是有更多下一個元素可以迭代(遍歷)
                     E next()獲取下一個可以遍歷元素
             反向遍歷(不能單獨用,必須先有正向遍歷)
                     boolean hasPrevious():判斷是否有更多的上一個元素可以迭代(遍歷)
                     E previous():獲取上一個上一個可以遍歷的元素
                 
	5)ConcurrentModificationException: 并發修改例外
		使用迭代器去遍歷元素,不能使用集合物件去操作元素,否則就出現并發修改例外
      	解決方案:
             1)使用迭代器去遍歷,迭代器添加元素--->List的特有遍歷方式ListIterator有添加
             2)使用集合遍歷,集合添加元素

4.選擇排序
	思想:
         使用0角標對應的元素依次和后面角標對應的元素進行比較,小的值往前放,第一次比較完畢
         最小值就出現在最小索引處,依次這樣比較,就可以得到一個排好序的陣列

         比較的次數:陣列長度-1次
    代碼:
    	public static void selectSort(int[] arr){
                    //外層回圈比較的次數
                    for(int x = 0 ;x < arr.length-1; x++){
                        for(int y = x + 1 ;y< arr.length ;y++){
                            //依次和后面角標對應的元素進行比較,小的值往前放
                            if(arr[y] < arr[x]){
                                int temp = arr[x] ;
                                arr[x] = arr[y] ;
                                arr[y] = temp ;
                            }
                        }
                    }
                }