JavaOOP 06 集合框架

兰巧儿

已于 2023-02-16 13:41:07 修改

阅读量194

点赞数 1

分类专栏： JavaOOP 文章标签： java jvm servlet

于 2023-02-16 08:35:28 首次发布

本文链接：https://blog.csdn.net/m0_72817617/article/details/129054039

版权

JavaOOP 专栏收录该内容

10 篇文章 1 订阅

订阅专栏

六、集合框架

6.1 Java集合概述

6.1.1 集合概念

集合就是一个放数据容器，它主要包括Collection和Map集合
集合中的元素全部为对象
集合可以存放不同类型、不限数量的数据类型。
集合包含的接口：Iterable，Collection，List，Set，Map

Java的集合类有两个接口派生而成 Collection 接口和 Map 接口

Collection 接口和 Map 接口为 java 集合框架的根接口
Collection 接口常用的子接口包含 List 接口和 Set 接口
Map 接口独立一支

Java 集合框架常用接口说明

名称	描述
Collection	● 单个值集合的根接口，最基本的集合接口 ● 一个 Collection 代表一组 Object (对象)。Java不提供实现类，只提供子接口（ List 接口和 Set 接口） ● Collection 接口存储一组可重复的无序对象
Set	● 继承 Collection 接口，存储一组不可重复的无序对象
List	● 继承 Collection 接口，存储一组可重复的有序对象 ● 元素顺序以元素插入的次序来放置元素，不会重新排序 ● 通过索引访问数组，索引从0开始 ● List 接口常用的实现类有 ArrayList 类和 LinkedList 类
Map	● 存储成对数据的根接口,可存储一组" key(键)-value(值对)"对象 ● 提供 key(键) 到 value(值) 的映射 ● Map 中的 key(键) 是无序的，不重复的 ● Map 中的 value(值) 是无序的，可重复的 ● 可以通过 key(键) 找到对应的 value(值)
Iterator	● 集合迭代器，可以遍历集合元素的接口
Collections	● 与 Collection 是不同的概念，它提供了对象合对象进行基本操作的通用接口方法 ● 包含各种有关集合操作的静态方法 ● 工具类，不可实例化

6.1.2 Collection 接口

Collection 接口是 List 接口和 Set 接口的父类，该接口定义的方法可用于操作 List集合和 Set 集合

Collection 接口常用的方法

方法	描述
boolean add (Object o)	用于向集合中添加一个元素，如果集合不允许重复且已经包含了指定元素，则返回 false
boolean addAll (Collection c)	将集合 c 里的所有元素添加到指定的集合里，添加成功返回 true
void clear ()	清除集合中的所有元素，将集合长度变为0
boolean contains (Object o)	判断集合中是否包含指定元素 o
boolean containsAll (Collection c)	判断集合中是否包含集合 c 里的所有元素
boolean remove (Object o)	删除集合中指定的元素 o，当集合中包含了一个或多个元素 o是，这些元素将被删除，成功返回 true
int size()	返回集合里元素的个数
boolean retainAll (Collection c)	从集合中删除集合 c 里不包含的元素，如果成功删除，返回 true
boolean removeAll (Collection c)	从集合中删除集合 c 里包含的所有元素，如果成功删除，返回 true
boolean isEmpty()	如果此集合中不包含任何元素，则返回 true
Object [] toArray()	把集合转换成数组，所有的集合元素变成对应的数组元素

定义接口

//使用 ArrayList 类对象
Collection list=new ArrayList();
//使用 HashSet 类对象
Collection set=new HashSet();

ArrayList 是 List 的子类

HashSet 是 Set 的子类

6.1.3 集合的遍历

当直接使用 println 输出集合时，将以[1,2,3…]的形式输出

如果想一次访问集合里的每一个元素，则需要使用某种方式遍历集合元素

主要有两种遍历集合的方法

1、使用 iterator 接口遍历集合元素

Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法
Iterator（迭代器）该类主要用于遍历集合对象，该类描述了遍历集合的常见方法
Iterator 接口定义的方法

方法	描述
boolean hasNext()	判断是否存在下一个遍历元素，存在则返回true
Object next()	返回遍历的下一个元素
void remove()	删除集合里上一次 next() 方法返回的元素

获取集合迭代器语法 :

Iterator 迭代器名=集合名.Iterator();

Iterator 集合遍历示例

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

public class Text01 {
    public static void main(String[] args) {
        //定义一个集合
        Collection list=new ArrayList();
        //添加元素
        list.add("鼠");
        list.add("牛");
        list.add("虎");
        list.add("兔");
        //获取集合迭代器
        Iterator lst=list.iterator();
        while(lst.hasNext()){
            System.out.println(lst.next());
        }
    }
}

