Java基础：集合全解

已于 2022-08-11 00:42:28 修改
阅读量290 收藏 1
点赞数 1
文章标签： java jvm 开发语言
于 2022-08-11 00:35:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50835087/article/details/126277066
版权

集合

一、集合框架
集合、数组都是对多个数据进行存储操作的结构，简称Java容器
说明：这里的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg.数据库等）

集合框架

Collection接口

Collection接口：单列集合，用来存储一个一个的对象

​ ----List接口：存储有序的、可重复的数据。 —>“动态”数组
​ ----ArrayList、LinkedList、Vector

​ ----Set接口：存储无序的、不可重复的数据
​ ----HashSet、LinkedHashSet、TreeSet

Map接口：双列集合，用来存储一对（key - value)一对的数据 —>y=f(x)
----HashMap、LinkedMap、TreeMap、Hashtable、Properties

集合的初始化和基本使用 非泛型

public class List {
    @Test
    public void test(){
        //初始化
        Collection coll=new ArrayList();
        //add(Object e)：将元素e添加到集合coll中
        coll.add("zmj");
        coll.add(123);
        coll.add(new Date());

        //size():获取添加的元素的个数
        System.out.println(coll.size());
        System.out.println(coll);

        //将集合中的元素添加到里另一个集合中
        Collection list = new ArrayList();
        list.add("ZMJ");
        list.add(321);
        //addAll(Collection list)：将coll集合中的元素添加到当前list的集合中
        list.addAll(coll);

        System.out.println(coll);//[zmj, 123, Wed Jun 22 18:28:58 CST 2022]
        System.out.println(list);//[ZMJ, 321, zmj, 123, Wed Jun 22 18:28:58 CST 2022]

        //clear()：清空集合元素
        coll.clear();

        //isEmpty()：判断当前集合是否为空
        if(coll.isEmpty()){
            System.out.println("该集合为空");
        }else {
            System.out.println(coll);
        }
    }
}

集合元素的遍历

集合元素的遍历操作：使用迭代器Iterator接口

  • 1.内部方法：hasNext()和 next()
  • 2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象
  • 3.默认游标都在集合的第一个元素之前
    /**
     * 集合元素的遍历操作：使用迭代器Iterator接口
     * 1.内部方法：hasNext()和  next()
     * 2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象
     * 3.默认游标都在集合的第一个元素之前
     * 4.迭代器内部定义了remove()，可以在遍历的时候，删除集合中的元素，此方法不同于集合中的remove()方法
     */
    @Test
    public void test(){
        Collection coll = new ArrayList();
        coll.add("124");
        coll.add(123);
        coll.add(new Person("zmj",22));
        coll.add(new String("zmj2"));
        coll.add(false);

        //迭代器：iterator本身不是容器,只是一个迭代器对象
        java.util.Iterator iterator = coll.iterator();

//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());

        //推荐使用方法
        //hasNext()：判断是否还有下一个元素
        while (iterator.hasNext()) {
            //next():
            //1.指针下移
            //2.将下移以后的集合位置上的元素返回
            System.out.println(iterator.next());
        }
    }
  • 4.迭代器内部定义了remove()，可以在遍历的时候，删除集合中的元素，此方法不同于集合中的remove()方法
    //测试Iterator中的remove()
    //未调用next()或者上一次调用next()方法后已经调用了remove方法，在调用remove将报异常IllegalStateException
    //相当于指针都还没有指向值，删什么？
    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add("124");
        coll.add(123);
        coll.add(new Person("zmj",22));
        coll.add(new String("zmj2"));
        coll.add(false);

        java.util.Iterator iterator = coll.iterator();

        while (iterator.hasNext()){
//            iterator.remove();//异常操作
            Object next = iterator.next();
            if("124".equals(next)){
                iterator.remove();
            }
        }
        System.out.println(coll);

        //一个迭代器处理一个流程
        java.util.Iterator iterator1 = coll.iterator();
        //使用新的迭代器iterator1执行遍历
        while (iterator1.hasNext()){
            System.out.println(iterator.next());
        }
    }

