备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

Java集合详解

2022-08-29 76
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Java集合详解

一、集合接口

在这里插入图片描述

Collection接口是构造集合框架的基础，定义了操作对象集合的共同方法。

  • List接口是有序，可包含重复元素的列表。
  • Set接口是无序的，无重复元素的集合的列表。

案例分析：

package com.collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
public class CollectionTest1 {
    public static void main(String[] args) {
        //有序，重复，有索引
        Collection c=new ArrayList();
        c.add("a");
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");
        c.add("d");
        System.out.println(c);  //[a, a, b, c, d, d]
        //无序，不重复，无索引
        Collection c1=new HashSet();
        c1.add("a");
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        c1.add("d");
        System.out.println(c1);  //[a, b, c, d]

    }
}

二、Collection常用API

方法名称 说明
public boolean add(E e) 把给定的对象添加到当前集合中
public void clear() 清空集合中所有的元素
public boolean remove(E e) 把给定的对象在当前集合中删除
public boolean contains(Object obj) 判断当前集合中是否包含给定的对象
public boolean isEmpty() 判断当前集合是否为空
public int size() 返回集合中元素的个数。
public Object[] toArray() 把集合中的元素，存储到数组中

案例分析：

package com.collection;

import java.util.ArrayList;
import java.util.Collection;

public class Collection_API {
    public static void main(String[] args) {
        Collection<String> c=new ArrayList<>();
        //添加元素
        c.add("小马哥");
        c.add("小飞侠");
        c.add("罗西");
        c.add("马奎斯");
        c.add("罗西");
        System.out.println(c);  //[小马哥, 小飞侠, 罗西, 马奎斯, 罗西]
        //获取集合大小
        System.out.println(c.size());  //5
        //判断集合是否为空
        System.out.println(c.isEmpty());  //false
       // System.out.println(c);
        //判断集合中是否包含某个元素
        System.out.println(c.contains("小马哥"));  //true
        //删除某个元素，如果是重复元素，则删除第一个
        System.out.println(c.remove("罗西"));  //true
        System.out.println(c);  //[小马哥, 小飞侠, 马奎斯, 罗西]
        //把集合转换为数组
        Object o=c.toString();
        System.out.println(o);  //[小马哥, 小飞侠, 马奎斯, 罗西]
        //清空集合元素
        c.clear();
        System.out.println(c);   //[]
        //将集合c2中的元素倒入c1中
        Collection<String> c1=new ArrayList<>();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        Collection<String> c2=new ArrayList<>();
        c2.add("d");
        c2.add("e");
        c2.add("f");
        c2.add("g");
        c1.addAll(c2);
        System.out.println(c1);  //[a, b, c, d, e, f, g]


    }
}

三、collection集合遍历方式

1.Iterator迭代器

  • Collection集合获取迭代器
方法名称 说明
Iterator iterator() 返回集合中的迭代器对象，该迭代器对象默认指向当前集合的0索引
  • Iterator常用的方法
方法名称 说明
boolean hasNext() 询问当前位置是否有元素存在，存在返回true ,不存在返回false
E next() 获取当前位置的元素，并同时将迭代器对象移向下一个位置，注意防止取出越界。

案例分析：

package com.collection.iterator;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

//collection集合遍历方式
public class IteratorTest {
    public static void main(String[] args) {
        //iterator遍历
        //创建Collection集合对象
        Collection<String> c=new ArrayList<>();
        //添加元素
        c.add("小马哥");
        c.add("小飞侠");
        c.add("罗西");
        c.add("马奎斯");
        c.add("罗西");
       //得到迭代器对象
        Iterator<String> it = c.iterator();
        //循环遍历
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}
/*
小马哥
小飞侠
罗西
马奎斯
罗西
 */

2.增强for循环遍历

for(元素数据类型变量名:数组或者Collection集合){
//在此处使用变量即可，该变量就是元素
}

案例分析：

package com.collection;

import java.util.ArrayList;
import java.util.Collection;

//增强for遍历
public class ForTest {
    public static void main(String[] args) {
        Collection<String> c=new ArrayList<>();
        //添加元素
        c.add("小马哥");
        c.add("小飞侠");
        c.add("罗西");
        c.add("马奎斯");
        c.add("罗西");
        for (String s : c) {
            System.out.println(s);
        }
    }
}
/*
小马哥
小飞侠
罗西
马奎斯
罗西

 */

3.案例分析

package com.collection.Test;

public class Student {
    private String name;
    private int age;
    private double height;