注意 Iterator 接口对元素进行遍历时，是把集合元素的值传给了迭代器，所以修改迭代器中存储的值，对集合元素本身没有任何影响

2、使用 foreach 循环遍历集合元素

语法 :

for(数据类型 迭代变量名 : 迭代对象){
    //引用迭代变量名的语句
}

示例

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

public class Text01 {
    public static void main(String[] args) {
        //定义一个集合
        Collection list=new ArrayList();
        //添加元素
        list.add("鼠");
        list.add("牛");
        list.add("虎");
        list.add("兔");
        //使用foreach遍历集合
        for(Object o:list){
            System.out.println(o);
        }
    }
}

注意 foreach 循环中的迭代变量也不是集合元素本身，系统只是把集合元素付给了迭代变量

遍历集合有两种方式 foreach遍历和 Iterator遍历

foreach 在遍历集合时不能对集合进行操作
iterator 在遍历集合时可以对集合进行操作，他是将自己的数据传给了 iterator迭代器

6.1.4 Java集合框架包含的主要内容

在这里插入图片描述

6.2 List

6.2.1 List 概述

List 集合是一类存储元素有序、可重复的集合，集合中每个元素都有相对应的索引
List 接口为 Collection 接口的子接口，可以使用 Collection 接口定义的全部方法
List 集合是有序集合，在 Collection 接口方法的基础上，扩展了一些方法
List 接口扩展的方法

方法	描述
void add(int index, Object element)	将元素 (element) 插入 List集合的指定位置(index)
boolean addAll (int index, Collection c)	将集合 c 所包含的所有元素插入 List 集合的指定位置(index)
Object get (int index)	返回集合 index 索引处的元素
int indexOf (Object o)	返回对象 o 在 List 集合当中第一次出现的位置
int lastIndexOf (Object o)	返回对象 o 在 List 集合当中最后一次出现的位置
Object remove (int index)	从集合中删除指定位置的元素,返回删除的对象
boolean remove()	从集合中删除指定对象，成功返回true
Object set (int index, Object element)	将 index 索引处的元素替换成 element 对象，返回被替换的元素
List subList (int fromIndex, int toIndex)	截取并返回集合或数组中的一部分，包含起始位置 (fromIndex) 到不包含结束位置 (toIndex) 的数据

List subList() 演示

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

public class Test02 {
    public static void main(String[] args) {
       List l1=new ArrayList();
        l1.add("1");
        l1.add("2");
        l1.add("3");
        l1.add("4");
        //截取 l1 集合 位置下标从0 到 3 不包含3
        List l2=l1.subList(0,3);
        System.out.println(l2);
    }
}

使用 List 接口的扩展方法，需要通过 List 接口的子类实例化对象调用
List 接口常用的子类有 ArrayList 类 和 LinkedList 类

6.2.2 ArrayList 集合类

ArrayList 类现类可变数组的大小，存储在内的数据称为元素
可以通过索引下标快速访问数据，允许对集合中的元素进行快速的随机访问
向ArrayList中插入与删除元素的速度相对较慢
ArrayList数组的存储方式和数组相同，都是在内存中分配连续空间

6.2.3 LinkedList 集合类

LinkedList 集合和 ArrayList 集合都是一个 List 集合，都可以根据索引下标随机访问集合中的元素
LinkedList 还具有双向链表结构，更加方便实现添加和删除的操作
但是LinkedList类随机访问元素的速度则相对较慢
除此之外，LinkedList 类还提供了实现链表操作的方法

LinkedList 集合实现链表操作的常用方法

方法	描述
void addFirst (Object o)	在链表的首部添加元素
void addLast (Object o)	在链表的尾部添加元素
Object getFirst ()	返回链表中的第一个元素
Object getLast ()	返回链表中的最后一个元素
Object removeFirst ()	删除并返回链表中的第一个元素
Object removeLast ()	删除并返回链表中的最后一个元素

注意 LinkedList 特有的方法必须是LinkedList 类型的集合才可以使用，如果是父类，则无法调用

例如：

     //正确操作
          LinkedList l1=new LinkedList();
           l1.removeLast();

6.2.4 ArrayList 集合类和 LinkedList 集合类的异同点

相同点：

ArrayList 和LinkedList 都是单列集合中 List 接口的实现类
都是存取允许重复，且有序的元素

不同点：

ArrayList的实现是动态数组，在内存中分配连续的空间
LinkedList 是以元素链表的形式存储它的数据，每一个元素都和它的前一个和后一个链接在一起
ArrayList查询快，增删慢
LinkedList查询慢，增删快

6.3 Set

6.3.1 Set 概述

Set 集合是一个存储数据无序且不允许重复的集合
和 List 接口一样，都是 Collection 的子接口
Set 集合与 Collection 集合基本上一样，没有提供额外方法
set 没有索引

6.3.2 HashSet 集合

