JAVA集合（下篇）

1.泛型

1.泛型的概述

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法，是JDK5中引入的特性。

List arrayList = new ArrayList();
arrayList.add("aaaa");
arrayList.add(100);

for(int i = 0; i< arrayList.size();i++){
    String item = (String)arrayList.get(i);
    Log.d("泛型测试","item = " + item);
}
//java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

运行时结果会以奔溃结束

ArrayList可以存放任意类型，例子中添加了一个String类型，添加了一个Integer类型，再使用时都以String的方式使用，因此程序崩溃了。为了解决类似这样的问题（在编译阶段就可以解决），泛型应运而生。 

泛型定义格式：

• <类型>:指定一种类型的格式。这里的类型可以看成是形参
• <类型1,类型2…>:指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参
• 将来具体调用时候给定的类型可以看成是实参, 并粗实参的类型只能是引用数据类型

JDK 1.7开始之后，泛型后面的申明可以省略不写

泛型和集合都只能支持引用数据类型，不支持基本数据类型

ArrayList<String> lists = new ArrayList<String>();
ArrayList<String> lists = new ArrayList<>();
// JDK 1.7开始之后，泛型后面的申明可以省略不写!!

• 泛型的好处：
  • 把运行的错误提前到编译时期
  • 避免了强制类型转换

2.泛型类

泛型类的概念：使用了泛型定义的类就是泛型类

常用泛型变量：T、E、V、K等形式的参数用来表示泛型

格式：

修饰符 class 类名<泛型变量>{}
//范例
public class Generic<T> {}

 泛型类的核心思想：是把出现泛型变量的地方全部替换成传输的真实数据类型

代码：

泛型类：

package ceshi;

public class Generic<T> {
    private T t;

    public T getT() {
        return t;
    }
    public void setT(T t) {
        this.t = t;
    }
}

测试类：

package ceshi;

public class GenericDemo {
    public static void main(String[] args) {
        Generic<String> g1 = new Generic<>();
        g1.setT("y1");

        Generic<Integer> g2 = new Generic<>();
        g2.setT(20);

        System.out.println(g1.getT()+","+g2.getT()); //y1,20

        Generic<Boolean> g3 = new Generic<>();
        g3.setT(true);
        System.out.println(g3.getT()); //true
    }
}

3.泛型方法

我们见到的大多数泛型类中的成员方法也都使用了泛型，有的甚至泛型类中也包含着泛型方法 

 泛型方法定义格式：

修饰符 <类型> 返回值类型 方法名(类型 变量名){}
//范例
public <T> void show(T t) {}

代码：

泛型方法定义：

/*public class Generic {
    public void show(String s) {
        System.out.println(s);
    }
    public void show(Integer i) {
        System.out.println(i);
    }
    public void show(Boolean b) {
        System.out.println(b);
    }
}*/

//泛型类改进
/*
public class Generic<T> {
    public void show(T t) {
        System.out.println(t);
    }
}
*/

//泛型方法
public class Generic {
    public <T> void show (T t) {
        System.out.println(t);
    }
}

 测试类：

public class GenericDemo {
    public static void main(String[] args) {
        /*Generic g1 = new Generic();
        g1.show("y1");
        g1.show(30);
        g1.show(true);*/

        //泛型类
        /*Generic<String> g1 = new Generic<>();
        g1.show("y1");

        Generic<Integer> g2 = new Generic<>();
        g2.show(10);*/

        //泛型方法
        Generic g = new Generic();
        g.show("y1");
        g.show(10);
        g.show(true);
        g.show(13.14);
        /*y1
        10
        true
        13.14*/

    }
}

4.泛型接口 

泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中 

泛型接口定义格式：

修饰符 interface 接口名称<类型> {}
//范例
public interface Generic<T> {}

 代码：

泛型接口： 

public interface Generic<T> {
    void show(T t);
}

实现类：

public class GenericImpl<T> implements Generic<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

测试类：

public class GenericDemo {
    public static void main(String[] args) {
        GenericImpl g1 = new GenericImpl();
        g1.show("y1");
        g1.show(10);
    }
}

 5.泛型的通配符

