注意: 凡是java中,要擷取索引值的內容都是包頭不包尾!!也就是 start - end.

1.      JVM有常量優化機制.在編譯的時候進行的

2.      通過gbk碼錶一箇中文代表兩個位元組,而且中文的第一個位元組一定是負數.

3.      JVM在列印物件引用的時候預設列印toString方法 .

4.      如果列印一個引用型別變數時,結果不是Object 類的toString方法的結果(雜湊碼值)

那麼就一定是重寫了tostring 方法,本類沒找到那麼父類一定有.

String類

注意:

(1)    String 重寫了toString 方法,所以列印是的自己本身.字串是常量,一旦賦值就不可以被改變.在使用數推薦用StringBuffer類,因為String類會不斷製造垃圾物件.

(2)    解碼:就是把計算機看的懂得轉化為我們可以看懂的.

(3)     Java中 == 基本型別比較的是值,引用型別比較的是雜湊碼值. Equals比較的是物件的局數值.

String面試題  在開發中最少出一個.

1.      構造方法(一個數組轉化為字串)

         ()初始化一個新建立的String 物件，使其表示一個空字元序列

         (byte[] bytes)解碼指定的 byte 陣列，構造一個新的String

    (byte[] bytes,int offset(開始索引), int length(多少個字元))

轉一部分(int offset:從哪個索引開始.int length (轉多少個)

         (char[] value)分配一個新的String,其表示字元陣列引數中當前包含的字元序列。

         (char[] value,int offset(開始索引),int count(多少個字元))

(int[] codePoints, int offset,int count)

總結: 構造方法中沒有單int陣列的形參構造.更沒有short,float,double的形參.

2.       獲取的方法每天練習.

1> Int  length()  獲取字串的長度

2> char  charAt(int  index)

根據索引獲取對應位置的字元,可以用於遍歷字串

(注意角標越界)

(int ch)返回指定字元(ch)在字串中第一次出現的索引。

(int ch, int fromIndex)

(int  ch :需要尋找的字元,  int fromIndex:從哪個索引值開始找)  

 例:String st = “abcd”; int a = st.indexOf(‘b’, 2)

(String str) 返回小串在大串中第一次出現的索引值,若沒有則返回-1.

(String str,int fromIndex)

  (String  str : 需要查詢的小串,int  fromIndex:從哪個索引值開始找)

(String str,intfromIndex)(從指定位置向前找,返回索引)

(int beginIndex)//從指定位置擷取字串,預設到末尾.

例: String st=”abcdefgh”

String st1=st.substring(2)//從索引值為2的字元開始擷取st的字串.預設到結尾.   

(int beginIndex, int endIndex)

從指定位置開始到指定位置結束擷取字串.(包頭不包尾)

10 > int  lastIndexOf (int ch)獲取最後一個字元的位置

3. 判斷的方法

1>    boolean  equals(Object anObject) 是否相等

boolean  equalsIgnoreCase(String  anotherString) 忽略大小寫是否相等

2>    Boolean  contains(String  str) 大串中是否包含小串 應用：搜尋

Boolean  endsWith(String str) 是否以指定子串結束

4>    Boolean  isEmpty()是否長度為0 如：

’’ ” 與null的區別: “ ”:是字串常量,同時也是String物件.可以呼叫String中的方法

                    null : 是空常量,不能呼叫任何方法,可以給任意的引用資料型別賦值.

5.     轉換的方法 [比較重要.] 每天都要練一次.

1>    字元陣列等 轉化為字串  (解碼: 把計算機看的懂的轉化為我們可以讀懂的)

1>    > 構造方法

String(char[]  c) 將字元陣列轉換為字串(構造方法)

String(char[]  c, int  a, int  b)

2>    > 呼叫valueOf  可以將任意型別轉化為字串.

Static  String valueOf (char[] data) 把字元陣列轉化為字串

Static  String valueOf(char[] data, int offset,int count)

valueOf其實底層也是用構造方法去實現的.相當於把String的構造方法封裝起來了.

注意的是: 呼叫valueOf方法只有char陣列,byte與int陣列裝化為字串只有用構造方法才可以.只能傳入單個數組轉化為字串.例: valueOf(100).

2>    字串 轉化為 字元陣列等 ( 編碼: 把我們讀的懂的轉化為計算機讀得懂的額 )

char[]  toCharArray() 將字串轉換為字元陣列 (char 只有這一種方法.)

byte[]  getBytes(); 把字串轉化為位元組陣列.

注意: 通過gbk碼錶一箇中文代表兩個位元組,而且中文的第一個位元組一定是負數,第二個位元組有可能是正數.

3>    字串之間的轉換

String  toUpperCase() 轉大寫

String  toLowerCase() 轉小寫

6.     其他方法

String  replace(char oldChar, charnewChar)  替換字元

String  replace(String old,String  new )   替換字串

1> String[]  split(String  regex)  正則切割(只能切割字串不能切割陣列)

可以用於字串排序.

split(String regex,int limit)正則切割幾刀.

正則匹配 str.matches(regex)

String  trim() 去除兩端的空格(一般用於註冊用的)

Int  compareTo(String str)  //s.compareto(s1); 按照字典的順序比較字串. 字元一個一個的比較. 例:

Int  compareToIgnoreCase() //按照字典的順序比較字串不區分大小寫的比較.

String  concat( String  st) // 兩個字串拼接.//不推薦使用.因為只能是字串拼接.

優先使用 + 來拼接.

StringBuffer  類,

String 與stringBuffer的區別:

1>     String是一個不可變的字元序列.(會製造很多垃圾物件)

2>     StringBuffer是一個現成安全的且效率低的可變字元序列(不會製造垃圾物件)

1.      構造方法

1>    ()構造一個不帶字元的字串緩衝區,預設容量為16.

2>    (int capacity)指定初始容量.

例:new StringBuffer(10);容量為10的字串緩衝區.

例:new StringBuffer(“heima”)

2.      StringBuffer的新增功能

1>     可以新增任意的型別到緩衝區中.並返回字串緩衝區本身.

2>     (int offset, char c)在指定位置把任意型別的的資料插入到緩衝區中,並返回緩衝區本身.

3.      StringBuffer的刪除功能

1 > (int index)刪除指定索引的字元.

2        >  (int start, int end)刪除起始索引和結束索引的字元.

4.       StringBuffer類的替換和反轉

1>  (int start, int end,String str)

替換 (包含頭不包含尾 == end – start的個數.).

5.  StringBuffer 的擷取功能.

1>   String (int start)

2>  (int start, int end)

注意: 返回的值不是stringBuffer  而是String

6.  其他方法 

2>     Char (int index)還回指定索引處的字元.

3>    (int index)還回指定索引處的字元ASCII碼值.

7.      String和stringBuffer的相互轉換.

1>    String-----à stringbuffer

構造方法,new StringBuffer(str)和 append()方法.

2>    Stringbuffer-----à string

構造方法,  tostring()方法, 

substring(0, length) ----常用的.

8.      String  , StringBuffer與 StringBuilder 的區別和聯絡

1>    String 是一個不可變的字元序列.

StringBuffer 是1.0版本的-是執行緒安全的同步的,效率低, StringBuilder1.5版本的-是執行緒不安全的不同步的,效率高.

2>    String雖然是引用型別但是在當做引數傳遞時,和基本型別是一樣的.(就是因為一旦被賦值就不會被改變的特點)

Arrays類的方法.

1>    toString(int[]  a);//列印陣列字串

2>    sort(int []  a);//給陣列排序.

3>    binarySearch(int [] a, int  key);//二分查詢.

基本型別包裝類

1.       將基本型別封裝成包裝類的好處:是可以在物件中定義更多的功能方法操作該資料.

常用的操作是: 用於基本型別與字串之間的轉換.

2.       基本型別與包裝類的對應

byte                    Byte

           short                  Short

           int                       Integer

           long                    Long

           float                   Float

           double               Double

           boolean             Boolean

3.      Integer舉例

1>  Integer沒有空構造的方法.只有兩種如下.

例: Integer a = new Integer(100);

       Integer b = new Integer("100");

       System.out.println(a + 100);//打印出200 說明a是int型別.

System.out.println(b+100);//打印出200

3>  基本型別和引用型別相互轉換.

Int---àstring :  最推薦前2種.

1/ 直接和 “”相連, 例: syso(100 + “”);

2/ 直接呼叫String類的valueOf方法, 例:syso(String.valueOf(100));

3/直接呼叫Integer的tostring(int a);例:syso(Integer.tostring(100));

注意的是:Integer的空參tostring()不是靜態的.

      Int[] ---à String

          1: s = s + a[i] + “ ”;  2: s += s.append(a[i] + “ ”);

      String--àint 最推薦第1種.其次第二種.

            1/ 直接呼叫靜態的parseInt();例:syso(Integer.parseInt(“100”));

2/ 用Integer的構造:例:int a =new Integer(“100”);

            3/ 用integer類中的intValue();

     總結: 基本資料型別的包裝類中.其中7種(除了char)都有parsexxxx()的方法,可以講這7種的字串表現形式轉換成基本資料型別.

為什麼:char型別沒有呢  因為char c = integer.pasexxx(“abcde”)中c只能存一個字元. 所以不可能成立.

           Char 只能用 toCharArray()來把字串轉化為字元陣列.

4>  自動裝箱和拆箱JDK1.5的新特性

自動裝箱:把基本資料型別轉換為包裝類型別.

自動拆箱: 把包裝類型別轉換為基本資料型別.

例:Integer i = 100;//自動裝箱

int a = I + 200;//自動拆箱.

   注意的是:-128到127是byte的取值範圍,如果在這個取值範圍內,自動裝箱就不會新建立物件,而是從常量池中獲取, 如果超過byte取值範圍就會再建立新的物件.

4. Reges  正則表示式  [主要看 API的內容]

在ptterm類中. Java.util.regex

2>   [  ]表示單個字元.

3>   [\\d]數字字元 [\\D]非數字字元.

4>  [x]* 零次或多次. [x]+ 一次或多次 [x]{n}恰好出現n次, {n,}最少出現n次,{n,m}出現的次數在這個範圍內.

5> String[]split切割功能.(只能切割字串不能切割陣列)

String[] split(String regex,int limit)正則切割.

正則匹配.str.matches(regex);

6>    正則的分組功能

格式:是左括號為準.

例: ((A)(B(C))) :表示 1. ((A)(B(C)))2. (A)3. (B(C))4. (C)

疊詞的正則: 快快樂樂

正則表示: (.)\\1(.)\\2//\\1代表 第一組再出現一次.\\2代表第二組再出現一次

例: String st = "我我....我...我.要...要要...要"

                +"學....學學..學.編..編編.編.程.程.程..程";

System.out.println(st.replaceAll("\\.","").replaceAll("(.)\\1+","$1"))

//$1表示獲取到第一組的資料.

5.   Matcher類 與Pattern類 //獲取字串中的額手機號碼.很重要

   Pattern和Matcher的結合使用

String st = "我現在的手機號是15181007725,以前用18988888888,還用過 13488888888";

         Pattern p1 = Pattern.compile("1[3458][\\d]{9}");//獲取一個正則表示式

         Matcher m1 = p1.matcher(st); // 獲取一個匹配器

         while(m1.find())            //是否有--與正則表示式相匹配的字串

 System.err.println(m1.group());//輸出find()找到的字串.

6. Math類概述

* publicstatic int abs(int a) //絕對值

* public static double ceil(double a)//天花板

* public static double floor(double a)//地板

* public static int max(int a,int b) min自學//最大數,最小數

* public static double pow(double a,double b)//a^b

* public static double random()  //0~1的隨機數

* public static int round(float a) 引數為double的 //自學四捨五入

* public static double sqrt(double a) 開平方.

7.  Random 類. 用於生成隨機數字流.

1>> 構造方法

  Random r = new Random();//建立一個隨機數生成器,它的種子是一個變化納秒值,

Random r1 = new Random(5);建立一個以種子5的隨機數生成器,地層是根據//演算法(地層是以種子為演算法的,種子確定了隨機數就確定了.)

int i1 = nextInt();//這個是生成一個int取值範圍內的隨機數.

例: int i2 = nextInt(100)//表示生成一個0 -99之間的隨機數.重點掌握

                     //這個可以用來猜數字遊戲

8. System類

1>  > System類不可以new物件.

System.in 標準鍵盤輸入流,system.out 輸出流,system.err錯誤輸出流

2>  > 方法

public static void gc()//垃圾回收器.

public static void exit(int status)//終止JVM  非0表示異常關閉

public static long currentTimeMillis()//獲取當前時間毫秒值

pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, intlength) //拷貝陣列.很重要集合的底層用這個

