Java集合进阶

最新推荐文章于 2023-03-07 17:03:55 发布
最新推荐文章于 2023-03-07 17:03:55 发布
阅读量131 收藏
点赞数
分类专栏： 搬运之前写的Java基础笔记 文章标签： java 开发语言 java-ee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55123599/article/details/123494110
版权
  • Collection
  • List
  • Set
  • 泛型
  • Map
  • Collections

集合类体系结构
在这里插入图片描述

Collection集合概述和使用
Collection集合概述

  • 是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
  • JDK不提供此接口的任何直接实现，它提供更具体的子接口(如Set和List)实现

创建Collection集合的对象

  • 多态的方式
  • 具体的实现类ArrayList

eg：

package Java;

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

public class CollectionDemo01 {
    public static void main(String[] args){
        //创建Collection集合的对象
        Collection<String> c=new ArrayList<String>();
        
        //添加元素：boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("java");

        //输出集合对象
        System.out.println(c);
    }
}

终端：
[hello, world, java]

Collection集合常用方法
方法名 说明
boolean add(E e)添加元素
boolean remove(Object o)从集合中移除指定的元素
void clear()清空集合中的元素
boolean contains(Object o)判断集合中是否存在指定的元素
boolean isEmpty()判断集合是否为空
int size()集合的长度，也就是集合中元素的个数
eg：

package Java;

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

public class CollectionDemo02 {
    public static void main(String[] args){
        //创建集合对象
        Collection<String> c=new ArrayList<String>();

        //boolean add(E e)：添加元素
        System.out.println(c.add("hello"));

        //输出集合对象
        System.out.println(c);
    }
}

终端：
true
[hello]

eg：

package Java;

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

public class CollectionDemo02 {
    public static void main(String[] args){
        //创建集合对象
        Collection<String> c=new ArrayList<String>();

        //boolean add(E e)：添加元素
        System.out.println(c.add("hello"));
        System.out.println(c.add("world"));

        //输出集合对象
        System.out.println(c);
    }
}

终端：
true
true
[hello, world]

eg：

package Java;

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

public class CollectionDemo02 {
    public static void main(String[] args){
        //创建集合对象
        Collection<String> c=new ArrayList<String>();

        //boolean add(E e)：添加元素
        System.out.println(c.add("hello"));
        System.out.println(c.add("world"));
        c.clear();

        //输出集合对象
        System.out.println(c);
    }
}

终端：
true
true
[]

eg：

package Java;

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

public class CollectionDemo02 {
    public static void main(String[] args){
        //创建集合对象
        Collection<String> c=new ArrayList<String>();

        //boolean add(E e)：添加元素
        c.add("hello");
        c.add("world");

        System.out.println(c.contains("world"));

        //输出集合对象
        System.out.println(c);
    }
}

终端：
true
[hello, world]

eg：

package Java;

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

public class CollectionDemo02 {
    public static void main(String[] args){
        //创建集合对象
        Collection<String> c=new ArrayList<String>();

        //boolean add(E e)：添加元素
        c.add("hello");
        c.add("world");

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

        //输出集合对象
        System.out.println(c);
    }
}

终端：
false
[hello, world]

eg：

package Java;

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

public class CollectionDemo02 {
    public static void main(String[] args){
        //创建集合对象
        Collection<String> c=new ArrayList<String>();

        //boolean add(E e)：添加元素
        c.add("hello");
        c.add("world");
        c.clear();
        System.out.println(c.isEmpty());

        //输出集合对象
        System.out.println(c);
    }
}

终端：
true
[]

eg：

package Java;

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

public class CollectionDemo02 {
    public static void main(String[] args){
        //创建集合对象
        Collection<String> c=new ArrayList<String>();

        //boolean add(E e)：添加元素
        c.add("hello");
        c.add("world");
        
        System.out.println(c.size());

        //输出集合对象
        System.out.println(c);
    }
}

终端：
2
[hello, world]

