Java常用集合梳理

最新推荐文章于 2022-11-13 22:02:46 发布
最新推荐文章于 2022-11-13 22:02:46 发布
阅读量156 收藏
点赞数
文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26350505/article/details/106824339
版权

集合

在java中,我们常常需要存放多个数据,这时我们常常想到用数组来存放,但如果需要存放的数据是不同类型的数据或者数据个数未知的,数组就无能为力了.这时使用集合来存放数据就解决了这些问题.
集合和数组比起来:
1.数组的长度是固定的,集合的长度是可变的.
2.数组只能存储同类型的对象,集合可以存储不同类型的对象.
3.集合只能存储对象,不能存储基本数据类型.(系统会自动将基本数据类型封装成对应的包装类型存储)

常用集合关系图

Collection

Collection是所有单列集合的父接口,在Collection中定义了单例集合(List和Set)的一些通用的方法,这些方法可以操作所有的单列集合.

常用方法:

  1. public boolean add(E e):把给定的对象添加到当前集合中.
		Collection<String> collection = new ArrayList<>();
        System.out.println(collection.add("abc")); //true
  1. public void clear():清空集合中所有的元素.
		Collection<String> collection = new ArrayList<>();
		collection.clear();
		System.out.println(collection); //[]
  1. public boolean remove(E e): 把给定的对象在当前集合中删除.
		Collection<String> collection = new ArrayList<>();
        collection.add("abc");
        collection.remove("abc");
        System.out.println(collection); //[]
  1. public boolean contains(Object obj): 判断当前集合中是否包含给定的对象.
		Collection<String> collection = new ArrayList<>();
        collection.add("abc");
        System.out.println(collection.contains("a")); //false
        System.out.println(collection.contains("abc")); //true ("abc"为一个对象)
  1. public boolean isEmpty(): 判断当前集合是否为空.
		Collection<String> collection = new ArrayList<>();
		System.out.println(collection.isEmpty()); //true
        collection.add("abc");
        System.out.println(collection.isEmpty()); //false
  1. public int size(): 返回集合中元素的个数.
		Collection<String> collection = new ArrayList<>();
        System.out.println(collection.size()); //o
        collection.add("abc");
        System.out.println(collection.size()); //1
  1. public Object[] toArray(): 把集合中的元素,存储到数组中.
		Collection<String> collection = new ArrayList<>();
        collection.add("abc");
        collection.add("123");
        collection.add("@#$%");
        System.out.println(Arrays.toString(collection.toArray())); //[abc, 123, @#$%]

Collection的遍历

  1. for增强(foreach)遍历(底层是依靠Iterator迭代器实现的)
		Collection<String>collection=new ArrayList<>();
        collection.add("a");
        collection.add("b");
        collection.add("c");
        for (String s : collection) {
            System.out.print(s+" "); //a b c
        }
  1. 迭代器遍历
		Collection<String> collection = new ArrayList<>();
        collection.add("a");
        collection.add("b");
        collection.add("c");
        Iterator<String> iterator = collection.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next()+" "); //a b c
        }
  1. 注意事项
    在遍历过程中不允许对集合进行增删操作,否则会出现IllegalStateException异常
		Collection<String> collection = new ArrayList<>();
        collection.add("a");
        collection.add("b");
        collection.add("c");
        Iterator<String> iterator = collection.iterator();
        for (String s : collection) {
            if(s.equals("a")){
                iterator.remove(); //IllegalStateException
            }
        }

正确对集合增删操作的方法:

		Collection<String> collection = new ArrayList<>();
        collection.add("a");
        collection.add("b");
        collection.add("c");
        Iterator<String> iterator = collection.iterator();
        while (iterator.hasNext()){
            String next = iterator.next();
            if(next.equals("a")){
                iterator.remove();
            }
        }
        System.out.println(collection); //[b, c]

