Java基础（十三）集合-迭代器（Iterator）、泛型、映射（Map＜k,v＞）

一、迭代器（Iterator接口）

（不属于集合，帮助实现类产生对象）

  a.底层根据指针挪动进行迭代遍历
  b.在遍历期间不能直接增删原集合元素
  c.iterator方法定义在Iterable接口里
  d.类实现Iterable接口产生的对象就能被增强for循环来进行操作---增强for循环底层由迭代器实现---增强for循环是jdk1.5新特性

代码演示：

packagecn.tedu.collection.list;

 

importjava.util.ArrayList;

importjava.util.Iterator;

importjava.util.List;

public class IteratorDemo{

public static void main(String[] args){

//创建集合对象

List<String> list=new ArrayList<>();

//添加元素

list.add("abc");

list.add("bc");

list.add("ac");

list.add("ab");

list.add("1abc");

 

//调用iterator方法来返回迭代器

Iterator<String> it=list.iterator();

//使用while循环实现迭代器遍历

while(it.hasNext()){//判断下一位是否有元素

//获取下一位元素

String s=it.next();

//使用迭代器提供remove方法

//改变标记值为false，java看见标记值就会把对应的原集合元素进行删除

//it.remove();

//根据集合的remove方法来删除元素

//直接增删原集合元素但是标记值没有改变最后比较的时候会报错

list.remove(s);

}

System.out.println(list);

}

}

二、泛型：参数化类型，jdk1.5新特性

泛型擦除：当泛型指定成确切类型时后续只能操作对应类型数据（编译时期）

代码演示：

package cn.tedu.type;

import sun.text.normalizer.UCharacter;

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

public class TypeDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        //当不使用泛型时存储数据很方便但是获取数据进行操作时就很复杂
        List list=new ArrayList();
        //三种效果一样---推荐使用方式--jdk1.7
        List<String> list1=new ArrayList<>();
        List list2=new ArrayList<String>();
        List<String> list3=new ArrayList<String>();

        //泛型指定元素类型(默认可以指定成所有的引用类型）
        //当泛型的类型指定之后，后续操作时都是使用之前指定的类型---泛型擦除（编译时期）
        list1.add("abc");

        //添加元素
        //没有泛型的指定--可以存储任意类型的数据
        //存储数据方便灵活
        list.add(123);
        list.add(true);
        list.add("abc");
        list.add('a');

        //获取集合元素对象
        //取出数据时需要确定具体类型--复杂
        for (Object i:list){
            //判断元素对象具体是什么类型
            if (i instanceof Integer){
                Integer in=(Integer) i;
            }else if(i instanceof Boolean){
                Boolean b=(Boolean) i;
            }else if(i instanceof String){
                String s=(String)i;
            }else {
                Character c=(Character)i;
            }
        }
    }
}

泛型的上下限：

泛型的上限：<? extends 类/接口>—可以接收类以及子类/接口以及子接口
泛型的下限：<? super 类/接口>—可以接收类以及父类/接口以及父接口

代码：

package cn.tedu.type;

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

public class TypeDemo2 {
    public static void main(String[] args) {
        //List<Number> list=new ArrayList<Integer>();
        //泛型没有向上造型
        List<Integer> list1 = new ArrayList<>();
        list1.add(123);
        list1.add(23);
        list1.add(13);
        list1.add(12);
        list1.add(1233);
        List<Double> list2 = new ArrayList<>();
        list2.add(1.2);
        list2.add(3.4);
        list2.add(5.43);
        List<String> list3 = new ArrayList<>();
        list3.add("abc");
        list3.add("bc");
        list3.add("ac");
        list3.add("ab");

        //调用方法
        m(list1);
        m(list2);
        //m(list3);
    }

    //定义方法来遍历所有元素类型时数值型的集合对象
    //?代表通配符  代表泛型可以指定的类
	//<? extends Number>---可以接收Number类以及子类
	//<? extends 类/接口>---可以接收类以及子类/接口以及子接口
	//泛型的上限
        public static void m(List<? extends Number> list){
        for (Object i:list){
            System.out.println(i);
        }
    }

    //<? super String>---可以接收String类以及父类
    //<? super 类/接口>---可以接收类以及父类/接口以及父接口
    //泛型的下限
    //上下限不能同时出现
    //public static void m(List<? super String> list){}
}

三、映射（Map<k,v>