    public Student() {
    }

    public Student(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    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;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

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


package com.collection.Test;

import java.util.ArrayList;
import java.util.Collection;

public class StudentTest {
    public static void main(String[] args) {
        Collection<Student> students=new ArrayList<>();
        students.add(new Student("小马哥",34,180.5));
        students.add(new Student("小飞侠",44,170.5));
        students.add(new Student("马奎斯",24,190.5));
        students.add(new Student("罗西",54,189.5));
        for (Student student : students) {
            System.out.println(student.getName()+"\t"+student.getAge()+"\t"+student.getHeight());
        }
    }
}
/*
小马哥    34    180.5
小飞侠    44    170.5
马奎斯    24    190.5
罗西    54    189.5
 */

四、List接口

  • List系列集合特点

    • ArrayList、LinekdList :有序，可重复，有索引。

  • List的实现类的底层原理

    • ArrayList底层是基于数组实现的，根据查询元素快，增删相对慢。
    • LinkedList底层基于双链表实现的，查询元素慢，增删首尾元素是非常快的。

1.Arraylist类

方法名称 说明
void add(int index,E element) 在此集合中的指定位置插入指定的元素
E remove(int index) 删除指定索引处的元素，返回被删除的元素
E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
E get(int index) 返回指定索引处的元素

案例分析：

package com.list;

import java.util.ArrayList;
import java.util.List;

public class ListTest {
    public static void main(String[] args) {
        //创建一个List集合对象
        List<String> list=new ArrayList();
        list.add("小马哥");
        list.add("小飞侠");
        list.add("马奎斯");
        list.add("小马哥");
        //在某个索引插入元素
        list.add(1,"罗西");
        System.out.println(list);  //[小马哥, 罗西, 小飞侠, 马奎斯, 小马哥]
        //根据索引删除元素
        list.remove(1);
        System.out.println(list);  //[小马哥, 小飞侠, 马奎斯, 小马哥]
        //根据索引获取元素
        System.out.println(list.get(2));   //马奎斯
        //修改某索引的元素
        list.set(1,"科比");
        System.out.println(list);  //[小马哥, 科比, 马奎斯, 小马哥]
    }
}

2.List遍历方式

  • for循环
  • iterator迭代器
  • 增强for循环

案例分析：

package com.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

//List遍历方式
public class ListTest2 {
    public static void main(String[] args) {
        List<String> list=new ArrayList();
        list.add("小马哥");
        list.add("小飞侠");
        list.add("马奎斯");
        list.add("小马哥");
        //for循环
        for (int i = 0; i <list.size() ; i++) {
            String s = list.get(i);
            System.out.println(s);
        }
        System.out.println();
        //iterator迭代器
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println();
        //增强for循环
        for (String s : list) {
            System.out.println(s);
        }

    }
}
/*
小马哥
小飞侠
马奎斯
小马哥

小马哥
小飞侠
马奎斯
小马哥

小马哥
小飞侠
马奎斯
小马哥
 */

3.List遍历删除相同元素

package com.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

//遍历删除相同元素
public class ListTest3 {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        System.out.println(list);  //[a, b, b, c, d, e]
        //迭代器删除元素
       /* Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            if ("b".equals(s)){
                it.remove();  //使用迭代器删除保证不后移
            }
        }
        System.out.println(list);  //[a, c, d, e]*/

       //for循环删除元素(方式一)
        /*for (int i = 0; i <list.size() ; i++) {
            String s = list.get(i);
            if ("b".equals(s)){
                list.remove("b");
                i--;
            }
        }
        System.out.println(list);  //[a, c, d, e]*/

        //for循环删除元素(方式二)
        for (int i =list.size()-1; i >=0 ; i--) {
            String s = list.get(i);
            if ("b".equals(s)){
                list.remove("b");
            }

        }
        System.out.println(list);  //[a, c, d, e]

    }
}

4.LinkedList类

package com.list;

import java.util.LinkedList;

public class LinkedListTest {
    public static void main(String[] args) {
        //LinkedList可以完成队列结构和栈结构
        //栈
        LinkedList<String> ll=new LinkedList<>();
        //入栈
        ll.addFirst("第一块积木");
        ll.addFirst("第二块积木");
        ll.addFirst("第三块积木");
        ll.addFirst("第四块积木");
        ll.addFirst("第五块积木");
        System.out.println(ll);
        //出栈
        System.out.println(ll.removeFirst());
        System.out.println(ll.removeFirst());
        System.out.println(ll.removeFirst());
        System.out.println(ll.removeFirst());
        System.out.println(ll);
        /*
        [第五块积木, 第四块积木, 第三块积木, 第二块积木, 第一块积木]
        第五块积木
        第四块积木
        第三块积木
        第二块积木
        [第一块积木]
         */

        //队列
        LinkedList<String> ll1=new LinkedList<>();
        //入队
        ll1.addLast("1");
        ll1.addLast("2");
        ll1.addLast("3");
        ll1.addLast("4");
        ll1.addLast("5");
        System.out.println(ll1);
        //出队
        System.out.println(ll1.removeLast());
        System.out.println(ll1.removeLast());
        System.out.println(ll1.removeLast());
        System.out.println(ll1.removeLast());
        System.out.println(ll1);
/*
[1, 2, 3, 4, 5]
5
4
3
2
[1]
 */

    }
}

五、set接口