HashSet 为 Set接口的实现类
可以实现对无序不重复数据的存储
具有很好的存取和查找性能
不允许存储重复的元素
没有索引，没有包含索引的方法，不能使用索引遍历
是无序集合，存储元素和取出元素的顺序可能不一致
如果出现重复数据，则会覆盖掉之前的数据
示例

public class Test02 {
    public static void main(String[] args) {
      HashSet set=new HashSet();
        set.add("西瓜");
        set.add("桃子");
        set.add("你好");
        set.add("核桃");
        //输出数组 都是无序的,不可重复的
        Iterator iterator=set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

6.3 Map

6.3.1 Map概述

Map 可以存储有映射关系的数据，也就是一组"键(key)-值(value)"的对象
Map可以存储若干个成对的键(key)-值(value)
其中键( key ) 为 Set 集合类型，无序且不可重复的
值( value) 也要求无序，但可重复
Map 集合对象不能使用 Collection 接口中定义的方法
Map 接口的常用方法

方法	描述
Object put(Object key, Object val)	以“键-值对”的方式进行存储，第一次添加时，返回值为null，如果添加重复的key，则会覆盖掉先添加的"键-值对"，返回被顶掉的 value值
Object get (Object key)	根据键返回相关联的值，如果不存在指定的键，返回null
int size()	返回元素个数
boolean remove (Object key)	删除由指定的键映射的“键-值对”
Set keySet ()	返回键的集合
Collection values ()	返回值的集合
boolean containsKey (Object key)	如果存在由指定的键映射的“键-值对”，返回true
Set entrySet ()	返回"键-值对" 集合，返回一个Set集合的 “键(key)-值(value)”
boolean isEmpty()	若不存在"键-值对"元素，则返回true
void clear()	删除该Map 对象中的所有的 “键-值对”

Map 接口提供了大量的实现类，典型实现类如 HashMap类、HashTable类、TreeMap类等，其中 HashMap 类是最常用的 Map 接口实现类

6.3.2 HashMap 集合的遍历

1. 通过KeySet() 方法返回键的集合为Set集合

2. 循环遍历键的集合

3. 通过每个键获取对应的值

示例

import java.util.*;

public class Test02 {
    public static void main(String[] args) {
     HashMap map=new HashMap();
     map.put(1,"一");
     map.put(2,"二");
     map.put(3,"三");
     map.put(4,"四");
     //将key返回为 set集合
     Set set=map.keySet();
     Iterator iterator= set.iterator();
     while (iterator.hasNext()){
         //接受每一个key
         Object key=iterator.next();
         System.out.print(key);
         //通过key获取value
         System.out.println(map.get(key));
     }
    }
}

6.3.3 Map.Entry

Map.Entry是Map的一个内部接口
用来保存形如 “键(key)-值(value)” 的元素
Map.Entry接口的常用方法

方法	描述
Object getKey ()	取得此 “键(key)-值(value)” 对应的 key 值
Object getValue ()	取得此 “键(key)-值(value)” 对应的 value 值
int hashCode()	返回该 “键(key)-值(value)” 的哈希码值
Object setValue(Object value)	用指定的值替换该 “键(key)-值(value)” 的 Value 值

使用 Map.Entry 遍历 Map 集合

import java.util.*;

public class Test02 {
    public static void main(String[] args) {
     HashMap map=new HashMap();
     map.put(1,"一");
     map.put(2,"二");
     map.put(3,"三");
     map.put(4,"四");
        //获取键-值对
        Set map1=map.entrySet();
        //遍历集合
        Iterator iterator=map1.iterator();
        while (iterator.hasNext()){
            //转为Map.Entry 类型
            Map.Entry me=(Map.Entry)iterator.next();
            //获取键 key
            System.out.print(me.getKey());
            //获取值
            System.out.println(me.getValue());
        }

    }
}

## 6.4 泛型集合

### 6.4.1 泛型概念

- **规范容器内的数据类型,约束集合中元素的类型**
- **语法 :**

~~~java
集合类型 <要规范的类型> 集合名=new 集合类型 <要规范的类型>();

示例

public class Test03 {
    public static void main(String[] args) {
        //集合内只可以存储Integer对象
        List<Integer> list=new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        //因为已经设置了泛型，所以不需要再转换类型
        int num= list.get(1);
    }
}

ue());
}

}

6.4 泛型集合

6.4.1 泛型概念

规范容器内的数据类型,约束集合中元素的类型
语法 :

集合类型 <要规范的类型> 集合名=new 集合类型 <要规范的类型>();

示例

public class Test03 {
    public static void main(String[] args) {
        //集合内只可以存储Integer对象
        List<Integer> list=new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        //因为已经设置了泛型，所以不需要再转换类型
        int num= list.get(1);
    }
}