• 为了表示各种泛型List的父类，可以使用类型通配符

  • 类型通配符: <?>
  • List<?>：表示元素类型未知的List,它的元素可以匹配任何的类型
  • 这种带通配符的List仅表示它是各种泛型List的父类,并不能把元素添加到其中

• 如果说我们不希望List<?>是任何泛型List的父类,只希望它代表某一类泛型List的父类，可以使用类型通配符的上限

  • 类型通配符 上限: <? extends类型>
  • List<? extends Number>：它表示的类型是Number或者其子类型

• 除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限

  • 类型通配符 下限:：<?super 类型>
  • List<? super Number>：它表示的类型是Number或者其父类型

 注：此处’？’是类型实参，而不是类型形参。再直白点的意思就是，此处的？和Number、String、Integer一样都是一种实际的类型，可以把？看成所有类型的父类。是一种真实的类型

可以解决当具体类型不确定的时候，这个通配符就是 ?  ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

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

public class GenericDemo {
    public static void main(String[] args) {
        //类型通配符: <?>
        List<?> list1 = new ArrayList<Number>();
        List<?> list2 = new ArrayList<String>();
        List<?> list3 = new ArrayList<Integer>();

        //类型通配符上限: <? extends类型>
//        List<? extends Number> list4 = new ArrayList<Object>(); 报错，超过上限
        List<? extends Number> list5 = new ArrayList<Number>();
        List<? extends Number> list6 = new ArrayList<Integer>();

        //类型通配符 下限:：<?super 类型>
        List<? super Number> list7 = new ArrayList<Object>();
        List<? super Number> list8 = new ArrayList<Number>();
//        List<? super Number> list9 = new ArrayList<Integer>(); 报错
    }
}

2.Map集合

1.Map集合的概述

• Map集合是一种双列集合，每个元素包含两个值
• Interface Map<K,V>； K：键的类型，V：值的类型
• Map集合的每个元素的格式：key = value(键值对元素)
• Map集合也被称为“键值对集合” 

• Map集合特点：
  • Map 集合的键是无序，不重复，无索引的
  • Map 集合后面重复的键对应的元素会覆盖前面的整个元素 

2.Map集合的基本方法

方法名	说明
public V put(K key, V value)	添加元素
public V remove(Object key)	根据键删除键值对元素
public void clear()	移除所有键值对元素
public boolean containKey(Object key) [kənˈteɪn]	判断集合是否包含指定的键
public boolean containValue(Object value)	判断集合是否包含指定的值
public boolean isEmpty()	判断集合是否为空
public int size()	集合的长度，也就是集合中键值对个数

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

public class MapDemo {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();

        //1,public V put(K key, V value) 	添加元素
        map.put("y1","10");
        map.put("y2","20");
        map.put("y3","30");
        System.out.println(map); //{y1=10, y2=20, y3=30}

        //2,public V remove(Object key) 	根据键删除键值对元素
        /*map.remove("y2");
        System.out.println(map); //{y1=10, y3=30}
        */

        //3,public void clear() 	移除所有键值对元素
       /* map.clear();
        System.out.println(map); //{}
        */

        //4,public boolean containKey(Object key) [kənˈteɪn] 	判断集合是否包含指定的键
        /*System.out.println(map.containsKey("y2")); //ture
        System.out.println(map.containsKey("y4")); //false*/

        //5,public boolean containValue(Object value) 	判断集合是否包含指定的值
//        System.out.println(map.containsValue("10")); //true

        //6,public boolean isEmpty() 	判断集合是否为空
//        System.out.println(map.isEmpty()); //false

        //7,public int size() 	集合的长度，也就是集合中键值对个数
        System.out.println(map.size()); //3
    }
}

 3 Map集合的获取方法（重要）

方法名	说明
public V get(Object key)	根据键获取值
public Set<k> keySet()	获取所有键的集合
public Collection<v> values()	获取所有值的集合
public Set<Map.Entry<K,V>> entrySet()	获取所有键值对对象的集合

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

public class MapDemo {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();

        //public V put(K key, V value) 	添加元素
        map.put("y1","10");
        map.put("y2","20");
        map.put("y3","30");
        System.out.println(map); //{y1=10, y2=20, y3=30}

        //1,public V get(Object key) 	根据键获取值
        System.out.println(map.get("y1")); //10
        System.out.println(map.get("y4")); //null

