Java集合基础整理

最新推荐文章于 2023-04-04 19:26:27 发布
最新推荐文章于 2023-04-04 19:26:27 发布
阅读量3k 收藏 1
点赞数 3
文章标签： java 集合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MQNing_Star/article/details/112731923
版权

Java集合基础整理

集合是java中提供的一种容器，可以用来存储多个数据。集合和数组的区别在于：数组的长度是固定的。集合的长度是可变的。数组中存储的是同一类型的元素，可以存储任意类型数据。集合存储的都是引用数据类型。如果想存储基本类型数据需要存储对应的包装类型。Java里边主要有两种集合，Collection接口和Map接口
Collection和Map图解

Collection接口

Collection接口：单列数据，定义了存取一组对象的方法的集合。集合层次中的根接口，JDK没有提供这个接口直接的实现类。

Collection接口是List、Set接口的父接口，该接口里定义的方法既可用于操作List集合，也可用于操作Set集合。

Collection接口的常用方法

方法名称描述
public boolean add(E e)向集合中插入一个元素
public boolean addAll(Collection<? extends E> c)将指定集合中的所有元素添加到此集合
public void clear( )清空集合中的所有元素
public boolean contains(Object o)查找一个元素是否存在
public boolean containsAll(Collection<?> c)如果集合包含指定集合中的所有元素，则返回true
public Iterator< E> iterator( )返回此集合中元素的迭代器
public boolean remove(Object o)从集合中删除一个对象
public boolean removeAll(Collection<?> c)从集合中删除一组对象
public boolean removeIf(Predicate<? super E> filter)删除满足给定谓词的所有此集合的元素
public boolean retainAll(Collection<?> c)仅保留此集合中包含在指定集合的元素
public int size( )返回此集合中的元素数
public int hashCode( )返回此集合的哈希吗值
public boolean isEmpty( )判断集合是否为空
public Object[ ] toArray( )返回一个包含此集合中所有元素的数组
< T>T[ ] toArray(T[ ] a)返回包含此集合中所有元素的数组；返回的数组的运行时类型是指定数组的运行时类型
public boolean equals(Object o)将指定的对象与此集合进行比较以获得相等性

Collection与Collections的区别

Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collections 是一个包装类，它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。

成员方法
sort(List< T>)根据元素的自然顺序，将指定列表按升序排序
max(Collection< T>)返回集合的最大元素
reverse(List< T>)反转List集合元素
shuffle(List< T>)使用默认的随机源随机置换指定的列表
public class Test{
    public static void main(String[] args) {

        //创建一个List
        List<Integer> list = new ArrayList<>();

        //添加数据
        list.add(1);
        list.add(2);
        list.add(2);
        list.add(5);
        list.add(5);
        list.add(6);
        list.add(2);
        list.add(4);
        System.out.println(list);
        
        System.out.println("集合中最大的元素为：" + Collections.max(list));
        Collections.sort(list);
        System.out.println("排序之后的集合：" + list);
        Collections.reverse(list);
        System.out.println("反转之后的集合：" + list);
        Collections.shuffle(list);
        System.out.println("打乱之后的集合：" + list);
    }
}

List接口

List接口是 Collection的子接口，记录元素的保存顺序，且允许有重复元素。和数组类似，List可以动态增长，查找元素效率高，相对的插入删除元素效率低，因为会引起其他元素位置改变。
List接口的实现类主要有：ArrayList、LinkedList和Vector

List接口的常用方法

方法名称描述
public boolean add(E e)将指定的元素追加到此列表的末尾
public void add(int index, E element)将指定的元素插入此列表中的指定位置
public boolean addAll(Collection c)清按指定集合的迭代器返回的顺序将指定集合中的所有元素附加到此列表的末尾
public boolean addAll(int index, Collection c)将指定集合中的所有元素插入到此列表中的指定位置
public void clear( )从此列表中删除所有元素
public boolean contains(Object o)如果此列表包含指定的元素，则返回true
public E get(int index)返回此列表中指定位置的元素
public int hashCode( )返回此列表的哈希码值
public int removeIf(Predicate<? super E> filter)删除满足给定谓词的所有此集合的元素
public boolean retainAll(Collection<?> c)仅保留此集合中包含在指定集合的元素
public int size( )返回此集合中的元素数
public int indexOf(Object o)返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
public boolean isEmpty( )判断集合是否为空
public Iterator iterator( )以正确的顺序返回该列表中的元素的迭代器
public int lastIndexOf(Object o)返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1
public E remove(int index)删除该列表中指定位置的元素
public E set(int index, E element)用指定的元素替换此列表中指定位置的元素
public int size( )返回此列表中的元素数