增强型for循环 foreach

  • for(集合元素的类型 局部变量 ： 集合对象）
  • 底层内部任然调用的迭代器
/**
 * Created by KingsLanding on 2022/6/24 16:22
 */
public class ForEach {

    @Test
    public void test(){
        Collection coll = new ArrayList();
        coll.add("124");
        coll.add(123);
        coll.add(new Person("zmj",22));
        coll.add(new String("zmj2"));
        coll.add(false);

        //增强型for循环
        //for(集合元素的类型   局部变量  ： 集合对象）
        //底层内部任然调用的迭代器
        for(Object obj:coll){
            System.out.println(obj);
        }
    }

    @Test
    public void test2(){
        int[] ints = {1, 2, 3, 4, 5};
        for (int i:ints){
            System.out.println(i);
        }
    }

    @Test
    public void test3(){
        String[] strings = {"AA", "AA"};

//        for(int i=0;i<strings.length;i++){
//            strings[i]="BB";
//            System.out.println(strings[i]);
//        }

        //该方法将查询结果存放到了str中，所以赋值也是赋值给了str而非strings中
        for(String str : strings){
            str="BB";
            System.out.println(str);//BB
        }

        for(int i=0;i<strings.length;i++){
            System.out.println(strings[i]);//AA
        }
    }

}

List接口

Collection接口：单列集合，用来存储一个一个的对象
----List接口：存储有序的、可重复的数据。 —>“动态”数组,替换原有的数组
----ArrayList：作为List接口的主要实现类；线程不安全，效率高；底层使用Object[] elementData存储（单链表）
----LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高，底层使用双向链表存储（数据结构）
----Vector：作为List接口的古早实现类：线程安全，效率低；底层使用Object[] elementData存储

  • ArrayList、LinkedList、Vector三者异同

    • 同：三个类都是实现了List接口，存储数据特点相同：有序可重复

    • 异：ArrayList：作为List接口的主要实现类；线程不安全，效率高；底层使用Object[] elementData存储

      ​ LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高，底层使用双向链表存储（数据结构）

      ​ Vector：作为List接口的古早实现类：线程安全，效率低；底层使用Object[] elementData存储

/**
 * Created by KingsLanding on 2022/6/24 18:45
 *
 *  三、集合框架
 *  Collection接口：单列集合，用来存储一个一个的对象
 *      ----List接口：存储有序的、可重复的数据。 --->“动态”数组,替换原有的数组
 *          ----ArrayList：作为List接口的主要实现类；线程不安全，效率高；底层使用Object[] elementData存储（单链表）
 *          ----LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高，底层使用双向链表存储（数据结构）
 *          ----Vector：作为List接口的古早实现类：线程安全，效率低；底层使用Object[] elementData存储
 *
 *  面试题：
 *  ArrayList、LinkedList、Vector三者异同
 *  同：三个类都是实现了List接口，存储数据特点相同：有序可重复
 *  异： ----ArrayList：作为List接口的主要实现类；线程不安全，效率高；底层使用Object[] elementData存储
 *       ----LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高，底层使用双向链表存储（数据结构）
 *       ----Vector：作为List接口的古早实现类：线程安全，效率低；底层使用Object[] elementData存储
 *
 */

ArrayList源码分析

  • 1、jdk7:(饿汉式）
    ArrayList list=new ArrayList();//初始化创建了长度为10的Object[] elementData存储（单链表），
    list.add(123);// elementData[0] = new Integer(123);
    …
    list.add(Xx);//如果此次的添加导致底层elementData数组容量不够，则要进行扩容，默认情况下，扩容为原来容量的1.5倍，即增加原容量的一半。同时将原数组里的数据复制到新的数组中

开发中建议使用带参构造器：ArrayList list = new ArrayList(int capacity)

  • 2、jdk8（懒汉式）
    ArrayList list=new ArrayList();//底层Object[] elementData存储（单链表），初始化化为｛｝，即没有创建初始长度

    list.add(123);//第一次调用add()时，底层才创建长度为10的数组，并将数据添加到elementData中
    …
    list.add(Xx);//如果此次的添加导致底层elementData数组容量不够，则要进行扩容，默认情况下，扩容为原来容量的1.5倍，即增加原容量的一半。同时将原数组里的数据复制到新的数组中

    jdk8延迟了数组的创建，节省了内存

ArrayList方法测试
public class aListTest {

    /**
     * ArrayList方法测试
     *
     * 常用方法：
     * 增删改查
     * add(Object obj)、remove(int index)\remove(Object obj)、
     * set(int index,Object ele)、get(int index)
     * 插：add(int index,Object ele)
     * 长度：size()
     * 遍历：(1)foreach增强
     *     (2)Iterator迭代器
     *     (3)普通循环
     */
    @Test
    public  void test2(){
        ArrayList<Object> list = new ArrayList<>();
        list.add(123);
        list.add("124");
        list.add(new Person("zmj",22));
        list.add(new String("zmj2"));
        list.add(false);

        //遍历方式：迭代器
        java.util.Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        //遍历方式：foreach
        System.out.println("*************");
        for(Object obj:list){
            System.out.println(obj);
        }

        //遍历方式：普通；size()返回此列表中的元素数。get()返回此列表中指定位置的元素
        System.out.println("************");

        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }

    }
    @Test
    public void test(){
        ArrayList<Object> list = new ArrayList<>();
        list.add(123);
        list.add("124");
        list.add(new Person("zmj",22));
        list.add(new String("zmj2"));
        list.add(false);

        System.out.println(list);

        List<Integer> integers = Arrays.asList(1, 2, 3);

        list.addAll(integers);//将integer中的所有元素复制给list集合

        System.out.println(list);

        System.out.println(list.size());//返回此列表中的元素数

        //返回指定的fromIndex （含）和toIndex之间的列表部分的视图;返回列表中的非结构性更改
        System.out.println(list.subList(2, 4));//[Person{name='zmj', age=22}, zmj2]

        //替换指定位置的元素
        list.set(3, new String("zmj"));
        System.out.println(list);

    }

    /**
     * 区分List中remove(int index)和remove（Object obj)
     */
    @Test
    public void test3(){
        ArrayList<Object> list = new ArrayList<>();
        list.add(123);
        list.add("124");
        list.add(new Person("zmj",22));
        list.add(new String("zmj2"));
        list.add(false);

        updateList(list);
        System.out.println(list);//[124, Person{name='zmj', age=22}, zmj2, false]
    }
    private void updateList(List list){
        //默认是remove(int index),移除第0位的数据
        //list.remove(0);
        //指定remove(Object obj)，移除数据为obj的
        list.remove(new Integer(123));
    }

}

LinkedList的源码分析

*      //初始化：内部声明了Node类型的first和last属性，默认值为null
*      LinkedList linkedList = new LinkedList();
*      linkedList.add(123);//将123封装到Node中，创建了Node对象
*
*    //其中Node定义位：体现了LinkedList的双向链表
*    private static class Node<E> {
*         E item;
*         Node<E> next;
*         Node<E> prev;
*
*         Node(Node<E> prev, E element, Node<E> next) {
*             this.item = element;
*             this.next = next;
*             this.prev = prev;
*      }
*     }

Vector源码分析

jdk7和jdk8中Vector()构造器创建对象时，底层都创键了长度为10的数组扩容默认扩容为原来的 数组长度的2倍

Set接口

Collection接口：单列集合，用来存储一个一个的对象
----Set接口：存储无序的、不可重复的数据
----HashSet:作为Set接口的主要实现类；线程不安全；可以存储null值
----LinkedHashSet:作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历
在添加数据的同时，每个数据还维护了两个引用， 记录此数据前一个数据和后一个数据
优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet
----TreeSet:可以按照添加对象的指定属性进行排序

Set:存储无序的、不可重复的数据

  • 无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加， 而是根据数据的哈希值决定的
  • 不可重复性：尽量保证哈希值不同，如果哈希值相同，那就需要保证添加的元素按照equals()判断时，不能返回true,即相同元素只能添加一个

添加元素的过程：以HashSet为例：

* 二、添加元素的过程：以HashSet为例：
*      我们向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，
*      此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即：索引位置），判断
*      此数组此位置上是否已经有元素：
*          如果此位置上没有其他元素，则元素a添加成功。--->
*          如果此位置上有其他元素b(或以链表形式存在的多个元素），则比较元素a与元素b的hash值：
*              如果hash值不同，这元素a添加成功。--->
*              如果hash值相同，进而需要调用元素a所在类的equals()方法：
*                  equals()方法返回true,元素a添加失败
*                  equals()方法返回false,元素a添加成功。--->
*
*  对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存在
*  jdk7：元素a放到数组中，指向原来的元素
*  jdk8：原来的元素在数组中，指向元素a
*  (七上八下）

HashSet测试

/**
 * HashSet底层：数组+链表的结构
 */
@Test
public void test(){
    Set<Object> set = new HashSet<>();
    set.add(123);
    set.add(123);
    set.add(new String("zmj"));
    set.add(new Person("zmj2",22));
    set.add(new Person("zmj2",22));//在Person类中重写equals()方法，以及 hashCode()方法，才能判断其哈希值
    set.add("124");
    System.out.println(set);//[Person{name='zmj2', age=22}, 124, zmj, 123]
}

LinkedHashSet的使用测试

/**
 LinkedHashSet的使用测试
 LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，
        记录此数据前一个数据和后一个数据
 优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet
 */
@Test
public void test2(){
    LinkedHashSet<Object> set = new LinkedHashSet<>();
    set.add(123);
    set.add(123);
    set.add(new String("zmj"));
    set.add(new Person("zmj2",22));
    set.add(new Person("zmj2",22));//在Person类中重写equals()方法，以及 hashCode()方法，才能判断其哈希值
    set.add("124");

    for(Object obj : set){
        System.out.println(obj);
    }
}

TreeSet

向TreeSet中添加的数据，要求是相同类型的对象。

/**
 1.向TreeSet中添加的数据，要求是相同类的对象。
 2.两种排序方式：自然排序（实现Comparable借口）和定制排序(在Person类中重写CompareTo(Object o)方法）
 3.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0  不再是equals()
 */
@Test
public void test3(){
    TreeSet<Object> set = new TreeSet<>();

    //不能添加不同类型的对象
    set.add(123);
    set.add(124);
    //set.add("zmj");
    set.add(12);
    set.add(-14);
    System.out.println(set);
}

@Test
public void test4(){
    //定制排序:按照年龄从小到大排序
    Comparator com=new Comparator(){
        @Override
        public int compare(Object o1, Object o2) {
            if(o1 instanceof Person && o2 instanceof Person){
                Person p1 = (Person)o1;
                Person p2 = (Person)o2;
                return Integer.compare(p1.getAge(),p2.getAge());
            }else {
                throw new RuntimeException("输入数据不匹配");
            }
        }
    };
    TreeSet<Object> set = new TreeSet<>(com);
    set.add(new Person("zmj",22));
    set.add(new Person("lnx",21));
    set.add(new Person("sbh",22));
    set.add(new Person("sbh",23));


    /**
     *  自然排序:通过在Person类里重写compareTo(Object o)方法实现
     @Override
     public int compareTo(Object o) {
     if(o instanceof Person){
     Person person=(Person)o;
     int compare = -this.name.compareTo(person.name);
     if(compare != 0){
     return compare;
     }else {
     return Integer.compare(this.age,person.age);
     }
     }else {
     throw new RuntimeException("类型不匹配");
     }
     }
     */

    for(Object obj : set){
        System.out.println(obj);
    }
}

Person类

package collection;

import java.util.Objects;

/**
 * Created by KingsLanding on 2022/6/24 13:48
 */
public class Person implements Comparable{
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person)) return false;

        Person person = (Person) o;

        if (age != person.age) return false;
        return name != null ? name.equals(person.name) : person.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    //TreeSet自然排序
    @Override
    public int compareTo(Object o) {
        if(o instanceof Person){
            Person person=(Person)o;
            int compare = -this.name.compareTo(person.name);
            if(compare != 0){
                return compare;
            }else {
                return Integer.compare(this.age,person.age);
            }
        }else {
            throw new RuntimeException("类型不匹配");
        }
    }
}

map接口

----Map:双列数据，存储key-value对的数据 --类似于：y=f(x)
----HashMap:作为Map的主要实现类：线程不安全，效率高；可以存储null的key和value
----LinkedHashMap:保证在遍历map元素时，可以按照添加的顺序实现遍历
原理：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素
对于频繁的遍历操作，此类执行效率高于HashMap
----TreeMap:保证添加的key-value对进行排序，实现排序遍历，此时考虑key的自然排序或定制排序
底层使用红黑树
----Hashtable:古早实现类；线程安全的，效率低，不能存储null的key和value
----properties:常用来处理配置文件（数据库链接配置文件）。key和value都是String类型

HashMap的底层：数组+链表 （jdk7)
数组+链表+红黑树 （jdk8)