collection集合的遍历
Iterator：迭代器，集合的专用遍历方式

  • Iterator iterator：返回此集合中元素的迭代器，通过集合的iterator()方法得到
  • 迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的

Iterator中常用方法

  • E next()：返回迭代中的下一个元素
  • boolean hasNext()：如果迭代具有更多元素，则返回true

eg：

package Java;

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

public class CollectionDemo02 {
    public static void main(String[] args){
        //创建集合对象
        Collection<String> c=new ArrayList<String>();

        c.add("hello");
        c.add("world");
        c.add("java");

        Iterator<String> it=c.iterator();
        System.out.println(it.next());
    }
}

终端：
hello

eg：

package Java;

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

public class CollectionDemo02 {
    public static void main(String[] args){
        //创建集合对象
        Collection<String> c=new ArrayList<String>();

        c.add("hello");
        c.add("world");
        c.add("java");

        Iterator<String> it=c.iterator();
        System.out.println(it.next());
        System.out.println(it.next());
    }
}

终端：
hello
world

eg：

package Java;

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

public class CollectionDemo02 {
    public static void main(String[] args){
        //创建集合对象
        Collection<String> c=new ArrayList<String>();

        c.add("hello");
        c.add("world");
        c.add("java");

        Iterator<String> it=c.iterator();
        if(it.hasNext()){
        System.out.println(it.next());
        }
        if(it.hasNext()){
            System.out.println(it.next());
        }
        if(it.hasNext()){
            System.out.println(it.next());
        }
        if(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

终端：
hello
world
java

eg：

package Java;

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

public class CollectionDemo02 {
    public static void main(String[] args){
        //创建集合对象
        Collection<String> c=new ArrayList<String>();

        c.add("hello");
        c.add("world");
        c.add("java");

        Iterator<String> it=c.iterator();

        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

终端：
hello
world
java

List
List集合概述

  • 有序集合(也称为序列)，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
  • 与Set集合不同，列表通常允许重复的元素
    List集合特点
    有序：存储和取出的元素顺序一致
    可重复：存储的元素可以重复

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

案例：List集合存储学生对象并遍历

并发修改异常
并发修改异常

  • ConcurrentModificationException
    产生原因
  • 迭代器遍历的过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致
    解决方案
  • 用for循环遍历，然后用集合对象做对应的操作即可

Listlterator
Listlterator：列表迭代器

  • 通过List集合的Listlterator()方法得到，所以说它是List集合特有的迭代器
  • 用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

Listlterator中的常用方法

  • E next()：返回迭代中的下一个元素
  • boolean hasNext()：如果迭代具有更多元素，则返回true
  • E previous()：返回列表中的上一个元素
  • boolean hasPrevious()：如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
  • void add(E e)：将指定的元素插入列表

eg：

package Java;

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

public class ListIteratorDemo {
    public static void main(String[] args){
        //创建集合对象
        List<String> list=new ArrayList<String>();

        list.add("hello");
        list.add("world");
        list.add("java");

        ListIterator<String> lit=list.listIterator();
        while(lit.hasNext()){
            String s=lit.next();
            System.out.println(s);
        }
    }
}

终端：
hello
world
java

增强for循环
增强for：简化数组和Collection集合的遍历

  • 实现terable接口的类允许其对象称为增强型for语句的目标
  • 它是JDK5之后出现的，其内部原理是一个lterator迭代器
    增强for的格式：
for(元素数据类型 变量名: 数组或者Collection集合){
    //在此处使用变量即可，该变量就是元素
}

范例：

int[] arr={1,2,3,4,5};
for(int i:arr){
    System.out.println(i);
}

数据结构之栈和队列
常见数据结构之栈
在这里插入图片描述栈是一种先进后出的模型
数据进入栈模型的过程称为：压/进栈
数据离开栈模型的过程称为：弹/出栈
在这里插入图片描述

常见数据结构之队列
在这里插入图片描述

数据从后端进入队列模型的过程称为：入队列
数据从前端离开队列模型的过程称为：出队列
队列是一种数据先进先出的模型

数据结构之数组和链表
常见数据结构之数组
在这里插入图片描述

查询数据通过索引定位，查询任意数据耗时相同，查询效率高
删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低
添加数据时，添加位置后的每个数据后移，再添加元素，添加效率极低

数组是一种查询快，增删慢的模型

常见数据结构之链表
在这里插入图片描述在这里插入图片描述

存储一个数据A，保存在地址11位置
再存储一个数据C，保存在地址37位置
再存储一个数据D，保存在地址96位置
在这里插入图片描述

在数据AC之间添加一个数据B，保存在地址54位置
删除数据BD之间的数据C

查询数组D是否存在，必须从头(head)开始查询
查询第3个数据，必须从头(head)开始查询

链表是一种增删快的模型(对比数组)
链表是一种查询慢的模型(对比数组)

List集合子类特点
List集合常用子类：ArrayList,LinkedList

  • ArrayList：底层数据结构是数组，查询快，增删慢
  • LinkedList：底层数据结构是链表，查询慢，增删快

LinkedList集合的特有功能
方法名 说明
public void addFirst(E e)在该列表开头插入指定的元素
public void addLast(E e)将指定的元素追加到此列表的末尾
public E getFirst()返回此列表中的第一个元素
public E getLast()返回此列表中的最后一个元素
public E removeFirst()从此列表中删除并返回第一个元素
public E removeLast()从此列表中删除并返回最后一个元素
eg：

package Java;

import java.util.LinkedList;

public class LinkedListDemo{
    public static void main(String[] args){
        //创建集合对象
        LinkedList<String> linkedList=new LinkedList<String>();
        
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");

        linkedList.addFirst("javase");
        linkedList.addLast("JVM");

        System.out.println(linkedList);
    }
}

终端：
[javase, hello, world, java, JVM]

eg：

package Java;

import java.util.LinkedList;

public class LinkedListDemo{
    public static void main(String[] args){
        //创建集合对象
        LinkedList<String> linkedList=new LinkedList<String>();
        
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");

        linkedList.addFirst("javase");
        linkedList.addLast("JVM");

        System.out.println(linkedList);
        System.out.println(linkedList.getFirst());
        System.out.println(linkedList.getLast());
    }
}

终端：
[javase, hello, world, java, JVM]
javase
JVM

eg：

package Java;

import java.util.LinkedList;

public class LinkedListDemo{
    public static void main(String[] args){
        //创建集合对象
        LinkedList<String> linkedList=new LinkedList<String>();
        
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");

        System.out.println(linkedList.removeFirst());
        System.out.println(linkedList.removeLast());
        System.out.println(linkedList);
        
    }
}

终端：
hello
java
[world]

Set集合
Set集合概述和特点
Set集合特点

  • 不包含重复元素的集合
  • 没有带索引的方法，所以不能使用普通for循环遍历

哈希值
哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

Object类中有一个方法可以获取对象的哈希值
public int hashCode()：返回对象的哈希码值

对象的哈希值特点

  • 同一个对象多次调用hashCode()方法返回的哈希值是相同的
  • 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同

HashSet集合概述和特点
HashSet集合特点

  • 底层数据结构是哈希表
  • 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
  • 没有带索引的方法，所以不能使用普通for循环遍历
  • 由于是Set集合，所以是不包含重复元素的集合

eg：

package Java;

import java.util.HashSet;

public class HashSetDemo {
    public static void main(String[] args){
        //创建集合对象
        HashSet<String> hs=new HashSet<String>();
        //添加元素
        hs.add("hello");
        hs.add("world");
        hs.add("java");
        //遍历
        for(String s:hs){
            System.out.println(s);
        }
    }
}

终端：
world
java
hello

HashSet集合保证元素唯一性源码分析
HashSet集合添加一个元素的过程：
在这里插入图片描述

HashSet集合存储元素：
要保证元素唯一性，需要重写hashCode()和equals()

常见数据结构之哈希表
哈希表

  • JDK8之前，底层采用数组+链表实现，可以说是一个元素为链表的数组
  • JDK8以后，在长度比较长的时候，底层实现了优化
    在这里插入图片描述在这里插入图片描述

LinkedHashSet集合概述和特点
LinkedHashSet集合特点

  • 哈希表和链表实现的Set接口，具有可预测的迭代次序
  • 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
  • 由哈希表保证元素唯一，也就是说没有重复的元素

eg：

package Java;

import java.util.HashSet;
import java.util.LinkedHashSet;

public class HashSetDemo {
    public static void main(String[] args){
        //创建集合对象
        HashSet<String> linkedHashSet=new LinkedHashSet<String>();
        //添加元素
        linkedHashSet.add("hello");
        linkedHashSet.add("world");
        linkedHashSet.add("java");
        //遍历
        for(String s:linkedHashSet){
            System.out.println(s);
        }
    }
}

终端：
hello
world
java

eg：

package Java;

import java.util.HashSet;
import java.util.LinkedHashSet;

public class HashSetDemo {
    public static void main(String[] args){
        //创建集合对象
        HashSet<String> linkedHashSet=new LinkedHashSet<String>();
        //添加元素
        linkedHashSet.add("hello");
        linkedHashSet.add("world");
        linkedHashSet.add("java");
        linkedHashSet.add("world");
        //遍历
        for(String s:linkedHashSet){
            System.out.println(s);
        }
    }
}

终端：
hello
world
java

TreeSet集合概述和特点
TreeSet集合特点

  • 元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法
    TreeSet()：根据其元素的自然排序进行排序
    TreeSet(Comparator comparator)：根据指定的比较器进行排序
  • 没有带索引的方法，所以不能使用普通for循环遍历
  • 由于是Set集合，所以不包含重复元素的集合

eg：

package Java;

import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args){
        //创建集合对象
        TreeSet<Integer> ts=new TreeSet<Integer>();
        
        ts.add(10);
        ts.add(40);
        ts.add(30);
        ts.add(50);
        ts.add(20);

        for(Integer i:ts){
            System.out.println(i);
        }
    }
}

终端：
10
20
30
40
50

eg：

package Java;

import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args){
        //创建集合对象
        TreeSet<Integer> ts=new TreeSet<Integer>();
        
        ts.add(10);
        ts.add(40);
        ts.add(30);
        ts.add(50);
        ts.add(20);

        ts.add(30);
        for(Integer i:ts){
            System.out.println(i);
        }
    }
}

终端：
10
20
30
40
50

自然排序Comparable的使用

