集合

一.集合框架

1.单例集合的体系结构

List接口：

　　　　1.有序的集合。

　　　　2.允许存储重复的元素。

　　　　有索引，可以使用普通for循环。

ArrayList：底层是数组实现的，查询快增删慢。

LinkedList：底层是链表实现的，查询慢增删快。

Set接口：

　　　　1.不允许存储重复的元素。

　　　　2.没有索引，不能使用for循环遍历。

HashSet：底层是哈希表+（红黑树）实现的，无索引，不能存储重复元素，存取无序。

LinkedHashSet：底层是哈希表+链表实现的，无索引，不能存储重复元素，可以保证存储顺序。

TreeSet：底层是二叉树实现的，一般用于排序。

二.ArrayList集合

1.

　　数组的长度是不可以改变的。
　　ArrayList集合的长度是可以改变的。

　　对于ArrayList来说，有一个尖括号<E>代表泛型。
　　泛型：也就是装载集合中的所有元素，全都是统一的类型。
　　注意，泛型只能是引用类型，不能是基本类型。

 //从jdk1.7开始，右侧尖括号可以不写类型，但是<>本身还是要写的。
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);//[]

        //向集合中添加一些数据，使用add（）方法。
        list.add("李三");
        System.out.println(list);
        list.add("张武");
        list.add("王六");
        list.add("李四");
        System.out.println(list);

 //       list.add(100);//错误写法，因为创建的时候尖括号已经说明了是字符串，添加进去的元素必修是字符串。
 

2.ArrayList常用方法

　　public boolean add(E e); : 向集合中添加元素，参数的类型和泛型一致。
　　对于ArrayList来说 add（） 添加一定会成功。
　　public E  get(int index); :从集合当中获取元素，参数是索引编号，返回值是对应的位置的元素。
　　public E remove(int index); :从集合当中删除元素，参数是索引编号，返回值是被删掉的元素。
　　public int size(); : 获取集合的长度，返回值是集合中包含的元素个数。

ArrayList<String> list = new ArrayList<>();
        System.out.println(list);
        //add()
        list.add("张三");
        list.add("李四");
        boolean success = list.add("王五");
        System.out.println(list);
        System.out.println("添加的动作是否成功："+success);

        //set（） 方法用于替换动态数组中指定索引的元素
        list.set(1,"囡囡");
        System.out.println(list);

        //get（） 索引从0开始
        String name = list.get(0);
        System.out.println(name);

        //remove
        String remove = list.remove(2);
        System.out.println("被删除的元素为："+remove);
        System.out.println(list);

        //size()
        int size = list.size();
        System.out.println("集合的长度为："+size);

3.总结

　　　1.arrayList由于本质是数组，所以它在数据的查询方面会很快，而在插入删除这些方面，性能下降很多，有移动很多数据才能达到应有的效果。

　　 2.arrayList可以存放null。

　　 3.如果希望向ArrayList集合中存储基本数据类型 要使用对应的包装类。

三.Collection集合

1.Collection是所有单列集合的父接口，因此在Collection中定义了单列集合（List和Set）一些通用的方法，用于操作所有的单列集合。方法如下：

　　boolean add(E e); 向集合中添加元素。
　　boolean remove(E e); 删除集合中的某个元素。
　　void clear();   清空集合中的所有元素。
　　boolean contains(E e); 判断集合中是否包含某个元素。
　　boolean isEmpty(); 判断集合是否为空。
　　int size(); 获取集合的长度。
　　Object[] toArray(); 将集合转成一个数组。

//创建集合
        Collection<String> list = new ArrayList<>();
        //boolean add(E e);  向集合中添加元素。
        list.add("Hello");
        list.add("World");
        list.add("heima");
        list.add("java");
        System.out.println(list); //[Hello, World, heima, java]

        //boolean contains(E e); 判断集合中是否包含某个元素。
        boolean result1 = list.contains("java");
        System.out.println(result1);//true

        //boolean remove(E e); 删除集合中的某个元素。
        boolean result = list.remove("Hello");
        System.out.println(result); //true
        System.out.println(list); //[World, heima, java]

        //void clear();   清空集合中的所有元素。
        list.clear();
        System.out.println(list); //[]

        //boolean isEmpty(); 判断集合是否为空。
        boolean empty = list.isEmpty();
        System.out.println(empty); //true

        //int size(); 获取集合的长度。
        int size = list.size();
        System.out.println(size); // 0

        //Object[] toArray(); 将集合转成一个数组
        list.add("AAA");
        list.add("bbb");
        list.add("CCC");

        Object[] array = list.toArray();
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
四.Iterator迭代器1.概念：即Collection集合元素通用的获取方式，在去元素之前先判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出来
　　　　一直把集合中的所有元素都取出来，这种取出方式的专业术语叫做迭代。
　　　　java.util.Iterator接口：迭代器（对集合进行遍历）