Collections常用方法

  1. public static void shuffle(List<?> list):打乱集合顺序.
		List<Integer>list=new ArrayList<>();
        list.add(10);
        list.add(20);
        list.add(30);
        Collections.shuffle(list);
        System.out.println(list); //[20, 10, 30]
  1. public static <T> void sort(List<T> list):将集合中元素按照默认规则排序.(在对应的类中已定义好默认排序规则)
		List<Integer>list=new ArrayList<>();
        list.add(20);
        list.add(30);
        list.add(10);
        Collections.sort(list);
        System.out.println(list); //[10, 20, 30]
  1. public static <T> void sort(List<T> list，Comparator<? super T> com ):将集合中元素按照指定规则排序.
		List<Integer> list = new ArrayList<>();
        list.add(20);
        list.add(30);
        list.add(10);
        list.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer integer, Integer t1) {
                return t1 - integer; //t1 - integer 为降序
            }						 //integer - t1 为升序
        });
        System.out.println(list); //[30, 20, 10]

List

List接口是Collection接口的子接口具备Collection的所有方法.将实现了List接口的对象称为List集合.

List接口的特点:

  1. 它是一个元素存取有序的集合.取出元素的顺序跟存入元素时的顺序相同.
  2. 它带有索引.可以通过索引精确地操作集合中的元素.
  3. 它允许集合中的元素重复.

常用方法: List作为Collection集合的子接口,不但继承了Collection接口中的全部方法,而且还增加了一些根据元素索引来操作集合的特有方法.

  1. public void add(int index, E element):将指定的元素,添加到该集合中的指定位置上.
		List<String> list = new ArrayList<>();
        list.add("a");
        list.add("c");
        list.add(1,"b");
        System.out.println(list); //[a, b, c]
  1. public E get(int index):返回集合中指定位置的元素。
		List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        System.out.println(list.get(1)); //b
  1. public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
		List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        System.out.println(list.remove(1)); //b
        System.out.println(list); //[a]
  1. public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
		List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        System.out.println(list.set(1,"c")); //b
        System.out.println(list); //[a, c]
ArrayList

ArrayList集合数据存储的结构是数组结构,所以它查询快,而在对集合进行增删操作时,由于集合是有序的,对应操作元素之后的元素都要向前或向后移动,它的底层是有一定容量的,若容量不足还会创建一个新的容量足够的ArrayList集合再将元素拷贝到新集合中.所以它增删慢.它用来查询数据、遍历数据是比较合适的.

LinkedList

LinkedList集合数据存储的结构是链表结构,在查询元素的时候底层会判断index离链头还是链尾更近,用来确定正向还是反向遍历,并找到该index对应的元素,所以它查询慢,而在对集合进行增删操作时,由于它是双向链表结构,只需要将被操作元素和它前后元素的引用关系修改就完成了.所以它增删快.如果要对集合中的数据进行大量的增删操作,用LinkedList会更好.

在这里插入图片描述

LinkedList是List的子类,List中的方法LinkedList都是可以使用,它还提供了大量首尾操作的方法.

  1. public void addFirst(E e):将指定元素插入此列表的开头.
		LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("b");
        System.out.println(linkedList); //[b]
        linkedList.addFirst("a");
        System.out.println(linkedList); //[a, b]
  1. public void addLast(E e):将指定元素添加到此列表的结尾.
		LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("b");
        System.out.println(linkedList); //[b]
        linkedList.addLast("a");
        System.out.println(linkedList); //[b, a]
  1. public E getFirst():返回此列表的第一个元素.
		LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("a");
        linkedList.add("b");
        System.out.println(linkedList.getFirst()); //a
  1. public E getLast():返回此列表的最后一个元素.
		LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("a");
        linkedList.add("b");
        System.out.println(linkedList.getLast()); //b
  1. public E removeFirst():移除并返回此列表的第一个元素.
		LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("a");
        linkedList.add("b");
        System.out.println(linkedList.removeFirst()); //a
  1. public E removeLast():移除并返回此列表的最后一个元素.
		LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("a");
        linkedList.add("b");
        System.out.println(linkedList.removeLast()); //b
  1. public E pop():从此列表所表示的堆栈处弹出一个元素.
		LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("a");
        linkedList.add("b");
        System.out.println(linkedList.pop()); //a
        System.out.println(linkedList); //[b]
  1. public void push(E e):将元素推入此列表所表示的堆栈.
    同1. public void addFirst(E e):将指定元素插入此列表的开头.
  2. public boolean isEmpty():如果列表不包含元素.则返回true.
		LinkedList<String> linkedList = new LinkedList<>();
        System.out.println(linkedList.isEmpty()); //true
        linkedList.add("a");
        System.out.println(linkedList.isEmpty()); //false