  • 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
  • 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

结论：

  • 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
  • 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(To)方法
  • 重写方法时，一定要注意排序规则则必须按照要求的主要条件和次要条件来写

比较器排序Comparator的使用

  • 存储学生对象并遍历，创建TreeSet集合使用带参构造方法
  • 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

结论：

  • 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序进行排序的
  • 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(To1,To2)方法
  • 重写方法时，一定要注意排序规则则必须按照要求的主要条件和次要条件来写

泛型
泛型概述
泛型：是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型，它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数
一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？
顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型
这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口

泛型定义格式：

  • <类型>：指定一种类型的格式。这里的类型可以看做是形参
  • <类型1，类型2…>：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参
  • 将来具体调用时候可以看成是实参，并且实参的类型只能是引用数据类型

泛型的好处：

  • 把运行时期的问题提前到了编译期间
  • 避免了强制类型转换

泛型类
泛型类的定义格式：

  • 格式：修饰符 class 类名<类型>{}
  • 范例：public class Generic{}
    此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型

泛型方法
泛型方法的定义格式：

  • 格式：修饰符 <类型> 返回值类型 方法名(类型 变量名){}
  • 范例：public void show(T t){}

泛型接口
泛型接口的定义格式：

  • 格式：修饰符 interface 接口名<类型>{}
  • 范例：public interface Generic{}

类型通配符
为了表示各种泛型List的父类，可以使用类型通配符