　　常用方法：
　　　　boolean hasNext() 如果迭代具有更多元素，则返回 true 。
       　　　　　　 判断集合中还有没有下一个元素，有就返回true，没有就返回false
　　　　E next() 返回迭代中的下一个元素。

　　　　Iterator迭代器，是一个接口，无法直接使用，需要使用Iterator接口的实现类对象，获取实现类的方式比较特殊.
　　　　Collection接口中有一个方法，叫iterator（）这个方法返回的是迭代器的实现类对象
　　　　Iterator<E> iterator()； 返回此集合中元素的迭代器。

　　　　迭代器的使用步骤（重点）
    　　　　1.使用集合中的方法iterator（）获取迭代器的实现类对象，使用Iterator接口接收（多态）
    　　　　2.使用Iterator接口中的hasNext（）方法判断还有没有下一个元素。
   　　　　 3.使用Iterator接口中的next（）方法取出集合中的下一个元素。
 Collection<String> coll = new ArrayList<>();
        coll.add("AAA");
        coll.add("BBB");
        coll.add("CCC");
        coll.add("DDD");
        coll.add("EEE");
        coll.add("FFF");

        //1.使用集合中的方法iterator（）获取迭代器的实现类对象，使用Iterator接口接收（多态）
        //注意：迭代器是有泛型的，集合是什么泛型，迭代器就是什么泛型。
        Iterator<String> iterator = coll.iterator();//迭代器的实现类对象把指针（索引）指向集合的-1索引

        while (iterator.hasNext()){
            String s = iterator.next();
            System.out.println(s);
        }
 
五.泛型　　1.创建集合对象使用泛型
　　　　　　好处：
　　　　　　　　1.避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型。
　　　　　　　　2.把运行期异常提升到了编译期。
　　　　　　弊端：
　　　　　　　　泛型是什么类型，只能存储什么类型。
　　2.创建集合对象不使用泛型
　　　　　　好处：
　　　　　　　　默认是Object类型，可以存储任何数据。
　　　　　　弊端：
　　　　　　　　不安全，会引发异常。
 
六.List集合 　　
List接口的特点：
        1.有序的集合。
        2.有索引，包含一些带索引的方法。
        3.允许存储重复的元素。

List接口带有索引的方法（特有）：
public void add(int index , E element) 将指定的元素插入此列表中的指定位置
public E get(int index) 返回此列表中指定位置的元素。
public E remove(int index) 删除该列表中指定位置的元素。
public E set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
 
 //创建一个集合,多态.
        List<String> list = new ArrayList<>();

        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("a");
        System.out.println(list);//[a, b, c, d, a]
        //public void add(int index , E element) 将指定的元素插入此列表中的指定位置
        list.add(2,"kuangshenshuo");//[a, b, kuangshenshuo, c, d, a]
        System.out.println(list);
        //public E remove(int index) 删除该列表中指定位置的元素。
        String remove = list.remove(2);
        System.out.println("被删除的元素为："+remove);//kuangshenshuo
        System.out.println(list);//[a, b, c, d, a]
        //public E get(int index) 返回此列表中指定位置的元素。
        String s = list.get(3);
        System.out.println("返回集合中索引为3的元素是："+s);
        System.out.println(list);
        //public E set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
        String s1 = list.set(4, "替换的元素");
        System.out.println("被替换的元素为："+s1);//被替换的元素为：a
        System.out.println(list);//[a, b, c, d, 替换的元素]
 
