java學習day14——StringBulider、集合、Iterator迭代器、泛型

StringBuilder類

String類：
字符串常量，創建後不可更改，字符串的底層是一個被final修飾的數組
private final byte[] value;
StringBuilder類：
字符串緩衝區，可以提高字符串的操作效率（看成一個長度可以變化的字符串）
底層也是一個數組，但是沒有被final修飾，可以改變長度
byte[] value = new byte[16];
StringBuilder在內存中始終是一個數組，佔用的空間少，效率高，如果超出了StringBuilder的容量，會自動的擴容
StringBuilder類的構造方法及常用方法

public class Demo01StringBuilder {
    public static void main(String[] args) {
        //空參構造方法
        StringBuilder bu1 = new StringBuilder();
        System.out.println("bu1:"+bu1);
        //帶字符串的構造方法
        StringBuilder bu2 = new StringBuilder("abc");
        System.out.println("bu2:"+bu2);
        //StringBuilder的常用方法
        //append方法返回的是this，即調用方法的對象bu1  this==bu1
        StringBuilder bu3 = bu1.append("efg");//把部的地址賦值給了bu3
        System.out.println(bu1);
        System.out.println(bu3);
        System.out.println(bu1==bu3);//地址相同

        //使用append方法無需接收返回值,可鏈式編程
        bu1.append("hij").append(1).append(true).append(5.2).append('中');
        System.out.println(bu1);

        //toString方法:StringBuilder->String
        String s = bu2.toString();
        System.out.println(s);
    }
}

集合Collection

集合框架

集合和數組的區別

1. 存儲的數據類型
   數組可以存儲基本類型，也可以存儲引用類型
   集合只能存儲引用類型
2. 存儲的內容
   數組只能存儲一種類型的數據
   集合可以存儲不同類型（Object），但一般存儲的是同一種類型
3. 長度
   數組不可變，集合可變

Colletion常用功能

import java.util.ArrayList;
import java.util.Collection;

/*
java.util.Collection接口：
是所有單列集合的最頂層的接口，裏面定義了所有單列集合共性的方法
任意的單列集合都可以使用Collection接口中的方法
 */
public class Demo01Collection {
    public static void main(String[] args) {
        // 創建集合對象，可以使用多態
        Collection<String> coll = new ArrayList<>();
        System.out.println(coll);//重寫了toString方法 []
        // public boolean add(E e):把給定對象添加到當前集合中
        coll.add("abc");
        coll.add("efg");
        System.out.println(coll);//[abc]

        // public int size()：返回集合中元素的個數
        System.out.println("coll中元素個數："+coll.size());

        // public Object[] toArray()；把結合中的元素，存儲到數組中// public Object[] toArray()；把結合中的元素，存儲到數組中
        Object[] array = coll.toArray();
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

        // public boolean remove(E e):把給定對象再當前集合中刪除,刪除成果返回true
        coll.remove("abc");
        System.out.println(coll);//[efg]

        // public boolean contains(E e)：判斷當前集合中是否包含給定的對象
        System.out.println(coll.contains("efg"));//true

        // public void clear()：情況集合當中所有的元素
        coll.clear();
        System.out.println(coll);//[]

        // public boolean isEmpty()：判斷當前集合是否爲空
        System.out.println(coll.isEmpty()); //true
    }
}

Iterator迭代器

Iterator迭代器的使用方法

/*
java.util.Iterator接口：迭代器（對集合進行遍歷）
有兩個常用方法
    boolean hasNext() 如果仍有元素可以迭代，則返回 true。
    E next() 返回迭代的下一個元素。
Iterator迭代器是一個接口，我們無法直接使用，需要使用Iterator接口的實現類對象，獲取實現類的方式比較特殊
Collection接口中有一個方法，叫iterator(),這個方法返回的就是迭代器的實現類對象
    Iterator<E> iterator() 返回在此collection的元素上進行迭代的迭代器
迭代器的使用步驟:
    1. 使用集合中的方法iterator()獲取迭代器的實現類對象，使用Iterator接口接收（多態）
    2. 使用Iterator接口中的方法hasNext判斷還有沒有下一個元素
    3. 使用Iterator接口中的方法next取出集合中的下一個元素
 */
public class Demo02Iterator {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        coll.add("abc");
        coll.add("def");
        coll.add("ghi");
        // Iterator<E>接口也是有泛型的，泛型跟集合保持一致
        Iterator<String > it = coll.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

增強for

import java.util.ArrayList;

/*
增強for循環：底層使用的也是迭代器，使用for循環的格式，簡化了迭代器的書寫
是JDK1.5之後出現的新特性
Collection<E> extends Iterable<E>:所有的單列集合都可以使用增強for
public interface Iterable<T>實現這個接口允許對象成爲 "foreach" 語句的目標。
增強for循環：用來遍歷集合和數組
格式：
    for(集合/數組的數據類型 變量名：集合名/數組名){
        sout(變量名)
    }
 */
public class Demo03ForEach {
    public static void main(String[] args) {
        demo01();
        demo02();
    }
    // 使用增強for循環遍歷集合
    private static void demo02() {
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        for(String s:list){
            System.out.println(s);
        }
    }