  • Set系列集合特点

    • 无序:存取顺序不一致不重复:可以去除重复
    • 无索引:没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取元素。

  • Set集合实现类特点

    • HashSet:无序、不重复、无索引。
    • LinkedHashSet:有序、不重复、无索引。
    • TreeSet:排序、不重复、无索引。
    • set集合的功能上基本上与collection的API一致。

1.HashSet类

  • HashSet:无序、不重复、无索引。

案例分析：

package com.set.hashSet;

import java.util.HashSet;
import java.util.Set;

public class Test1 {
    public static void main(String[] args) {
        Set<String> sets=new HashSet<>();
        sets.add("小马哥");
        sets.add("小飞侠");
        sets.add("马奎斯");
        sets.add("罗西");
        System.out.println(sets);  //[马奎斯, 小马哥, 罗西, 小飞侠]

    }
}

综合案例分析：

package com.set.hashSet;

public class Student {
    private String name;
    private int age;
    private char sex;

    public Student() {
    }

    public Student(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    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;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        if (sex != student.sex) return false;
        return name.equals(student.name);
    }

    @Override
    public int hashCode() {
        int result = name.hashCode();
        result = 31 * result + age;
        result = 31 * result + (int) sex;
        return result;
    }

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


package com.set.hashSet;

import java.util.HashSet;
import java.util.Set;

public class StudentTest {
    public static void main(String[] args) {
        Set<Student> sets=new HashSet<>();
        sets.add(new Student("小马哥",34,'男'));
        sets.add(new Student("小马哥",34,'男'));
        sets.add(new Student("小飞侠",24,'女'));
        System.out.println(sets);  //[Student{name='小飞侠', age=24, sex=女}, Student{name='小马哥', age=34, sex=男}]

    }
}

注意：

  • 如果希望Set集合认为2个内容相同的对象是重复的应该怎么办?

    • 重写对象的hashCode和equals方法。

2.TreeSet类