ArrayList

ArrayList是List接口的主要实现类，ArrayList是一个动态数组，由于基于数组方式实现，无容量的限制，在执行插入元素时可能要扩容，在删除元素时并不会减少数组的容量，非线程安全。允许任何符合规则的元素插入包括null，它的规模可变并且能像链表一样被访问。它提供的功能类似Vector类但不同步，它是以Array方式实现的List，允许快速随机访问存储的元素，支持随机访问， 查询速度快， 增删元素慢。

Arrays类的常见操作

此处再辨别下Java中的Arrays类，这是JDK中提供了一个专门用于操作数组的工具类，位于java util 中，常用方法有：

方法名称描述
public String toString (array)将数组array转换成字符串
public void sort (array)对数组进行升序排列
public void fill (arr, val)将数组arr全部元素赋值为val
public boolean equals (arr1, arr2)判断两个数组是否相等
public arr copyOf (arr, ength)将数组arr复制成一个长度为length的新数组
public int binarySearch(arr, val)查询元素val在arr中的下标值
import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        int a[]={12,20,13,42,72,26,35,10,46,26,53};
        int b[]={3,5,7,8,54,23,9};
        int c[]={3,5,7,8,54,23,9};

        String str=Arrays.toString(a);       //将特点数组转为字符串
        System.out.println("字符串："+str);

        Arrays.sort(a);                      //对数组array的元素进行升序排列
        System.out.println("排序后："+Arrays.toString(a));

        Arrays.fill(a,99);               //所以元素都赋值成特定值
        System.out.println("赋值后："+Arrays.toString(a));

        boolean boo1=Arrays.equals(a,b);     //判断两个数组是否相等
        boolean boo2=Arrays.equals(b,c);
        System.out.println("a:"+a);
        System.out.println("b:"+b);
        System.out.println("c:"+c);
        System.out.println("ab相等？"+boo1);
        System.out.println("bc相等？"+boo2);


        int d[]=Arrays.copyOf(b,b.length);   //把数组复制成特定长度的数组,与直接赋值不同
        System.out.println("d:"+Arrays.toString(d));
        System.out.println("d:"+d);
        System.out.println("b:"+b);

        int i=Arrays.binarySearch(b, 5); //查询特定因素在数组中的下标
        System.out.println("下标是："+i);
    }
}

LinkedList

LinkedList基于双向链表机制实现，提供最佳顺序存取，适合插入和移除元素，非线程安全。由这个类定义的链表也可以像栈或队列一样被使用。特点是频繁的插入或删除元素时有较好的性能，随机访问集合中的元素性能较差。

Vector

Vector基于Object数组的方式来实现的。基于synchronized实现的线程安全的ArrayList，是线程同步的，效率很低，在插入元素时容量扩充的机制和ArrayList稍有不同。

List 相关题目

1、Collection框架中实现比较要实现什么接口

  1. Comparable/Comparator

2、ArrayList和Vector的区别

  1. 线程同步，Vector线程安全，ArrayList线程不安全
  2. 效率问题，Vector效率低，ArrayList效率高
  3. 增长数量，Vector以2倍增长，ArrayList以1.5倍增长
  4. Vector还有一个子类Stack

3、ArrayList和LinkedList的区别

  1. 都是线程不安全，相对线程安全的Vector，执行效率高。
  2. ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
  3. 对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
  4. 对于新增和删除操作add(特指插入)和remove，LinkedList比较占优势，因为ArrayList要移动数据。

4、说出ArrayList,Vector, LinkedList的存储性能和特性

  1. ArrayList和Vector使用数组存储元素；LinkedList使用链表存储元素
  2. ArrayList和Vector插入删除数据时，需要搬运数据，效率较差；LinkedList使用链表，不需要搬运数据，效率高
  3. ArrayList和Vectory查询时，按数组下标查询，不需要遍历，效率高；LinkedList需要遍历，查询效率底