1.概念

存储多个有关系（映射关系）的数据的容器
k代表的是键，v代表的是值，一个键可以得到一个值，键不能重复，但是值可以重复，一个映射由多个键和值组成。
把键和值看做成键值对，把这些键值对抽取成类—Entry，Entry产生的每个对象都是真实的键值对，一个映射由多个键值对组成的。

package cn.tedu.type;

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

public class MapDemo1 {
    public static void main(String[] args) {
        //创建映射对象
        Map<String,Integer> map=new HashMap<>();
        //添加元素
        map.put("abc",123);
        map.put("bc",23);
        map.put("ac",13);
        map.put("ab",12);
        map.put("1abc",1123);
        map.put("a2bc",1223);
        map.put("ab3c",1233);
        //键不能重复,会舍弃掉新的键更新为新的值
        //map.put("ab3c",3333);

        //清空映射
        //map.clear(); //{}

        //判断是否包含键/值
        System.out.println(map.containsKey("abc"));//true
        System.out.println(map.containsValue(4567));//false

        //把映射中左右的键值对放到Set集合中
        //Map.Entry<String,Integer>---代表键值对类型
        Set<Map.Entry<String,Integer>> set=map.entrySet();

        //由键获取值
        System.out.println(map.get("abc"));//123

        //判断映射是否为空
        System.out.println(map.isEmpty());//false

        //把映射中所有的键放到Set集合中
        //Set<String> set=map.keySet();

        //根据键来删除(键值对）
        System.out.println(map.remove("abc"));
        //根据键和值来删除(保证键和值存在才能删除键值对）
        System.out.println(map.remove("abc",123));

        //元素个数/键值对个数
        System.out.println(map.size());//6

        //把映射中的所有的值放到集合里
        Collection<Integer> c=map.values();
        //无序
        //底层由键来确定存储位置，键无序的导致键值对也是无序的
        System.out.println(map);


    }
}

2.映射遍历

1.先获取所有的键再获取所有的值

package cn.tedu.type;

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

public class MapDemo2 {
    public static void main(String[] args) {
        //创建映射对象
        Map<String,Integer> map=new HashMap<>();
        //添加元素
        map.put("abc",123);
        map.put("bc",23);
        map.put("ac",13);
        map.put("ab",12);
        map.put("1abc",1123);
        map.put("a2bc",1223);
        map.put("ab3c",1233);

        //获取所有的键
        Set<String> set=map.keySet();
        //遍历Set集合
        for (String s:set){
            //由键来获取值
            System.out.println(s+"="+map.get(s));

        }
    }

}

2.先获取所有的键值对在再获取键和值

package cn.tedu.type;

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

public class MapDemo3 {
    public static void main(String[] args) {
        //创建映射对象
        Map<String, Integer> map = new HashMap<>();
        //添加元素
        map.put("abc", 123);
        map.put("bc", 23);
        map.put("ac", 13);
        map.put("ab", 12);
        map.put("1abc", 1123);
        map.put("a2bc", 1223);
        map.put("ab3c", 1233);

        /*//获取所有的键值对
        Set<Map.Entry<String, Integer>> set = map.entrySet();
        //遍历Set集合
        for (Map.Entry<String, Integer> m : set) {
            //来获取获取值
            System.out.println(m.getKey() + "=" + m.getValue());
        }*/

        //常用写法(两步合为一步）
        for (Map.Entry<String,Integer> m:map.entrySet()){
            //来获取获取值
            System.out.println(m.getKey() + "=" + m.getValue());
        }
    }
}

Map是映射的顶级接口
实现类：HashMap、Hashtable

HashMap

 a.底层基于数组+链表来存储数据
 b.不能重复且不能保证顺序恒久不变
 c.允许存储null值和null键
 d.默认初始容量为16，默认加载因子为0.75，默认是在原来的基础上增加一倍
 e.给定初始容量时（2`n~2`n+1），底层最终的容量值就是2`n+1值
 f.异步式线程不安全的映射

Hashtable

a.最早的映射类
b.键和值都不能是null
c.默认初始容量为11，默认加载因子为0.75，每次扩容都是在原来的基础上增加一倍再加1
d.指定初始容量为多少底层真实容量就为多少
f.同步式线程安全的映射

映射是集合吗？

不是，映射是映射，集合是集合，是不同的容器。·是Java Collection Franmework成员