  • TreeSet:排序、不重复、无索引。

案例分析：

package com.set.TreeSet;

import java.util.Set;
import java.util.TreeSet;

public class Test1 {
    public static void main(String[] args) {
        Set<Integer> s1=new TreeSet<>();  //无序，不重复，可排序
        s1.add(21);
        s1.add(12);
        s1.add(12);
        s1.add(1);
        s1.add(56);
        s1.add(45);
        System.out.println(s1);  //[1, 12, 21, 45, 56]

        Set<String> s2=new TreeSet<>();  ////无序，不重复，可排序
        s2.add("小马哥");
        s2.add("A");
        s2.add("Z");
        s2.add("D");
        s2.add("z");
        s2.add("a");
        System.out.println(s2);  //[A, D, Z, a, z, 小马哥]

    }
}

1.自然排序和比较器排序

  • 自定义排序规则
  • TreeSet集合存储对象的的时候有2种方式可以设计自定义比较规则

  • 方式一

    • 让自定义的类（如学生类)实现comparable接口重写里面的compareTo方法来定制比较规则。

  • 方式二

    • TreeSet集合有参数构造器，可以设置Comparator接口对应的比较器对象，来定制比较规则。

案例分析：

package com.set.TreeSet;

public class Student implements Comparable<Student> {
    private String name;
    private int age;
    private double score;

    public Student(String name) {
        this.name = name;
    }

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    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;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
//第一种类定义比较规则
    @Override
    public int compareTo(Student o) {
        //按照年龄排序
        //return this.getAge()-o.getAge(); //去掉了年龄相同的元素
        //[Student{name='小马哥', age=23, score=99.9}, Student{name='马奎斯', age=34, score=70.9}, Student{name='罗西', age=44, score=85.5}]
        return this.getAge()-o.getAge()>=0?1:-1;  //保留了年龄相同的元素
        //[Student{name='小马哥', age=23, score=99.9}, Student{name='小飞侠', age=23, score=89.5}, Student{name='马奎斯', age=34, score=70.9}, Student{name='罗西', age=44, score=85.5}]
    }
}


package com.set.TreeSet;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

public class StudentTest {
    public static void main(String[] args) {
        //集合自带比较器对象进行规则制定
        Set<Student> s=new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
               // return (int) (o1.getScore()-o2.getScore()); //升序
                return (int) (o2.getScore()-o1.getScore());  //降序
                //[Student{name='小马哥', age=23, score=99.9}, Student{name='小飞侠', age=23, score=89.5}, Student{name='罗西', age=44, score=85.5}, Student{name='马奎斯', age=34, score=70.9}]
            }
        });
        s.add(new Student("小马哥",23,99.9));
        s.add(new Student("小飞侠",23,89.5));
        s.add(new Student("马奎斯",34,70.9));
        s.add(new Student("罗西",44,85.5));
        System.out.println(s);

    }
}

注意：

  • 两种方式中，关于返回值的规则：

    • 如果认为第一个元素大于第二个元素返回正整数即可。
    • 如果认为第一个元素小于第二个元素返回负整数即可。
    • 如果认为第一个元素等于第二个元素返回0即可，此时Treeset集合只会保留一个元素，认为两者重复。

    • 注意:

      • 如果TreeSet集合存储的对象有实现比较规则，集合也自带比较器，默认使用集合自带的比较器排序。

六、可变参数

  • 可变参数

    • 可变参数用在形参中可以接收多个数据。
    • 可变参数的格式:数据类型...参数名称可变参数的作用

  • 传输参数非常灵活，方便。可以不传输参数，可以传输1个或者多个，也可以传输一个数组

    • 可变参数在方法内部本质上就是一个数组。
    • 可变参数的注意事项:
    • 一个形参列表中可变参数只能有一个
    • 可变参数必须放在形参列表的最后面

案例分析：