Set

Set接口继承了Collection接口,也继承了它的所有方法,实现了Set接口的类叫做Set集合.

Set接口的特点:
元素无索引,元素存取无序,元素不可重复.

HashSet

HashSet保证元素唯一的原理: 它的底层是哈希表结构,哈希表保证元素唯一依赖于hashCode()和equals()方法.
当HashSet集合存储元素时,就会调用该元素的hashCode方法计算哈希值,然后判断该哈希值位置上是否有相同哈希值的元素,如果没有就直接存储,如果有就产生了哈希冲突,这时就会调用该元素的equals方法与该哈希值位置上的元素一一进行比较,如果该位置上有任一元素与该元素相同,就不存储,如果该位置上所有元素都与该元素不同,就直接存储.

给HashSet中存放自定义类型元素时,需要重写对象中的hashCode和equals方法,建立自己的比较方式,才能保证HashSet集合中的元素不可重复性.

import java.util.*;

class Person {
    private String name;
    private String job;

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(name, person.name) &&
                Objects.equals(job, person.job);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, job);
    }

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

public class Demo {
    public static void main(String[] args) {
        Person p1 = new Person("张三", "老师");
        Person p2 = new Person("李四", "医生");
        Person p3 = new Person("李四", "医生");
        HashSet<Person> hashSet = new HashSet<>();
        hashSet.add(p1);
        hashSet.add(p2);
        hashSet.add(p3);
        System.out.println(hashSet); //[Person{name='李四', job='医生'}, Person{name='张三', job='老师'}]
        System.out.println(p1.hashCode()); //25062431
        System.out.println(p2.hashCode()); //26795352
        System.out.println(p3.hashCode()); //26795352
    }
}
LinkedHashSet

LinkedHashSet是链表和哈希表组合的一个数据存储结构,使用它可以保证元素取出时的顺序和存入时相同.

		LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("a");
        linkedHashSet.add("c");
        linkedHashSet.add("b");
        for (String s : linkedHashSet) {
            System.out.print(s+" "); //a c b 
        }
        HashSet<String> hashSet = new HashSet<>();
        hashSet.add("a");
        hashSet.add("c");
        hashSet.add("b");
        for (String s : hashSet) {
            System.out.print(s+" "); //a b c 
        }
TreeSet

TreeSet集合是Set接口的一个实现类,底层依赖于TreeMap,是一种基于红黑树的实现,它元素唯一,元素没有索引,使用元素的自然顺序对元素进行排序,或者根据创建时提供的Comparator进行排序.

		TreeSet<Integer> treeSet1 = new TreeSet<>();
        treeSet1.add(3);
        treeSet1.add(1);
        treeSet1.add(2);
        System.out.println(treeSet1); //[1, 2, 3]
        TreeSet<Integer> treeSet2 = new TreeSet<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer integer, Integer t1) {
                return t1 - integer; //t1 - integer为降序
            }						 //integer - t1为升序
        });
        treeSet2.add(3);
        treeSet2.add(1);
        treeSet2.add(2);
        System.out.println(treeSet2); //[3, 2, 1]

Map

Map接口是所有双列集合的顶层父接口.Map<K,V> K用来限制键的类型,V用来限制值的类型.

  1. Map集合存储元素是以键值对的形式存储,也就是说每一个键值对都有键和值
  2. 通过键取值
  3. Map集合中的键不能重复,如果键重复了,那么值就会被覆盖.
  4. Map集合中的值是可以重复的.