5、去掉一个Vector集合中重复的元素

  1. 自行遍历，用另外一个Vector来判断是否有重复
  2. 用Set(TreeSet或HashSet)来去重
  3. 用Apache的CollectionUtil工具类去重
  4. 还有一种简单的方式，HashSet set = new HashSet(vector);

List 两种遍历方法

增强for循环

//简化数组和集合的遍历
for(Object o : list) {
    System.out.println(o);
}

迭代器
对过程的重复,称为迭代。迭代器是遍历Collection集合的通用方式。可以在对集合遍历的同时进行添加、删除等操作。
常用方法
next() :返回迭代的下一个元素对象
hasNext() :如果仍有元素可以迭代,则返回true
列表迭代器是List体系独有的遍历方式，可以在对集合遍历的同时进行添加、 删除等操作,但是必须通过调用列表迭代器的方法来实现。

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

public class Test {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");

        Iterator it = list.iterator();
        while (it.hasNext()){                      //如果迭代器中有元素，就一直迭代
            String s = (String) it.next();
            System.out.println(s);
        }
        //需求:判断集合中如果有字符串"b"，就在其后边添加一个新的字符串: java
        ListIterator lit = list.listIterator();    //创建列表迭代器
        while (lit.hasNext()){
            String s1 = (String) lit.next();
            if ("b".equals(s1)) {
                lit.add("java");                   //只有列表迭代器可以添加值
            }
            System.out.println(s1);
        }
        System.out.println(list);
        
    }
}

Set接口

Set 是Collection的子接口，不记录元素的保存顺序，且不允许有重复元素，该接口没有提供额外的方法，检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 。Set集合中的元素不按特定方式排序，只是简单的把对象加入集合中，就像往口袋里放东西。Set接口不允许包含相同的元素果试把两个相同的元素加入同一个Set集合中，则会添加操作失败。Set接口判断两个对象是否相同是根据equals() 方法 ，而不是使用 == 运算符。

HashSet

HashSet是Set接口的典型实现，大多数时候使用Set集合时都使用这个实现类。HashSet 能够快速定位一个元素，无序不可重复，底层是HashMap，存放的值在HashMap的key部分。HashSet按Hash算法来存储集合中的元素，因此具有很好的存取、查找、删除性能。
1、HashSet 具有以下特点：

  • 不能保证元素的排列顺序
  • HashSet不是线程安全的
  • 集合元素可以是null

2、HashSet集合判断两个元素相等
两个对象通过 hashCode() 方法比较相等，并且两个对象的 equals() 方法返回值也相等。对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则。

3、HashSet添加元素的原理
当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据 hashCode值，通过某种散列函数决定该对象在HashSet底层数组中的存储位置。如果两个元素的hashCode()值相等，会再继续调用equals方法，如果equals方法结果为true，则添加失败。如果为false，那么会保存该元素，但是该数组的位置已经有元素了， 那么会通过链表的方式继续链接存储。如果两个元素的equals() 方法返回true，但它们的 hashCode() 返回值不相等，hashSet将会把它们存储在不同的位置，但依然可以添加成功。

4、重写hashCode() 方法的基本原则
在程序运行时，同一个对象多次调用 hashCode() 方法应该返回相同的值。当两个对象通过equals()方法比较返回true时，这两个对象的hashCode()方法的返回值应该相等。对象中用作equals()方法比较的实例变量，都应该用来计算hashCode值。

import java.util.Objects;

public class Student {
    private int id;
    private String name;

    //无参构造与全参构造
    // get与set方法
    // toString方法
    // equals与hashCode方法
    ...
}

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

public class Test {
    public static void main(String[] args) {
        Set<Student> set = new HashSet<>();
        Student s1 = new Student(1, "张三");
        Student s2 = new Student(2, "李四");
        Student s3 = new Student(3, "王二");
        Student s4 = new Student(3, "王二");

        set.add(s1);
        set.add(s2);                           //多次添加会自动依据equals()和hashCode()两种方法去重
        set.add(s3);
        set.add(s4);

        Iterator<Student> it = set.iterator(); //使用迭代器来遍历
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s);
        }

        System.out.println(set);
        for (Student student : set) {
            System.out.println(student);       //打印顺序与添加顺序并不相同
        }
    }
}

