集合（第十一天）：泛型，Collection，迭代遍历，List，ArrayList，LinkedList，Map；

一，集合框架 

       如图： 

 二，泛型

好处：可以把报错的实际提前，在编译器就报错，而不是运行后才抛出异常

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

public class Demo1 {
    public static void main(String[] args) {
       // String[] a=new String[5];
        //没有泛型，数据类型根本没有约束
        List list = new ArrayList<>();//向集合中存入数据
        list.add("小王");
        list.add(5);
        //引入泛型
        List<String> list1 = new ArrayList<String>();
        list1.add("小数");
        //list1.add(5);//错误，数据类型错误
    }
}

注：泛型里只能放引用类型 

泛型及增强for

public class Demo2 {
    public static void main(String[] args) {
        Integer[] a = {1,2,3,4,5,6,7,8,9,10};
        print(a);
        System.out.println();
        String[] b={"一个","两个","三个","四个","五个","六个","七个"};
        print(b);
    }
    private static void print(String[] a){
        for (String i:a){
            System.out.print(i);
        }
    }
    private static void print(Integer[] a) {
        for (Integer i:a){
            System.out.print(i);
        }
    }
}

 三，Collection接口以及迭代器的使用

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

public class demo1 {
    public static void main(String[] args) {
        Collection<Integer> c = new ArrayList<Integer>();
        c.add(100);
        c.add(200);
        c.add(300);
        c.add(400);
        c.add(500);
        c.add(600);
        System.out.println(c);
        //System.out.println(c);//Ctrl+D:向下复制
        System.out.println(c.equals(200));//false
        System.out.println(c.contains(200));//true
        System.out.println(c.toString());//打印集合中所有元素
        System.out.println(c.hashCode());//获取集合对应的哈希码值
        System.out.println(c.isEmpty());//false判断集合是否为空
        Collection<Integer> c2 = new ArrayList<Integer>();
        c2.add(10);
        c2.add(20);
        c2.add(30);
        c2.add(40);
        c2.add(50);
        c2.add(60);
        c.addAll(c2);
        System.out.println(c);
        System.out.println(c.containsAll(c2));//判断c是否包c2中的所有元素
        System.out.println(c.retainAll(c2));//取两集合的交集
        //迭代，遍历集合
        //获取迭代器
        System.out.println("===============================");
        Iterator<Integer> it =c.iterator();
        while(it.hasNext()){//判断集合是否有下一个集合可以迭代
            //System.out.println(it.next());
            Integer next = it.next();//获取本轮迭代到的元素
            System.out.println(next);
        }
    }
}

四，List接口

特点：元素有下标，数据是有序的，允许存放重复的元素

import java.util.*;

public class Demo1 {
    public static void main(String[] args) {
    List<String> list = new ArrayList();
        list.add("大娃");
        list.add("二娃");
        list.add("三娃");
        list.add("四娃");
        list.add("五娃");
        list.add("六娃");
        list.add("七娃");
        System.out.println(list);
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }
        System.out.println(list.remove("大娃"));//移除集合中指定元素
        System.out.println(list.size());//获取集合中元素的个数
        System.out.println(list.contains("大娃"));//判断集合是否包含指定元素
        System.out.println(list.isEmpty());//判断集合是否为空
        System.out.println(Arrays.toString(list.toArray()));//集合转数组
        //测试集合间的操作
        List<String> list2 = new ArrayList();
        list2.add("1");
        list2.add("2");
        list2.add("3");
        list2.add("4");
        list2.add("5");
        list2.add("6");
        list2.add("7");
        System.out.println(list.addAll(list2));//将list2集合中的元素添加到list集合中去
        System.out.println(list.addAll(1,list2));//将list2中的元素加到list集合的1号索引处
        System.out.println(list.retainAll(list2));
        System.out.println("=================================");
        //list特有功能
        list.add("小蝴蝶");
        list.add(1,"小蝴蝶");
        list.add(3,"蛇精");
        System.out.println(list.get(3));//获取指定位置上的元素
        System.out.println(list.set(2,"蝎子精"));//在指定索引处添加指定元素
        
    }
}

集合迭代

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

public class Demo02 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("振亚");
        list.add("振辉");
        list.add("振兴");
        list.add("云翔");
        list.add("土包");
        list.add("菜饼");
        System.out.println(list);
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }
        System.out.println("======================");
        for (String i:list){
            System.out.println(i);
        }
        System.out.println("==========================");
        for (int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }/*listIterator属于List接口特有的迭代器
* Iterator<E>--父接口--hasNext()--next()
* listIterator<E>--子接口--除了父类的功能以外
* 还有自己的特有功能，比如逆序遍历，添加元素等等，但是都很少用
* public interface ListIterator<E> extends Iterator<E>
* */
System.out.println("===========================");
ListIterator<String> it2 = list.listIterator();
while (it2.hasNext()){
    String next = it2.next();
    System.out.println(next);    }
}

 五，ArrayList实现类

        底层结构：数组，内存空间是连续的，增删操作比较慢，查询操作比较块（建立在数据量大时），元素有下标

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