src - 源陣列。

srcPos - 源陣列中的起始位置。

dest - 目標陣列。

destPos - 目標資料中的起始位置。

length - 要複製的陣列元素的數量

9.  BigInteger 類 在Math 的包下 (不用於金融和證券  瞭解即可 )

表示任意精度的整數.

*可以讓超過Integer範圍內的資料進行運算

 B:構造方法

*public BigInteger(String val)

C:成員方法

*public BigInteger add(BigInteger val) // + 加

*public BigInteger subtract(BigInteger val)// - 減

*public BigInteger multiply(BigInteger val)// * 乘

*public BigInteger divide(BigInteger val)// /(除)

*public BigInteger[] divideAndRemainder(BigInteger val) //除數和餘數的陣列.

BigDecimal 為了更精確的儲存小數.   (瞭解)

開發是推薦用兩種方法.(更精確)

1.  BigDecimal字串的構造方法.

例: BigDecimal  bd1 = new BigDecimal(“2.0”);

        BigDecimal  bd2 = new BigDecimal(“1.1”);

          Syso(bd1. Subtract(bd2));

2. static  BigDecimal (long val)方法.

例: BigDecimal  bd1 = BigDecimal.valueOf(2.0); 

        BigDecimal  bd2 = BigDecimal.valueOf(1.1);

