007-集合，list,set,map

集合的概念

集合就是一种存放数据容器
集合和数组的区别
    数组：1、数组是定长，一旦定义长度不能改变
         2、数组既可以存基本数据类型 int[] double[],还可以存放引用数据类型  Person[]  User[]
         3、数组中的每一个元素都是相同的数据类型    Object[] 
    集合：1、长度是可以改变的
         2、集合只能存储引用数据类型 List<Integer>
         3、集合可以保存不同类型的数据

Collection集合

• 常用方法

public class Demo1 {
    public static void main(String[] args) {
        //创建Collection接口对象
        Collection coll = new ArrayList();

        //boolean add(E e)  向集合中添加一个元素
        coll.add(1);
        coll.add("cxk");
        coll.add(20.2);

        //boolean addAll(Collection c)   //向集合中添加一个集合

        // void clear()       清空集合中的所有元素
        //coll.clear();

        //boolean contains(Object o)    判断集合中是否包含指定元素
        boolean b = coll.contains(1);
        System.out.println(b);

        //boolean containsAll(Collection<?> c)   判断集合中是否包含指定集合

        // boolean isEmpty()    判断集合是否为空(不是null)
        boolean b1 = coll.isEmpty();
        System.out.println(b1);

        // boolean remove(Object o)  移除集合中指定元素,如果不存在该元素，则返回false
        boolean b2 = coll.remove("cxk1");
        System.out.println(b2);

        // int size()    返回集合中元素的个数
        int size = coll.size();
        System.out.println(size);


        // Object[] toArray()    将集合转换成数组
        Object[] arr = coll.toArray();
        System.out.println(Arrays.toString(arr));


        System.out.println(coll);

    }
}

迭代器

迭代器   判断集合中有没有下一个元素，如果有取出这个元素，并继续往下判断.......这个过程叫迭代

• 迭代器使用

public class Demo2 {
    public static void main(String[] args) {
        Collection coll = new ArrayList();

        //添加元素
        coll.add("cxk");
        coll.add("李四");
        coll.add("王五");
        coll.add(100);

        //集合的遍历
        /**
         * 增强for循环 
         * 
         * for(集合元素的类型 变量名:集合名){
         *             变量名 ---->集合中每一个元素
         * }
         */
//        for (Object obj : coll) {
//            System.out.println(obj);
//        }

        //迭代器   判断集合中有没有下一个元素，如果有取出这个元素，并继续往下判断.......这个过程叫迭代

        //创建迭代器对象
        Iterator it = coll.iterator();
        //判断有没有下一个元素
        while(it.hasNext()) {
            //将游标向下移动，并且取出当前这个元素
            System.out.println(it.next());
        }
//        System.out.println("是否有下一个元素"+it.hasNext());
//        System.out.println("取出下一个元素"+it.next());
//        
//        System.out.println("是否有下一个元素"+it.hasNext());
//        System.out.println("取出下一个元素"+it.next());
//        
//        System.out.println("是否有下一个元素"+it.hasNext());
//        System.out.println("取出下一个元素"+it.next());
//        
//        System.out.println("是否有下一个元素"+it.hasNext());
//        System.out.println("取出下一个元素"+it.next());
//        
//        System.out.println("是否有下一个元素"+it.hasNext());
//        System.out.println("取出下一个元素"+it.next());
    }
}

• 迭代器的问题

1、在迭代器迭代的过程中不要取增加或者删除元素。
2、在迭代器的循环里不要调用多次next方法
public class Demo3 {
    public static void main(String[] args) {
        // 在对集合进行迭代的时候，能不能向里面添加或者删除元素
        // 判断有没有cxk如果有加入一个rose

        Collection coll = new ArrayList();
        coll.add("cxk");
        coll.add("lisi");
        coll.add("wangwu");
        coll.add("zhaoliu");
        coll.add("tianqi");

        // 1、获取迭代器对象
        Iterator it = coll.iterator();

//        while(it.hasNext()) {
//            if(it.next().equals("cxk")) {
        // 在对集合进行迭代的时候，能不能向里面添加或者删除元素
//                //coll.add("rose");   //错误
//                //coll.remove("zhaoliu");//错误
//            }
//        }

//        while(it.hasNext()) {
//            if(it.next().equals("cxk")) {
//                it.remove();
//            }
//        }
//        Iterator it1 = coll.iterator();
//        while(it1.hasNext()) {
//            System.out.println(it1.next());
//        }

        //在迭代器循环中不要調用多次next方法
        while (it.hasNext()) {
            Object obj = it.next();
            if (obj.equals("123")) {
                // .......
            }
            System.out.println(obj);
        }
    }
}