Map结构的理解

 - **Map中的key:**无序的，不可重复的，***使用Set存储所有的key***    --->key所在的类要重写equals()和HashCode()方法
  • **Map中的value:**无序的，可重复的，使用Collection存储所有的value —>value所在的类要重写equals()方法
    一个键值对：key-value构成了一个Entry对象。
    • **Map中的entry:**无序的，不可重复的，使用Set存储所有的entry

HashMap的底层实现原理

* HashMap的底层实现原理。（以jdk7为例）
*      HashMap map = new HashMap();
*      在实例化后，底层创建了长度为16的一维数组Entry[] table
*      ...可能已经执行过多次put...
*      map.put(key1,value1);
*      首先，调用key1所在的类的hashCode()方法计算key的哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中
*      的存放位置
*      如果此位置上的数据为空，此时key1-value1添加成功。    --->1
*      如果此位置上的存在数据，（意味着此位置上存在一个或多个数据（以链表形式存在），那么就需要比较key1
*      和已经存在的一个或多个数据的哈希值：
*          如果key1的哈希值与已经存在的数据的哈希值都不同，此时key1-value1添加成功 --->2
*          如果key1的哈希值与已经存在的某一个数据(key2-value2)的哈希值相同，则需要继续比较：
*              调用key1所在类的equals(key2)方法:
*                  如果equals()返回false:此时key1-value1添加成功 --->3
*                  如果equals()返回true:此时key1-value1中的value1将替换原有与key1相同的key2对应的value2
*
*     关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储
*     在不断的添加过程中，会涉及到扩容问题，当超出临界值（12）且要存放的位置非空时，扩容；默认的扩容方式：扩容为原来容量的2倍，并将原有的数据复制过来
*
*     jdk8 相较于jdk7在底层实现方面的不同之处：
*          1.new HashMap();初始化时底层没有创建一个长度为16的数组（懒汉式）
*          2.jdk8底层的数组是：Node[],而不是Entry[]
*          3.首次调用put()方法时，底层创建长度为16的数组
*          4.jdk7底层结构只有：数组+链表。
*            七上八下：jdk7中新的元素指向旧的元素。jdk8中旧的元素指向新的元素
*     jdk8底层结构：数组+链表+红黑树；当数组的某一个索引位置上的元素以链表的形式存在的数据个数 > 8
*     且当前数组长度 > 64时，此时索引位置上的所有数据改为使用红黑树存储（二叉树链表，查询遍历效率更高）
*
*      DEFAULT_ INITIAL_ CAPACITY : HashMap的默认容量，16
*      DEFAULT_ LOAD FACTOR: HashMap的默认加载因子: 0.75
*      threshold:扩容的临界值，=容量*填充因子: 16 * 0.75 => 12
*      TREEIFY_THRESHOLD: Bucket 中链表长度大于该默认值，转化为红黑树:8
*      MIN_TREEIFY_CAPACITY:桶中的Node 被树化时最小的hash表容量:64
*