常用方法:

  1. public V put(K key, V value):把指定的键与指定的值添加到Map集合中.
		Map<String,Integer>map=new HashMap<>();
        map.put("张三",18);
        System.out.println(map); //{张三=18}
  1. public V remove(Object key):把指定的键所对应的键值对元素在Map集合中删除,返回被删除元素的值.
		Map<String,Integer>map=new HashMap<>();
        map.put("张三",18);
        map.put("李四",19);
        System.out.println(map.remove("张三")); //18
        System.out.println(map); //{李四=19}
  1. public V get(Object key):根据指定的键，在Map集合中获取对应的值.
		Map<String,Integer>map=new HashMap<>();
        map.put("张三",18);
        map.put("李四",19);
        System.out.println(map.get("张三")); //18
  1. public boolean containsKey(Object key):判断该集合中是否有此键
		Map<String,Integer>map=new HashMap<>();
        map.put("张三",18);
        System.out.println(map.containsKey("张三")); //true
        System.out.println(map.containsKey("李四")); //false
  1. public Set<K> keySet(): 获取Map集合中所有的键,存储到Set集合中.
		Map<String,Integer>map=new HashMap<>();
        map.put("张三",18);
        map.put("李四",19);
        map.put("王五",20);
        Set<String> keys = map.keySet();
        System.out.println(keys); //[李四, 张三, 王五]
  1. public Collection<V> values() 获取Map集合中所有的值,存储到Collection集合中.
		Map<String,Integer>map=new HashMap<>();
        map.put("张三",18);
        map.put("李四",19);
        map.put("王五",20);
		Collection<Integer> values = map.values();
        System.out.println(values); //[19, 18, 20]
  1. public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合).
		Map<String, Integer> map = new HashMap<>();
        map.put("张三", 18);
        map.put("李四", 19);
        map.put("王五", 20);
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        System.out.println(entrySet); //[李四=19, 张三=18, 王五=20]

Map的遍历

  1. for增强(foreach)遍历(底层是依靠Iterator迭代器实现的)
		Map<String, Integer> map = new HashMap<>();
        map.put("张三", 18);
        map.put("李四", 19);
        map.put("王五", 20);
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        for (Map.Entry<String, Integer> entries : entrySet) {
            System.out.print(entries+" "); //李四=19 张三=18 王五=20
        }
  1. 迭代器遍历
		Map<String, Integer> map = new HashMap<>();
        map.put("张三", 18);
        map.put("李四", 19);
        map.put("王五", 20);
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        for (Map.Entry<String, Integer> entries : entrySet) {
            String key = entries.getKey();
            Integer value = entries.getValue();
            System.out.print(key+"="+value+" "); //李四=19 张三=18 王五=20 
        }

HashMap

键唯一,键值对存取无序, 由哈希表保证键唯一.

		HashMap<String,Integer> HashMap =new HashMap<>();
        HashMap.put("张三",18);
        HashMap.put("李四",19);
        HashMap.put("王五",20);
        System.out.println(HashMap); //{李四=19, 张三=18, 王五=20}
LinkedHashMap

键唯一,键值对存取有序(取出顺序与存入顺序一致),由哈希表保证键唯一,由链表保证键值对存取有序.

		LinkedHashMap<String,Integer>linkedHashMap=new LinkedHashMap<>();
        linkedHashMap.put("张三",18);
        linkedHashMap.put("李四",19);
        linkedHashMap.put("王五",20);
        System.out.println(linkedHashMap); //{张三=18, 李四=19, 王五=20}

TreeMap

键唯一,可以对键值对进行排序.
TreeMap集合和Map相比没有特有的功能,底层的数据结构是红黑树,可以对元素的键进行排序，排序方式有两种:自然排序和比较器排序,到时使用的是哪种排序,取决于我们在创建对象的时候所使用的构造方法.

		TreeMap<Integer, String> treeMap1 = new TreeMap<>();
        treeMap1.put(1, "张三");
        treeMap1.put(2, "李四");
        treeMap1.put(3, "张三");
        System.out.println(treeMap1); //{1=张三, 2=李四, 3=张三}
        TreeMap<Integer, String> treeMap2 = new TreeMap<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer integer, Integer t1) {
                return t1 - integer; //t1 - integer为降序
            }						 //integer - t1为升序
        });
        treeMap2.put(1, "张三");
        treeMap2.put(2, "李四");
        treeMap2.put(3, "张三");
        System.out.println(treeMap2); //{3=张三, 2=李四, 1=张三}