泛型

jdk1.5之后的新特性
如果不使用泛型，那么在集合中存储元素或者获取元素，都需要不断向上转型和向下转型，有可能会出现类型转换异常。

使用泛型好处：实际上就是将类型转换的检查(提升到了编译期)
       缺点：这样以来集合中能存储相同的数据类型

语法：
     集合类型<泛型类型>

代码演示：

public class Demo4 {
    public static void main(String[] args) {
        //不使用泛型带来的问题
//        Collection coll = new ArrayList();
//        
//        //将字符串变成Object    向上转型
//        coll.add("cxk");
//        coll.add("lisi");
//        coll.add("王五");
//        coll.add(20);
//        
//        //获取迭代器对象
//        Iterator it = coll.iterator();
//        while(it.hasNext()) {
//            //从集合中获取元素得到Object类型
//            Object obj = it.next();
//            //将Object类型转换成String类型    向下转型
//            String s = (String)obj;
//            System.out.println(s.length());
//        }
        //表示Collection集合的泛型是String类型
        //在jdk1.7之后泛型的右边可以省略不写
        Collection<String> coll = new ArrayList<>();
        coll.add("cxk");
        coll.add("20");
        coll.add("lsis");

        //遍历元素   迭代器的泛型就是集合的泛型
        Iterator<String>  it =  coll.iterator();

        while(it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
    }
}

ArrayList集合

• 常用方法

public class Demo1 {
    public static void main(String[] args) {
        //创建ArrayList集合，泛型为String
        ArrayList<String> list = new ArrayList<>();
        //向集合中添加元素
        list.add("cxk");
        list.add("lisi");
        list.add("wangwu");

        //void add(int index, E element)  将元素添加指定的下标位置。
        list.add(3, "rose");
        System.out.println(list);


        //E get(int index)  获取指定下标上的元素
        String str = list.get(0); 
        System.out.println(str);        

        //int indexOf(Object o)  获取指定元素在集合中下标位置，如果不存在返回-1
        int index = list.indexOf("cxk"); 
        System.out.println(index); 

        // E remove(int index)   移除集合中指定下标对应的元素，且返回该元素
        String str1 = list.remove(3);
        System.out.println(str1);//rose
        System.out.println(list); 


        // E set(int index, E element)    修改指定的下标对应的元素，返回的是被修改之前的元素
        String str2 = list.set(2, "斯古拉斯");
        System.out.println(str2);
        System.out.println(list);

    }
}

• ArrayList遍历的三种方式

public class Demo2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("cxk");
        list.add("lisi");
        list.add("wangwu");

        //遍历有三种方式：
        //1、foreach循环
//        for (String string : list) {
//            System.out.println(string);
//        }


        //2、for循环
//        for(int i=0; i < list.size() ; i++) {
//            System.out.println(list.get(i));
//        }

        //3、迭代器
//        Iterator<String> it = list.iterator();
//        while(it.hasNext()) {
//            System.out.println(it.next());
//        }        
    }
}

• ListIterator迭代器

//在ArrayList中使用ListIterator迭代器，可以实现边迭代，边操作元素
ListIterator<String> it = list.listIterator();
while(it.hasNext()) {
    //System.out.println(lit.next());
    String name = it.next();
    if(name.equals("lisi")) {
        //it.add("张三");
        it.set("李四");
    }
}
System.out.println(list);

LinkedList集合

public class Demo1 {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<String>();
        list.add("cxk");
        list.add("lisi");
        list.add("wangwu");

        //void addFirst(E e)    //在集合第一个位置上添加指定的元素
        list.addFirst("rose");
        System.out.println(list);
        //void addLast(E e)  //在集合最后一个位置上添加指定的元素
        list.addLast("jack");
        System.out.println(list);

        //E element()      //获取集合中的第一个元素
        String str1 = list.element();
        System.out.println(str1);
        System.out.println(list);

