JAVA-集合

集合概述

• 集合是一个容器，可以一次容纳多个对象。集合不能直接存储基本数据类型，也不能直接存储JAVA对象。集合当中存储的都是JAVA对象的内存地址。（或者说集合存储的都是引用）
  list.add = 100；//自动装箱Integer
  集合在JAVA中本身就是一个容器，是一个对象。集合在任何时候存储的都是引用。
• 集合结构图
  
  上述类图中，实线边框的是实现类，比如ArrayList，LinkedList，HashMap等，折线边框的是抽象类，比如AbstractCollection，AbstractList，AbstractMap等，而点线边框的是接口，比如Collection，Iterator，List等

/**
 * Collection是集合父接口，常用方法通用
 */
public class collectionTest {
    public static void main(String[] args) {
        //创建集合对象
        //Collection c = new Collection(); 接口是抽象的，无法实例化
        //多态
        Collection c = new ArrayList();
        //集合添加元素
        c.add(123);
        c.add("zhangsan");
        c.add(new Object());
        c.add(true);
        //获取集合元素的个数
        System.out.println(c.size());//4
        //清空集合
        c.clear();
        System.out.println(c.size());//0
        //在添加元素
        c.add("hahaha");
        c.add("hehehe");
        //判断集合中是否包含元素。包含返回ture，不包含返回false
        boolean b = c.contains("hehe");
        System.out.println(b);//false
        System.out.println(c.size());//2
        //删除集合中某个元素
        c.remove("hahaha");
        System.out.println(c.size());//1
        //判断集合中元素的个数是否为0；
        System.out.println(c.isEmpty());//false
        //集合转数组
        c.add(123);
        c.add("balabala");
        Object[] obj = c.toArray();
        for (int i=0;i<obj.length;i++){
            Object o = obj[i];
            System.out.println(o);//hehehe   123    balabala
        }
    }
}

一、Iterator迭代器

• Iterator是遍历/迭代的通用方式
  在Map集合中不能使用，在所有的Collection及子类可以使用

/**
 * Iterator是遍历/迭代的通用方式
 * 在Map集合中不能使用，在所有的Collection及子类可以使用
 */
public class CollectionTest02 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add(112);
        c.add("hahaha");
        c.add("中国");
        //获取集合迭代器对象
        Iterator it =c.iterator();
        // hasNext()如果有元素返回ture  next()返回迭代的下一个元素
        while (it.hasNext()){
            Object obj=it.next();
            System.out.println(obj);
        }
    }
}

执行内存图

二、集合的分类

Collection 接口的接口 对象的集合（单列集合）
├——-List 接口：元素按进入先后有序保存，可重复
│—————-├ LinkedList 接口实现类， 链表， 插入删除， 没有同步， 线程不安全
│—————-├ ArrayList 接口实现类， 数组， 随机访问， 没有同步， 线程不安全
│—————-└ Vector 接口实现类 数组， 同步， 线程安全
│ ———————-└ Stack 是Vector类的实现类
└——-Set 接口： 仅接收一次，不可重复，并做内部排序
├—————-└HashSet 使用hash表（数组）存储元素
│————————└ LinkedHashSet 链表维护元素的插入次序
└ —————-TreeSet 底层实现为二叉树，元素排好序

List集合

List/Set总结：

（1）、List,Set都是继承自Collection接口，Map则不是
（2）、List特点：元素有放入顺序，元素可重复 ，Set特点：元素无放入顺序，元素不可重复，重复元素会覆盖掉，（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的，加入Set 的Object必须定义equals()方法 ，另外list支持for循环，也就是通过下标来遍历，也可以用迭代器，但是set只能用迭代，因为他无序，无法用下标来取得想要的值。）
（3）.Set和List对比：
Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。
List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变。

Map集合

Map常用方法

package gather;

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

//Map常用方法
public class MapTest {
    public static void main(String[] args) {
        //创建集合对象
        Map<Integer,String>map = new HashMap<>();
        //向集合中添加元素
        map.put(1,"zhangsan");
        map.put(2,"lisi");
        map.put(3,"wangwu");
        //通过Key,获取value
        String valve=map.get(2);
        System.out.println(valve);
        //获取键值对的数量
        System.out.println("键值对的数量:"+map.size());
        //通过key,删除key-value
        map.remove(2);
        System.out.println("键值对的数量:"+map.size());
        //判断是否包含某个Key
        System.out.println(map.containsKey(4));//false
        //判断是否包含某个value
        System.out.println(map.containsValue("zhangsan"));//true
        //情况map集合
        map.clear();
        System.out.println(map.size());//0
        //获取所以的value
        Collection<String> values=map.values();
        for (String s:values){
            System.out.println(s);
        }
    }

}

Map集合遍历

package gather;

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

//map集合的遍历第一种方式
public class Maptest01 {
    public static void main(String[] args) {
        //遍历的第一种方式:获取所有的key,通过key遍历value
        Map<Integer,String>map = new HashMap<>();
        map.put(1,"zhangsan");
        map.put(2,"lisi");
        map.put(3,"wangwu");
        map.put(4,"zhaoliu");
        //获取所有的key,所有的key是一个set集合
        Set<Integer>keys = map.keySet();
        //遍历key,通过key获取value
        //迭代器方式
        Iterator<Integer> it = keys.iterator();
        while (it.hasNext()){
            //取出其中一个key
            Integer key = it.next();
            //通过key获取value
            String values = map.get(key);
            System.out.println(key+"="+values);
        }
       /* //foreach也可以
        for (Integer key : keys){
            System.out.println(key+"="+map.get(key));
        }
*/

    }
}

• 第二种遍历方式内存图

package gather;

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

/**
 * map集合遍历的第二种方式
 * 这种方式效率比较高,因为获取key和value都是直接从node对象中获取的属性值
 * 适合大数据量
 */
public class Maptest02 {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        map.put(1,"zhangsan");
        map.put(2,"lisi");
        map.put(3,"wangwu");
        map.put(4,"zhaoliu");
        //把map集合直接全部转换成Set集合 set<Map.Entry>
        Set<Map.Entry<Integer,String>> set = map.entrySet();
        //遍历set集合,每一次取出一个node
        /*Iterator<Map.Entry<Integer,String>> it = set.iterator();
        while (it.hasNext()){
            Map.Entry<Integer,String> node = it.next();
            Integer key = node.getKey();
            String value = node.getValue();
            System.out.println(key+"="+value);
        }*/
        //foreach
        for (Map.Entry<Integer,String>node : set){
            System.out.println(node.getKey()+"="+node.getValue());
        }
    }
}

哈希表数据结构详解