Java笔记-集合框架

最新推荐文章于 2022-10-20 15:05:49 发布
最新推荐文章于 2022-10-20 15:05:49 发布
阅读量638 收藏 2
点赞数 1
CC 4.0 BY-SA版权
分类专栏： JavaSE 文章标签： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u011753266/article/details/80257405

一、集合框架概述

1.引入集合框架

申明一个50长度的数组来存储数据的缺陷：

  1. 数组长度固定不变，不能很好地适应元素数量动态变化的情况。若要存储大于50个元素，则数组长度不足；若只存储20长度的数据，则造成内存空间浪费。
  2. 虽然可通过数组名.length获取数组的长度，却无法直接获取数组中真实存储的狗狗个数。
  3. 数组采用在内存中分配连续空间的存储方式，根据下标可以快速获取对应的信息，但是根据信息查找的时候效率低下，需要多次比较。在进行频繁插入、删除操作时同样效率低下。

2.Java集合框架包含的内容

Java集合框架为我们提供了一套性能优良、使用方便的接口和类，它们都位于java.util包中。

集合框架包括三大块内容：对外接口、接口实现和对集合运算的算法。

Java集合框架简图：

这里写图片描述

  • 接口：表示集合的抽象数据类型，如：Collection, List, Set, Map, Iterator。
  • 实现：集合框架中接口的具体实现，如：ArrayList, LinkedList, HashMap, TreeMap, HashSet, TreeSet。
  • 算法：在实现了的接口对象身上完成某种有用的计算方法，例如：查询、排序等。Java 提供了进行集合操作的工具类Collections (注意不是Collection)，为我们提供了对集合进行排序等多种算法实现。使用时查看 JDK 帮助文档。

上图中可以看出Java 集合框架中的两大类接口：Collection 和 Map。Collection又有两个子接口：List 和 Set。通常说Java集合框架共有三大类接口：List, Set 和 Map。共同点：都是集合接口，都可以用来存储很多对象。区别如下：

  • Collection接口存储一组不唯一（允许重复）、无序的对象。
  • Set接口继承Collection接口，存储一组唯一（不允许重复）、无序的对象。
  • List接口继承Collection接口，存储一组不唯一（允许重复）、有序（以元素插入的次序来放置元素，不会重新排列）的对象。
  • Map接口存储一组成对的键-值对象，提供key-value映射。key不要求有序，不允许重复。value同样不要求有序，但允许重复。
  • Iterator接口是负责定义访问和遍历元素的接口。

List可以理解为数组，元素内容可以重复并且有序。
Set可以理解为数学中的集合，数据不重复并且无序。

这里写图片描述

Map可以理解为数学中的集合，只是其中每个元素都由key-value两个对象组成。

这里写图片描述

二、List接口

ArrayList 对数组进行了封装，实现了长度可变的数组。ArrayList 存储数据的方式和数组相同，都是在内存中分配连续的空间，如下图。它的优点在于遍历元素和随机访问元素的效率比较高。

这里写图片描述

LinkedList 采用链表存储方式，如下图所示，优点在于插入、删除元素时效率比较高。他提供了额外的addFirst(), addLast(), removeFirst(), removeLast()等方法，这些方法使得 LinkedList 可被用作堆栈（stack）或者队列（queue）。

这里写图片描述

1.ArrayList集合类

ArrayList 接口中定义的各种常用方法如下表：

方法名称说明
boolean add(Object o)在列表末尾顺序添加元素，起始索引位置从0开始
void add(int index, Object o)在指定的索引位置添加元素，原索引位置及其后面的元素依次后移
注意：index∈[0, list.size()]
int size()返回列表中的元素个数
Object get(int index)返回指定索引位置处的元素
boolean contains(Object o)判断列表中是否存在指定元素
boolean remove(Object o)从列表中删除元素
Object remove(int index)从列表中删除指定位置元素
注意：index∈[0, list.size() - 1]

示例如下：

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