LinkedHashMap的底层实现原理（了解）

*      源码：
*      static class Entry<K,V> extends HashMap.Node<K,V> {
*         Entry<K,V> before, after;//记录添加元素的先后顺序
*         Entry(int hash, K key, V value, Node<K,V> next) {
*             super(hash, key, value, next);
*         }
*     }

*     总结：常用方法
 *     添加：put(Object key,Object value)
 *     删除：remove(Object key)\clear()
 *     修改：put(Object key,Object value)
 *     查询：get(Object key)
 *     长度：size()
 *     遍历：keySet()\values()\entrySet()
 */
public class MapTest {

    /**
        方法测试
        添加、删除、修改
        Object put(Object key,Object value):将指定key-value添加（或修改）当前map对象中
        void putAll(Map m):将m中的所有key-value对存放到当前的map中
        Object remove(Object key):移除指定key的key-value对，并返回value
        void clear():清空当前map中的所有数据
     */
    @Test
    public void test(){
        Map map = new HashMap();
        LinkedHashMap linkMap = new LinkedHashMap();

        //添加
        map.put("AA",123);
        map.put("BB",123);
        map.put(123,123);
        //修改
        map.put("AA",124);
        System.out.println(map);

        Map map1 =new HashMap();

        map1.put("CC",123);
        map1.put("DD",123);

        //将集合map1中的所有元素复制给map
        map.putAll(map1);
        System.out.println(map);

        //remove(Object key)
        Object value = map.remove("DD");
        System.out.println(value);

        System.out.println(map);

        //clear()
        map.clear();
        System.out.println(map);
    }