Syso( bd1. Subtract(bd2));

10. Date 類  表示特定的瞬間.獲取當前時間物件

    *A:Date類的概述

    * 類 Date 表示特定的瞬間，精確到毫秒。

*B:構造方法

      *public Date() //代表的是當前時間

       *public Date(long date)//引數傳為0 表示1970年1月1日0點的時間.

                               //傳遞的是大於0的數就是 初始時間加上這個數

*C:成員方法

    * public long getTime()//通過時間物件獲取當前時間的毫秒值.

  (  System.currentTimeMillis()通過系統類的方法獲取毫秒值.)

    * public void setTime(long time)

          等效於 publicDate(long date)有參物件. 沒什麼卵用.

          只是setTime是改變時間物件,構造是建立一個時間物件

10.DateFormat是日期/時間格式化子類的抽象類，它以與語言無關的方式格式化並解析日期或時間。是抽象類，所以使用其子類SimpleDateFormat

11. SimpleDateFormat  日期格式化類 檢視API

           * public SimpleDateFormat()

           * public SimpleDateFormat(String pattern)

*C:成員方法  檢視API

           * public final String format(Date date) //將日期轉換為字串.

             例:Date d =new Date();SimpleDateFormat sdf = SimpleDateFormat(“y/M/dH:m:s”);

                   Syso(sdf.format(d));