  • 类型通配符：<?>
  • List<?>：表示元素类型未知的List，它的元素可以匹配任何的类型
  • 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中

如果我们不希望List<?>是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型类型通配符的上限

  • 类型通配符上限：<?extends 类型>
  • List<?extends Number>：它表示的类型是Number或者其子类型

除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限

  • 类型通配符下限：<?super 类型>
  • List<?super Number>：它表示的类型是Number或者其父类型

可变参数
可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的

  • 格式：修饰符 返回值类型 方法名(数据类型…变量名){}
  • 范例：public static int sum(int…a){}

可变参数注意事项

  • 这里的变量其实是一个数组
  • 如果一个方法有多个参数，包含可变参数，可变参数要放在最后

可变参数的使用
Arrays工具类中有一个静态方法：

  • public static List asList(T…a)：返回由指定数组支持的固定大小的列表
  • 返回的集合不能做增删操作，可以做修改操作

List接口中有一个静态方法：

  • public static List of(E…elements)：返回包含任意数量元素的不可变列表
  • 返回的集合不能做增删改操作

Set接口中有一个静态方法：

  • public static Set of(E…elements)：返回一个包含任意数量元素的不可变集合
  • 在给元素的时候，不能给重复的元素
  • 返回的集合不能做增删操作，没有修改的方法

Map集合
Map集合概述

