java集合介绍（list 、set、map）

1.Collection单列集合
在这个接口下主要有一下的2大类
 List ：元素有序、可重复的集合  Set ：元素无序、不可重复的集合 1.1Collection 接口方法
1 、添加 add(Object obj) addAll(Collection coll) 2 、获取有效元素的个数 int size() 3 、清空集合 void clear() 4 、是否是空集合 boolean isEmpty() 5 、是否包含某个元素 boolean contains(Object obj) ：是通过元素的 equals 方法来判断是否是同一个对象 boolean containsAll(Collection c) ：也是调用元素的 equals 方法来比较的。拿两个集合的元素挨个比较。 6 、删除 boolean remove(Object obj) ：通过元素的 equals 方法判断是否是要删除的那个元素。只会删除找到的第一个元素 boolean removeAll(Collection coll) ：取当前集合的差集 7 、取两个集合的交集 boolean retainAll(Collection c) ：把交集的结果存在当前集合中，不影响 c 8 、集合是否相等 boolean equals(Object obj) 9 、转成对象数组 Object[] toArray() 10 、获取集合对象的哈希值 hashCode() 11 、遍历 iterator() ：返回迭代器对象，用于集合遍历案例

public class CollectionDome
{
    public static void main(String[] args) {
//        f1();
//        f2();
        f3();
    }
    //基础方法
    public static void f1(){
        Person person1=new Person("张三",22);
        Person person2=new Person("王五",12);
        Collection collection1=new ArrayList<>();
        //添加单个元素元素
        collection1.add(123);
        collection1.add("DFP");
        collection1.add(person1);
        System.out.println("collection1:"+collection1);

        Collection collection2=new ArrayList<>();
        collection2.add(345);
        collection2.add("CCC");
        collection2.add(person2);
        System.out.println("collection2:"+collection2);
        //添加单个集合元素
        collection1.addAll( collection2);
        System.out.println("collection1:"+collection1);
        //获取有效元素的个数
        int size = collection1.size();
        System.out.println("长度:"+size);

        //是否是空集合
        boolean empty1 = collection1.isEmpty();
        System.out.println(empty1);
        //清空集合
//        collection2.clear();
        System.out.println("collection2.isEmpty:"+collection2.isEmpty());

        //是否包含某个元素是通过元素的equals方法来判断是否是同一个对象
        System.out.println("equals方法来判断是否是同一个对象"+collection1.contains(123));
//        也是调用元素的equals方法来比较的。拿两个集合的元素挨个比较。
        System.out.println("是否包含某个集合"+collection1.containsAll(collection2));

        //移除某个元素
        boolean remove = collection2.remove(345);
        System.out.println("移除某个元素"+remove);
        System.out.println("collection2:"+collection2);

        Collection collection3=new ArrayList<>();
        collection3.add("CCC");
        //取当前集合的差集
        boolean removeAll = collection1.removeAll(collection3);
        System.out.println("取当前集合的差集:"+removeAll);
        System.out.println("C1:"+collection1);

        //取两个集合的交集
        System.out.println(collection2);
        boolean b = collection2.retainAll(collection3);
        System.out.println("collection2:"+collection2);

    }
    //迭代器运用
    public static void f2(){
        Person person1=new Person("张三",22);
        Collection collection1=new ArrayList<>();
        //添加单个元素元素
        collection1.add(123);
        collection1.add("DFP");
        collection1.add(person1);
        System.out.println("collection1:"+collection1);
        //获取Iterator类
        Iterator iterator = collection1.iterator();
        System.out.println("iterator:"+iterator);

//        while (iterator.hasNext()){
//            Object next = iterator.next();
//            System.out.println(next);
//        }
        //因为上面的遍历 已经将iterator遍历到末尾，如果不重新创建Iterator类下一个指向空指针
//        System.out.println(iterator.next());//报错
        //执行行到末尾报错空指针
//        while (iterator.next()!=null){
//            System.out.println(iterator.next());
//        }
        for (Iterator it = iterator; it.hasNext(); ) {
            System.out.println(iterator.next());
        }

    }
    //转换
    public static void f3(){
        Collection list=new ArrayList<>();
        //数组  转换为  列表
        char[] c=new char[] {'c','b','w'};
        List chars = Arrays.asList(c);
        System.out.println(chars);
        Iterator iterator = chars.iterator();
        while (iterator.hasNext()){
            char[] next = iterator.next();
            System.out.println(next);
        }

        list.add(1);
        list.add(11);
        list.add(111);
        //列表转换为 数组
        Object[] objects = list.toArray();
        System.out.println(objects);
        for (int i=0;i 
 1.2List接口 
 List的实现类 : 
 ArrayList:list的主要实现类、线程不安全，查找效率高，底层使用Object [] elementDate数组。自动扩容 1.5倍。

LinkedList :对于频繁 插入、删除效率更高，底层使用双向链表。

Vector:list的古老接口的实现类，线程安全，效率低，使用object对象。 
 public class ListDome {
    public static void main(String[] args) {
//        f1();
        f2();
    }
    //ArrayList方法操作
    public static void f1(){
        Person person=new Person("张三",22);
        List list=new ArrayList<>();
        list.add(1234);
        list.add("DFP");
        list.add("222");
        list.add(person);
        System.out.println("Lsit:"+list);

        List list1=new ArrayList<>();
        list1.add(111);
        //在index位置插入ele元素
        list1.add(0,222);

        List list2=new ArrayList<>();
        list2.add(222);
        list2.add(222);

        list.addAll(list1);
        //从index位置开始将eles中的所有元素添加进来
        list.addAll(0,list2);
        System.out.println("Lsit:"+list);

        //获取指定index位置的元素
        System.out.println("获取指定index位置的元素:"+list.get(2));

        //返回obj在集合中首次出现的位置
        System.out.println("返回obj在集合中首次出现的位置:"+list.indexOf(1234));
        //返回obj在当前集合中末次出现的位置
        System.out.println("返回obj在当前集合中末次出现的位置:"+list.lastIndexOf(person));

        //移除指定index位置的元素，并返回此元素
        Object remove = list.remove(2);
        System.out.println("移除:"+remove+"后的："+list);
        Object remove1 = list.remove(person);
        System.out.println("移除:"+remove1+"后的："+list);
        //设置指定index位置的元素为xx，返回值是当前位置的原有值并且替换了
        Object set = list.set(2, "00");
        System.out.println("set:"+set+"后的："+list);

        //返回从fromIndex到toIndex 位置的子集合 不包含 2位置的
        List list3 = list.subList(0, 2);
        System.out.println(list3);

        for (Object i:list) {
            System.out.println(i);
        }


    }
    //LinkedList放操作
    public static void f2(){
        LinkedList list=new LinkedList<>();
        list.add(11);
        list.add("sss");
        list.add(new Person("DFP",18));
        System.out.println(list);
        //大部分方法和ArrayList相识 介绍不同的方法
        //收尾插入
        list.addFirst("the 1");
        list.addLast("the end");
        list.add(0,"00");
        System.out.println(list);

        Object[] objects = list.toArray();
        for (Object object : objects) {
            System.out.println("sss:"+object);
        }

        //获取收尾元素
        Object first = list.getFirst();
        Object last = list.getLast();
        System.out.println(first);
        System.out.println(last);

        //移除收尾元素
        list.removeFirst();
        list.removeLast();
        System.out.println(list);


    }
} 
 1.3set接口 
 主要实现类 
 HashSet：存储无序的，不可重复的数据 
 LinkedHashSet：HashSet的子类，遍历数据的时候可以按照插入顺序遍历 对于频繁的操作效率更高。 
 TreeSet：按照对象的指定属性进行排序 
 *  1.无序性不等于随机性、存储的数据再底层数组中并非按照数组的索引的顺序进行添加而是根据数据的哈希值进行添加.
* 2.不可重复性，在保证添加的的元素按照equals()判断，不放回为true进行添加 
 要求；添加到set中的数据 在他的类中 要包含 hashCode和equals方法重写的hashCode和equals方法  尽可能保持一致性。 
 
public class SetDome {
    public static void main(String[] args) {
//        f1();
//        f2();
        f3();
    }
    //HashSet
    public static void f1(){
        //set中的方法和Collection一样 使用方法也相识
        HashSet set=new HashSet<>();
        set.add(11);
        set.add("ccc");
        set.add(new Person("DFP",23));
        System.out.println("HashSet:"+set);

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
    //LinkedHashSet
    public static void f2(){
        
        Set set=new LinkedHashSet();
        set.add(111);
        set.add("ccc");
        set.add(new Person("DFP",23));
        System.out.println("LinkedHashSet："+set);
    }

    
    public static void f3(){
        TreeSet treeSet=new TreeSet<>();
        treeSet.add(11);
        treeSet.add(22);
        treeSet.add(2);
        treeSet.add(-67);
//        treeSet.add("1");//报错所以内容类型一致性
        System.out.println(treeSet);

        TreeSet treeSet1=new TreeSet<>();
        treeSet1.add(new Person("DFP",22));
        treeSet1.add(new Person("AB",77));
        treeSet1.add(new Person("Jm",25));
        //排序规则的体现
        treeSet1.add(new Person("Tom",17));
        treeSet1.add(new Person("Tom",67));
        treeSet1.add(new Person("Tom",41));
        System.out.println(treeSet1);

    }
} 
 2.Map双列集合 
 

 主要的实现类 HashMap、
 LinkedHashMap、
 TreeMap、
 Hashtable
 
2.1 HashMap 
        Map的主要实现类，线程不安全，效率高，可以存储null的key和value。 jdk7（数组+链表）jdk8（数组+链表+红黑树） 
 *  HashMap底层原理（jdk7）：
 *      HashMap map=new HashMap(); 在实例化与一个对象之后 创建一个长度是16的一位数组Entry【】table;
 *      在执行多次put之后...map.put(k1,v1);
 *      首先调用，k1所在类的hashCode（）计算k1的哈希值，此时哈希值经过某种算法之后，得到Entry数组中的存放位置。
 *     1. 如果此时位置上的数据不为空，此时的k1-v1直接成功添加。
 *     2. 如果此时位置的数据不为空，（意味着此时位置上存在一个或者多个数据通过链表的形式存储），比较k1和已存在的数据的哈希值。
 *          a.如果k1的哈希值与已存在的数据的哈希值不相同，此时的k1-v1 添加成功。
 *          b。如果k1的哈希值和已存在的某个（key-value）的哈希值相同，继续比较k1类的equals（key）
 *              如果equals返回结果false表示不相同。成功添加k1-v1
 *              如果equals返回结果true表示相同，使用v1替换value。
 *     3.扩容问题：
 *          超出临界值并且存储的位置非空的时候触发
 *          默认方式：扩容为原来 的2倍 将原数据拷贝过来
 * HashMap底层原理（jdk8）：
 *         1. HashMap map=new HashMap()：不创建长度16的数组
 *         2. 是Node【】数组不是 entry【】数组
 *         3、首次调用put方法的时候，创建长度16的数组
 *         4.数组+链表+红黑树：当前数组的某个位置的索引位置上的元素以链表形式存在的数据个数>8
 *              且长度>64的时候 此时的数组改为红黑树存储 
2.2 LinkedHashMap 
保证在遍历Map元素的时候，可以按照添加属性进行遍历。原因是在HashMap的基础上底层结构上，添加了一对指针，指向首尾。频繁的遍历操作，效率更高。 
2.3TreeMap 
在保证按照添加的key-value对进行排序，实现排序的遍历，此时可以考虑key的自然或者定制排序（底层使用红黑树）。 
2.4Hashtable 
古老的实现类，线程安全。 
2.5 案例 
public class MapDome {
    public static void main(String[] args) {
        f1();
//        f2();
    }
    //HashMap
    public static void f1(){
        System.out.println("f1*****************");
        Map map=new HashMap<>();
        map.put("A",-5);
        map.put("kk",76);
        map.put("3412",1);
        map.put("D",new Person("张三",22));
        System.out.println(map) ;
//        HashMap hashMap=new HashMap<>();
//        hashMap.put("李四",145);
//        hashMap.put("李六",190);
//        hashMap.put("王四",1425);
//        System.out.println("hashMap:"+hashMap);
//        //将m中的所有key-value对存放到当前map中
//        hashMap.putAll(map);
//        System.out.println("hashMap:"+hashMap);
//        //移除指定key的key-value对，并返回value
//        Object remove = hashMap.remove("3412");
//        System.out.println("移除"+remove+"的hashMap:"+hashMap);
//        //获取指定key对应的value
//        Object o = hashMap.get("李四");
//        System.out.println("得到李四："+o);
//        //是否包含指定的key
//        System.out.println("存在王四？"+hashMap.containsKey("王四"));
        是否包含指定的value
//        System.out.println("存在1425？"+hashMap.containsValue(1425));
//        //返回map中key-value对的个数
//        System.out.println("hashmap的长度："+hashMap.size());
//        //清空当前map中的所有数据
//        hashMap.clear();
//        System.out.println(hashMap);
        //替换key的value，返回原来的value
        Object replace = map.replace("A", 100);
        System.out.println("替换"+replace+":"+map);
        Set entrySet = map.entrySet();
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
    }
    //LinkedHashMap
    public static void f2(){
        //方法上一致
        System.out.println("f2*****************");
        LinkedHashMap map=new LinkedHashMap<>();
        map.put("A",-5);
        map.put("kk",76);
        map.put("3412",1);
        map.put("D",new Person("张三",22));
        System.out.println(map);
        //遍历
        
        Set set = map.keySet();
        Collection values = map.values();
        Iterator setI = set.iterator();
        Iterator valueI = values.iterator();
        while (setI.hasNext()){
            Object next = setI.next();
            System.out.print(next+"t");
        }
        System.out.println();
        while (valueI.hasNext()){
            Object nextv = valueI.next();
            System.out.print(nextv+"t");
        }
        System.out.println();
        Set entrySet = map.entrySet();
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }


    }

}
java集合介绍（list 、set、map）

Java相关栏目本月热门文章