LinkedHashSet

LinkedHashSet是HashSet的子类，LinkedHashSet也是根据元素的hashCode值来决定元素的存储位置。但它同时使用双向链表维护元素的次序，元素的顺序与添加顺序一致。
由于LinkedHashSet需要维护元素的插入顺序，因此性能略低于HashSet，但在迭代访问Set里的全部元素时有很好的性能。LinkedHashSet不允许集合元素重复。

TreeSet

TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态。TreeSet底层使用红黑树结构存储数据元素。TreeSet两种排序方法：自然排序和定制排序。默认情况下，TreeSet采用自然排序。

TreeSet自然排序

TreeSet会调用集合元素的compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序(默认情况)排列。如果试图把一个对象添加到TreeSet时，则该对象的类必须实现Comparable接口。实现Comparable的类必须实现compareTo(Object obj) 方法，两个对象即通过compareTo(Object obj) 方法的返回值来比较大小。对于TreeSet 集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过compareTo(Object obj) 方法比较返回值。当需要把一个对象放入TreeSet 中，重写该对象对应的equals() 方法时，应保证该方法与compareTo(Object obj) 方法有一致的结果。

TreeSet定制排序

TreeSet的自然排序要求元素所属的类实现Comparable接口，如果元素所属的类没有实现Comparable接口，或不希望按照升序(默认情况)的方式排列元素，希望按照其它属性大小进行排序，则考虑使用定制排序。定制排序，通过Comparator接口来实现。需要重写compare(T o1,T o2)方法。利用int compare(T o1,T o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2。要实现定制排序，需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器。使用定制排序判断两个元素相等的标准是：通过Comparator比较两个元素返回了0。

Set相关题目

1、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢?是用==还是equals( )?它们有何区别?

  • Set里的元素是不能重复的，元素重复与否视具体情况而定：
  1. HashSet使用equals比较
  2. TreeSet使用compareTo进行比较

2、两个对象值相同(x.equals(y) == true)，但却可有不同的hashcode，这句话对不对?

  • 不对，如果两个对象x 和 y 满足equals等，它们的hashCode应当相同，因此重写equals方法必须重写hashCode
  1. hashCode等，equals不一定同，但hashCode最好散列化
  2. 任何对象equals null都得false
  3. 没有继承关系的两个类，equals都得false
  4. 重写equals方法的类最好是值类，即不可变

3、TreeSet里面放对象，如果同时放入了父类和子类的实例对象，那比较时使用的是父类的compareTo方法，还是使用的子类的compareTo方法，还是抛异常？

  • 应该是没有针对问题的确切的答案，当前的add方法放入的是哪个对象，就调用哪个对象的compareTo方法，至于这个compareTo方法怎么做，就看当前这个对象的类中是如何编写这个方法的

Map接口

Map与Collection并列存在，Map提供key到value的映射。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。Map中的key用Set来存放，不允许重复，即同一个Map对象所对应的类，须重写hashCode()和equals()方法。Map接口的常用实现类：HashMap、TreeMap、LinkedHashMap和Properties。

Map接口的常用方法

方法名称描述
public V put(K key, V value)向集合中添加元素
public V get(Object key)通过指定key获取value
public void clear( )清空集合中的所有元素
public int size( )返回此集合中的元素数
public boolean isEmpty( )判断集合是否为空
public boolean containsKey(Object key)判断集合中是否包含指定key
public boolean containsValue(Object value)判断集合中是否包含指定value
public Set<泛型> keySet( )获取集合中所有的key，返回一个包含所有key元素的Set集合
Collection values( )获取集合中所有的value，返回一个包含所有value元素的Collection集合
V remove(Object key)删除指定key的键值对
public Set<Map.Entry<K,V>> entrySet()将Map集合转换成Set集合
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Test {
    public static void main(String[] args) {
        Map<Integer,Student> map = new HashMap<>();

        Student s1 = new Student(1,"张三");
        Student s2 = new Student(2,"李四");
        Student s3 = new Student(3,"张三");

        System.out.println(map.put(1,s2));                   //利用键去覆盖数值的时候会返回被覆盖的值
        System.out.println(map.put(1,s1));
        map.put(2,s2);
        map.put(3,s3);
        map.remove(3);

        System.out.println(map);
        
        Set<Integer> keys = map.keySet();                     //获取map中的key,组成一个set集合
        Iterator<Integer> it = keys.iterator();               //将set集合变为一个迭代器
        while (it.hasNext()){                                 //遍历key组成的迭代器
            Integer key = it.next();
            System.out.println("key:"+ key +" value:"+map.get(key));    //打印结果
        }

        for (Integer integer : map.keySet()) {                //使用for遍历所有的key
            System.out.println(map.get(integer));
        }
        for (Student value : map.values()) {                  //使用for遍历所有的value
            System.out.println(value);
        }
    }
}

HashMap

HashMap是Map接口使用频率最高的实现类。HashMap 实际上是一个 “链表散列” 的数据结构，即数组和链表的结合体。HashMap 的底层结构是一个数组，数组中的每一项是一条链表。HashMap 是 Hashtable 的轻量级实现，不同之处在于HashMap是非同步的，允许使用null键和null值，与HashSet一样，不保证映射的顺序。

  • 所有的key构成的集合是Set：无序的、不可重复的。所以，key所在的类要重写：equals()和hashCode()
  • 所有的value构成的集合是Collection：无序的、可以重复的。所以，value所在的类要重写：equals()
  • HashMap判断两个key相等的标准是：两个key通过equals() 方法返回true， hashCode值也相等。
  • HashMap判断两个value相等的标准是：两个value通过equals()方法返回true。
  • HashMap可以使用null值为key或value

HashMap的存储结构

  • HashMap的存储结构是数组+链表+红黑树实现。当实例化一个HashMap时，会初始化initialCapacity和loadFactor，在put第一对映射关系时，系统会创建一个长度为initialCapacity的Node数组，这个长度在哈希表中被称为容量(Capacity)，在这个数组中可以存放元素的位置我们称之为 “桶”(bucket)，每个bucket都有自己的索引，系统可以根据索引快速的查找bucket中的元素。

  • 每个bucket中存储一个元素，即一个Node对象，但每一个Node对象可以带一个引用变量next，用于指向下一个元素，因此，在一个桶中，就有可能生成一个Node链。也可能是一个一个TreeNode对象，每一个TreeNode对象可以有两个叶子结点left和right，因此，在一个桶中，就有可能生成一个TreeNode树。而新添加的元素作为链表的last，或树的叶子结点。

LinkedHashMap

LinkedHashMap 是 HashMap的子类，在HashMap存储结构的基础上，使用了一对双向链表来记录添加元素的顺序。 该链表负责维护Map的迭代顺序，与插入顺序一致，因此性能比HashMap低，但在迭代访问Map里的全部元素时有较好的性能。

TreeMap

TreeMap存储Key-Value时，需要根据key-value对进行排序。TreeMap可以保证所有的Key-Value对处于有序状态，非线程安全，底层采用红黑树的数据结构，无容量限制。TreeSet底层是用TreeMap实现的，TreeMap也有两种排序方式，自然排序和定制排序。

Hashtable

  • HashMap线程不安全，Hashtable是线程安全的。

  • HashMap可以使用null值为key或value，Hashtable不允许使用null作为key和value。

  • Hashtable实现原理和HashMap相同，底层都使用哈希表结构，查询速度快。

  • Hashtable和HashMap一样也不能保证其中Key-Value对的顺序。

Properties

Properties类是Hashtable 的子类，是线程安全的，该对象用于处理属性文件。由于属性文件里的key、value都是字符串类型，所以Properties里的key和value都是字符串类型 。

import java.util.Properties;

public class Test {

    public static void main(String[] args) {

        Properties properties = new Properties();

        properties.setProperty("url","jdbc:msql://localhost:3306");
        properties.setProperty("username","root");
        properties.setProperty("password","root");

        System.out.println(properties.getProperty("url"));
        System.out.println(properties.getProperty("username"));
        System.out.println(properties.getProperty("password"));
    }
}

Map相关题目

1、HashMap与HashTable的区别？

  • HashMap没有考虑同步，是线程不安全的；Hashtable使用了synchronized关键字，是线程安全的
  • 效率问题，Hashtable效率低，HashMap效率高
  • HashMap允许K/V都为null；hashtable后者K/V都不允许为null
  • HashMap继承自AbstractMap类；而Hashtable继承自Dictionary类
  • HashMap把Hashtable的contains方法去掉了，改成containsValue和containsKey。因为contains方法容易让人引起误解。
  • 取值不同，HashMap用的是Iterator接口，而Hashtable中还有使用Enumeration接口

2、如何决定选用HashMap还是TreeMap？

  • 对于在Map中插入、删除和定位元素这类操作，HashMap是最好的选择。然而，假如你需要对一个有序的key集合进行遍历，TreeMap是更好的选择。基于你的collection的大小，也许向HashMap中添加元素会更快，将map换为TreeMap进行有序key的遍历。

3、List和 Map区别?

  • 一个是存储单列数据的集合，另一个是存储键和值的双列数据的集合，List中存储的数据是有顺序，并且允许重复；Map中存储的数据是没有顺序的，其键是不能重复的，它的值是可以有重复的。
    1. List有重复值，Map没有重复key，但可以有重复值
    2. List有序，Map不一定有序
    3. List只能存单列值，Map可以存双列值

4、List, Set, Map是否继承自Collection接口?

  • List，Set是，Map不是

5、List、Map、Set三个接口，存取元素时，各有什么特点？

  • List使用get(index)取值，也可以使用Iterator、toArray取值
  • Set只能通过Iterator、toArray取值
  • Map取值使用get(key)取值，也可以使用keySet取键值集合，也可使用values取值集合，entrySet取全部映射。
枫林顾南
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Map集合（超详解）
weixin_67150631的博客
06-29 3261
Map HashMap,红黑树
Map集合
好好学习
07-22 910
Map集合概述 Map<K,V> 将键映射到值的对象，一个映射不能包含重复的键；每个键最多只能映射到一个值 Map集合的特点： 1、Map集合是一个双列集合，一个元素包含两个值（一个key，一个Value） 2、Map集合中的元素，key和value的数据类型可以相同，也可以不同 3、Map集合中的元素，key是不允许重复的，value是可以重复的 4、Map集合中的元素，key和value是一一对应的 HashMap java.util.HashMap<k,v>集合，implem
【学习集合--Map集合】
dugeho的博客
04-04 438
TreeMap，HashMap，LinkedHashMap学习
ES6语法新特性之----数组Map和数组reduce
aaa123_456aaa的博客
11-09 381
1.先看数组map的简单使用 a.数组map自带循环 b.处理的值回填对应的位置 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, in
java基础之集合总结
09-05
此文档属于本人当初学习java基础之集合，所整理的文档。里面整理了单列集合Collection与双列集合Map的子类及常用方法。希望对你的学习有帮助，谢谢！
java基础集合篇.wps
12-30
整理了一下java基础的集合部分，有list，map，set等及其相关。
Java基础知识整理 初学者.zip
12-01
这份"Java基础知识整理 初学者.zip"压缩包包含了一份名为"Java基础.gmind"的思维导图，旨在帮助初学者构建对Java基础知识的全面理解。以下是根据这个主题详细展开的知识点： 1. **Java简介**：Java是由Sun ...
Java基础知识整理
02-25
Java基础知识整理 Java是一种广泛应用于...本文对Java基础知识进行了系统性的整理和总结，涵盖了面向对象、访问控制权限、Final关键字、内部类、集合等多个方面的知识点，旨在帮助读者快速掌握Java语言的基础知识。
JAVA核心知识点整理
最新发布
03-12
4. **集合框架**：Java集合框架包括List（如ArrayList、LinkedList）、Set（如HashSet、TreeSet）和Map（如HashMap、TreeMap）。了解它们的特性和使用场景，以及迭代器和泛型的概念，对编写高效代码至关重要。 5. *...
数组之map方法详解
热门推荐
weixin_44206231的博客
12-23 1万+
原理： map作用是映射调用此方法的数组，不会改变原始数组，返回原始数组每一项的操作，组成一个新数组，长度和原始数组一致 方法： Array.map((item,index,arr)=>{ //item => 数组的每一项 //index => 数组每一项的索引 //arr => 原数组 }) 实例： let arr = [1,2,3] let newArr = arr.map((item,index,arr)=>{ return item+1 }) //newArr
Map集合总结
huochefei的博客
10-25 731
Map是什么 Map怎么用 Map特性好处 Map继承体系 Map接口常用方法 V put​(K key, V value) 向Map集合中添加键值对 V get​(Object key)通过可以获取value void clear()清空Map集合 boolean containsKey(Object key)判断Map中是否包含某个key boolean containsValue(Object value)判断Map中是否包含某个value boolean isEmpty()判断M
集合：Map详解.
lwj_07的博客
03-27 1603
目录： 一、Map接口常用方法 二、遍历Map集合的两种方式【重点】 三、哈希表数据结构 四、属性类：Properties类 五、TreeSet集合 六、Collections工具类 . 一、Map接口常用方法 java.util.Map接口中常用的方法: 1. Map和Collection没有继承关系。 2. Map集合以key和value的方式存储数据:键值对 key和value都是引用数据类型。 key和value都...
java集合（Map）
weixin_57341232的博客
10-05 873
本文详细讲述了Map集合的相关内容，包括HashMap,TreeMap......
map原理解析
吾昂王
05-08 618
map() 方法创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。 map不改变原数组 map返回数组元素操作后的值，就是一定有返回值 map遍历一次产生一个返回值 var arr = [1,4,9,16]; const map1 = arr.map(x => x *2); console.log(map1); // [2,8,18,32] 而如下写时： var arr = [1, 4, 9, 16]; const map1 = arr.map(x => {
JS中map（）与forEach（）的用法
weixin_39786171的博客
05-21 1万+
相同点： 1.都是循环遍历数组中的每一项 2.每次执行匿名函数都支持三个参数，参数分别为item（当前每一项），index（索引值），arr（原数组） 3.匿名函数中的this都是指向window 4.只能遍历数组   不同点： map（） map方法返回一个新的数组，数组中的元素为原始数组调用函数处理后的值 也就是map（）进行处理之后返回一个新的数组 ⚠️注意：map（）方...
数组map用法总结
weixin_30345577的博客
06-16 253
数组中，map方法，指的是是数组的映射。 map基本语法如下：function回调支持3个参数，第1个是遍历的数组内容；第2个是对应的数组索引，第3个是数组本身。 map方法的作用不难理解，“映射”嘛，也就是原数组被“映射”成对应新数组。下面这个例子是数值项求平方： 还有下面的例子： 输出： 在实际使用的时候，我们可以利用map方法方便获得对象数组中的特定属性值们。例...
数组中map()方法的运用
jh_jing的博客
08-30 5017
1、map() 方法返回一个新数组，新数组中的元素为原始数组中的每个元素调用函数处理后得到的值。 2、map() 方法按照原始数组元素顺序依次处理元素。 注意：map() 不会对空数组进行检测。 注意：map() 不会改变原始数组。 注意：函数的作用是对数组中的每一个元素进行处理，返回新的元素。 3、语法 map是数组的方法，有一个参数，参数是一个函数，函数中有3个参数 参数1：item必须。当前元素的值 参数2：index，可选。当前元素在数组中的索引值 参数3：arr可选。当前元素..
map<int,int>和数组
weixin_30338743的博客
08-05 3465
我们知道，要是将数组开成int a[0xFFFFFFF]这么大，那是肯定不行。 它会提示too big. 但是如果用map的话，那就可以了。 从这个方面来讲，map就是数组的升级版喽！ 这个可是我发现的哦。 下面简单的给出一个例子来。 题目：http://acm.swust.edu.cn/oj/problem/0822/ 下面给出错误的代码： View Code #...
Java基础核心知识树状图
12-05
Java基础知识总结,适合自学Java的同学梳理知识框架,查缺补漏;本文档图文并茂,内容偏基础,适合入门小白

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值