        // E getFirst()   //获取集合的第一个元素
        String str2 = list.getFirst();
        System.out.println(str2);
        System.out.println(list);

        // E getLast()  //获取集合的最后一个元素   
        String str3 = list.getLast();
        System.out.println(str3);
        System.out.println(list);

        //boolean offer(E e)  
        boolean b = list.offer("hanmeimei");
        System.out.println(b);
        System.out.println(list);

        // E peek()  //获取集合的第一个元素
        String str4 = list.peek();
        System.out.println(str4);
        System.out.println(list);

        //E poll()   //获取第一个元素，并将第一个元素移除
        String str5 = list.poll();
        System.out.println(str5);
        System.out.println(list);

        //E pop()  //获取第一个元素，并将第一个元素移除
        String str6 = list.pop();
        System.out.println(str6);
        System.out.println(list);

        //void push(E e)  //将指定的元素添加到第一个位置
        list.push("lilei");
        System.out.println(list);

        // E remove()    //移除集合中的第一个元素并返回这个元素
        String str7 = list.remove();
        System.out.println(str7);
        System.out.println(list);

        // E removeFirst()  //移除集合中的第一个元素并返回这个元素
        String str8 = list.removeFirst();
        System.out.println(str8);
        System.out.println(list);

        // E removeLast() //移除集合中的最后一个元素并返回这个元素
        String str9 = list.removeLast();
        System.out.println(str9);
        System.out.println(list);        
    }
}

常见面试题

ArrayList和LinkedList区别

1、ArrayList它底层使用数组实现的，所以在对ArrayList查询的时候效率高，增删的效率低

2、LinkedList它底层是双向链表结构，所以在对LinkedList查询的时候效率低，增删的效率高

ArrayList和Vector的区别

ArrayList和Vector底层都是用数组实现的，ArrayList是线程不安全的效率高，Vector是线程安全的效率低，Vector现在已经不使用

常见的数据结构

• 栈结构
• 数组结构
• 双向链表结构
• 红黑树

HashSet集合

特点：HashSet集合
    1、无序的
    2、不能重复
    3、没有下标

• 代码实现

public class Demo1 {
    public static void main(String[] args) {
        //创建HashSet集合对象
        HashSet<String> set = new HashSet<String>();
        set.add("cxk");
        set.add("lisi");
        set.add("lisi");
        set.add("wangwu");
        set.add("重地");
        set.add("通话");
        System.out.println(set);
//        Iterator<String> it = set.iterator();//Curl+1
//        while(it.hasNext()) {
//            System.out.println(it.next());
//        }
    }
}

LinkedHashSet集合

特点：LinkedHashSet集合
    1、有序的
    2、不能重复
    3、没有下标
public class Demo2 {
    public static void main(String[] args) {
        LinkedHashSet<String> set = new LinkedHashSet<String>();
        set.add("cxk");
        set.add("wangwu");
        set.add("wangwu");
        set.add("lisi");
        System.out.println(set);
    }
}

HashMap基本使用

public class Demo1 {
    public static void main(String[] args) {
//        //K   表示键的类型 V 值的类型
//        Map<String, String> map  = new HashMap<>();
//        //向Map集合中添加元素
//        map.put("name", "张三");
//        map.put("age", "30");
//        map.put("sex", "男");
//        map.put("hobby", "篮球");
//        //简单输出
//        System.out.println(map);
//        
//        //获取指定的元素    根据key取value
//        String name = map.get("name");
//        System.out.println(name);
        Map<String, String> map  = new HashMap<>();
        map.put("name", "cxk");
        map.put("cn", "中国");
        map.put("us", "美国");
        map.put("cn", "中国人民共和国");
        map.put("china", "中国人民共和国");
        //简单输出
        System.out.println(map);
        //map的特点：key是不能重复的。如果有重复。后面会将前面覆盖 value可以重复
    }
}

map的特点：key是不能重复的。如果有重复。后面会将前面覆盖 value可以重复

HashMap的其他方法