七.LinkedList集合LinkedList集合的特点：
    1.底层是链表结构：查询慢，增删快。
    2.里面包含了大量的操作首尾元素的方法。
   　　 注意，使用LinkedList特有的方法时，不能使用多态。

    void addFirst(E e) 在该列表开头插入指定的元素。
    void addLast(E e) 将指定的元素追加到此列表的末尾。
    void push(E e) 将元素推送到由此列表表示的堆栈上。

    E getFirst() 返回此列表中的第一个元素。
    E getLast() 返回此列表中的最后一个元素。

    E removeFirst() 从此列表中删除并返回第一个元素。
    E removeLast() 从此列表中删除并返回最后一个元素。
    E pop() 从此列表表示的堆栈中弹出一个元素。
 LinkedList<String> linked = new LinkedList<>();
        linked.add("a");
        linked.add("b");
        linked.add("c");
        linked.add("d");

        System.out.println(linked);//[a, b, c, d]
        //void addFirst(E e) 在该列表开头插入指定的元素。
        linked.addFirst("WWW");
        System.out.println(linked);//[WWW, a, b, c, d]
        //void addLast(E e) 将指定的元素追加到此列表的末尾。
        linked.addLast("kuangshenshuo");
        System.out.println(linked);//[WWW, a, b, c, d, kuangshenshuo]
        //void push(E e) 将元素推送到由此列表表示的堆栈上。
        linked.push("ABCDE");
        System.out.println(linked);//[ABCDE, WWW, a, b, c, d, kuangshenshuo]

        //linked.clear();

        if (!linked.isEmpty()){
            // E getFirst() 返回此列表中的第一个元素。
            String first = linked.getFirst();
            System.out.println(first);//ABCDE
            //E getLast() 返回此列表中的最后一个元素。
            String last = linked.getLast();
            System.out.println(last);//kuangshenshuo
        }

        //E removeFirst() 从此列表中删除并返回第一个元素。
        //E removeLast() 从此列表中删除并返回最后一个元素。
        //E pop() 从此列表表示的堆栈中弹出一个元素。
        String s = linked.removeFirst();
        System.out.println("被移除的第一个元素是："+s);//被移除的第一个元素是：ABCDE
        String s1 = linked.removeLast();
        System.out.println("被移除的最后一个元素是："+s1);//被移除的最后一个元素是：kuangshenshuo
        System.out.println(linked);//[WWW, a, b, c, d]
        String pop = linked.pop();
        System.out.println(pop);//WWW
        System.out.println(linked);//[a, b, c, d]
 
八.Set集合java.util.Set接口 extends Collection接口
　　Set集合接口的特点：
                1.不允许存储重复的元素。
                2.没有索引，不能使用普通for循环遍历集合。
 public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(4);
        //使用迭代器遍历
        Iterator<Integer> iterator = set.iterator();
        while (iterator.hasNext()){
            Integer i = iterator.next();
            System.out.println(i);
        }
        //使用增强for遍历集合

        for (int i:
             set) {
            System.out.println(i);
        }

    }
 


java.util.HashSet集合 implements Set接口
　　HashSet特点：
            1.不允许存储重复的元素。
            2.没有索引，不能使用普通for循环遍历集合。
            3.是一个无序的集合。
            4.底层是哈希表结构，查询速度非常快。
Set集合保证存储的元素唯一：
    　　  存储的元素（String，Integer.... Student,Person...）必须重写HashCode方法和equals方法。
 
 
九.LinkedHashSet集合java.util.LinkedHashSet集合 extends HashSet集合
LinkedHashSet集合的特点：
    底层是一个哈希表（数组/链表+红黑树）+链表  ，多了一条链表保证元素有序。
public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add("abc");
        set.add("www");
        set.add("it");
        set.add("heima");
        set.add("www");
        System.out.println(set);//[abc, www, heima, it]

        LinkedHashSet<String> linked = new LinkedHashSet<>();
        linked.add("abc");
        linked.add("www");
        linked.add("it");
        linked.add("heima");
        linked.add("www");
        System.out.println(linked);//[abc, www, it, heima]
    }
 
十.Map集合java.util.Map<k,v> 接口
Map集合的特点：
        1.Map集合是一个双列集合，一个元素包含俩个值。（一个key，一个value）。
        2.Map集合中的元素，key和value的数据类型可以相同，也可以不同。
        3.Map集合中的元素，key是不允许重复的，value是可以重复的。
        4.Map集合中的元素，key和value是一一对应的。
java.util.HashMap<k,v> 集合 implements Map<k,v>接口
HashMap集合的特点：
        1.HashMap底层是哈希表，查询速度特别快。
        2.HashMap是一个无序的集合。