/**
 * @author 天道酬勤
 */
public class ArrayListDemo {
    public static void main(String[] args) {
        // 创建4个学生对象,Student类的属性:int age, String stuName
        Student s1 = new Student("s1", 18);
        Student s2 = new Student("s2", 17);
        Student s3 = new Student("s3", 16);
        Student s4 = new Student("s4", 15);
        // 创建ArrayList集合对象并把4个对象放入其中
        List<Student> students = new ArrayList<>();
        students.add(s1);
        students.add(s2);
        students.add(s3);
        // 添加s4到下标为2的指定位置
        students.add(3, s4);
        // 输出集合中Student对象数量
        System.out.println("集合中共有" + 
            students.size() + "个Student对象");
        // 通过遍历集合显示各条信息
        System.out.println("初始Student信息:");
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            System.out.println(s.getStuName() + 
                "\t" + s.getAge());
        }
        // 删除下标为0的Student对象（第一条信息）
        students.remove(0);
        // 删除指定的Student对象
        students.remove(s4);
        // 显示删除后的列表信息
        System.out.println("删除后集合中共有" + 
            students.size() + "个Student对象");
        for (int i = 0; i < students.size(); i++) {
            Student s = students.get(i);
            System.out.println(s.getStuName() + 
                "\t" + s.getAge());
        }
        // 判断集合中是否包含指定的信息
        if (students.contains(s3)) {
            System.out.println("s3 is in ArrayList");
        } else {
            System.out.println("s3 is not in ArrayList");
        }

    }
}

运行结果如下图所示：

这里写图片描述

3.LinkedList集合类

LinkedList 除了上表中列出的各种方法外还包括一些特殊的方法，如下表所示：

方法名称说明
void addFirst(Object o)在列表的首部添加元素
void addLast(Object o)在列表的末尾添加元素
Object getFirst()返回列表中的第一个元素
Object getLast()返回列表中的最后一个元素
Object removeFirst()删除并返回列表中的第一个元素
Object removeLast()删除并返回列表中的最后一个元素

示例代码如下：

import java.util.LinkedList;

/**
 * @author 天道酬勤
 */
public class LinkedListDemo {
    public static void main(String[] args) {
        // 创建4个学生对象,Student类的属性:int age, String stuName
        Student s1 = new Student("s1", 18);
        Student s2 = new Student("s2", 17);
        Student s3 = new Student("s3", 16);
        Student s4 = new Student("s4", 15);
        // 创建LinkedList集合对象并把多个Student对象放入其中
        LinkedList<Student> students = new LinkedList<>();
        students.add(s1);
        students.add(s2);
        students.addFirst(s3);
        students.addLast(s4);
        // 查看第一个Student对象的名字
        System.out.println("第一个对象的stuName:" + 
            students.getFirst().getStuName());
        // 查看最后一个Student对象的名字
        System.out.println("最后一个对象的stuName:" + 
            students.getLast().getStuName());
        // 删除第一个Student对象和最后一个Student对象
        students.removeFirst();
        students.removeLast();
        // 显示删除后集合中的信息
        System.out.println("删除后的LinkedList信息");
        for (int i = 0; i < students.size(); i++) {
            System.out.println(students.get(i).getStuName() + 
                "\t" + students.get(i).getAge());
        }
    }
}

三、Set接口

Set 接口可以存储一组唯一、无序的对象。

常用实现类有HashSet。

1.HashSet类动态存储数据

在数据量大的情况下，要查找某个数据，LinkedList 和 ArrayList 效率低下，前者由于数据结构决定效率底下，后者由于不知道下标，需要遍历一遍才可以。这时候我们需要HashSet。它实现了Set 接口，是使用 Set 集合的最常用的一个实现类。
HashSet特点如下：

  • 集合内的元素是无序排列的
  • HashSet 类是非线程安全的
  • 允许集合元素值为NULL

下表列出了 HashSet 类的常用方法：