*public Date parse(String source)//將字串轉換為日期物件.

            例: String s = “2000/08/08 08:08:08”;//這裡一定要和下面的格式對應起來

                   SimpleDateFormat sdf = new SimpleDateFormat(“yyyy/MM/ddHH:mm:ss”);

                   Date d = sdf.parse(s);

        練習:求我來到這個世界多少天.

12. Calender類   看API是抽象類,他的方法其實都是在子類實現的.他的直接子類是

          注意:抽象類由於不能建立物件.就造成了本類的方法不能呼叫,解決的方法有兩種1) 父類的引用指向子類物件來實現. Calender c = Calender.getInstance()

2)就是建立一個子類的物件呼叫子類重寫的方法.       

1.  獲取日期的方法.

 static Calendar getInstance()//獲得一個預設時區和語言環境的日曆

 int get(intfield) //返回給定日曆欄位的值  

2.  public void add(intfield,int amount)//對指定欄位相加或相減.

public final void set(int year,intmonth,int date)//修改指定欄位.

集合

1. 陣列和集合儲存引用資料型別,存的都是地址值

2.  集合框架

* A:集合的由來

*陣列長度是固定,當新增的元素超過了陣列的長度時需要對陣列重新定義,太麻煩,java內部給我們提供了集合類,能儲存任意物件,長度是可以改變的,隨著元素的增加而增加,隨著元素的減少而減少

*B:陣列和集合的區別

    * 區別1:

        * 陣列既可以儲存基本資料型別,又可以儲存引用資料型別,基本資料型別儲存的是值,引用資料型別儲存的是地址值

     *集合只能儲存引用資料類型(物件)集合中也可以儲存基本資料型別,但是在儲存的時候會自動裝箱變成物件

      例:100 地層相當於 new Integer(100)   裝箱在集合裡面引用相當廣泛.

    * 區別2:

     *陣列長度是固定的,不能自動增長

        * 集合的長度的是可變的,可以根據元素的增加而增長(部分集合的底層是用陣列來實現的)

*C:陣列和集合什麼時候用

     *1,如果元素個數是固定的推薦用陣列

     *2,如果元素個數不是固定的推薦用集合

    有的人就想不管是不是固定的都用集合,完全可以但是會浪費空間.而且效率低.

*D:集合繼承體系圖  (自己畫)

3. Collection 集合 它的方法在開發中都會使用.底層是陣列實現

一.Collection 的方法 以及 ArrayList方法

1> boolean add(E e)  給集合新增元素 .新增的是一個個物件.