package com.params;

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        //不传参数
        //sum();
        //可以传一个参数
        sum(12);
        //可以传多个参数
        sum(23,34,45);
        //可以传一个数组
        //sum(new int[]{12,23,34,45});

    }
    public static void sum(int age,int ... num){
        System.out.println("元素个数："+num.length);
        System.out.println("元素内容："+ Arrays.toString(num));

    }
}
/*
元素个数：0
元素内容：[]
元素个数：1
元素内容：[12]
元素个数：3
元素内容：[23, 34, 45]
元素个数：4
元素内容：[12, 23, 34, 45]

 */

七、集合操作的工具类Collections

  • collections排序相关API

    • 使用范围:只能对于List集合的排序。
  • 排序方式1:
方法名称 说明
public static void sort(List list) 将集合中元素按照默认规则排序
  • 注意:本方式不可以直接对自定义类型的List集合排序，除非自定义类型实现了比较规则Comparable接口。
  • 排序方式2:
方法名称 说明
public static void sort(List list,Comparator<? super T> c) 将集合中元素按照指定规则排序

案例分析：

package com.collection.collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        /*list.add("小马哥");
        list.add("小飞侠");
        list.add("马奎斯");
        list.add("罗西");*/

        //批量添加元素
        Collections.addAll(list,"小马哥","小飞侠","马奎斯","罗西");  //[小马哥, 小飞侠, 马奎斯, 罗西]
        System.out.println(list);
        //打乱集合顺序
        Collections.shuffle(list);
        System.out.println(list);  //[马奎斯, 小飞侠, 罗西, 小马哥]
        //将集合中元素按默认规则排序
        List<Integer> l=new ArrayList<>();
        Collections.addAll(l,12,34,23,78,99,35);
        Collections.sort(l);
        System.out.println(l);  //[12, 23, 34, 35, 78, 99]
        //将集合中元素按指定规则排序
    }
}

八、Map接口

1.Map集合概述

  • Map集合是一种双列集合，每个元素包含两个数据。
  • Map集合的每个元素的格式: key=value(键值对元素)。
  • Map集合也被称为“键值对集合”。

  • Map集合整体格式:

    • Collection集合的格式:[元素1,元素2,元素3..]
    • Map集合的完整格式:{key1=value1 , key2=value2 , key3=value3 , ...}

  • Map集合体系特点

    • Map集合的特点都是由键决定的。
    • Map集合的键是无序,不重复的，无索引的，值不做要求（可以重复)。
    • Map集合后面重复的键对应的值会覆盖前面重复键的值。
    • Map集合的键值对都可以为null。

  • Map集合实现类特点

    • HashMap:元素按照键是无序，不重复，无索引，值不做要求。(与Map体系一致)
    • LinkedHashMap:元素按照键是有序，不重复，无索引，值不做要求。

案例分析：

package com.map;
import java.util.HashMap;
import java.util.Map;
public class Test {
    public static void main(String[] args) {
        Map<String,Integer> m=new HashMap<>();
        m.put("小马哥",33);
        m.put("小飞侠",44);
        m.put("马奎斯",33);
        m.put("罗西",45);
        m.put(null,null);
        System.out.println(m);  //{null=null, 马奎斯=33, 小马哥=33, 罗西=45, 小飞侠=44}

    }
}

2.Map集合API

  • Map集合

    • Map是双列集合的祖宗接口，它的功能是全部双列集合都可以继承使用的。
方法名称 说明
v put(K key,v value) 添加元素
v remove(0bject key) 根据键删除键值对元素
void clear() 移除所有的键值对元素
boolean containsKey(0bject key) 判断集合是否包含指定的键
boolean containsValue(0bject value) 判断集合是否包含指定的值
boolean isEmpty() 判断集合是否为空
int size() 集合的长度，也就是集合中键值对的个数

案例分析：

