【7.29笔记】Map、泛型、Collections的使用

遍历Map集合

思路一：先遍历key，再通过key>>>value
方法一:增强型for遍历key的集合(Set)
方法二:通过迭代器Iterator遍历key的集合()
思路二: 获取map中的所有键值对,然后再对键值对中分别获取key和value
方法三://遍历键值对的集合,把每个键值(obj)–Map.Entry(键值对的类型)对拿出来

public class Country {
    public static void main(String[] args) {
        Map countries=new HashMap();
        countries.put("China","中国");
        countries.put("USA","美国");
        countries.put("England","英国");
        countries.put("French","法国");
        System.out.println(countries.size());
        String country1=(String)countries.get("China");
        System.out.println(country1);
        String country2=(String)countries.get("Australia");

        System.out.println("判断列表中是否存在China:  "+countries.get("China"));
        System.out.println("判断列表中时候否存在Australia:  "+countries.get("Australia"));
        countries.remove("England");
        System.out.println(countries.size());
        System.out.println();
        System.out.println();
        //获取键值对的号集合,值得集合,键值的集合
        System.out.println(countries.keySet());
        System.out.println(countries.values());
        System.out.println(countries);

        //遍历map,先遍历Key,通过Key>>>value
        //方法一增强for遍历Key的集合(set)
        System.out.println("****************************");
        Set keys= countries.keySet();
        for (Object obj : keys) {
            String key=(String)obj;//获取到了Map中的每一个Key
            String value=(String)countries.get(key);//根据Map中的每一个Key去获取对应的value
            System.out.println(key+"--"+value);

        }
        //方法二: Iterator遍历key的集合
        Iterator itr=keys.iterator();
        while(itr.hasNext()){
            String key=(String)itr.next();
            String value=(String)countries.get(key);
            System.out.println(key+"--"+value);
        }
        //遍历map思路二:获取map中的所有键值对,然后再对键值对中分别获取key和value
        System.out.println("************************");
        Set set=countries.entrySet();//获取map中的键值对
        //遍历键值对的集合,把每个键值(obj)--Map.Entry(键值对的类型)对拿出来
        for (Object obj : set) {
            Map.Entry me=(Map.Entry)obj;
            String key=(String)me.getKey();//获取键值对中的键
            String value=(String)me.getValue();//获取键值对中的值
            System.out.println(key+"--"+value);
        }

    }
}

泛型

1.概念：泛型是一个未知的数据类型
E e：Element 元素
T t：Type 类型等
2.使用泛型和不使用泛型的区别
不适用泛型
好处：集合不使用泛型，默认类型是Object类型，可以存储任意类型
弊端：不安全，会引发类型转换异常
使用泛型
好处：避免的转换的麻烦，存储什么类型，取出什么类型；把运行期异常提醒到编译器
弊端：泛型是什么类型只能存储什么类型
3.泛型的定义和使用
1.泛型类
定义格式：修饰符 class 类名<泛型>{}

class ArrayList<E> {
    public boolean add(E e) {}
    public E get(int index) {}
}

2.泛型方法
定义格式：修饰符 <泛型> 返回值类型 方法名（参数(使用泛型)）{}

public <M> void fx(M m) {
   System.out.println(m);
}

3.泛型接口
第一种方法：定义接口的实现类，实现接口，指定接口的泛型
第二种方法：定义接口的实现类，接口是什么类型，指定实现类也是相同的接口，类跟着接口走，相当于确定了一个泛型类
4.泛型的通配符
泛型的通配符：？，代表任意数据类型
使用方式：不能通过创建对象使用；只能作为方法的参数使用
5.泛型的限定
泛型上限限定：？ extend E，表示使用的泛型只能是E类的子类或者本身
泛型下限限定：？ super E，表示使用的泛型只能是E类的父类或者本身。

Collections类

类Collections是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。

java.lang.Object
java.util.Collections

Collections中常用的方法：
（1）sort()排序方法
函数定义：public static <T extends Comparable<? super T>> void sort(List list) 根据元素的
自然顺序对指定列表按升序进行排序。
参数：要排序的列表。
函数定义： public static void sort(List list,Comparator<? super T> c)，根据指定比较器产生的顺序对指定列表进行排序。此列表内的所有元素都必须可使用指定比较器相互比较。
参数：list-要排序的列表；c-确定列表顺序的比较器。
（2）binarySearch()二分查找方法
函数定义：public static int binarySearch(List<? extends Comparable<? super T>> list,T key)
使用二分搜索法搜索指定列表，以获得指定对象，在进行此方法调用前比较要将列表元素按照升序排序，否则结果不确定，此方法会执行O(n)次链接遍历和O(log n)次元素比较。
参数: list-要搜索的链表，key-要搜索的键。
函数定义： public static int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 根据指定的比较器对列表进行升序排序。
参数：list-要搜索的列表，key-要搜索的键，c-排序列表的比较器。
（3）reverse()反转方法
函数定义：public static void reverse(List<?> list)，反转指定列表中元素的顺序，此方法以线性时间运行。
参数：list-元素要被反转的列表
（4）shuffle()改组方法
函数定义：public static void shuffle(List<?> list)，使用默认随机源对指定列表进行置换，所有置换发生的可能性都是大致相等的。
参数：list-要改组的列表
函数定义：public static void shuffle(List<?> list,Random rnd),使用指定的随机源对指定列表进行置换。
参数：list-要改组的列表，rnd-用来改组列表的随机源。
（5）swap()交换方法
函数定义：public static void swap(List<?> list,int i，int j)，在指定列表的指定位置处交换元素。
参数：list-进行元素交换的列表，i-要交换的一个元素的索引，j-要交换的另一个元素的索引。
（6）fill()替换方法
函数定义：public static void fill(List<? super T> list,T obj)，使用指定元素替换指定列表中的所有元素，线性时间运行。
参数:list-使用指定元素填充的列表，obj-用来填充指定列表的元素。
（7）copy()复制方法
函数定义：public static void copy(List<? super T> dest,List<? extends T> src)，将所有元素从一个列表复制到另一个列表。执行此操作后，目标列表中每个已复制元素的索引将等同于源列表中该元素的索引，目标列表的长度至少必须等于源列表。
参数：dest-目标列表，src-源列表。
（8）min()最小值法
函数定义：public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)，根据元素的自然顺序返回给定Collection的最小元素，Collection中的所有元素必须实现Comparable接口，此外，collection中的所有元素都必须是可相互比较的。
参数：coll-将确定其最小元素的collection。
函数定义：public static T min(Collection<? extends T> coll,Comparator<? super T> comp),根据指定比较器产生的顺序，返回给定collection的最小元素。
参数：coll-将确定其最小元素的collection，comp-用来确定最小元素的比较器。
（9）max()最大值方法
函数定义：public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)，根据元素的自然顺序，返回给定collection的最大元素。
参数：coll-将确定其最大元素的collection。
函数定义：public static T max(Collection<?extends T> coll,Comparator<? super T> comp)，根据指定比较器产生的顺序，返回给定collection的最大元素。
参数：coll-将确定其最大元素的collection，comp-用来确定最大元素的比较器
（10）rotate()轮换方法
函数定义：public static void rotate(List<?> list，int distance)，根据指定的距离轮转指定列表中的元素。
参数：list-要轮换的列表，distance-列表轮换的距离，可以使0、负数或者大于list.size()的数。
（11）replaceAll()替换所有函数
函数定义：public static boolean replaceAll(List list,T oldVal,T newVal)，使用另一个值替换列表总出现的所有的某一指定值。
参数：list-在其中进行替换的列表；oldVal-将被替换的原值；newVal-替换oldVald的新值。