在List集合中可以儲存重複元素所以任何型別都是返回true.Set集合中不可以儲存重複元素. 由於集合只能儲存引用資料型別所以基本資料型別會自動裝箱.Object類是任何類的直接接或間接的父類.

       2>boolean remove(Object o) 刪除集合中的指定元素.

      boolean removeAll(Collection c) // 刪除交集.

      booleanretainAll(Collection c) 取交集 如果改變是true未改變 false

3>voidclear() 清空集合.

       4>booleancontains(Object o)是否包含指定元素

          booleancontainsAll(Collection c)//取交集 判斷是否包含

5>booleanisEmpty()判斷是否為空

       6> int size()獲取集合中的元素個數.

7.Object[] toArray();把集合轉換成任何型別的陣列

遍歷陣列:其實就是依次獲取集合中的每一個元素 遍歷

二. Iterator介面  迭代器.(遍歷集合)  ArrayList中是繼承了Collection中的

Boolean hasNext() 判斷是否有元素可以迭代.則返回true,會指標後移

    E next()  (只能呼叫一次,呼叫多次指標會向後移動多洗)獲取迭代的下一個元素.這個會指標後移獲取下一個元素

上面兩個方法是迭代的黃金組合  用while迴圈.

集合框架(迭代器的原理及原始碼解析)(瞭解)

A:迭代器原理

 迭代器原理:迭代器是對集合進行遍歷,而每一個集合內部的儲存結構都是不同

的,所以每一個集合存和取都是不一樣,那麼就需要在每一個類中定義hasNext()和next()方法,這樣做是可以的,但是會讓整個集合體系過於臃腫,迭代器是將這樣的方法向上抽取出介面,然後在每個類的內部,定義自己迭代方式,這樣做的好處有二,第一規定了整個集合體系的遍歷方式都是hasNext()和next()方法,第二,程式碼有底層內部實現,使用者不用管怎麼實現的,會用即可

* B:迭代器原始碼解析

*1,在eclipse中ctrl +shift + t找到ArrayList類

*2,ctrl+o查詢iterator()方法

*3,檢視返回值型別是new Itr(),說明Itr這個類實現Iterator介面

*4,查詢Itr這個內部類,發現重寫了Iterator中的所有抽象方法

三.  List 介面

1> List集合中的特有功能概述

*void add(intindex,E element)//指定位置插入指定元素,別的元素向後移.

*E remove(intindex) //刪除指定位置(索引)的元素.返回獲取這個元素

*E get(intindex)  //獲取指定位置的元素.並返回獲取這個元素遍歷List特有的遍歷方法.

*E set(int index,E element)替換指定位置的元素.

*A:案例演示

   * 通過size()和get()方法結合使用遍歷。

         Listlist = new ArrayList();

         list.add(newStudent("張三", 18));

         list.add(newStudent("李四", 18));

         list.add(newStudent("王五", 18));

         list.add(newStudent("趙六", 18));

         for(inti = 0; i < list.size(); i++) {

             Students = (Student)list.get(i);

             Sys.out.println(s.getName()+ "," + s.getAge());

         }

四.  ListIterator集合框架(不常用知道就可以)

1> 迭代的時候新增元素就會 -併發修誤.ConcurrentModificationException

就要用到 ListIterator迭代器.(這是用迭代器的黃金組合)

    1/ void add() 新增到迭代器中 (List特有的方法).

五. 集合框架(Vector的特有功能) (瞭解只在面試題中出現)

Vector 被list完全替代掉了 開發不會在用.

* A:Vector類概述

* B:Vector類特有功能

  * public void addElement(E obj)

  * public E elementAt(int index)

  * public Enumeration elements()

* C:案例演示 

  * Vector的迭代

          Vector v = new Vector();    //建立集合物件,List的子類

          v.addElement("a");

          v.addElement("b");

          v.addElement("c");

          v.addElement("d");

          //Vector迭代

          Enumeration en = v.elements();          //獲取列舉

          while(en.hasMoreElements()) {       //判斷集合中是否有元素

              System.out.println(en.nextElement());//獲取集合中的元素

          }

六. List三個子類的特點

集合框架(List的三個子類的特點)

 A:List的三個子類的特點

     ArrayList:

         底層資料結構是陣列，查詢快，增刪慢。

         執行緒不安全，效率高。

     Vector:  (只會出現在面試題中)

         底層資料結構是陣列，查詢快，增刪慢。

         執行緒安全，效率低。

     Vector相對ArrayList查詢慢(執行緒安全的)

     Vector相對LinkedList增刪慢(陣列結構)

     LinkedList:

         底層資料結構是連結串列，查詢慢，增刪快。

         執行緒不安全，效率高。

     Vector和ArrayList的區別

         Vector是執行緒安全的,效率低

         ArrayList是執行緒不安全的,效率高

     共同點:都是陣列實現的

    ArrayList和LinkedList的區別

         ArrayList底層是陣列結果,查詢和修改快

         LinkedList底層是連結串列結構的,增和刪比較快,查詢和修改比較慢

     共同點:都是執行緒不安全的