package com.map;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Test1 {
    public static void main(String[] args) {
        //创建Map集合
        Map<String,Integer> m=new HashMap<>();
        //添加元素
        m.put("小马哥",33);
        m.put("小飞侠",44);
        m.put("马奎斯",33);
        m.put("罗西",45);
        //清空集合
        //m.clear();
        //System.out.println(m);  //{}
        //判断集合是否为空
        System.out.println(m.isEmpty());  //false
        //根据键获取对应的值
        Integer i = m.get("小马哥");
        System.out.println(i);  //33
        //根据键删除整个元素
        System.out.println(m.remove("小马哥"));  //33
        System.out.println(m);  //{马奎斯=33, 罗西=45, 小飞侠=44}
        //判断是否包含某个键
        System.out.println(m.containsKey("罗西")); //true
        System.out.println(m.containsKey("小马哥"));  //false
        //判断是否包含某个值
        System.out.println(m.containsValue(45));  //true
        //获取全部键的集合
        Set<String> keySet = m.keySet();
        System.out.println(keySet);  //[马奎斯, 罗西, 小飞侠]
        //获取全部值的集合
        Collection<Integer> values = m.values();
        System.out.println(values);  //[33, 45, 44]
        //集合的大小
        System.out.println(m.size());  //3
        //合并其他Map集合
        Map<String,Integer> m1=new HashMap<>();
        m1.put("a",1);
        m1.put("b",2);
        Map<String,Integer> m2=new HashMap<>();
        m1.put("c",3);
        m1.put("d",4);
        m1.putAll(m2);  //把m2中的元素合并到m1中
        System.out.println(m1);   //{a=1, b=2, c=3, d=4}


    }
}

3.Map集合遍历方式

1.键找值

  • 先获取Map集合的全部键的Set集合。
  • 遍历键的Set集合，然后通过键提取对应值。
方法名称 说明
Set<K> keySet() 获取所有键的集合
V get(Object key) 根据键获取值

案例分析：

package com.map;

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

public class Test2 {
    public static void main(String[] args) {
        Map<String,Integer> m=new HashMap<>();
        //添加元素
        m.put("小马哥",33);
        m.put("小飞侠",44);
        m.put("马奎斯",33);
        m.put("罗西",45);
        //键找值
        //先获取所有的键
        Set<String> keys = m.keySet();
        for (String key : keys) {
            Integer values = m.get(key);
            System.out.println(key+"="+values);
        }
    }
}
/*
马奎斯=33
小马哥=33
罗西=45
小飞侠=44

 */

2.键值对

  • 先把Map集合转换成Set集合，Set集合中每个元素都是键值对实体类型了。
  • 遍历Set集合，然后提取键以及提取值。
  • 键值对涉及到的API:
方法名称 说明
Set<Map.Entry<K,V>> entrySet(） 获取所有键值对对象的集合
K getKey() 获得键
v getValue() 获取值

案例分析：

package com.map;

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

public class Test3 {
    public static void main(String[] args) {
        Map<String,Integer> m=new HashMap<>();
        //添加元素
        m.put("小马哥",33);
        m.put("小飞侠",44);
        m.put("马奎斯",33);
        m.put("罗西",45);
        //把Map集合转换为set集合
        Set<Map.Entry<String, Integer>> entries = m.entrySet();
        //for遍历
        for (Map.Entry<String, Integer> entry : entries) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key+"="+value);
        }

    }
}
/*
马奎斯=33
小马哥=33
罗西=45
小飞侠=44
 */

注意：

  • 如果希望元素可以重复，又有索引，索引查询要快?

    • 用ArrayList集合，基于数组的。（用的最多)

  • 如果希望元素可以重复，又有索引，增删首尾操作快?

    • 用LinkedList集合，基于链表的。

  • 如果希望增删改查都快，但是元素不重复、无序、无索引。

    • 用HashSet集合，基于哈希表的。

  • 如果希望增删改查都快，但是元素不重复、有序、无索引。

    • 用LinkedHashSet集合，基于哈希表和双链表。

  • 如果要对对象进行排序。

    • 用TreeSet集合，基于红黑树。后续也可以用List集合实现排序。