        //2,public Set<K> keySet() 	获取所有键的集合，存储到Set集合中
        Set<String> key = map.keySet();
        for(String s:key) {
            System.out.println(s);
            /*y1
            y2
            y3*/
        }

        //3,public Collection<V> values() 	获取所有值的集合，存储到Collection集合中
        Collection<String> vlaues = map.values();
        for(String s:vlaues) {
            System.out.println(s);
            /*10
            20
            30*/
        }

        //4,public Set<Map.Entry<K,V>> entrySet() 	获取所有键值对对象的集合（Set集合）
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for(Map.Entry<String, String> s:entries) {
            System.out.println(s);
            /*
            y1=10
            y2=20
            y3=30*/
        }
    }
}

4.Map集合的三种遍历方法

1."键找值"的方式遍历

2."键值对"的方式遍历

3.Lambda 表达式（JDK1.8开始之后的新技术）

1."键找值"的方式遍历

获取所有键的集合。用keySet()方法实现

遍历键的集合，获取到每一个键。用增强for实现

根据键去找值。用get(Object key)方法实现

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

public class MapDemo {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();

        //public V put(K key, V value) 	添加元素
        map.put("y1", "10");
        map.put("y2", "20");
        map.put("y3", "30");
        System.out.println(map); //{y1=10, y2=20, y3=30}

        //1、获取所有键的集合：用keySet()方法实现
        Set<String> keySet = map.keySet();

        //2、遍历键的集合，获取到每一个键：用增强for遍历实现
        for (String key : keySet) {
            //3、根据键去找值：在增强for中，用get(Object key)方法实现
            String value = map.get(key);
            System.out.println(key + "=" + value);
            /*
            y1=10
            y2=20
            y3=30*/
        }
    }
}

2."键值对"的方式遍历

• 获取所有键值对对象的集合
  • Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合
• 遍历键值对对象的集合，得到每一个键值对对象
  • 用增强for实现，得到每一个Map.Entry

• 根据键值对对象获取键和值
  • 用getValue()得到值
  • 用getKey()得到键

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

public class MapDemo {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();

        //public V put(K key, V value) 	添加元素
        map.put("y1", "10");
        map.put("y2", "20");
        map.put("y3", "30");
        System.out.println(map); //{y1=10, y2=20, y3=30}

        //1、获取所有键值对对象的集合：Set<Map.Entry<K,V>> entrySet()
        Set<Map.Entry<String, String>> entrySet = map.entrySet();

        //2、遍历键值对对象的集合，得到每一个键值对对象：用增强for实现，得到每一个Map.Entry
        for(Map.Entry<String, String> me:entrySet) {
            //3、根据键值对对象获取键和值：在增强for中，用geKey()得到键；用getValue()得到值
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key+"="+value);
            /*
            y1=10
            y2=20
            y3=30*/
        }
    }
}

3. Lambda表达式方式遍历 

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

public class MapDemo {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();

        //public V put(K key, V value) 	添加元素
        map.put("y1", "10");
        map.put("y2", "20");
        map.put("y3", "30");
        System.out.println(map); //{y1=10, y2=20, y3=30}

        map.forEach((k , v) -> {
            System.out.println(k+"="+v);
            /*
            y1=10
            y2=20
            y3=30*/
        });
    }
}

5.HashMap集合

Map集合的键和值都可以存储自定义类型

如果希望Map集合认为自定义类型的键对象重复了，必须重写对象的hashcode()和equals()方法

HashMap 基于哈希表的 Map 接口实现，是以 key-value 存储形式存在，即主要用来存放键值对。HashMap 的实现不是同步的，这意味着它不是线程安全的。它的 key、value 都可以为 null，此外，HashMap 中的映射不是有序的。

​

 案例：

​

学生类：

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

测试类：

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