    // 使用增強for循環遍歷數組
    private static void demo01() {
        int[] arr = {1, 2, 3, 4, 5};
        for(int i:arr){
            System.out.println(i);
        }
    }
}

泛型

泛型是一種未知的數據類型，當我們不知道使用什麼數據類型的時候，可以使用泛型
泛型也可以看成是一個變量，用來接收數據類型
E e：Element 元素
T t：Type 類型
ArrayList集合在定義的時候，不知道集合中都會存儲什麼類型的數據，所以使用泛型，創建對象的時候會確定泛型的類型，會把數據類型作爲參數傳遞，賦值給泛型E

使用泛型的好處

import java.util.ArrayList;
import java.util.Iterator;

public class Demo01Generic {
    public static void main(String[] args) {
//        show01();
        show02();
    }
/*
    創建集合對象，使用泛型
    好處：
        1.避免了類型轉換的麻煩，存儲的是什麼類型，去除的就是什麼類型
        2.把運行期異常（代碼運行之後會拋出的異常），提升到了編譯器(寫代碼的時候會報錯)
    弊端：泛型是什麼類型，就只能存儲什麼類型的工具
 */
    private static void show02() {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
//        list.add(1);//編譯的時候就直接報錯
    }

    /*
    創建集合對象，不使用泛型
    好處：集合不使用泛型，默認的類型就是Object類型，可以存儲任意類型的數據
    弊端：不安全，會引發異常
     */
    private static void show01() {
        ArrayList list = new ArrayList();
        list.add("abc");
        list.add(1);

        Iterator it = list.iterator();
        while(it.hasNext()){
            // 取出元素也是object類型
            Object obj = it.next();
            System.out.println(obj);

            // 想要使用String類特有的方法length獲取字符串的長度
            //需要向下轉型
            String s = (String)obj;
            System.out.println(s.length()); //拋出ClassCastException異常
        }
    }
}

定義和使用含有泛型的類

定義含有泛型的類

/*
定義一個含有泛型的類，模擬ArrayList集合
泛型是一個未知的數據類型，當我們不確定什麼數據類型的時候，可以用泛型
泛型可以接收任意的數據類型，可以使用Integer,String,Student,...
創建對象的時候確定泛型的數據類型
 */
public class GenericClass<E> {
    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}

使用含有泛型的類

public class Demo02Generic {
    public static void main(String[] args) {
        // 不寫泛型默認爲Object類型
        GenericClass gc = new GenericClass();
        gc.setName("只能是字符串");
        Object obj = gc.getName();

        //創建GenericClass對象，泛型用Integer類型
        GenericClass<Integer> gc2 = new GenericClass<>();
        gc2.setName(1);
        Integer name = gc2.getName();
        System.out.println(name);
    }
}

定義和使用含有泛型的方法

/*
定義含有泛型的方法：泛型定義在方法的修飾符和返回值之間
格式：
    修飾符<泛型> 返回值類型 方法名（參數列表（使用泛型））{
        方法體；
    }
含有泛型的方法，在調用方法的時候確定泛型的數據類型
傳遞什麼類型的參數，泛型就是什麼類型
 */
public class GenericMethod {
    // 定義一個含有泛型的方法
    public <M> void method01(M m){
        System.out.println(m);
    }
    //定義一個含有泛型的靜態方法
    public static <S> void method02(S s){
        System.out.println(s);
    }
}

/*
測試含有泛型的方法
 */
public class Demo03GenericMethod {
    public static void main(String[] args) {
        GenericMethod gm = new GenericMethod();
        gm.method01(10);
        gm.method01("abc");
        gm.method01(true);
        gm.method01(8.8);

        gm.method02("靜態方法，不建議創建對象使用");
        GenericMethod.method02("靜態方法");
    }
}

泛型通配符

不知道使用什麼類型接收時用<?>

import java.util.ArrayList;
import java.util.Iterator;

public class Demo05Generic {
    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);

        ArrayList<String> list2 = new ArrayList<>();
        list2.add("a");
        list2.add("b");

        printArray(list1);
        printArray(list2);
    }
    public static void printArray(ArrayList<?> list){
        Iterator<?> it = list.iterator();
        while(it.hasNext()){
            Object o = it.next();
            System.out.println(o);
        }
    }
}

泛型的上限限定和下限限定

鬥地主案例

需求分析

代碼

import java.util.ArrayList;
import java.util.Collections;

public class DouDiZhu {
    public static void main(String[] args) {
        // 定義一個存儲54張牌的ArrayList集合
        ArrayList<String> poker = new ArrayList<>();
        // 定義兩個數組，一個數組存儲牌的花色，另一個存儲序號
        String[] colors = {"♠","♥","♣","♦"};
        String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
        // 先把大王小王存儲到撲克集合中
        poker.add("大王");
        poker.add("小王");
        // 循環嵌套遍歷兩個數組，組裝52張牌
        for(String number:numbers){
            for(String color :colors){
                // 把組裝好的牌存到poker中
                poker.add(color+number);
            }
        }
        System.out.println(poker);
        // 洗牌，使用collections中的工具類
        //static void shuffle(List<?> list)  使用默認隨機源對指定列表進行置換。
        Collections.shuffle(poker);
        // 發牌
        // 定義四個集合，存儲玩家的牌和底牌
        ArrayList<String> player01 = new ArrayList<>();
        ArrayList<String> player02 = new ArrayList<>();
        ArrayList<String> player03 = new ArrayList<>();
        ArrayList<String> dipai = new ArrayList<>();
        // 遍歷poker集合
        for (int i = 0; i < poker.size(); i++) {
            String p = poker.get(i);
            if(i>=51){
                dipai.add(p);
            }else if(i%3 == 0){
                player01.add(p);
            }else if(i%3 == 1){
                player02.add(p);
            }else if(i%3 == 2){
                player03.add(p);
            }
        }
        // 看牌
        System.out.println("劉德華："+player01);
        System.out.println("周潤發："+player02);
        System.out.println("周星馳："+player03);
        System.out.println("底牌："+dipai);
    }
}

結果