文章标签：
Java
索引
API
存储
关键词：
Java集合
不会压弯的小飞侠
目录
相关文章
还算善良
|
30天前
|
Java
【Java】如果一个集合中类型是String如何使用拉姆达表达式 进行Bigdecimal类型计算？
【Java】如果一个集合中类型是String如何使用拉姆达表达式 进行Bigdecimal类型计算？
还算善良
25 0
我开始找你了
|
1月前
|
算法 Java 数据处理
Java集合框架的优缺点
Java集合框架的优缺点
我开始找你了
21 0
༺ཌༀൢ学海无涯ൢༀད༻
|
1月前
|
网络协议 算法 Java
Java的集合、线程、网络编程、反射
Java的集合、线程、网络编程、反射
༺ཌༀൢ学海无涯ൢༀད༻
19 0
Java的集合、线程、网络编程、反射
mrq4nk6ni2neg
|
1月前
|
安全 算法 Java
Java中的线程安全集合
【2月更文挑战第23天】本文将介绍Java中的线程安全集合，包括它们的使用场景、优缺点以及如何在实际项目中应用。通过阅读本文，你将了解到线程安全集合的重要性以及如何在多线程环境下使用它们来提高程序的性能和稳定性。
mrq4nk6ni2neg
33 0
希屿风
|
1月前
|
存储 算法 Java
JAVA的集合框架
JAVA的集合框架
希屿风
17 0
冷水鱼。
|
1月前
|
存储 Java 容器
Java中的集合框架
Java中的集合框架
冷水鱼。
21 0
尘尘尘尘
|
1月前
|
存储 算法 Java
Java中的集合框架：高效管理数据的关键
Java中的集合框架：高效管理数据的关键
尘尘尘尘
16 0
JavaBuild
|
2天前
|
存储 Java C++
Java集合篇之深度解析Queue，单端队列、双端队列、优先级队列、阻塞队列
Java集合篇之深度解析Queue，单端队列、双端队列、优先级队列、阻塞队列
JavaBuild
12 0
薛伟同学
|
13天前
|
存储 Java 编译器
Java集合丛林：深入了解集合框架的秘密
Java集合丛林：深入了解集合框架的秘密
薛伟同学
15 0
Java集合丛林：深入了解集合框架的秘密
java开发-郭老师
|
16天前
|
Java BI
Java 获取周，月，年日期集合（统计图）
Java 获取周，月，年日期集合（统计图）
java开发-郭老师
25 0
Java 获取周，月，年日期集合（统计图）

热门文章

最新文章

  • 1
    Java中的多线程编程：概念、实现与性能优化
  • 2
    基于 java + Springboot + vue +mysql 大学生实习管理系统（含源码）
  • 3
    使用Java代码打印log日志
  • 4
    Java数据结构与算法-java数据结构与算法（二）
  • 5
    【JVM故障问题排查心得】「Java技术体系方向」Java虚拟机内存优化之虚拟机参数调优原理介绍（一）
  • 6
    深入理解Java并发编程：线程安全与性能优化
  • 7
    Java入门高频考查基础知识4（字节跳动面试题18题2.5万字参考答案）
  • 8
    开发语言详解（python、java、Go(Golong)。。。。）
  • 9
    《理解 WebSocket：Java Web 开发的实时通信技术》
  • 10
    java线程池讲解面试
  • 1
    Java中的集合框架：深入理解与应用
    19
  • 2
    Java并发编程：理解并使用Future和Callable接口
    17
  • 3
    性能工具之 Java 调试工具 JDB
    45
  • 4
    JAVA云HIS系统医院信息管理源码
    31
  • 5
    Java基于物联网技术的智慧工地云管理平台源码 依托丰富的设备接口标准库，快速接入工地现场各类型设备
    148
  • 6
    [Java基础]——JVM内存模型
    36
  • 7
    [Java基础]——类的生命周期
    13
  • 8
    [java进阶]——泛型类、泛型方法、泛型接口、泛型的通配符
    23
  • 9
    【java进阶】Java中线程的实现方式
    14
  • 10
    【java进阶】集合的三种遍历(迭代器、增强for、Lambda)
    17

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）