  • Interface Map<K,V> K：键的类型；V：值的类型
  • 将键映射到值的对象，不能包含重复的键；每个键可以映射到最多一个值
  • 举例：学生的学号和姓名
    20180101 小豫
    20180102 小静
    20180103 小晓

创建Map集合的对象

  • 多态的形式
  • 具体的实现类HashMap

eg:

package Java;

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

public class MapDemo {
    public static void main(String[] args){
        Map<String,String> map=new HashMap<String,String>();
        map.put("20180101", "小豫");
        map.put("20180102", "小静");
        map.put("20180103", "小晓");

        //输出集合对象
        System.out.println(map);
    }
}

终端：
{20180103=小晓, 20180102=小静, 20180101=小豫}

eg：

package Java;

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

public class MapDemo {
    public static void main(String[] args){
        Map<String,String> map=new HashMap<String,String>();
        map.put("20180101", "小豫");
        map.put("20180102", "小静");
        map.put("20180103", "小晓");
        map.put("20180103", "小可");

        //输出集合对象
        System.out.println(map);
    }
}

终端：
{20180103=小可, 20180102=小静, 20180101=小豫}

Map集合的基本功能
方法名 说明
V put(K key,V value)添加元素
V remove(Object key)根据键删除键值对元素
void clear()移除所有的键值对元素
boolean containsKey(Object key)判断集合是否包含指定的键
boolean containsKey(Object value)判断集合是否包含指定的值
boolean is Empty()判断集合是否为空
int size()集合的长度，也就是集合中键值对的个数

Map集合的获取功能
方法名 说明
V get(Object key)根据键获取值
Set <K> keySet()获取所有键的集合
Collection <V> values()获取所有值的集合
Set<Map.Entry<K,V>>entrySet()获取所有键值对对象的集合

eg：

package Java;

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

public class MapDemo {
    public static void main(String[] args){
        Map<String,String> map=new HashMap<String,String>();
        map.put("鱼皮", "上海");
        map.put("落拓", "香港");
    
        System.out.println(map.get("鱼皮"));
        System.out.println(map.get("Mars"));

        Set<String> keySet=map.keySet();
        for(String key:keySet){
            System.out.println(key);
        }

        Collection<String> values=map.values();
        for(String value:values){
            System.out.println(value);
        }
    }
}

终端：
上海
null
鱼皮
落拓
上海
香港

Collections
Collections概述和使用
Collections类的概述：