B:List有三個兒子，我們到底使用誰呢?

     查詢多用ArrayList

     增刪多用LinkedList

     如果都多ArrayList (開發用的最多)

作業: 1:集合的由來?   2:集合和陣列的區別?  3:Collection集合的功能概述?

4:Collection集合儲存字串並遍歷?(迭代器) 5:Collection集合儲存自定義物件並遍歷?(迭代器) 6:List集合的特有功能? 7:List集合儲存字串並遍歷?(迭代器和普通for) 8:List集合儲存自定義物件並遍歷?(迭代器和普通for) 9:併發修改異常出現的原因?解決方案?

10:常見的資料結構的特點?

    陣列：

    連結串列：

11:List集合的子類特點

    ArrayList:

    Vector:

    LinkedList:

12:List的三個兒子你準備使用誰?請說明理由。

七.    ArrayList 方法的底層編寫的原理.(刪除重複元素)

案例1: 去除ArrayList中重複字串元素方式  新陣列去替換老陣列

案例2: 去除ArrayList中自定義物件的重複字串元素方式

  結論: contains 和remove方法的底層都是 用equals方法實現的.所以我們在使用自定義物件當做引數傳遞時要刪除重複元素時必須重寫自定義類的equals方法.

八. LinkedList 底層是連結串列實現的.

1.  特有的方法.

1>    public void addFirst(E e)及addLast(E e)//在頭加 及 在尾加.

2>     public E getFirst()及getLast() //獲取第一個元素 及 獲取最後一個元素

3>     public E removeFirst()及public EremoveLast()

  //刪除第一個 及 刪除 最後一個

4>     public E get(int index); //獲取指定索引的元素.

2.  棧和佇列的區別

棧: 是先進後出.  佇列:是先進先出.

作業: 用 LinkedeList 模擬棧和佇列.

九.  泛型 Generic-集合框架(泛型概述和基本使用)(會用就行)

1. :泛型好處

     1>提高安全性(將執行期的錯誤轉換到編譯期)

     2> 省去強轉的麻煩

2. C:泛型基本使用

   1>  <>中放的必須是引用資料型別

2>:泛型使用注意事項

        3> 前後的泛型必須一致,或者後面的泛型可以省略不寫(1.7的新特性菱形泛型) 

        4> 泛型一般不定義為Object因為沒有意義.

          成為類的泛型時.例: class 類名<泛型型別>

          成為方法的泛型時.

              一般情況下方法的泛型和類的泛型一致.若不一致就必須要宣告自己的型.

但是靜態方法必須要宣告自己的泛型.

例: public<泛型> 返回型別 方法名 (泛型型別 變數名)

           3. 泛型高階之萬用字元

                 A:泛型萬用字元<?>

*任意型別，如果沒有明確，那麼就是Object以及任意的Java類了

*B:? extends E

    * 向下限定，E及其子類

*C:? super E

    * 向上限定，E及其父類

十.  集合框架(增強for)(重點掌握)JDK1.5的新特性

1)好處:  簡化陣列和Collection集合的遍歷 它的底層

   只要可以用迭代器的迭代的類就一定可以用增強for迴圈.

2)原理: 底層依賴的是迭 代器(Iterator) 相當於把迭代器封裝了起來.

3)格式：

       for(元素資料型別變數 : 陣列變數或者Collection集合變數) {

           syso(i)

       }

作業: 陣列，集合儲存元素用增強for遍歷

4) 集合框架(三種迭代的能否刪除重複元素)  (重點掌握)

1>普通for迴圈,可以刪除,但是索引要 – (減減)

2>迭代器,可以刪除,但是必須使用迭代器自身的remove()方法,否則會出現併發修改異常(建議檢視API) 

3>增強for迴圈不能刪除

十一: 靜態匯入 ,看懂就可以  JDK1.5的敗筆 (掌握 面試會考)

1. 格式: import static 包名….類名.方法名 

2. 注意事項

方法必須是靜態的,如果有多個同名的靜態方法，容易不知道使用誰?這個時候要使用，必須加字首。由此可見，意義不大，所以一般不用，但是要能看懂。

