精华内容
下载资源
问答
  • 2021-03-11 13:38:44

    List list = new ArrayList(){ {

    add("First Object");

    add("Second Object");

    add("Third Object");

    }};

    Map map = new HashMap(){ {

    put("First Key", "First Value");

    put("Second Key", "Second Value");

    put("Third Key", "Third Value");

    put("Fourth Key", "Fourth Value");

    }};

    Java List&Map简单初始化方法

    Java中List与Map初始化的一些写法 // InitCollections.java - sample of init collect package com.util; import java ...

    JAVA构造MAP并初始化MAP

    第一种方法:static块初始化 public class Demo{ private static final Map myMap; static { m ...

    Java集合—Map

    简介 Map用户保存具有映射关系的数据,因此Map集合里保存着两组数,一组值用户保存Map里的key,另一组值用户保存Map里的value,key和value都可以是任何引用类型的数据.Map的key ...

    Java集合——Map接口

    1.定义 Map用于保存存在映射关系的数据.其中,key值不能重复(使用equals()方法比较),value值可

    更多相关内容
  • 相信大家在日常的开发过程中,经常需要对List或Map里面的符合某种业务的数据进行删除,但是如果不了解里面的...下面这篇文章将会给大家详细介绍Java如何在List和Map遍历过程中删除元素,有需要的朋友们可以参考借鉴。
  • Java Map集合使用方法介绍(1)——在字典中添加内容并显示Java Map集合使用方法介绍(1)——在字典中添加内容并显示Javaimport java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util....

    Java Map集合使用方法介绍(1)——在字典中添加内容并显示

    Java Map集合使用方法介绍(1)——在字典中添加内容并显示

    Java

    import java.util.HashMap;

    import java.util.Iterator;

    import java.util.Map;

    import java.util.Map.Entry;

    import java.util.Scanner;

    import java.util.Set;

    public class DictionaryDemo {

    public static void main(String[] args) {

    Map animal = new HashMap();

    System.out.println("请输入三组单词对应的注释,并存放到HashMap中");

    Scanner console = new Scanner(System.in);

    int i = 0;

    // 添加数据

    while (i < 3) {

    System.out.println("请输入Key值");

    String key = console.next();

    System.out.println("请输入value值(注释)");

    String value = console.next();

    animal.put(key, value);

    i++;

    }

    // 打印输出value的值(直接使用迭代器)

    System.out.println("*******************");

    展开全文
  • 主要介绍了Java HashMap 如何正确遍历并删除元素方法小结,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Java集合(Collection、Map

    千次阅读 2021-03-16 00:49:06
    ①数组初始化之后,长度不可以进行改变,不便于扩展②数组中提供的方法和属性少,不便于进行添加、删除、插入等操作,且效率不高,同时无法直接获取存储元素的个数③数组存储的数据是有序的可以重复的而java集合类...

    0、Java集合框架概述

    集合可以将多个对象的引用动态放入容器中,方便对对象进行一些操作。现有的用来存放多个对象的结构为Array数组,但数组存在一些弊端:

    ①数组初始化之后,长度不可以进行改变,不便于扩展

    ②数组中提供的方法和属性少,不便于进行添加、删除、插入等操作,且效率不高,同时无法直接获取存储元素的个数

    ③数组存储的数据是有序的可以重复的

    而java集合类可以用于存储数量不等的多个对象,还可用于保存具有映射关系的关联数组

    Java集合体系

    Collection接口:单列数据,定义了存取一组对象的方法的集合

    -------------|List接口:元素有序、可重复的集合 类似一个“动态”数组

    ------------------------|ArryaList类:是List接口的主要实现类;线程不安全,效率高;底层使用Object[ ]数组

    ------------------------|LinkedList类:对于频繁的插入、删除操作,使用此类效率比ArrayList高;底层使用双向链表

    ------------------------|Vector类:作为List接口的古老实现类;线程安全,效率低;底层使用Object[ ]数组

    -------------|Set接口:元素无序、不可重复的集合 更接近于高中所讲的“集合”概念

    ------------------------|HashSet类:作为Set接口的主要实现类;线程不安全的;可以存储null值

    ------------------------------------|LinkedHashSet类:作为HashSet的子类,遍历器内部数据时,可以按照添加时的顺序遍历

    ------------------------|TreeSet类:可以按照添加对象的指定属性进行排序

    Map接口:双列数据,保存具有映射关系“key-value”对的集合 类似于数学上的y=f(x)

    -------------|Hashtable类:作为古老的实现类,线程安全,效率低,不能存储null的key和value

    ------------------------|Properties类:常用来处理文件,key和value都是String类型的

    -------------|HashMap类:是Map的主要实现类,线程不安全的,效率高;可以存储null的key和value

    ------------------------|LinkedHashMap类:保证在遍历map元素时,可以按照添加的顺序进行遍历(在原有结构的基础上,按照添加顺序使用了双链表)

    -------------|TreeMap类:按照添加的key-value对进行排序,实现排序遍历(key的自然排序和定制排序)

    439e5312f7e4

    Collection接口继承树

    439e5312f7e4

    Map接口继承树

    1.Collection接口

    1.1 Collection接口中的常用方法

    使用Iterator接口遍历集合元素

    Collections接口继承了java.lang.Iterable接口,该接口有一个iterator()方法,所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象。集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标都在集合的第一个元素之前

    @Test

    public void test1(){

    Collection col=new ArrayList();

    col.add("aaaa");

    col.add("bbbb");

    col.add("vv");

    col.add("wweeeee");

    Iterator iterator = col.iterator();

    while(iterator.hasNext()){ //判断是否还有下一个元素

    //next():指针下移,将下移后集合位置上的元素返回

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

    }

    }

    使用foreach遍历数组元素

    底层仍然是调用Iterator完成操作,但注意用来修改数组元素是无用的

    @Test

    public void test1(){

    Collection col=new ArrayList();

    col.add("aaaa");

    col.add("bbbb");

    col.add("vv");

    col.add("wweeeee");

    Iterator iterator = col.iterator();

    while(iterator.hasNext()){ //判断是否还有下一个元素

    //next():指针下移,将下移后集合位置上的元素返回

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

    }

    //注意此处一定要重新获取

    iterator=col.iterator();

    while(iterator.hasNext()){ //判断是否还有下一个元素

    //next():指针下移,将下移后集合位置上的元素返回

    Object str=iterator.next();

    if (str.equals("vv"))

    iterator.remove(); //使用iterator删除集合中的元素

    }

    //使用foreach循环遍历集合元素

    for(Object str:col){

    System.out.println(str);

    }

    }

    add(Object e) 添加元素

    size() 集合中的元素个数

    addAll(Collection col) 将集合中的元素全部添加到当前集合中

    isEmpty()

    boolean remove(Object obj) 通过元素的equals方法判断是否是要删除的那个元素,只会删除找到的第一个元素

    boolean removeAll(Collection col) 取当前集合的差集

    boolean retainAll(Collection col) 把交集的结果存在当前集合中,不影响c

    boolean equals(Object o)判断集合是否相等

    Object[] toArray()转换成对象数组

    hashCode()获取当前集合对象 的哈希值

    扩展:数组变成集合 Arrays.asList(array)

    1.2 List接口中的方法

    java中使用数组存储数据具有局限性(如上所述),所以通常使用List代替数组。List集合类中元素有序、可重复,集合中的每个元素都有其对应的顺序索引,可以根据元素的存储位置序号存取容器中的元素。List中的常用实现类有:ArrayList、LinkedList、Vector

    List接口:元素有序、可重复的集合 类似一个“动态”数组

    -------|ArryaList类:是List接口的主要实现类;线程不安全,效率高;底层使用Object[ ]数组

    -------|LinkedList类:对于频繁的插入、删除操作,使用此类效率比ArrayList高;底层使用双向链表

    由于List接口的特性是元素可以通过其位置序号进行访问,所以List接口比Collection接口多出了一些有关下标index的方法,这些是Set接口中没有的,所以Collection中也没有

    void add(int index, Object ele) 在index位置插入ele元素

    boolean addAll(int index, Collection c) 在index位置插入集合c中的所有元素

    Object get(int index) 获取指定位置的元素

    int indexOf(Object o) 返回第一次出现o的位置

    int lastIndexOf(Object o) 返回最后一次出现o的位置

    Object remove(int index) 移除index位置的元素

    💢 此处一定要注意,Collection接口有一个remove(Object o)方法,如果输入是int,此时会有限考虑此int值为index,而不是数组中的元素,因为数组中存到是包装类

    Object set(int index, Object element) 设置index处的元素为element,并返回原来该位置的元素

    List subList(int fromIndex, int toIndex) 返回从fromIndex到toIndex-1的子集合(左闭右开)

    @Test

    public void test3(){

    List list = new ArrayList(); //多态

    list.add(0);

    list.add(1);

    list.add(2);

    list.add(3);

    list.add(4);

    list.add(5);

    //1 void add(int index, Object ele) 在index位置插入ele元素

    list.add(3,'A');

    System.out.println(list); //[0, 1, 2, A, 3, 4, 5]

    //2 boolean addAll(int index, Collection c) 在index位置插入集合c中的所有元素

    List list1 = new ArrayList();

    list1.add('B');

    list1.add('C');

    list1.add('D');

    list.addAll(4,list1);

    System.out.println(list); //[0, 1, 2, A, B, C, D, 3, 4, 5]

    //3 Object get(int index) 获取指定位置的元素

    System.out.println(list.get(1)); //1

    //4 int indexOf(Object o) 返回第一次出现o的位置

    System.out.println(list.indexOf(3)); //7

    //5 int lastIndexOf(Object o) 返回最后一次出现o的位置

    System.out.println(list.lastIndexOf(4)); //8

    //6 Object remove(int index) 移除index位置的元素

    // 此处一定要注意,Collection接口有一个remove(Object o)方法

    // 如果输入是int,此时会有限考虑此int值为index,而不是数组中的元素

    // 因为数组中存到是包装类

    System.out.println(list.remove(4)); //B

    System.out.println(list); //[0, 1, 2, A, C, D, 3, 4, 5]

    //7 Object set(int index, Object element) 设置index处的元素为element,并返回原来该位置的元素

    System.out.println(list.set(0,"hhhhhhh")); //0

    System.out.println(list); //[hhhhhhh, 1, 2, A, C, D, 3, 4, 5]

    //8 List subList(int fromIndex, int toIndex) 返回从fromIndex到toIndex-1的子集合(左闭右开)

    List list2 =list.subList(0,3);

    System.out.println(list2); //[hhhhhhh, 1, 2]

    }

    由于List接口是有顺序的,所以不仅可以通过之前的两种方法进行遍历(迭代器和for each),还可以使用最普通的通过位置来遍历,下面使用LinkedList来举例

    @Test

    public void test4(){

    List list = new LinkedList();

    list.add(0);

    list.add(1);

    list.add(2);

    list.add(3);

    list.add(4);

    list.add(5);

    for(int i=0;i

    System.out.println(list.get(i));

    }

    }

    💸一道面试题

    @Test

    public void test5(){

    List list = new ArrayList(); //多态

    list.add(1);

    list.add(2);

    list.add(3);

    list.add(4);

    list.add(5);

    updateList(list);

    System.out.println(list);

    }

    private void updateList(List list){

    list.remove(2);

    }

    答案: [1, 2, 4, 5] 原因上面提到过(1.2的remove方法中)

    1.3List的三个实现类

    1.3.1 ArrayList

    ArrayList在jdk7和jdk8中的实现有所不同(建议查看源码,顺着add函数一直看下去)

    jdk7️⃣中:创建ArrayList的同时就在内存中开辟空间,当内存不够时,扩容为原来的1.5倍。扩容是一个耗时的操作,所以建议在开发中使用带参的构造器:ArrayList list = new ArrayList(int capacity)

    ArrayList list = new ArrayList();//底层创建长度为10的object[ ]数组elementData

    list.add(123);//elementData[0]=new Integer(123);

    //.......

    list.add(11);//如果此次的添加导致底层elementData数组容量不够,则扩容

    //默认情况下扩容为原来的1.5倍,同时需要将原有数组中的数据复制到新的数组中

    jdk8️⃣中:创建ArrayList时并没有在内存中开辟空间,而是在首次调用add()函数添加元素时才创建长度为10的数组,并将元素添加进去,其他的与jdk7无异

    ArrayList list = new ArrayList();//底层object[ ] elementData初始化为{ },实际长度为0

    list.add(123);//第一次调用add,底层创建长度为10的数组,并将123添加到数组中

    //.......

    list.add(11);//如果此次的添加导致底层elementData数组容量不够,则扩容

    //默认情况下扩容为原来的1.5倍,同时需要将原有数组中的数据复制到新的数组中

    小结:jdk7中的ArrayList的对象的创建类似于单例的饿汉式,而jdk8中的ArrayList的对象的创建类似于单例的懒汉式,延迟了数组的创建,节省内存

    1.3.2 LinkedList

    创建list的时候实际上创建了一个空的list,源码:

    ransient int size = 0;

    /**

    * Pointer to first node.

    * Invariant: (first == null && last == null) ||

    * (first.prev == null && first.item != null)

    */

    transient Node first;

    /**

    * Pointer to last node.

    * Invariant: (first == null && last == null) ||

    * (last.next == null && last.item != null)

    */

    transient Node last;

    /**

    * Constructs an empty list.

    */

    public LinkedList() {

    }

    内部声明了Node类型的first和last属性,默认值为null,从源码可以看出,LinkedList是以双向链表的形式进行存储,添加的元素都被封装到Node中,每次添加元素时,都会与last元素链接起来(下面的代码是从源码中抽出来的,配合食用效果更佳)

    public boolean add(E e) {

    linkLast(e);

    return true;

    }

    /**

    * Links e as last element.

    */

    void linkLast(E e) {

    final Node l = last;

    final Node newNode = new Node<>(l, e, null);

    last = newNode;

    if (l == null)

    first = newNode;

    else

    l.next = newNode;

    size++;

    modCount++;

    }

    //内部使用Node进行存储,Node中的属性声明以及构造器

    private static class Node {

    E item;

    Node next;

    Node prev;

    Node(Node prev, E element, Node next) {

    this.item = element;

    this.next = next;

    this.prev = prev;

    }

    }

    1.3.3 Vector

    通过Vector()构造器创建对象时,底层都创建了长度为10的数组,在扩容方面,默认扩容为原来的数组长度的2倍

    1.4Set接口

    Set接口是Collection的子接口,它没有提供额外的方法。Set集合中不允许包含相同的元素,Set判断两个对象是否相同使用的不是==运算符,而是根据equals()方法

    Set接口:元素无序、不可重复的集合 更接近于高中所讲的“集合”概念

    ----------|HashSet类:作为Set接口的主要实现类;线程不安全的;可以存储null值

    ------------------|LinkedHashSet类:作为HashSet的子类,遍历器内部数据时,可以按照添加时的顺序遍历

    ----------|TreeSet类:可以按照添加对象的指定属性进行排序

    无序性不等于随机性,存储的数据在底层数组中并非按照数组索引的顺序添加,而是按照数据的哈希值进行存储

    不可重复性:保证添加的元素按照equals进行判断是,不能返回true,即相同的元素只能添加一个

    以HashSet为例描述添加元素的过程

    ① 调用该元素所在类的hashCode()方法,计算其哈希值,利用此哈希值通过某种算法计算出在HashSet底层数组的存放位置(索引位置)

    ② 判断该位置上是否有元素

    ③ 如果没有元素,则添加成功;

    如果有其他元素(链表形式连接),则挨个进行比较:如果hash值不同,则添加成功,;如果hash值相同但equals()返回false,则添加成功;如果hash相同,equals()返回true,则添加失败

    在链表处采用七上八下的做法:jdk7中,添加的元素放在数组位置,指向原链表列;jdk8中,添加的元素放在链表中,原数组中的元素仍在原地

    hash值不多讲,直接使用重写时idea提供的即可

    1.5Set的三个实现类

    1.5.1 HashSet

    HashSet的底层实际上是HashMap

    HashSet是Set接口的典型实现,大多时候使用Set集合时都使用这个实现类。HashSet使用Hash算法来存储集合中的元素,因此具有很好的存取、查找、删除性能

    HashSet中判断两个元素相等的标准:hashCode() 和equals()都相等

    重写hashCode()的基本原则:在程序运行时,同一个对象多次调用hashCode()方法应该返回相同的值;当两个对象的equals方法返回true时,这两个对象的hashCode方法的返回值也应该相等;equals方法用来比较的field都应该用来计算hashCode值

    1.5.2 LinkedHashSet

    LinkedHashSet作为HashSet的子类,在添加数据的同时,每个数据还维护了两个引用,记录此数据的前一个数据和后一个数据(双向链表),所以能够实现按照添加顺序进行遍历,对于频繁的遍历操作,LinkedHashSet的效率高于HashSet

    1.5.3 TreeSet

    TreeSet和后面要讲的TreeMap底层采用的是红黑树的方式进行存储,查找元素的速度比List要快,可以实现按照指定属性进行排序输出

    由于TreeSet需要对元素进行比较,所以要写该元素对应类的比较器(自然排序、定制排序),此时比较两个对象是否相同的标准不是equals而是compare或者compareTo方法

    向TreeSet中添加的数据必选是相同类的对象

    public class StudentTestDemo{

    @Test

    public void test1(){

    TreeSet set = new TreeSet();

    set.add(new StudentTest(12,"ddddd"));

    set.add(new StudentTest(13,"gggg"));

    set.add(new StudentTest(9,"rrrr"));

    set.add(new StudentTest(4,"ppppp"));

    for(Object student : set){

    System.out.println(student);

    }

    }

    }

    class StudentTest implements Comparable{

    int age;

    String name;

    public StudentTest(int age, String name) {

    this.age = age;

    this.name = name;

    }

    @Override

    public int compareTo(Object o) {

    Integer ageInteger= age;

    return ageInteger.compareTo(((StudentTest)o).age);

    }

    @Override

    public String toString() {

    return "StudentTest{" +

    "age=" + age +

    ", name='" + name + '\'' +

    '}';

    }

    }

    💸面试题一道

    💢 注意重写了Person的equals()和hashCode()

    public class PersonTest{

    @Test

    public void test(){

    HashSet set = new HashSet();

    Person person1=new Person(1001,"AA");

    Person person2=new Person(1002,"BB");

    set.add(person1);

    set.add(person2);

    person1.name="CC";

    set.remove(person1);

    System.out.println(set); //[Person{age=1002, name='BB'}, Person{age=1001, name='CC'}]

    set.add(new Person(1001,"CC"));

    System.out.println(set); //[Person{age=1002, name='BB'}, Person{age=1001, name='CC'}, Person{age=1001, name='CC'}]

    set.add(new Person(1001,"AA"));

    System.out.println(set);

    //[Person{age=1002, name='BB'}, Person{age=1001, name='CC'}, Person{age=1001, name='CC'}, Person{age=1001, name='AA'}]

    }

    }

    class Person{

    int age;

    String name;

    public Person(int age, String name) {

    this.age = age;

    this.name = name;

    }

    @Override

    public String toString() {

    return "Person{" +

    "age=" + age +

    ", name='" + name + '\'' +

    '}';

    }

    @Override

    public boolean equals(Object o) {

    if (this == o) return true;

    if (o == null || getClass() != o.getClass()) return false;

    Person person = (Person) o;

    return age == person.age &&

    Objects.equals(name, person.name);

    }

    @Override

    public int hashCode() {

    return Objects.hash(age, name);

    }

    }

    2.Map接口

    2.1 Map接口的基础知识

    Map接口:双列数据,保存具有映射关系“key-value”对的集合 类似于数学上的y=f(x)

    -------------|Hashtable类:作为古老的实现类,线程安全,效率低,不能存储null的key和value

    ------------------------|Properties类:常用来处理文件,key和value都是String类型的

    -------------|HashMap类:是Map的主要实现类,线程不安全的,效率高;可以存储null的key和value

    ------------------------|LinkedHashMap类:保证在遍历map元素时,可以按照添加的顺序进行遍历(在原有结构的基础上,按照添加顺序使用了双链表)

    -------------|TreeMap类:按照添加的key-value对进行排序,实现排序遍历(key的自然排序和定制排序)

    对Map的进一步理解

    Map中的key是无序的、不可重复的,如果将所有的key抽取出来,应该使用Set来存储,因此key所在的类要重写equals()和hashCode()方法(参考HashSet)

    Map中的value是无序的、可重复的,如果将所有的value抽取出来,应该使用Collection来存储

    一个键值对:key-value构成了一个Entry对象

    Map中的Entry是无序的、不可重复的,使用Set存储所有的entry

    增、改:Object put(Object key, Object value) 将键值对添加到或者修改当前的map对象

    void putAll(Map m)将m中所有的键值对存储到当前map中

    删:Object remove(Object key)删除指定key值的键值对,返回其value值

    void clear():清楚map中的所有数据,但是此时的map并不是null,只是没有存数据

    查:Object get(Object key) 获取指定key对应的value

    boolean containsKey(Object key)是否包含指定的key

    boolean containsValue(Object value)是否包含指定的value

    int size()

    boolean isEmpty()判断当前map是否为空

    boolean equals(Object obj)判断当前map和参数对象obj是否相等(类型不相同的话一定不相等)

    元视图操作的方法

    Set keySet() 返回所有key构成的set集合

    Collection values() 返回所有values构成的Collection集合

    Set entrySet() 返回所有key-value对构成的set集合

    //遍历所有的set

    public void test(){

    //遍历所有的key 遍历key-value对的方法之一

    HashMap map = new HashMap();

    map.put("AA",123);

    map.put("BB",456);

    map.put("CC",789);

    Set keys=map.keySet();

    //迭代器 foreach keys.size() 都可以

    Iterator iterator1=keys.iterator();

    while(iterator1.hasNext()){

    Object o=iterator1.next();

    System.out.println("key:"+o+";value:"+map.get(o));

    }

    //遍历所有的values

    Collection values = map.values();

    for(Object o:values){

    System.out.println(obj);

    }

    //遍历key-value对的方法之二

    Set entrySet = map.entrySet();

    Iterator iterator2 = entrySet.iterator();

    while(iterator2.hasNext()){

    Object o=iterator1.next();

    Map.Entry entry = (Map.Entry)o;

    System.out.println("key:"+entry.getKey()+";value:"+entry.getValue());

    }

    }

    2.2 Map的相关实现类

    2.2.1 HashMap

    HashMap的底层:

    jdk7.0及之前:数组+链表

    jdk8.0及之后:数组+链表+红黑树

    此处以HashMap(jdk7.0)为例用来理解添加键值对的基本过程:

    HashMap map = new HashMap(); //实例化之后,底层创建了长度为16的一维数组Entry[] table

    map.put(key1, value1);

    ① 调用key1所在类的hashCode()计算其hash值,此hash值经过计算后得到Entry数组中的存放位置

    ② 如果此位置为空,则key1-value1添加成功

    ③如果跟不为空,证明此位置上存在着一个或多个通过链表结构链接的entry,比较key1与他们的哈希值(过程与HashSet的添加过程相同)

    ④如果hash不相同,则添加成功;如果hash相同,equals不同,则添加成功;如果都相同,则使用value1替换原位置上的value,更新成功。(添加成功的情况均以链表的形式存在,并且添加的过程中会涉及到扩容的问题,建议查看源码,扩容为原来容量的二倍,将原有的数据复制过来)

    JDK8.0相较于JDK7.0在底层实现方面的不同:

    ① new HashMap() 底层并不会创建一个长度为16的数组

    ② jdk 8底层的数组是 Node[ ]

    ③ 首次使用put方法添加数据时,底层创建长度为16的数组

    ④ jdk7.0及之前的底层结构为数组+链表;jdk8.0及之后的底层结构为数组+链表+红黑树。具体来说,当数组某一个索引位置上的元素以链表形式存在的数组个数>8且当前数组的长度>64时,此时会将此索引上的所有数据改为红黑树进行存储

    🚩强烈建议查看源码

    几个比较重要的常量

    1️⃣DEFAULT_INITIAL_CAPACITY:HashMap的默认容量,16(初始化的容量)

    2️⃣DEFAULT_LOAD_FACTOR:加载因子,默认加载因子为0.75

    3️⃣thread:扩容的临界值=容量加载因子 160.75=12

    4️⃣TREEIFY_THRESHOLD:Bucket中链表长度大于该默认值(8)时,转化为红黑树

    5️⃣MIN_TREEIFY_CAPACITY:Bucket中的Node被树化时最小的hash表容量 64

    2.2.2 LinkedHashMap

    是HashMap的子类,在其基础上使用双向链表将元素按照添加顺序连接起来,频繁执行遍历操作时建议使用LinkedHashMap(同一个位置上的元素使用单向链表连接)

    2.2.3 Properties

    该对象用于处理属性文件。由于属性文件里的key和value都是字符串类型,所以Properties里的key和value也都是字符串类型

    存取数据时,建议使用setProperty(String key, String value)方法和getProperty(String key)

    示例(idea创建属性文件的后缀为.properties,看看就好了,涉及到文件读写的exception没有处理)

    public void test(){

    Properties pro = new Properties();

    FileInputStream fis = new FileInputStream("jdbc.properties");

    pro.load(fis);

    String name = pro.getproperty("name");

    pro.setproperty("password","123456789");

    fis.close();

    }

    3.Collections工具类

    Collections是一个操作List、Set和Map等集合的工具类

    Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作,还提供了对集合对象设置不可变、对集合对象实现同步控制等方法

    排序操作:

    reverse(List) 反转

    shuffle(List) 对List中元素进行随机排序

    sort(List) 根据元素所在类的自然排序都元素按照升序进行排序

    sort(List, Comparator) 定制排序

    swap(List, int ,int) 交换指定位置上的两个元素

    查找、替换

    Object max(Collection) 按照元素的自然排序,返回集合中的最大元素

    Object max(Collection, Comparator)按照元素的定制排序,返回集合中的最大元素

    Object min(Collection)

    Object min(Collection, Comparator)

    int frequency(Collection, Object) 返回集合中指定元素出现的次数

    void copy(List dest,List src) 将src的内容复制到dest中

    boolean replaceAll(List list, Object oldVal, Object newVal)使用新值替换List对象的所有旧值

    需要注意的💢void copy(List dest,List src)` 将src的内容复制到dest中

    在源码中,会首先比较dest和src的长度,如果dest.size()

    正确的处理方式如下:

    List dest = Arrays.asList(new Object[list.size]);//list为需要被复制的src

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

    Collections.copy(dest,list);

    System.out.println(dest);

    Collections类中提供了多个synchronizedXxx()方法,该方法可以将指定的集合包装成线程同步的集合,从而可以解决多线程并发访问集合时的线程安全问题,例如synchronizedCollection()、synchronizedList()、synchronizedMap()、synchronizedSet()

    其实看它的源码,使用的还是类自己的原始方法,只是包装的时候,用synchronized同步代码块的方式把它包裹起来了

    展开全文
  • javaMap集合的常用方法

    千次阅读 2021-03-14 16:36:30
    Map集合和Collection集合的区别Map集合是有Key和...1、V put(Kkey, Vvalue)向map集合中添加Key为key,Value为value的元素,当添加成功时返回null,否则返回value。就是说Map集合中的Key是不能重复的,这就类似于Set...

    Map集合和Collection集合的区别

    Map集合是有Key和Value的,Collection集合是只有Value。

    Collection集合底层也是有Key和Value,只是隐藏起来。

    1、V put(K key, V value)

    向map集合中添加Key为key,Value为value的元素,当添加成功时返回null,否则返回value。

    就是说Map集合中的Key是不能重复的,这就类似于Set集合中元素不能重复,但是Map集合中的Value是可以重复。

    c9091916ce78e9670ff2f746f19c45ca.png

    2、void putAll(Map extends K,? extends V> m)

    向map集合中添加指定集合的所有元素

    69c4bec1328c1872d035e4fa972e8fad.png

    3、void clear()

    把map集合中所有的键值删除

    e42915ac5c00f2b43e852c91b844ec8b.png

    4、boolean containsKey(Object key)

    检出map集合中有没有包含Key为key的元素,如果有则返回true,否则返回false。

    1b16454e3cdf5e69ded229304cbecb3b.png

    5、boolean containsValue(Object value)

    检出map集合中有没有包含Value为value的元素,如果有则返回true,否则返回false。

    78c0c3e044c615971a304200f0243205.png

    返回map到一个Set集合中,以map集合中的Key=Value的形式返回到set中。

    8c5a629f89bb98cde33e4ec40caae719.png

    补充:一般我们遍历HashMap的时候,推荐是用这种方式。不用再通过map的get(key)方法拿值,性能会提升。参考sonar代码规范

    1dc0a7eae669f7a2ff14953069fbca22.png

    7、boolean equals(Object o)

    判断两个Set集合的元素是否相同

    28ecc35a6ef12482b37f24111b89fc52.png

    底层也是重写了equals方法

    查看HashMap集合时,没有发现equals方法,那么我们就去找他的父类。

    2a31ca30535e49096232ca8b66e56eb9.png

    30d26a8e7c8614acd40c4e1616d08c7e.png

    根据map集合中元素的Key来获取相应元素的Value

    4e59ccd05c0fecaab0c50968e20f43a2.png

    9、int hashCode()

    返回map集合的哈希码值

    1812480d8b747ffb8f229bfed1b1675a.png

    10、boolean isEmpty()

    检出map集合中是否有元素,如果没有则返回true,如果有元素则返回false

    2f3fc22dcb2908dd20a9eb147a7ac179.png

    11、Set keySet()

    返回map集合中所有Key

    50ba21aa0512f730b4948a1d8593b2ae.png

    12、V remove(Object key)

    删除Key为key值的元素

    50c0bc0cb8f2cd122fee65ff3c94c2d9.png

    13、int size()

    返回map集合中元素个数

    87e4792b4c3a1d8746a027c392484e6b.png

    返回map集合中所有的Value到一个Collection集合

    dd9237366c4004e558c9a730dd25a396.png

    展开全文
  • Java中增加Map值的最有效的方法

    千次阅读 2021-02-25 18:54:35
    一些测试结果我已经得到了很多好的答案这个问题 – 感谢人们 – 所以我决定运行一些测试,并找出哪个方法是最快的。我测试的五种方法是:>我在the question中提出的“ContainsKey”方法> Aleksandar Dimitrov...
  • JavaMap集合的详细使用方法

    千次阅读 2022-04-02 15:14:49
    JavaMap集合的详细使用方法
  • Set和Map接口调用of的时候不能有重复元素。 public class OfLianXi { public static void main(String[] args) { List<Integer> list = List.of(1, 2, 3, 4); //直接用List接口添加,返回一个List类型 .
  • Java根据条件删除Map元素

    千次阅读 2021-02-12 19:17:13
    今天在写程序过程中,需要根据判断条件删除一个Map中的相应数据,我自然而然想到可以通过调用Map中的remove(Object key)函数进行删除:代码如下:public Map processMap(Map list) {Map map = list;Iterator iter = ...
  • map 添加元素 保持添加时顺序不变

    千次阅读 2020-06-16 18:22:51
    Map map=new LinkedHashMap();
  • Map中根据条件删除元素

    千次阅读 2021-03-15 03:00:13
    今天在写程序过程中,需要根据判断条件删除一个Map中的相应数据,我自然而然想到可以通过调用Map中的remove(Object key)函数进行删除:代码如下:public Map processMap(Map list) {Map map = list;Iterator iter = ...
  • Java map集合顺序如何同步添加顺序

    千次阅读 2021-02-26 15:16:39
    一般使用map用的最多的就是hashmap,但是hashmap里面的元素是不按添加顺序的,那么除了使用hashmap外,还有什么map接口的实现类可以用呢?这里有2个,treeMap和linkedHashMap,但是,要达到我们的要求:按添加顺序...
  • 创建List、Map添加元素简洁写法

    千次阅读 2021-01-27 19:17:22
    创建List、Map添加元素简洁写法 //常用的写法 List<String> list= new ArrayList<>(); Map map = new HashMap<>(); map.put("key1","value1"); map.put("key2","value2"); list.add("ABC")...
  • map集合中的添加方法put(k,v)

    千次阅读 2021-03-16 12:52:54
    package com.day15.Map;import java.util.Collection;import java.util....import java.util.Map;public class MapOne {public static void main(String[] args) {fun();info();Map ma=new HashMap<>();m...
  • JavaMap的一些常用方法

    千次阅读 2021-03-04 02:30:40
    package exam;import java.util.Collection;...import java.util.Map;import java.util.Set;public class Test2 {public static void main(String[] args) {//Map的使用//定义MapMap MyMap = new H...
  • 之前在上一篇《java常用对象API中集合框架之Map的用法》文章中简单的例举了一些Map集合中的一些简单方法和一些常用的子类,那么本章将对例举的方法和子类进行一一的详细说明和举例,这样也是为了让更多的朋友们学习...
  • JAVAmap中参数的添加修改

    千次阅读 2021-02-26 12:50:37
    Map的接口Map---实现MapMap.Entry--Map的内部类,描述Map中的按键/数值对。SortedMap—扩展Map,使按键保持升序排列关于怎么使用,一般是选择Map的子类,而不直接用Map类。下面以HashMap为例。public static ...
  • Java遍历Map的5种方法

    千次阅读 2022-03-21 18:30:46
    通过map.entrySet()方法,可以获取到一个set集合,而这个集合的每一个元素就是一个键值对。 如此就可以通过遍历通过map.entrySet()获取到的set集合来达到遍历Map的目的了。 示例代码展示一下。 通过这种方式,可以...
  • Java中将元素添加到HashMap

    千次阅读 2021-02-27 20:52:26
    要将元素添加到HashMap,请使用put()方法。首先,创建一个HashMap-HashMaphm=newHashMap();现在,让我们向HashMap添加一些元素-hm.put("Maths",newInteger(98));hm.put("Science",newInteger(90));hm.put("English",...
  • Map集合中元素为<String,Student>类型 这个元素类型就可以根据自己的需要去设定了 需求:想要将两个集合中的元素合并到同一个集合中,并且两个集合中的元素是不相同的 结果的集合类型可自行选择 @Test ...
  • Java遍历List、Map添加、删除元素

    千次阅读 2019-06-04 14:04:59
    本文主要演示遍历List、Map时的添加、删除元素操作。 关于List和Map相关的遍历问题,笔者已在《Java常用数据结构基础知识总结(二)》一文中做了简要介绍,如有需要的可以参考,此处不再赘述。 源码如下: 1.基于...
  • Java8 Map 中新增的方法使用记录

    千次阅读 2018-11-01 14:53:18
    得益于 Java 8 的 default 方法特性,Java 8 对 Map 增加了不少实用的默认方法,像 getOrDefault, forEach, replace, replaceAll, putIfAbsent, remove(key, value), computeIfPresent, computeIfAbsent...
  • 1. 介绍本入门教程将介绍Java8中如何合并两个map。更具体说来,我们将研究不同的合并方案,包括Map含有重复元素的情况。2. 初始化我们定义两个map实例private static Map map1 = new HashMap<>();private ...
  • Java集合类中的 Map.containsVaule() 方法判断 Map 集合中是否包含指定的键值。如果 Map 集合中包含指定的键值对象,则返回 true,否则返回 false。语法:containsValue(Object value)参数说明:value:要查询的 Map...
  • 展开全部和HashMap方法一样,也是用put添加元素,LinkedHashMap也是java.util.Map的实现类区别在于Hashmap 是一个最常用的Map,它根据键的HashCode值存储数62616964757a686964616fe59b9ee7ad9431333365653739据,根据...
  • java如何向数组里添加元素

    千次阅读 2021-03-13 20:26:28
    本文收集整理关于java如何向数组里添加元素的相关议题,使用内容导航快速到达。内容导航:Q1:java数组如何循环添加元素public static void main(String[] args) {int a=9;int b=5;int c=2;int d=7;int []sult=new ...
  • Java中获取HashMap中的元素

    千次阅读 2021-02-28 06:07:45
    让我们首先创建一个HashMap并添加元素-HashMaphm=newHashMap();//将元素放入maphm.put("Maths",newInteger(98));hm.put("Science",newInteger(90));hm.put("English",newInteger(97));现在,获取大小-hm.size()以下...
  • 一、最常见的初始化方式先创建,再添加元素List从源码可以看出:List 的默认长度为10递增后的长度为先前长度的 1.5 倍最大长度是 Integer.MAX_VALUE,即 2,147,483,647 或 0x7f ff ff ffListlist = new ArrayList<...
  • 对List接口实现类ArrayList、LinkedList; Set接口实现类HashSet、TreeSet、...LinkedList与ArrayList:LinkedList采用链表结构,在数据量较大时,插入元素只需改变插入点的相应索引,其他元素不受影响。ArrayList...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 216,674
精华内容 86,669
关键字:

java map添加元素的方法

java 订阅