public class Demo3 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList();
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        list.add(60);
        System.out.println(list);
        System.out.println(list.clone());//清空集合
        System.out.println(list.indexOf(20));//判断元素第一次出现的下标
        System.out.println(list.lastIndexOf(20));//判断元素最后一次出现的下表
        System.out.println(list.set(2,77));//将下标位2的元素替换成77
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()){
            Integer next = iterator.next();
            System.out.println(next);
        }
    }
}

六，LinkedList实现类

底层结构：链表，内存空间是不连续的，效率高，增删操作比较快，查询操作比较慢（数据量大时），元素有下标；

        注意：我们这里所说的快和慢，是建立在数据量比较大的情况下

        注意：LinkedList查询慢也不是都慢，首位操作还是比较快的

        注意：LinkedList也是List序列的实现类，所以它的元素也是有下标的，也可以根据元素下标

对元素做操作，只不过常用首位操作而已

        注意：ArrayList底层数组的内存空间是连续的，LinkedList底层链表的内存空间是不连续的，靠着节点之间的地址值相连       

import java.util.Iterator;
import java.util.LinkedList;

public class Demo4 {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList();
        list.add("唐僧");
        list.add("孙悟空");
        list.add("猪八戒");
        list.add("沙僧");
        list.add("白龙马");
        System.out.println(list);
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }
        list.addFirst("观音");
        list.addLast("佛祖");
        System.out.println(list.getFirst());
        System.out.println(list.getLast());
        System.out.println(list.removeFirst());
        System.out.println(list.removeLast());
        //peek系列：查询相关
        System.out.println(list.peek());//查询集合中的首元素
        System.out.println(list.peekFirst());//查询首元素
        System.out.println(list.peekLast());//查询尾元素
        //offer：新增功能
        System.out.println(list.offer("斗罗大陆"));//将指定元素田间到元素末尾
        System.out.println(list.offerFirst("三体"));//添加至开始位置
        System.out.println(list.offerLast("钢铁是怎么练成的"));//添加至末尾
        //poll：移除系列
        System.out.println(list.poll());//移除集合的首元素
        System.out.println(list.pollFirst());
        System.out.println(list.pollLast());
    }
}

七，Map接口

        Entry<K,V>--键值对--KEY和VALUE

        键与值是---对应的关系，可以根据KEY取到对应的VALUE

        注意：KEY不允许重复

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

public class Demo1 {
    public static void main(String[] args) {
        //创建Map
        Map<Integer,String> map = new HashMap<>();
        map.put(9527,"零零七");
        map.put(1234,"黑熊精");
        map.put(6666,"王Sir");
        map.put(6527,"零零八");
        //map中的key不允许重复，如果重复，此key对应的value会被覆盖
        //map中的value可以重复。
        System.out.println(map);
        System.out.println(map.hashCode());//获取集合的哈希码值
        System.out.println(map.equals("黑熊精"));//false,map,对象与对象中的一个数据不相等
        System.out.println(map.isEmpty());//判断集合是否为空
        System.out.println(map.size());//判断集合中键值对的个数
        System.out.println(map.containsKey(9527));//判断集合是否包含指定的键
        System.out.println(map.containsValue("零零八"));//判断集合是否包含指定的值
        System.out.println(map.get(9527));//根据指定的key获取对应的value
        System.out.println(map.remove(9527));//根据指定的key删除对应的键值对
        System.out.println(map);//值没了
        System.out.println(map.containsKey(9527));//键也没了
        /*
        * 将map集合中的所有value值取出，放入一个Collection集合中
        * Collection《type》中type的类型取决于map中value的类型
        * */
        Collection<String> values = map.values();
        System.out.println(values);
        Map<Integer,String> map2 = new HashMap<>();
        map.put(1241,"零零七");
        map.put(2343,"黑熊精");
        map.put(2344,"王Sir");
        map.put(2385,"零零八");
        System.out.println("=====================");
       map.putAll(map2);
        System.out.println(map);
        
    }
}

map集合的迭代

方式一：遍历map中的数据，但map本身没有迭代器，所i有需要先转换成set集合在迭代

使用方法：keySet（）；

Set<Integer> keySet = map.keySet();
Iterator<Integer> iterator = keySet.iterator();
while(iterator.hasNext()){
    Integer next = iterator.next();
    String s = map.get(next);
    System.out.println(next+":"+s);
}

方式二：这个方案是把map中的每一对键值对看作是一个个Entry《K，V》

有几个就把几个Entry放入Set集合中

Set<Map.Entry<Integer, String>> entries = map.entrySet();
Iterator<Map.Entry<Integer, String>> iterator = entries.iterator();
while(iterator.hasNext()){
    Map.Entry<Integer, String> next = iterator.next();
    Integer key = next.getKey();
    String value = next.getValue();
    System.out.println(key+":"+value);
}