qq_26350505
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【白雪红叶】JAVA学习技术栈梳理思维导图.xmind
04-25
关于java程序员发展需要学习的路线整理集合 技术 应用技术 计算机基础知识 cpu mem disk net 线程，进程 第三方库 poi Jsoup zxing Gson 数据结构 树 栈 链表 队列 图 操作系统 linux 代码控制...
Java课堂笔记、代码、java核心知识点梳理、java笔试面试资料.zip
最新发布
01-03
Java基础知识点：包括数据类型、面向对象特性、异常处理、集合框架等。 Java核心技术：如多线程、网络编程、序列化等都有详细的解释和示例。 常用框架：如Spring、MyBatis等框架的使用方法和内部原理都有涉及。 ...
javaSE之集合框架(2)集合常用实现类学习指南，包括ArrayList，LinkedList,HashMap，HashSet等常用集合，以及工具类Collections，Iterator等等
qq_37795916的博客
03-12 304
集合常用实现类 1. Collections 1.1 概念 是什么 是个java.util下的类,是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化(将非同步的集合转换成同步的)等操作。 2.2 常用方法 sort(Collection，[Comparator]): 对集合进行排序。 reverse(List list): 反转集合中的元素。 shuffle(Collection): 对集合进行随机排序。 fill(List list, Object
Java集合---04--Set
时光里的博客
10-31 364
Set接口 Set接口： 存储无序的 不可重复的数据 HashSet： 作为Set接口的主要实现类； 线程不安全的 可以存储null值 LinkedHashSet： 作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历 对于频繁的遍历操作，LinkedHashSet效率高于HashSet. TreeSet： 可以按照添加对象的指定属性，进行排序。 ...
【Java-集合】HashSet 、LinkedHashSet 介绍及遍历操作
笔记、Bug解决
02-01 1039
文章目录1、前言2、HashSet3、LinkedHashSet 1、前言   Set 集合最大的特点就是不能有重复的元素，这和我们高中所学的集合非常相似。 2、HashSet 数据结构：底层使用的是 HashMap （数组+红黑树） 安全性：线程不安全 扩容机制：数组的初始容量为16，负载因子 0.75，当数组使用的个数达到 16*0.75 = 12 时就会扩容为原来的两倍。 如何判断元素一样：通过 equals（）与 hashCode（）方法，都返回true表明元素相等。 HashSet遍历： pu
Java LinkedHashMap 逆序遍历
06-20 5444
原文：http://blog.csdn.net/lsm135/article/details/51246911 import java.util.ArrayList;   import java.util.LinkedHashMap;   import java.util.ListIterator;   import java.util.Map;       public 
[Java] Set的几种遍历方式，适用于HashSet、LinkedHashSet和TreeSet
qq_40898875的博客
03-19 3648
Set的几种遍历方式 介绍 Java中Set是属于Collection接口下的实现分支，其实现类共有以下三种： HashSet：特点是集合中元素是不可重复的，集合中的元素无序，且与插入顺序无关，由HashMap实现，因此二者有部分特性是一致的，如初始大小为16，加载因子为7.5，元素存储在HashMap的key当中，从而也保证了集合的元素的唯一性； LinkedHashSet：特点是集合中元素是不可重复的，并且集合中元素顺序与插入时顺序一致； TreeSet：特点是集合中的元素是不可重复，并且集合中元素顺
corejava基础重要知识点总结
12-12
类：一组类型相同事物高度抽象之后的集合概念 创建对象的模板 -》 class 对象：类的一个具体的实例 例子： 人和范冰冰之间的关系？ 类和对象 HelloKitty和猫之间的关系？ 对象和类 引用：对象的名字 *:一个...
java8集合源码分析-javajuice:Java相关知识：基础知识、面试题
06-04
java8 ...本篇适用于对Java有一些基础的程序员，着重介绍Java中的各种坑和进阶技巧。 除了+、-、×、/，你还知道Java中其他的运算符嘛？ 比如&、&&、|、||、^、<<、>>、>>>？ 你了解他们的区别与
java.xmind
07-24
Java基础知识，xmind梳理，包含大部分Java基础知识：类型，面向对象三大特征，常用的api，集合，数据结构和算法，多线程，Java基础，反射，网络，Java1.8新特性，io流
java集合总体系整理
05-29
在编程中，我们常常需要集中存放多个数据，比如：学校的学生花名册，考试成绩等等，类似情况。有人会会说：数组也可以呀！没错，但是数组有它的优点也有它的不足之处： 1.我们在使用数组时，一旦为数组指定长度，那么这个数组的长度就会是不可变的，如果需要保存数量变化的数据，数组就显的无能为力了。 2.数组固然方便使用，但是数组没有办法保存映射关系的数据，比如：语文：89，数学：100。。。或者：某某 ：男，某某：女等等。 为了保存数量不确定的数据，以及保存具有映射关系的数据（也称为关联数组），Java提供了集合类。集合类主要负责保存、盛装其他数据，因此集合类也被称为容器类。
java linkedhashset用法_遍历Java LinkedHashSet的元素
weixin_35368877的博客
02-16 4090
首先，创建一个LinkedHashSet并向其中添加元素-LinkedHashSetset=newLinkedHashSet();set.add(10);set.add(20);set.add(30);set.add(40);set.add(50);set.add(60);现在，使用Iterator遍历元素-Iteratori=set.iterator();while(i.hasN...
Java集合，超详细整理，适合新手入门
你好, 我在学java的博客
11-13 4337
创建TreeSet对象时如果传入了一个Comparator对象，就用实现的compare方法去除重复元素，如果方法返回0，就认为不应该添加；如果没有传入Comparator对象，则以添加对象的实现的Comparable接口的compareTo方法去除重复元素；原因：创建TreeSet对象时如果传入了一个Comparator对象，就用实现的compare方法比较；如果没有传入Comparator对象，则以添加对象的实现的Comparable接口的compareTo方法比较；第二次添加时，遍历所有的key。
集合部分：集合遍历的三种方式，集合中常见的方法，集合的正序遍历，集合的逆序遍历，list，set，map，内部比较器comparable与外部比较器comparator的区别，数组转集合与集合转数组
wyqwilliam的博客
08-19 850
 集合： package com.bjsxt.collection; import java.util.ArrayList; import java.util.Collection; import java.util.Date; import java.util.Iterator; public class TestCollection { /** ...
java集合知识点梳理
jh_554的博客
07-21 707
java集合学习笔记整理
java集合整理
weixin_44883971的博客
03-15 134
java集合整理1. java集合的常规比较2、JDK1.8中ConcurrentHashMap中的CAS和synchronized在哪使用的3、Arrays.asList方法后的List可以扩容吗？4、HashMap中hash函数做了哪些改动？（1.7->1.8）5.hashmap中1.7和1.8的区别6. 如何解决哈希冲突 1. java集合的常规比较 （1）HashMap：初始容量16、扩容两倍、默认加载因子是0.75，extends AbstractMap implements Map,长度是
Java 集合系列1、细思极恐之ArrayList
weixin_34313182的博客
05-04 171
1、ArrayList 概述 ArrayList 底层数据结构为 动态数组 ，所以我们可以将之称为数组队列。 ArrayList 的依赖关系： public class ArrayList&lt;E&gt; extends AbstractList&lt;E&gt; implements List&lt;E&gt;, RandomAccess, Cloneable, java.io.Se...
头歌java常用集合答案
05-26
Java 常用的集合有以下几种： 1. List：可以存储重复元素的有序...这些集合类都是 Java 集合框架中的一部分，使用方便，提供了大量的方法来操作集合中的元素。根据不同的需求，我们可以选择合适的集合类来处理数据。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值