  • 是针对集合操作的工具类
    Collections类的常用方法：
  • public static <T extends Comparable<? super T>> void sort(List list)：将指定的列表按升序排序
  • public static void reverse (List <?> list)：反转指定列表中元素的顺序
  • public static void shuttle(List <?> list)：使用默认的随机源随机排列指定的列表

eg：

package Java;

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

public class CollectionDemo01 {
    public static void main(String[] args){
        List<Integer> list=new ArrayList<Integer>();
        list.add(30);
        list.add(20);
        list.add(50);
        list.add(10);
        list.add(40);
        Collections.shuffle(list);
        System.out.println(list);
    }
}

终端：
[30, 50, 10, 20, 40]

安娜和她的笔记本
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java集合进阶】Collection 体系集合详解（ArrayList，LinkedList，HashSet，TreeSet...）
zhangxia_的博客
01-16 2355
集合是对象的容器，定义了多个对对象操作的方法，实现了和数组一样的功能，集合类全部位于`java.util.*` 包中，使用该类前需要进行导包操作导入相应的 Java 类。Java集合结构庞大，其主要分为两大类，单列集合 Collection 和双列集合 map。所谓的单列集合是一次只能添加一个数据，而双列集合就是一次可以添加一对数据。
JAVA——集合进阶
weixin_51411716的博客
02-02 299
Part.n——集合进阶 集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变 包含： Collection List（元素可重复，储存和取出的元素顺序一致） Set（元素不可重复） 泛型 Map Collections ①Collection集合概述 是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素 JDK不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现 创建Collection集合的对象 ..
12.集合进阶
qq_43626215的博客
02-15 341
一、collocation 1.集合知识回顾 集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变 2.集合类体系结构 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WwhqYCGk-1613353684149)(C:\Users\关兮月\Desktop\学习笔记\java\image-20210123095728599.png)] 3.Collection集合概述和使用 Collection集合概述 是单例集合的顶层接口，它表示一组对象，这些对象也
面试的角度诠释Java工程师（二）
ZHOUBANGDING的博客
02-19 620
转自：http://www.importnew.com/23557.html 续言： 相信每一位简书的作者，都会有我这样的思考：怎么写好一篇文章？或者怎么写好一篇技术类的文章？我就先说说我的感悟吧，写文章其实和写程序是一样的。为什么我会说它们是一样的？简单思考一下…… 程序：程序是由某语言的工程师用一段段代码逻辑连贯出来的，或许当事人是看得懂滴，但是问题是你要让项目经
java集合框架全面进阶
03-16
Java集合框架是Java编程语言中不可或缺的一部分，它提供了一组接口和类，用于高效地存储、管理和操作数据。本篇文章将深入探讨Java集合框架的各个方面，帮助开发者从基础到高级全面掌握这一关键知识。 首先，我们要...
Java集合进阶之Collection单列集合（List）
乔巴俊儿~~的博客
10-30 518
目录 前言 集合概述 Collection集合 概述 常用方法 遍历（迭代器） 并发修改异常 List集合 概述 特点以及特有方法 列表迭代器 三种遍历方法 LinkedList集合的特有功能 总结 前言 “集合”，顾名思义，就是把一组元素放在一起，集合便相当于一种容器，把这些数据元素保存起来。在Java语言中，集合体系分布较广，它大致可分为List、Set、Queue和Map四种体系。今天我主要介绍单列集合Collection以及它的子接口List集合（A...
java进阶笔记.pdf
11-30
Java进阶笔记 本资源摘要信息主要涵盖 Java 编程语言的基础知识，包括 Java API 的概述、String 类的概述、String 构造方法、String 对象的特点、StringBuilder 类的概述、StringBuilder 构造方法、StringBuilder ...
java工程师进阶学习资料
03-03
Java开发者需要理解Redis的数据结构（如字符串、哈希、列表、集合、有序集合）以及其使用场景。学习Redis的持久化机制（如RDB和AOF），主从复制，以及Sentinel和Cluster集群解决方案，能帮助你在实际项目中更好地...
JAVA进阶 —— 集合进阶
最新发布
hdakj22的博客
03-07 508
双列集合Map的三种遍历方式和三种实现类：HashMap、LinkedHashMap、TreeMap，以及可变参数和Collections工具类
java进阶----集合
不会飞的小飞侠24
09-26 537
凡是能够用来存储数据的都可以看成是容器：
Java进阶---集合
pngyul的博客
04-04 427
PS : 前段时间花了大半个月的时间了解前端的一些基本知识，现在转向后端开发。X之前学过java,但是当时在学习d的过程中缺乏实践和整理，现在有一部分知识已经健忘，比如集合、I/O、反射、多线程以及网络编程等。我们知道，学习Web后端得要有扎实的Java基础。所以现在先重新捡起这几个方面的知识，加深印象。   一.Collection 1.集合与数组的区别 集合，集合是java中提供的一种...
Java进阶总结——集合
大唐一品
09-27 184
Java进阶总结——集合 说明：对于以上的框架图有如下几点说明 1.所有集合类都位于java.util包下。Java的集合类主要由两个接口派生而出：Collection和Map，Collection和Map是Java集合框架的根接口，这两个接口又包含了一些子接口或实现类。 集合接口：6个接口（短虚线表示），表示不同集合类型，是集合框架的基础。 抽象类：5个抽象类（长虚线表示），对集合接口的部分实现。可扩展为自定义集合类。 实现类：8个实现类（实线表示），对接口的具体实现。 Collection 接口是一组
Java进阶 -- 集合总结
水里的鱼
08-12 232
集合的体系结构 单列集合：Collection接口 List接口 Set接口 双列集合：Map接口 List集合 list集合的特征： 1、有序 2、元素可以重复 3、有索引 ArrayList集合（重点*****） 底层：数组结构，查询快，增删慢。 常用的方法： 增/添加： boolean add(E e):添加一个元素到集合末尾，返回值表示是否添加成功，默认都是返回true。 ...
Java集合(进阶)
weixin_62142545的博客
01-13 1209
Java集合基础知识
【JAVA进阶】集合
Javascript_tsj的博客
01-04 677
数组的特点集合的特点1、数组和集合的元素存储的个数问题。数组定义后类型确定，长度固定 集合类型可以不固定，大小是可变的。2、数组和集合存储元素的类型问题。数组可以存储基本类型和引用类型的数据。集合只能存储引用数据类型的数据。3、数组和集合适合的场景 数组适合做数据个数和类型确定的场景。集合适合做数据个数不确定，且要做增删元素的场景，集合种类更多，功能更强大。1.集合的体系特点集合类体系结构Collection集合体系Collection集合特点List系列集合：添加的元素是。
Java进阶知识——集合
jhckn18402219的博客
02-12 496
集合 一、集合概念： 对象的容器，定义了对多个对象进行操作的常用方法。类似数组的功能 二、集合和数组的区别： （1）数组长度固定，集合长度不固定 （2）数组可以存储基本类型和引用类型，集合只能存储引用类型。 三、Collection体系集合 （1）List接口的特点：有序，有下标，元素可重复，无唯一性。 实现类：ArrayList和LinkedList以及Vector（较老，现在不使用) （2）Set接口的特点：无序，无下标，元素不可重复，有唯一性。 实现类：HashSet和TreeSet(实现了So
Java异常处理与集合进阶：ArrayIndexOutOfBoundsException与编译时异常解析
现在转向集合部分，集合是Java中存储和操作对象的主要方式。`Collection`是所有集合类的顶级接口，包括`List`、`Set`和`Queue`等子接口。`List`是一个有序的集合，允许包含重复元素，提供了按索引访问元素的功能。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值