java.util.LinkedHashMap<k,v> extend  HashMap<k,v>集合
LinkedHashMap集合的特点：
        1.LinkedHashMap集合的底层是哈希表+链表（保证迭代顺序）。
        2.LinkedHashMap集合是一个有序的集合。
 
1.Map接口中的常用方法 
  /*
          public V put(K key, V value) 将指定的值与此映射中的指定键相关联。
             存储键值对的时候 key不重复，返回值是null。
             存储键值对的时候 key重复，会使用新的value值替换map中重复key对应的的value，返回被替换的value值。
            */
    public static void show01(){
        //创建集合
        Map<String, String> map = new HashMap<>();

        String put = map.put("1", "2");
        System.out.println(put);//null
        System.out.println(map);//{1=2}
        String put1 = map.put("1", "3");
        System.out.println(put1);//2
        System.out.println(map);//{1=3}
        map.put("100","200");
        map.put("1000","2000");
        map.put("10000","20000");
        System.out.println(map);
    }

    /*
       public V remove(Object key) 从该地图中删除指定键的映射（如果存在）,返回被删除的value值。
               key存在，返回被删除的value值。
               key不存在，返回null。
        */
    public static void show02(){

        Map<Integer, String> map = new HashMap<>();
        map.put(1,"张三");
        map.put(2,"李四");
        map.put(3,"王五");
        System.out.println(map);//{1=张三, 2=李四, 3=王五}
        String v1 = map.remove(2);
        System.out.println("被删除的元素的值："+v1);//被删除的元素的值：李四
        System.out.println(map);//{1=张三, 3=王五}
        String v2 = map.remove("4");
        System.out.println("被删除的元素的值："+v2);//被删除的元素的值：null


    }

    /*
        public V get(Object key) 返回指定键映射到的值，如果此映射不包含键的映射，则返回 null 。
         */
    private static void show03() {

        Map<Integer, String> map = new HashMap<>();
        map.put(1,"张三");
        map.put(2,"李四");
        map.put(3,"王五");
        System.out.println(map);//{1=张三, 2=李四, 3=王五}
        String s = map.get(2);
        System.out.println("键为2所对应的值为："+s);//键为2所对应的值为：李四
        String s1 = map.get(4);
        System.out.println("键为4所对应的值为："+s1);//键为4所对应的值为：null
    }

    /*
    boolean containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。
     */
    private static void show04() {
        Map<Integer, String> map = new HashMap<>();
        map.put(1,"张三");
        map.put(2,"李四");
        map.put(3,"王五");
        boolean b = map.containsKey(1);
        System.out.println(b);//true
    }
 2.Map集合的第一种遍历方式：通过键找值Map集合中的方法：
    Set<K> keySet() 返回此地图中包含的键的Set视图 。
实现步骤：
    1.使用Map集合中的方法keySet() ，把Map集合中的key取出来，存储到一个Set集合中。
    2.遍历Set集合，获取每一个元素key。
    3.通过Map集合中的get()方法通过每一个key找到对应的value。
 
 Map<String,Integer> map = new HashMap<>();
        map.put("张三",1);
        map.put("李四",2);
        map.put("王五",3);

        Set<String> set = map.keySet();

        //使用迭代器来遍历set集合
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            String key = it.next();
            Integer value = map.get(key);
            System.out.println(key+"="+value);
        }

        System.out.println("-----------------");
        //使用增强for来遍历set集合
        for (String key:set){
            Integer value = map.get(key);
            System.out.println(key+"="+value);
        }
3.Map集合遍历的第二种方法：使用Entry对象遍历。在Map接口中有一个内部接口Entry，
    作用：当Map集合一创建，那么就会在Map集合中创建一个Entry对象，
          用来记录键与值，（键与值的映射关系）。

Map集合中的方法：
    Set<Map.Entry<K,V>> entrySet() 返回此地图中包含的映射的Set视图。

实现步骤：
    1.使用Map集合中的方法，entrySet() ，把Map集合中的多个Entry对象取出来。
    2.遍历Set集合，获取每一个Entry对象。
    3.使用Entry对象中的方法getKey()和 getValue()获取键和值。
  Map<Integer,String> map = new HashMap<>();
        map.put(1,"张三");
        map.put(2,"李四");
        map.put(3,"王五");

        Set<Map.Entry<Integer, String>> entry = map.entrySet();
        //使用迭代器遍历
        Iterator<Map.Entry<Integer, String>> it = entry.iterator();
        while (it.hasNext()){
            Map.Entry<Integer, String> obj = it.next();
            System.out.println(obj.getKey()+"="+obj.getValue());
        }
        System.out.println("==============");
        //使用增强for遍历
        for (Map.Entry<Integer,String> obj:entry
             ) {
            System.out.println(obj.getKey()+"="+obj.getValue());
        }