    public void test2(){
        /**
         方法测试：元素查询操作
         Object get(Object key):获取指定key对应的value
         boolean containsKey(Object key):是否包含指定的key
         boolean containsValue(Object key):是否包含指定的value
         int size():返回map中key-value对的个数
         boolean isEmpty():判断map是否为null
         boolean equals(Object obj):判断当前map和指定的集合对象是否相等
         */
        Map map = new HashMap();
        map.put("AA",123);
        map.put("BB",123);
        map.put(123,123);
        System.out.println(map);

        System.out.println(map.get("AA"));

        boolean bool = map.containsKey("BB");
        System.out.println(bool);

        boolean bool1 = map.containsValue("123");
        System.out.println(bool1);

        System.out.println(map.size());

        System.out.println(map.isEmpty());

        Map map1 =new HashMap();

        map1.put("CC",123);
        map1.put("DD",123);

        System.out.println(map.equals(map1));

    }

    @Test
    public void test3(){
        /**

         元视图的遍历操作
         Set keySet();返回所有key构成的Set集合
         Collection values();返回所有value构成的collection集合
         set entrySet();返回所有key-value对构成的Set集合
         */
        Map map = new HashMap();
        map.put("AA",123);
        map.put(22,125);
        map.put("BB",124);

        //遍历所有的key
        Set set = map.keySet();

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("**********");
        //遍历所有的value
        Collection values = map.values();

        for(Object obj:values){
            System.out.println(obj);
        }

        //遍历所有的key-value
        //方式一、entrySet()
        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            //entrySet集合中的元素都是entry
            Object obj = iterator1.next();
            System.out.println(obj);
            //将entry强转为map,分别拿到key和value
            Map.Entry entry= (Map.Entry) obj;
            System.out.println(entry.getKey() + "===>" + entry.getValue());
        }