十二 : 集合框架(Changeable可變引數)jdk1.5(掌握)

1> 格式  (可變引數其實就是陣列.)

       修飾符 返回值型別 方法名(資料型別… 變數名){}

       例:publicint[] get(int … arr){ }

2> 注意事項：

      這裡的變數其實是一個數組

 如果一個方法有可變引數，並且有多個引數，那麼，可變引數必須放在最後一個

例: public void get(int x,string s,int … arr){}

十三. 陣列與集合相互轉換.(掌握)

    1> 陣列-à集合  

固定格式:List<E> list=  Arrays.aslist(E,e);因為這是Arrays類中的靜態方法.所以這是固定格式

注意事項: 基本資料型別轉換成集合,會將陣列當做一個物件. 要想基本資料型別轉換成集合,就必須是基本資料型別的包裝類.

        例: 錯誤寫法:int[] a = {1,2,3,4}

正確寫法:Integer[] a = {1,2,3,4};

                List<Integer> list = Arrays.aslist(a);

  2> 集合---à陣列

方法1: Object[] obj = 集合變數.toArray(); 無參的轉換

方法2: T[] t = 集合變數.toArray(T[]a); 有參的轉換

   例: Integer[] it = list.toArray(new Integer[引數個數]);

   注意: [引數個數] 如果陣列長度小於或等於集合的size時,轉換後就會等於集合的長度.如果陣列的長度大於size,分配的長度就和指定的長度一樣. (最好要練習練習)

十四: 集合巢狀之ArrayList巢狀ArrayList(掌握)

    格式:  例:for(Array<Parson> a : list){for(Parsonp : a){ syso(p)}}

         例: ArrayList<Array<Parson>>list = new ArrayList<>();

              Array<Parson>a1 = new ArrayList<>();

    a1.add(newParson(“小”,12));

a1.add(newParson(“小小”,13));

              Array<Parson>a2 = new ArrayList<>();

                   a2.add(newParson(“大”,22));

a2.add(newParson(“大大”,23));

              list.add(a1);  list.add(a2);

十五 : set  介面

    1> 由於set是Collection的子介面.所以Collection的方法set都有.

        而且Set沒有特有的方法

        Set介面無重複元素的本質是:地層呼叫了hashcoude()和equals()方法.

        作業: HashSet儲存字串並遍歷

    2> 這裡用set的實現類 HashSet 來描述 Set類.

 (1)HashSet 實現集合類.

   無索引, 無重複元素,存和取無序

    1. 作業:儲存自定義物件，並保證元素唯一性(非常重要)

       必須重寫hashCode()和equals()方法

        記住:記憶體中只有hashcode()值是一樣的時候才會呼叫equals方法.不然永遠都不會呼叫  比如:火車上自己的座位上有人坐了才回去比較.

    開發中可以由Eclipse自動生成

拓展:為什麼Eclipse自動生成的hashcoude()中 ,常量是31呢?

    答:1) 31是個質數,較少公約數,2)  31不大也不小不會超出int取值範圍.

       3) 31剛還是2向左移5位再減1取得更好算.

publicbooleanequals(Object obj) {

                            if (this ==obj)   //傳入的物件等於本物件

                                 returntrue; 

                             if (obj ==null) //傳入的物件為空.空指標異常

                                 return false;

                            if(getClass() !=obj.getClass())//本物件的位元組碼檔案不等於

                            returnfalse;                 傳入檔案的位元組碼檔案

                            Parsonother =(Parson)obj;//上面都滿足了就可以向下轉型了.

                            if (age !=other.age) //如果本物件的年齡不等於傳入的年齡

                                 returnfalse;

                            if (name ==null) {   //如果本物件的名字為空.

                                 if (other.name !=null)//傳入的物件不為空

                                  returnfalse;

                             } elseif (!name.equals(other.name))//名字不相等

                                 returnfalse;

                                returntrue;

                        }

     上面不用自己寫,但是原理要掌握,程式碼優化

2. HashSet原理

* 我們使用Set集合都是需要去掉重複元素的, 如果在儲存的時候逐個equals()比較, 效率較低,雜湊演算法提高了去重複的效率, 降低了使用equals()方法的次數

* 當HashSet呼叫add()方法儲存物件的時候, 先呼叫物件的hashCode()方法得到一個雜湊值, 然後在集合中查詢是否有雜湊值相同的物件

* 如果沒有雜湊值相同的物件就直接存入集合

* 如果有雜湊值相同的物件, 就和雜湊值相同的物件逐個進行equals()比較,比較結果為false就存入, true則不存