方法说明
boolean add(Object o)如果此 Set 中尚未包含指定元素，则添加指定元素
void clear()从此 Set 中移除所有元素
int size()返回此 Set 中元素的数量（Set 的容量）
boolean isEmpty()如果此 Set 不包含任何元素，则返回true
boolean contains(Object o)如果此 Set 包含指定元素，则返回true
boolean remove(Object o)如果指定元素存在于此 Set 中，则将其移除

下面代码演示使用HashSet类常用方法存储并操作信息，并遍历集合，代码如下所示：

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

public class HashSetDemo {
    public static void main(String[] args) {
        Set<String> hs = new HashSet<>();
        for (int i = 0; i < 100; i++) {
            hs.add(Integer.toString(i));
        }
        for (String s : hs) {
            System.out.println(s);
        }
    }
}

该结果的部分运行结果如下所示（所以Set一组无序唯一的数据）：
这里写图片描述

如果添加多次相同数据，则实际只添加了一次该数据：

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

public class HashSetDemo {
    public static void main(String[] args) {
        Set<String> hs = new HashSet<>();
        hs.add("1");
        hs.add("1");
        for (String s : hs) {
            System.out.println(s);
        }
    }
}

运行结果如下所示：
这里写图片描述

注意：
HashSet 不能使用（或者不推荐） 简单 for 循环遍历。
但是可以使用 Iterator 接口遍历，示例如下：

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