        //遍历所有的key-value
        //方式二、分别遍历key和value，然后显示
        Set set1 = map.keySet();
        Collection values1 = map.values();
        Iterator iterator2=set.iterator();
        Iterator iterator3=values.iterator();
        while (iterator2.hasNext()&&iterator3.hasNext()){
            System.out.println(iterator2.next() + "===>" + iterator3.next());
        }
    }
}
King'sLanding
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Java中的集合类型体系
小鱼的博客
06-20 292
1、集合主要分为Collection接口和Map接口；2、Collection接口分别被Queue、List和Set三个接口继承；3、List接口被AbstractList实现，分为三个子类：LinkedList、ArrayList、Vector； 元素按进入先后有序保存，可重复，元素有序 ；4、Set接口被AbstractSet实现，分为两个子类：HashSet、TreeSet；仅接收一次，不可重复，元素无序 ；5、Map接口被AbstractMap实现，分为两个子类：HashMap、TreeMap；6
Java基础之集合
weixin_46858031的博客
10-30 529
目录 Collection Collection常用方法 Collection接口遍历元素方式1-使用lterator(迭代器)>基本介绍 迭代器的执行原理 Collection接口遍历对象方式2-for循环增强 List接口的常用方法 List的三种遍历方式 ArrayList与LinkedList的区别： Set接口的常用方法 Set接口的遍历方式 Set接口基本介绍 Map集合 Map接口常用方法 Hashtable和 HashMap对比 ​ 在Java中，...
【Java基础】之集合详解篇(一篇彻底通透)
奔跑的菜鸟的Run博客
02-11 403
一片囊括List，Set，Map补充了可变参数，Collestions工具类，集合问题一篇解决 什么是集合呢？集合和数组类似都是容器，可以用来储存数据，但是它们之间又有不同。数组定义完成并启动后，类型确定、长度固定。不适合元素的个数和类型不确定的业务场景，更不适合做需要增删数据操作。数组的功能也比较的单一，处理数据的能力并不是很强大。集合的大小不固定，启动后可以动态变化，类型也可以选择不固定。集合更像气球。集合非常适合元素个数不能确定，且需要做元素的增删操作的场景。
java中的集合基础
weixin_45834289的博客
02-25 124
集合的基本使用
JAVA基础——集合知识点整理
最新发布
jsdtfza的博客
05-16 619
当一个类有自己特有的“逻辑相等”概念,当改写equals()的时候，总是要改写hashCode()，根据一个类的equals方法（改写后），两个截然不同的实例有可能在逻辑上是相等的，但是，根据Object.hashCode()方法，它们仅仅是两个对象。jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]
java基础之集合详解（list，set，map）
sinat_26552841的博客
01-06 994
虽然HashMap是线程不安全的，但是它的效率远远高于Hashtable，这样设计是合理的，因为大部分的使用场景都是单线程。取余（%）操作中如果除数是 2 的幂次，则等价于与其除数减一的与（&）操作（也就是说 hash % length == hash &(length - 1) 的前提是 length 是 2 的 n 次方）。在TreeSet中，不保留“元素的插入顺序”，因为元素将按照某种升序排序插入TreeSet中，或者换句话说，“元素的插入顺序”不需要与“检索”相同元素的顺序”。
集合
weixin_30606461的博客
09-30 2801
0Collection接口和Map接口 1 Collection集合 1.1 集合概述 集合：集合是java中提供的一种容器，可以用来存储多个数据。集合和数组既然都是容器，它们有啥区别呢？ 数组的长度是固定的。集合的长度是可变的。 数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中...
Java全基础
zpx_034的博客
07-12 274
Java基础概述，帮助快速复习基础语法（最近比较忙，图片就不建库一一更改链接显示了，有需要此文章的小伙伴私信发你~）
java集合类的全解
07-23
最新整理的集合全集 对map 和 collection 下的类进行了详细的整理。
Java基础-ArrayList方法全解(上).pdf
11-19
ArrayList是Java集合框架中常用的动态数组，它允许我们在运行时添加、删除和访问元素。在Java中，ArrayList实现了List接口，因此它支持有序的元素序列，并且允许有重复元素。本文将深入解析ArrayList的主要方法，...
Java注释全解文档.zip
03-02
本文档集合了关于Java注释的全面解析，涵盖了Spring、Hibernate以及Struts2框架中的注解使用。以下是对每个标签及文件内容的详细阐述： 1. **Java注释** - 单行注释：`// 注释内容`，常用于临时性的代码说明。 - ...
Java基础----集合类汇总
03-28
NULL 博文链接：https://andelu.iteye.com/blog/1260288
java面试全解.pdf
10-17
#### 五、Java集合框架 - **接口继承关系和实现**：主要包括Collection、Set、List、Map等接口以及它们的具体实现类。 - **List**： - **ArrayList**：基于数组实现，查询效率高，不适合频繁的增删操作。 - **...
JAVA语言 答案全解
11-06
1. **基础语法**：Java的基础语法结构，如变量声明、数据类型（基本类型与引用类型）、运算符、控制流程（if语句、for循环、while循环、switch语句）以及方法的定义与调用。 2. **类与对象**：面向对象编程的核心，...
JAVA的集合类型总结（List，Vector，Set，Map）
ruiqu1650914788的博客
10-23 698
java的集合类型大全和解释
Java基础篇——集合
尘的学习记录
08-16 500
本文介绍了java集合中的List、Set、Map的相关知识，以及它们三者的区别。
Java之集合详解（一）
qq_50692350的博客
08-05 1055
Java
JAVA集合基础（一）
zz18532164242的博客
05-31 751
集合基础
java集合（重要知识点汇总）超详细
qq_64513441的博客
07-01 3321
1.1.1集合的引出 1.1.2数组的disadvantage 1.1.3集合的advantage 1.2.1集合的框架结构 1.3.1Collection接口和常用方法 1.3.2Collection 接口常用方法,以实现子类 ArrayList 来演示. CollectionMethod.java 1.4.1Collection 接口遍历元素方式 1-使用 Iterator(迭代器) 1.4.2迭代器的执行原理(看代码,含详细解释) 1.4.3Collection 接口遍历方式 2加强for...
Java语法全解：从基础到进阶
"Java语法大全包含了Java编程的基础要素，包括词法规则、数据类型、常量与变量、运算符和表达式、语句、数组和字符串等核心概念。此外，还涉及了Java程序的运行机制，如源代码的编译过程、字节码的执行以及JVM的角色...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

King'sLanding

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值