Java后端笔记7

一、集合

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

/**
 * Create by xiye on 2019/11/26 12:04
 */
public class Demo1_集合 {
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<>();

        collection.add("NO1");
        collection.add("NO2");
        collection.add("NO3");
        collection.add("NO4");

        System.out.println(collection);
        // 大小
        System.out.println(collection.size());
        // 移除
        collection.remove("NO2");
        System.out.println(collection);
        // 包含
        System.out.println(collection.contains("NO3"));
        System.out.println(collection.contains("NO5"));
        // 转数组
        Object[] array = collection.toArray();
        System.out.println(array.length);
        // 清空
        collection.clear();
        // 判空
        System.out.println(collection.isEmpty());

    }
}

二、迭代器

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

/**
 * Create by xiye on 2019/11/26 14:48
 */
public class Demo2_迭代器 {
    /*迭代器
    *   常用方法：next()获取下一个元素、hasNext()判断是否有下一个元素
    *   一般使用于 遍历 Collection集合和数组
    *   注意：不要对其进行增加或删除操作
    *
    * */
    public static void main(String[] args) {

        List<String> list = new ArrayList<>();
        list.add("何类");
        list.add("How are you");
        list.add("a li sei you");

        System.out.println("------------------迭代器形式：");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        System.out.println("------------------增强for形式：");
        for (String s : list) {
            System.out.println(s);
        }
    }
}

三、泛型

import com.xiye.bean.MyList;
import com.xiye.service.MyService;
import com.xiye.service.impl.MyServiceImpl;

import java.util.Set;

/**
 * Create by xiye on 2019/11/26 15:32
 */
public class Demo3_泛型 {
    /*泛型
    *   1、泛型类：在类名之后加上“<字符>”
    *   2、泛型接口：同泛型类
    *   3、泛型方法：在返回类型修饰符之前添加“<字符>”
    * */
    public static void main(String[] args) {
        // 泛型类
        System.out.println("--------------泛型类");
        MyList<String> strList = new MyList<>();
        strList.set("123");
        strList.set(1213L);
        strList.set(true);
        strList.set('a');

        // 泛型接口
        System.out.println("--------------泛型接口");
        MyServiceImpl<String, Integer> myService = new MyServiceImpl<>();
        myService.set("key1", 123);
        myService.set("key2", 10);

        Set<String> keys = myService.getKey();
        for (String key : keys) {
            System.out.println(key + "=" + myService.getValue(key));
        }

        // 泛型方法
        System.out.println("--------------泛型方法");
        print(0);
    }


    public static <T> void print(T t) {
        System.out.println(t.getClass());
    }
}

package com.xiye.bean;

/**
 * Create by xiye on 2019/11/26 15:32
 */
public class MyList<T> {

    public <E> void set(E e) {
        Class<?> aClass = e.getClass();
        System.out.println(aClass);
    }

}

package com.xiye.service;

import java.util.Set;

/**
 * Create by xiye on 2019/11/26 15:58
 */
public  interface MyService<K, V> {

    V getValue(K k);
    Set<K> getKey();
}

package com.xiye.service.impl;

import com.xiye.service.MyService;

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

/**
 * Create by xiye on 2019/11/26 16:24
 */
public class MyServiceImpl<K, V> implements MyService<K, V> {
    @Override
    public V getValue(K k) {
        return map.get(k);
    }

    @Override
    public Set<K> getKey() {
        return map.keySet();
    }

    public Map<K, V> map = new HashMap<>();

    public void set(K k, V v) {
        map.put(k, v);
    }

}

四、通配符

import java.util.ArrayList;
import java.util.List;

/**
 * Create by xiye on 2019/11/26 16:35
 */
public class Demo4_通配符 {
    /*通配符
     *   无限通配符：“<?>”
     *       一般做遍历时，接收任意参数，不能添加对其元素进行修改
     *       遍历时，遍历类型是Object类
     *   上限通配符：“<? extends 类>”
     *       即只接收当前类及其子类
     *   下限通配符：“<? super 类>”
     *       即只接收当前类及其父类
     *
     * */
    public static void main(String[] args) {
        List<Integer> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<Number> list3 = new ArrayList<>();
        List<Object> list4 = new ArrayList<>();

        infiniteWildcard(list1);     // OK
        infiniteWildcard(list2);     // OK
        infiniteWildcard(list3);     // OK
        infiniteWildcard(list4);     // OK


        upperWildcard(list1);        // OK
        upperWildcard(list2);        // NO
        upperWildcard(list3);        // OK
        upperWildcard(list4);        // NO

        lowerWildcard(list1);        // NO
        lowerWildcard(list2);        // NO
        lowerWildcard(list3);        // OK
        lowerWildcard(list4);        // OK
    }

    // 无限通配符
    public static void infiniteWildcard(List<?> list) {
        for (Object o : list) {
            System.out.println(o);
        }
        System.out.println(list.getClass());
    }

    // 上限通配符
    public static void upperWildcard(List<? extends Number> list) {

    }
    // 下限通配符
    public static void lowerWildcard(List<? super Number> list) {

    }
}