public class HashSetDemo {
    public static void main(String[] args) {
        Set<String> hs = new HashSet<>();
        for (int i = 0; i < 100; i++) {
            hs.add(Integer.toString(i));
        }
        Iterator<String> it = hs.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

运行结果与上面相同，无序唯一，在这里不演示了。

四、Map接口

Map 接口存储一组成对的键-值对象，提供key（键）到value （值）的映射。Map 中的 key 不要求有序，不允许重复。value 同样不要求有序，但允许重复。

最常用的Map 实现类是HashMap，它的存储方式是哈希表。哈希表也称为散列表，是根据关键码值（key value）而直接进行访问的数据结构。也就是说，他通过把关键码映射到表中一个位置来进行访问记录，以加快查找速度。存放记录的数组称为散列表。使用这种方式存储数据的优点是查询指定元素效率高。

1.HashMap集合类

建立key-value对象，实现映射关系。如：CN->中华人民共和国，根据 “CN” 可以查找到 “中华人民共和国”，通过删除键可实现对应值的删除，存储和修改。

HashMap常用方法如下：

方法名称说明
Object put(Object key, Object value)以”键-值对”的方式进行存储。
注意：键必须是唯一的，值可以重复。如果试图添加重复的键，那么最后加入的”键-值对”将替换原先的”键-值对”。
Object get(Object key)根据键返回和关联的值，若不存在指定的键，则返回NULL
Object remove(Object key)删除指定的键映射的”键-值对”
int size()返回元素个数
Set keySet()返回键的集合
Collection values()返回值的集合
boolean containsKey(Object key)若存在指定的键映射的”键-值对”，则返回true
boolean isEmpty()若不存在键-值映射关系，则返回true
void clear()从此映射中移除所有映射关系

代码示例如下所示：

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

public class HashMapDemo {
    public static void main(String[] args) {
        // 使用HashMap存储多组国家英文简称和中文全称的"键-值对"
        Map<String, String> hmap = new HashMap<>();
        hmap.put("CN", "中华人民共和国");
        hmap.put("US", "美利坚合众国");
        hmap.put("RU", "俄罗斯联邦");
        hmap.put("FR", "法兰西共和国");
        // 显示"CN"对应国家的中文名称
        String country = hmap.get("CN");
        System.out.println(country);
        // 显示集合中元素的个数
        System.out.println("Map中共有:" + hmap.size() + "组数据");
        // 两次判断Map中是否存在"FR"值
        System.out.println("Map中包含FR的key吗?" 
            + hmap.containsKey("FR"));
        hmap.remove("FR");
        System.out.println("Map中包含FR的key吗?" 
            + hmap.containsKey("FR"));
        // 分别显示键集,值集和键-值对集
        System.out.println(hmap.keySet());
        System.out.println(hmap.values());
        System.out.println(hmap);
        // 清空HashMap并判断
        hmap.clear();
        if (hmap.isEmpty()) {
            System.out.println("已经清空HashMap中的数据!");
        }
    }
}

运行结果如下图所示：
这里写图片描述

五、迭代器Iterator

所有集合接口都没有提供相应的遍历方法，而是把遍历交给迭代器 Iterator 完成。 Iterator 为集合而生，专门实现集合的遍历。它隐藏了各种集合实现类的内部细节，提供了遍历集合的统一编程接口。

Collection 接口的 Iterator()方法返回一个 Iterator ， 然后通过 Iterator 接口的两个方法即可方便的实现遍历。

  • boolean hasNext()：判断是否存在另一个可访问的元素。
  • Object next()：返回要访问的下一个元素。

1.使用Iterator遍历List集合类

用 Iterator 接口来遍历 List 中的元素（ArrayList 和 LinkedList）：

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

public class IteratorList {
    public static void main(String[] args) {
        // ArrayList演示
        List<String> ls = new ArrayList<>();
        ls.add("1");
        ls.add("2");
        ls.add("3");
        ls.add("4");
        System.out.println("ArrayList中的所有数据:");
        Iterator<String> it = ls.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

        // LinkedList演示
        List<String> linkl = new LinkedList<>();
        linkl.add("7");
        linkl.add("8");
        linkl.add("9");
        linkl.add("10");
        System.out.println("\n");
        System.out.println("LinkedList中所有数据:");
        Iterator<String> linkl_it = linkl.iterator();
        while (linkl_it.hasNext()) {
            System.out.println(linkl_it.next());
        }
    }
}

运行结果如下：
这里写图片描述

2.使用Iterator遍历Map集合类

代码如下：

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

public class IteratorMap {
    public static void main(String[] args) {
        // HashMap
        Map<String, String> map = new HashMap<>();
        map.put("1", "1");
        map.put("2", "2");
        map.put("3", "3");
        map.put("4", "4");
        Set<String> keys = map.keySet();
        Iterator<String> it = keys.iterator();
        while (it.hasNext()) {
            String key = it.next();
            System.out.println(map.get(key));
        }
    }
}

运行结果如下：
这里写图片描述

3.使用Foreach循环遍历Map集合

代码如下：

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

public class ForEachMap {
    public static void main(String[] args) {
        // HashMap
        Map<String, String> map = new HashMap<>();
        map.put("1", "1");
        map.put("2", "2");
        map.put("3", "3");
        map.put("4", "4");
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println(map.get(key));
        }
    }
}

运行结果如下：
这里写图片描述

3.使用Foreach循环遍历List集合

代码如下：

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

public class ForEachList {
    public static void main(String[] args) {
        List<String> arrayList = new ArrayList<>();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        arrayList.add("4");
        System.out.println("遍历arrayList结果:");
        for (String s : arrayList) {
            System.out.println(s);
        }
        List<String> linkedList = new LinkedList<>();
        linkedList.add("11");
        linkedList.add("22");
        linkedList.add("33");
        linkedList.add("44");
        System.out.println("遍历linkedList结果:");
        for (String s : linkedList) {
            System.out.println(s);
        }
    }
}

运行结果如下：
这里写图片描述

六、泛型集合

Collection 的 add(Object obj)方法的参数就是 Object 类型，无论把什么对象放入 Collection 及其子接口或实现类中，都认为只是 Object 类型，在通过 get(int index)方法取出集合中元素时必须进行强制类型转换，不仅繁琐且容易出现ClassCastException异常。Map 中使用put(Object key, Object value)和get(Object key)方法存取对象时、使用 Iterator 的next()方法获取元素时也存在同样的问题。

JDK 1.5 中通过引用泛型（Generic）有效的解决了这个问题。在 JDK 1.5 中已经改写了集合框架中的所有接口和类，增加了对泛型的支持。

使用泛型集合在创建集合对象时指定集合中元素的类型，从集合中取出元素时无需进行类型强制转换，而且如果把非指定类型对象放入集合，会出现编译错误。

该页全部代码均使用了泛型集合，样式为：

//从左到右List为集合类型，
//String为List中存放的元素的引用数据类型或者对象
//（不可使用基本数据类型）
//右边的String可以不写
List<String> listName = new ArrayList<String>();
//Map同理,右边的<String, String>中的两个String要么都写，要么一个写
Map<String, String> mapName = new HashMap<String, String>();
java集合框架学习笔记
日常笔记 | 干货分享 | 毕设源码 | 毕设指导 | 答辩指导
08-06 409
一、什么是集合 存放在java.util.*。是一个存放对象的容器。 存放的是对象的引用，不是对象本身 长度不固定 只能存放对象 二、collection接口 collection的使用 增加元素 add(); 判断是否包含某个元素 contains(); 删除某个元素 remove(); 遍历元素（iterator迭代器） package com.zheng.demo1; import java.util.ArrayList; import java.util.Collection; impo
【狂神说笔记—— Java基础08-集合框架】
weixin_46055348的博客
07-10 818
【狂神说笔记—— Java基础08-集合框架】
Java框架学习笔记
04-13
Java框架学习笔记
Java集合框架笔记(全)
cjdxyang的博客
09-07 312
Java集合框架* 集合 一、集合概念 集合即对象的容器，实现了对对象常用的操作，类似数组功能。 二、集合和数组的区别 数组长度固定，集合长度不固定 数组可以存储基本类型和引用类型，集合只能存储引用类型 位置：java.util.*; [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YImVAHUd-1631018959607)(D:\Typora\QQ截图20210828004159.jpg)] Collection体系集合 Collection是体系的根接口，代表一组对
java 集合框架笔记
wanghaha1991514的博客
06-29 210
HashMap 底层的实现是数组与链表,允许使用null键与null值，不保证存储的顺序，线程不安全。每个Entry中存储key，value，next()，通过key的hash值，计算Entry应该存储在数组中的位置，出现冲突时，通过链表增加到数组元素的后面，存储的位置基本和value没有关系。Jdk1.8以后HashMap的实现方式做了一些改变，但是基本思想还是没有变得，只是在一些地方做了优化，...
---Java笔记---
02-20
总的来说，理解并熟练运用Java集合框架中的ArrayList和LinkedList，以及其他数据结构，对于提升代码质量和运行效率有着重要的作用。在实际开发中，应根据具体需求选择最适合的数据结构，以实现最优的性能和可维护性...
Java笔记-集合与算法
08-14
**Java集合框架**是Java标准库的一个核心组成部分，它提供了存储和操作集合的一系列接口和实现类。这些集合类库的设计遵循了一些基本的原则，例如将接口与实现相分离。 ##### 1.1 集合接口 - **Collection接口**：...
java笔记 Java-Web笔记 J2EE三大框架笔记
10-19
首先，Java笔记主要涉及Java语言的基础语法、面向对象编程概念、异常处理、集合框架、多线程、IO流、网络编程等内容。Java的基础是理解其核心特性，如类、接口、继承、封装、多态等面向对象概念。异常处理确保程序在...
java笔记--集合类
11-23
1. **接口与实现**：`List`是Java集合框架中的一个接口，定义了一系列操作列表的基本方法，如添加、删除、索引访问等。而`ArrayList`是`List`接口的主要实现之一，它内部使用一个数组来存储元素，当数组空间不足时，...
java集合框架笔记
03-18
List set ArraryList Map java集合框架笔记 基于Array的List，其实就是封装了Array所不具备的一些功能方便我们使用
java笔记——Java集合框架
theone_ID的博客
10-20 852
上课学习笔记
集合框架总结笔记一
QuestionsZhang的专栏
11-03 360
按照上面的图一一介绍 关于集合的概述     集合是一个能够存储对象并且可变长度的容器。在Java中，就此需求提供了一套相当完整的容器类库，它们就是集合类。 集合类由于内部数据结构(存储对象的方式)不同，在Java中，将其分为了许多类与接口，它们各司其职。这些集合大体可以分为两类:单列集合与双列集合。单列集合顶层接口是Collection，它又有两个常用的子接口List和Set接口。双列...
JAVA基础 框架笔记
supperpop的博客
02-27 849
1.一般情况下，java源文件名与类名相同，如果类名与源文件名不相同，javac编译时，跟的事源文件名(javac *.java)，生成的字节码文件(*.class)与类名相同2.公共类源文件名必须与类名相同3.final常亮（不可变数据）定义名称每个字母都大写，不能自增自建4.单行注释 "//" 多行注释 "/* */" javadoc 是生成java注释，(javadoc -d ./doc *...
JAVA 集合框架学习笔记
zhangyufeng0126的博客
06-01 1677
集合框架 为什么使用集合框架 Java集合框架包含的内容 集合框架的接口 List接口的实现类 ArrayList集合类 List接口常用方法 LinkedList集合类 迭代器Iterator Set&HashSet HashMap
【JAVA】集合框架 学习笔记
qq_37792173的博客
09-11 431
首先说一下什么是java集合框架，相信初学者刚开始听这个的时候，对于这个东西的概念是很模糊的。下面我用通俗一点的语言来描述它的由来以及意思。相信大家都知道数组，这是一个可以对数进行存储编辑的结构，但是在面向对象编程里面，我们不仅有数字，还有对象，简单的数组无法满足对对象的存储和编辑，因此，java集合框架就诞生了。每一种集合都是以一种不同的形式来对对象进行存储。
Java集合框架读书笔记（一）
01-16 257
容器，就是可以容纳其他Java对象的对象。对于基本数据类型需要完成对象包装后才能被放进去，java的自动拆装包可以自动完成。 Java里对象都存在堆上，且对象只能通过引用访问，句柄和直接指针方式，容器里放的起始就是对象的引用而不是对象本身。 JCF中定义了14种容器接口： 上述接口的对应实现： 迭代器（Iterator） JCF的迭代器提供了遍历容器中元素的方法，只有容器本身清除容器里元素的组...
集合框架总结笔记三
QuestionsZhang的专栏
11-03 356
泛型 泛型是在定义类或者接口时指定类型形参，这个形参在声明变量或创建对象时确定。泛型其实是应用在编译时期的技术，用于检测所操作的引用数据的类型，提高了程序的安全性。如果我们需要在类的方法中，接收任意且相同类型的两个参数，利用前边所学的知识，我们只能将参数类型定义为Object。当传入参数时，虽然可以传入任意类型，但是也可以是两个不同类型。显然这样满足不了需求，这时我们便需要用到泛型技术。泛型的定...
javaoop——第八课笔记(第六章)
qq_40677004的博客
03-26 455
第一节：集合框架概述与体系结构一：概述1、集合的概念：是一种工具类，就像是容器，储存任意数量的具有共同属性的对象。2、集合的作用： A：在类的内部，对数据进行组织； B：简而快速的搜索查找其中的某一条元素； C：有的集合接口，提供了一系列排列有序的元素，并且可以在序列中间快速的插入或者删除有关的元素； D：有的集合接口，提供了映射关系，可以通过关键字(ke...
Java源码学习笔记：集合框架与小程序案例
标题中的“实验,java程序源码,java集合源码笔记汇总”表明本文档是一份针对Java程序和Java集合框架源码的实验记录和学习笔记。这份文档可以作为学习Java编程语言，特别是Java集合框架的学习资源。 描述中提到的“几...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值