public class MapDemo03 {
    public static void main(String[] args) {
        //创建HashMap集合对象
        HashMap<String,Student> hm =new HashMap<>();

        Student s1 = new Student("y1",10);
        Student s2 = new Student("y2",20);
        Student s3 = new Student("y3",30);

        hm.put("itheima1",s1);
        hm.put("itheima2",s2);
        hm.put("itheima3",s3);

        //键找值
        Set<String> keySet = hm.keySet();
        for(String key:keySet) {
            Student value = hm.get(key);
            System.out.println(key+","+value.getName()+","+value.getAge());
            /*itheima3,y3,30
            itheima1,y1,10
            itheima2,y2,20*/
        }
        System.out.println("---------");

        //键值对
        Set<Map.Entry<String, Student>> entrySet= hm.entrySet();
        for(Map.Entry<String, Student> me:entrySet) {
            String key = me.getKey();
            Student value = me.getValue();
            System.out.println(key+","+value.getName()+","+value.getAge());
            /*itheima3,y3,30
            itheima1,y1,10
            itheima2,y2,20*/
        }

    }
}

 6. LinkedHashMap（HashMap子类）

• LinkedHashMap集合是有序不重复的键值对集合

public class LinkedHashMapDemo {
    public static void main(String[] args) {
        Map<String , Integer> map = new LinkedHashMap<>();
        map.put("y1",10);
        map.put("y2",20);
        map.put("y3",30); 
        map.put("y3",100); //键不变，只是替换其值
        
        System.out.println(map);// {y1=10, y2=20, y3=100}   
    }
}

7.TreeMap

TreeMap是一个基于key有序的key value散列表。

• map根据其键的自然顺序排序，或者根据map创建时提供的Comparator排序
• 不是线程安全的
• key 不可以存入null
• 底层是基于红黑树实现的 

3.可变参数与

可变参数又称参数个数可变,用作方法的形参出现，那么方法参数个数就是可变的了

格式：修饰符 返回值类型 方法名(数据类型…变量名){ }

范例:public static int sum(int...a){} 

这里的变量其实是一个数组

一个方法有多个参数，包含可变参数，可变参数放最后

范例：public static int sum(int b,int...a){} 

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

public class GenericDemo {
    public static void main(String[] args) {
        System.out.println(sum(10,20));
        System.out.println(sum(10,20,30));
        System.out.println(sum(10,20,30,40));
        /*
        30
        60
        100*/
    }
    public static int sum(int...a) { //a为数组
        int sum =0;
        for(int i:a) {
            sum +=i;
        }
        return sum;
    }
    //一个方法有多个参数，可变参数放最后
    /*public static int sum(int b,int...a) {
        return 0;
    }*/
}

可变参数的使用：

• Arrays工具类中有一个静态方法：

  • public static List asList(T… a)：返回由指定数组支持的固定大小的列表
  • 返回的集合不能做增删操作，可以做修改操作

• List接口中有一个静态方法：

  • public static List of(E… elements)：返回包含任意数量元素的不可变列表
  • 返回的集合不能做增删改操作

• Set接口中有一个静态方法：

  • public static Set of(E… elements) ：返回一个包含任意数量元素的不可变集合
  • 在给元素的时候，不能给重复的元素
  • 返回的集合不能做增删操作，没有修改的方法

 

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;

public class GenericDemo {
    public static void main(String[] args) {
        //1、public static <T> List<T> asList(T... a)：返回由指定数组支持的固定大小的列表
/*        List<String> list = Arrays.asList("java", "python", "scala");
        System.out.println(list); //[java, python, scala]

//        list.add("javase"); //UnsupportedOperationException;不支持请求操作
//        list.remove("java"); //UnsupportedOperationException;不支持请求操作
        list.set(0,"javase");
        System.out.println(list); //[javase, python, scala]*/

		//2、public static <E> List<E> of(E... elements)：返回包含任意数元素的不可变列表
		List<String> list = List.of("java","python","scala","java")
		System.out.println(list); //[javase, python, scala,java]
		
		//list.add("javaee"); //UnsupportedOperationException
		//list.remove("java"); //UnsupportedOperationException
		//list.set(0,"javaee") //UnsupportedOperationException
		
        //3、public static <E> Set<E> of(E.... elements)：返回-一个包含任意数量元素的不可变集合
        //Set<String> set = Arrays.of("java", "python", "scala","java"); //set集合不能重复
        Set<String> set = Arrays.of("java", "python", "scala");
        System.out.println(set); //[java, python, scala]
		
		//set.add("javaee"); //UnsupportedOperationException
		//set.remove("java"); //UnsupportedOperationException

    }
}