4.HashMap集合存储自定义类型的键值。Map集合保证key是唯一的：
        作为key的元素，必须重写HashCode（）方法equals（）方法。
/*
    HashMap集合存储自定义类型的键值。
        key:String类型
            String类型重写HashCode（）方法equals（）方法，保证了key唯一。
        value：Student类型
            value值可以重复，（同名同年龄的人视为同一个人）。
     */
    private static void show01() {
            //创建HashMap集合
        HashMap<String,Student> map = new HashMap<>();
            //往集合中添加元素
        map.put("北京",new Student("张三",18));
        map.put("上海",new Student("李四",19));
        map.put("广州",new Student("王五",20));
        map.put("北京",new Student("赵六",21));
        //遍历集合
        Set<String> set = map.keySet();
        for (String key: set
             ) {
            System.out.println(key+"-->"+map.get(key));
        }
        System.out.println("--------------");
        Set<Map.Entry<String, Student>> entrySet = map.entrySet();
        for (Map.Entry<String,Student> obj: entrySet
             ) {
            System.out.println(obj.getKey()+"-->"+obj.getValue());
        }
    }


    /*
    HashMap集合存储自定义类型的键值。
        key:Student类型
            Student类型重写HashCode（）方法equals（）方法，保证了key唯一。
        value：String类型
            可以重复
     */

    private static void show02(){
        //创建HashMap集合
        HashMap<Student,String> map = new HashMap<>();
        //往集合中添加元素
        map.put(new Student("张三",18),"法国");
        map.put(new Student("李四",19),"法国");
        map.put(new Student("王五",20),"法国");
        map.put(new Student("张三",18),"英国国");

        //遍历集合
        Set<Student> set = map.keySet();
        for (Student key:set
             ) {
            System.out.println(key+"-->"+map.get(key));
        }


    }
 5.LinkedHashMapjava.util.LinkedHashMap<k,v> extends HashMap<k,v>
Map接口的哈希表和链表的实现，具有可预知的迭代顺序。
底层原理：
    哈希表+链表（有序的）
 HashMap<String, String> map = new HashMap<>();
        map.put("a","b");
        map.put("c","b");
        map.put("d","b");
        map.put("a","c");
        System.out.println(map);//{a=c, c=b, d=b} 无序的 ，key不允许重复。


        System.out.println("============");
        LinkedHashMap<String, String> lhp = new LinkedHashMap<>();
        lhp.put("a","b");
        lhp.put("c","b");
        lhp.put("d","b");
        lhp.put("a","c");
        System.out.println(lhp);//{a=c, c=b, d=b} 有序的，key不允许重复
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

posted @ 2024-02-12 16:22 蠡烬阅读(19) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· java数组

· java面向对象

· 【Java基础】集合一篇文章带你看懂集合，万字详述集合

· 这可能是你见过最全的集合

· Java SE08_集合笔记

阅读排行：
· 25岁的心里话
· 闲置电脑爆改个人服务器（超详细） #公网映射 #Vmware虚拟网络编辑器
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· 零经验选手，Compose 一天开发一款小游戏！
· 一起来玩mcp_server_sqlite，让AI帮你做增删改查！！

公告

昵称：蠡烬
园龄： 1年3个月
粉丝： 0
关注： 1

+加关注

2025年3月

日

一

二

三

四

五

六

集合

一.集合框架

1.单例集合的体系结构

二.ArrayList集合

1.

2.ArrayList常用方法

3.总结

三.Collection集合

1.Collection是所有单列集合的父接口，因此在Collection中定义了单列集合（List和Set）一些通用的方法，用于操作所有的单列集合。方法如下：

四.Iterator迭代器

五.泛型

六.List集合

七.LinkedList集合

八.Set集合

九.LinkedHashSet集合

十.Map集合

1.Map接口中的常用方法

2.Map集合的第一种遍历方式：通过键找值

3.Map集合遍历的第二种方法：使用Entry对象遍历。

4.HashMap集合存储自定义类型的键值。

5.LinkedHashMap

公告

搜索

常用链接

随笔档案

阅读排行榜