public class Demo2 {
    public static void main(String[] args) {
        Map<String, String> map  = new HashMap<>();
        map.put("name", "cxk");
        map.put("cn", "中国");
        map.put("us", "美国");
        map.put("cn", "中国人民共和国");
        map.put("china", "中国人民共和国");

        // Set<K> keySet()      获取map集合中所有的key
        Set<String> set = map.keySet();
        for (String s : set) {
            //System.out.println(s);
        }

        //Collection<V> values()   获取map集合中所有的value
        Collection<String> values = map.values();
        for (String s : values) {
            //System.out.println(s);
        }

        //Set<Map.Entry<K,V>> entrySet()    获取Map集合中的所有键和值组成的Entry对象
        //Map集合实际就是Entry
        Set<Entry<String, String>> entrySet = map.entrySet();
        for (Entry<String, String> entry : entrySet) {
            //System.out.println(entry);
            //取出entry对象中的key
            System.out.println(entry.getKey());
            //取出entry对象中的value
            System.out.println(entry.getValue());
        }

        System.out.println("----------------------------------------------------------");
        //是否包含指定的key
        boolean b1 = map.containsKey("name");
        System.out.println("是否包含name这个key:"+b1);
        //是否包含指定value
        boolean b2 = map.containsValue("中国");
        System.out.println("是否包含中国这个value:"+b2);

        //根据指定key移除这个键值对，如果存在key返回这个value，如果不存在key返回null
        String s = map.remove("name");
        System.out.println(s);
        System.out.println(map);

        //如果添加元素的时候，这个key存在，返回这个key所对应的值，并覆盖为新的value
        //如果key不存在，返回的都是null
        String s1 = map.put("cn", "30");
        System.out.println(s1);
        System.out.println(map);
    }
}

HashTable类

public class Demo1 {
    public static void main(String[] args) {
//        Map<String, String>     map = new Hashtable<String, String>();
//        map.put("name", "cxk");
//        map.put("name", "zhangsan");
//        map.put("age", "30");
//        //map.put("sex", null);
//        map.put(null, "hha");
//        System.out.println(map);

        Map<String, String> map = new HashMap<String, String>();
        map.put(null, "你好");
        map.put("name",null);
        map.put(null,null);
        System.out.println(map);
        String str1 = map.get(null);
        System.out.println(str1);

        //HashMap和HashTable区别
        //1、HashMap是线程不安全的，HashTable线程安全的
        //2、HashMap的键和值都可以为null，HashTable不可以
    }
}

HashMap和HashTable区别

1、HashMap是线程不安全的，HashTable线程安全的
2、HashMap的键和值都可以为null，HashTable不可以

Map与实体类对比

public class Demo1 {
    public static void main(String[] args) {
        List<Book> list =new ArrayList<>();
        Book book1 = new Book(1, "三国", "罗贯中", 100);
        Book book2 = new Book(2, "水浒传", "施耐庵", 80);
        Book book3 = new Book(3, "西游记", "吴承恩", 90);
        list.add(book1);
        list.add(book2);
        list.add(book3);

        System.out.println(list);
        System.out.println("-----------------------------------------------");

        Map<String, Object> map1 = new HashMap<>();
        map1.put("id", 1);
        map1.put("name","三国");
        map1.put("author","罗贯中");
        map1.put("price",100);

        Map<String, Object> map2 = new HashMap<>();
        map2.put("id", 2);
        map2.put("name","水浒传");
        map2.put("author","施耐庵");
        map2.put("price",80);

        Map<String, Object> map3 = new HashMap<>();
        map3.put("id", 3);
        map3.put("name","西游记");
        map3.put("author","吴承恩");
        map3.put("price",90);

        List<Map<String, Object>> list1 = new ArrayList<Map<String,Object>>();
        list1.add(map1);
        list1.add(map2);
        list1.add(map3);
        System.out.println(list1);
    }
}

测试

/**
 * 利用集合保存省市数据
 */
public class Demo1 {
    public static void main(String[] args) {
        Map<String, List<String>> map = new HashMap<String, List<String>>();
        List<String> list1 = new ArrayList<String>();
        list1.add("武汉");
        list1.add("黄冈");
        list1.add("黄石");

        List<String> list2 = new ArrayList<String>();
        list2.add("长沙");
        list2.add("湘潭");
        list2.add("常德");

        map.put("湖北",list1 );
        map.put("湖南",list2);

        List<String> citys = map.get("湖北");
        System.out.println(citys);
    }
}