泛型和枚舉

1.泛型的簡介

在泛型中寫的是一個對象，不能是基本的資料類型（寫起對應的包裝類）

*List周遊方式：for循環、疊代器、增強for

*set周遊方式：疊代器、增強for（元素無序、不能重複出現）

*在map上使用泛型

  Map（key，value）

  周遊方式：1）擷取所有的key，通過key得到value，使用get方法

                    2）擷取key和value的關系

package com.dzg.learn.day07;

import org.junit.jupiter.api.Test;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class TestGenericity {

    @Test
    public void testMap(){
        /**
         * 在Map上使用泛型
         */
        Map<String,String> mapsets = new HashMap<String,String>();
        mapsets.put("a","a");
        mapsets.put("b","b");
        mapsets.put("c","c");
        mapsets.put("d","d");

        /**
         * map的周遊方式1:
         *      擷取所有的key，通過key值來擷取value值
         */
        Set<String> keysets = mapsets.keySet();
        for(String str:keysets){
            System.out.println(str+":"+mapsets.get(str));
        }
        System.out.println("=========");
        /**
         * map的周遊方式2:
         *      擷取key和value的關系
         */
        //得到key和value的關系
        Set<Map.Entry<String,String>> sets1 = mapsets.entrySet();
        //周遊sets1
        for (Map.Entry<String,String> entry:
             sets1) {
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
    }
}
           

2.泛型方法

    *定義一個數組，實作指定位置的元素的交換 

@Test
    public void swapElement(){
        Integer arr1[] = {1,2,3,4,5};
        System.out.println(Arrays.toString(arr1));
        swap(arr1,1,3);
        System.out.println(Arrays.toString(arr1));

        System.out.println("============");
        String arr2[] ={"aa","bb","cc","dd"};
        System.out.println(Arrays.toString(arr2));
        swap(arr2,0,3);
        System.out.println(Arrays.toString(arr2));
    }

    /**
     * 泛型交換的方法,T表示任意類型
     * 若不是用泛型的方法，對于不同類型的數組交換資料，需要寫出不同的方法（重載）
     * @param arr
     * @param i
     * @param j
     * @param <T>
     */
    public <T>void swap(T[] arr,int i,int j){
        T temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
           

泛型的擦除：泛型隻出現在源代碼階段，當編譯之後泛型就不存在了

3.泛型在類上使用（了解）

4.枚舉的簡介

***構造方法有參數，在每個執行個體上都需要傳遞參數

***在沒個枚舉類都實作抽象方法

package com.dzg.learn.day07;

import org.junit.jupiter.api.Test;

public class TestEnum {

    //知道枚舉的對象，得到枚舉的名稱和下标
    @Test
    public void test1(){
        //得到枚舉的對象
        Color color1 = Color.RED;
        //枚舉的名稱
        String str = color1.name();
        //枚舉的下标
        int index = color1.ordinal();
        System.out.println(index +":"+str);
    }
    //根據枚舉的名稱，得到枚舉的對象和名稱
    @Test
    public void test2(){
        String name = "GREEN";
        //得到對象
        Color color = Color.valueOf(name);
        //枚舉下标
        int index = color.ordinal();
        System.out.println(index+":"+color);
    }

    //知道枚舉的下标，得到枚舉的名稱和對象
    @Test
    public void test3(){
        int index = 2;
        //得到枚舉的對象
        Color color[] = Color.values();
        //根據下标得到對象
        Color col = color[index];
        String name = col.name();
        System.out.println(name+":"+col);
    }
}

enum Color{
    RED,GREEN,YELLOW;
}
           

5.靜态導入（了解）

  可以在java類中直接導入靜态的常量或者方法,導入之後可以直接使用對應的方法

  import static *******

  import static java.util.Arrays.sort

6.自動拆裝箱

   裝箱：把基本的資料類型轉換成包裝類

            八種基本資料類型對應的包裝類：int -- Integer 、char --Character 其他的首字母大寫

   拆箱：把基本的包裝類轉換成基本的資料類型

  JDK向下相容

7.增強for循環

 * 實作Iterable接口

 *map沒有實作該接口，list和set實作了

 * 底層就是疊代器，出現為了替代疊代器

8.可變參數：

   如果實作的多個方法，這些方法裡面的邏輯基本相同，唯一不同的是傳遞參數的個數不同，

可以使用可變參數。

   資料類型...數組名稱（三個點）、必須放在參數清單最後

  add（int...nums）nums相當于一個數組