3.將自定義類的物件存入HashSet去重複

* 類中必須重寫hashCode()和equals()方法

*hashCode(): 屬性相同的物件返回值必須相同, 屬性不同的返回值儘量不同(提高效率)

*equals(): 屬性相同返回true, 屬性不同返回false,返回false的時候儲存

(1.1)LinkedHashSet集合類

    1) LinkedhashSet的特點

 1.因為是hashset的子類,所以也能保證元素唯一,與hashset原理一樣 .方法也是一樣的

2. 底層是連結串列實現的,是Set集合中唯一一個能保證怎麼存就怎麼取的集合物件.

  作業: 產生10個1-20之間的隨機數要求隨機數不能重複

作業: Scanner從鍵盤讀取一行輸入,去掉其中重複字元, 打印出不同的那些字元

  作業:將集合中的重複元素去掉   addAll();

(1.2)TreeSet 集合類  (底層是二叉樹)  很重要

    1) TreeSet的特點  (重點對自定義類的操作的關鍵就是重寫CompareTo)

1.底層是二叉樹—兩個叉, 其實就是(compareTO)

儲存的特點:小的存在左邊(負數),大的存在右邊(正數)相等就不存(0)

2.對物件排序,也保證了物件的唯一.

3.當compareTo的方法返回值為0時就不存.

當compareTo的方法返回值為正數時排右邊

當compareTo的方法返回值為負數時排左邊..

   2)自然排序  (構造器為空) (按照字典順序排列) (Comparable )

1.用自定義物件時,必須重寫Comparable 介面的的方法.要不然排不了序.格式:ComparTo(應用型別  型別變數)

2.Comparable的compareTo()的方法.自定義類的操作的關鍵就是重寫CompareTo方法.

特點:

 1. TreeSet類的add()方法中會把存入的物件提升為Comparable型別(所以自定義物件就必須重寫CompareTo方法)

  2.呼叫物件的compareTo()方法和集合中的物件比較

          3. 根據compareTo()方法返回的結果進行儲存

作業: TreeSet儲存自定義物件並遍歷練習1(按照姓名排序)

TreeSet儲存自定義物件並遍歷練習2(按照年齡排序)

儲存自定義物件並遍歷練習2(按照姓名的長度排序)

 3) 比較器排序 (構造為比較器)  Comparator 特點

   1. 建立TreeSet的時候可以制定 一個Comparator(比較器)

例: TreeSet ts = new TreeSet(比較器物件)

          2. 如果傳入了Comparator的子類物件, 那麼TreeSet就會按照比較器中的順序排序

 3. add()方法內部會自動呼叫Comparator介面中compare()方法排序

          4. 呼叫的物件是compare方法的第一個引數,集合中的物件是compare方法的第二個引數

    4) 兩種方式的區別  (主要看建立的TreeSet的物件的構造)

1.TreeSet建構函式什麼都不傳, 預設按照類中Comparable的順序(沒有就報錯ClassCastException)

          2.TreeSet如果傳入Comparator, 就優先按照Comparator

作業:在一個集合中儲存了無序並且重複的字串,定義一個方法,讓其有序(字典順序),而且還不能去除重複 (很重要) 多練

public static voidmain(String[] args) {

                 ArrayList<String> list = newArrayList<>();

                 list.add("ccc");

                 list.add("ccc");

                 list.add("aaa");

                 list.add("aaa");

                 list.add("bbb");

                 list.add("ddd");

                 list.add("ddd");

                 sort(list);

                 System.out.println(list); }                   

            /* * 對集合中的元素排序,並保留重複

             * 1,void

             *2,List<String> list

             */

            public static void sort(List<String> list) {

                 TreeSet<String> ts = new TreeSet<>(new

Comparator<String>(){//定義比較器(new Comparator(){}是Comparator的子類物件)

                     @Override

                     public int compare(String s1, String s2) {//重寫compare方法

                 int num = s1.compareTo(s2);      //比較內容

                 return num == 0? 1 : num; }});  //如果內容一樣返回一個不為0的數字即可

                 ts.addAll(list);//將list集合中的所有元素新增到ts中

                 list.clear(); //清空list

                 list.addAll(ts);//將ts中排序並保留重複的結果在新增到list中

作業: 從鍵盤接收一個字串, 程式對其中所有字元進行排序,例如鍵盤輸入: helloitcast程式列印:acehillostt

作業: 程式啟動後, 可以從鍵盤輸入接收多個整數, 直到輸入quit時結束輸入. 把所有輸入的整數倒序排列列印