集合

最新推荐文章于 2024-11-04 20:33:37 发布
最新推荐文章于 2024-11-04 20:33:37 发布
阅读量297 收藏
点赞数 1
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014017580/article/details/62056328
版权

java集合框架位于java.util包下

Collection接口

该接口的定义如下：

public interface Collection<E>
    extends Iterable<E>

collection是存放单值最大的父接口，可以向其中保存多个单值数据，此接口中的方法主要有：

方法描述
public boolean add(E o)向集合中插入对象
public boolean addAll(Collection e将一个集合的内容插入进来
public void clear()清除此集合中的所有元素
public boolean contains(Object o)判断一个对象是否在集合中存在
public boolean containsAll(Collection c)判断一组对象是否在集合中存在
public boolean equals(Object o)比较对象
Public int hashCode()哈希码
public boolean isEmpty()判断集合是否为空
public Iterator iterator()为Iterator接口实例化
public boolean remove(Object o)删除指定对象
public boolean removeAll(Collection c)删除一组对象
public boolean retainAll(Collection c)保存指定内容
public int size()求出集合的大小
public Object[] toArray()将一个集合变为对象数组
public T[] toArray(T[] a)指定好返回的对象数组类型

但是在开发中一般不提倡直接使用Collection接口，因为这会导致表示的操作意义不明确。Collection主要的子接口如下：

List：可以存放重复的数据
set：不能存放重复的内容，所有重复内容靠hashCode（）和equals（）两个方法区分
queue：队列接口
sortedSet：可以对集合中的数据进行排序

List接口

List接口的定义如下：

public interface List extends Collection

List接口对Collection接口扩充了大量的方法，比较常用的方法为：

方法描述
public void add(int index,E element)在指定位置增加元素
public boolean addAll(int index,Collection c)在指定位置增加一组元素
public E get(int index)返回指定位置的元素
public int indexOf(Object o)查找指定元素的位置
public int lastIndexOf(Object o)从后向前查找指定元素的位置
public ListIterator listIterator()为Listiterator接口实例化
public E remove(int index)按指定的位置删除元素
public List subList(int fromIndex,int toIndex)取出这个范围内的子元素
public E set(int index,E element)替换指定位置的元素

List接口比Collection扩充了更多的方法，但是如果要想使用此接口，则需要通过其子类进行实例化。

List接口的常用字类

ArrayList

此类事List的子类，可以直接为List接口实例化。此类定义如下： 

public class ArrayList<E>
    extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, Serializable

示例：验证增加操作 

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

public class JavaDemo{
    public static void main(String args[]){
        List<String> list = null;       //定义List对象
        Collection<String> c = null ;   //定义Collection对象
        list = new ArrayList<String> ();
        c = new ArrayList<String>() ;
        list.add("hello");
        list.add("world");
        list.add("beijing");
        list.add("yunnan");
        System.out.println(list);

        c.add("PYL");
        c.add("sichuang");
        list.addAll(c);
        list.addAll(1,c);
        System.out.println(c);
        System.out.println(list);
    }
}

执行结果：

[hello, world, beijing, yunnan]
[PYL, sichuang]
[hello, PYL, sichuang, world, beijing, yunnan, PYL, sichuang]

在List接口中还有一个子类：Vector。Vector的定义为：

public class Vector
extends AbstractList
implements List, RandomAccess, Cloneable, Serializable

Vector和ArrayList一样都是继承自AbstractList类，两者的区别有：

比较点ArrayList（使用较多）Vector
推出时间JDK1.2之后推出，属于新的操作类JDK1.0时推出，属于旧的操作类
性能采用异步处理方式，性能更高采用同步处理方式，性能较低
线程安全属于非线程安全的操作类属于线程安全的操作类
输出只能使用Iterator，foreach输出可以使用Iterator、foreach、Enumeration输出

LinkedList子类和Queue接口

LinkedList是一个链表操作类，定义如下： 

public class LinkedList<E>
    extends AbstractSequentialList<E>
        implements List<E>, Queue<E>, Cloneable, Serializable

Queue接口是Collection的子接口，定义如下：

public interface Queue<E>
    extends Collection<E>

　 Queue接口也可以增加元素并输出，此接口的方法定义如下：

方法描述
public boolean add(E e)增加元素
public E element()找到链表的表头
public boolean offer(E o)将指定元素增加到链表的表尾
public E peek()找到但并不删除链表的表头
public E poll()找到并删除此链表的表头
Public E remove（）检索并移除表头

　　 LinkedList类中除了实现以上方法外，还提供有以下方法：

方法描述
public void addFirst(E o)在链表开头增加元素
public void addLast(E o)在链表结尾增加元素
public boolean offer(E o)将指定元素增加到链表的结尾
public E removeFirst（）删除链表的第一个元素并返回该元素
public E removeLast（）删除链表的最后一个元素并返回该元素

Set接口

Set接口也是Collection接口的子接口，但是与List接口不同的是：Set接口不能加入重复的元素。Set接口定义如下：

public interface Set<E>
    extends Collection<E>

Set接口的主要方法与Collection是一致的，并没有对Collection几口进行扩充，只是比Collention接口要求更严格了：不能增加重复的元素。

Set接口的子类

散列的存放：HashSet

该类的定义如下：

public class HashSet<E>
    extends AbstractSet<E>
        implements Set<E>, Cloneable, Serializable

该子类的主要特点是：里面不能存放重复的元素，而且采用散列的存储方式，没有顺序。

有序的存放：TreeSet

该类的定义如下： 

public class TreeSet<E>
    extends AbstractSet<E>
        implements NavigableSet<E>, Cloneable, Serializable

该子类的主要特点是：存放的元素不能重复，可以排序

TreeSet中的元素是有序的，所以对于一个对象必须指定好其排序顺序，且TreeSet中的每个对象所在的类都必须实现Comparable接口才可以正常使用。

集合的输出

在类集中提供有以下4中常见的输出操作：

  • Iterator:迭代输出，是使用最多的输出方式；
  • ListIterator：是Iterator的子接口，专门用于输出List中的内容；
  • Enumeration：是一个旧的接口，功能与Iterator类似；
  • foreach：JDK1.5之后提供的新功能，可以输出数组或集合。

迭代输出：Iterator

其定义为：

public interface Iterator<E>

此接口使用时也需要指定泛型，但是此处指定的泛型类型需要与集合中的泛型类型一致。此接口定义了3个方法，为：

方法描述
public boolean hasNext()判断是否有下一个值
public E next()取出当前元素
public void remove()移除当前元素

示例：集合的输出和删除操作 

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

public class JavaDemo{
    public static void main(String args[]){
        List<String> list = null;
        list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("beijing");
        list.add("yunnan");
        Iterator<String> ite = list.iterator();
        while(ite.hasNext()){
            System.out.print(ite.next() + "、");
        }

        while(ite.hasNext()){
            String str = ite.next();
            if("world".equals(str)){
                ite.remove();
            }else{
                System.out.print(str + "、");
            }
        }
        System.out.println();
        System.out.println("删除之后的集合：" + list);
    }
}

注意：集合操作也有一个remove（）方法，但是如果在使用Iterator输出时由集合对象调用自身的删除方法，则会出现运行时错误。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class JavaDemo{
    public static void main(String args[]){
        List<String> list = null;
        list = new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("beijing");
        list.add("yunnan");
        Iterator<String> ite = list.iterator();
        while(ite.hasNext()){
            String str = ite.next();
            if("world".equals(str)){
                list.remove(str);
            }else{
                System.out.print(str + "、");
            }
        }
        System.out.println();
        System.out.println("删除之后的集合：" + list);
    }
}
D:\JAVA>java JavaDemo
hello、Exception in thread "main" 
    java.util.ConcurrentModificationException
        at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
        at java.util.ArrayList$Itr.next(Unknown Source)
        at JavaDemo.main(JavaDemo.java:15)

从程序的运行结果可以发现，内容却是被删除了，但是迭代输出在内容删除之后就终止了。因为集合本身的内容被破坏掉，所以迭代将出现错误，会停止输出。

双向迭代输出：ListIterator

　　Iterator接口得主要功能是由前向后单向输出，而此时如果想要实现由后向前或者由前向后的双向输出，则必须使用Iterator的子接口—-ListIterator。ListIterator接口的定义如下： 

public interface ListIterator<E> extends Iterator<E>

此接口定义了比Iterator接口更多的方法、主要方法有：

方法描述
public boolean hasNext()判断是否有下一个值
public E next()取出当前元素
public void remove（）移除当前元素
public void add(E e)将指定元素增加到集合
public boolean hasPrevious()判断是否有上一个元素
public E previous()取出当前元素
public int nextIndex()返回下一个元素的索引号
public int previousIndex()返回上一个元素的索引号
public void set(E e)替换元素

ListIterator接口只能通过List接口实例化，即：只能输出List接口中的内容。在List接口中定义了如下方法可以为ListIterator接口实例化：

public ListIterator<E> listIterator()

示例：双向迭代输出

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

public class JavaDemo{
    public static void main(String args[]){
        List<String> list = new ArrayList<String>() ;
        list.add("hello");
        list.add("_");
        list.add("world");
        ListIterator<String> liter = list.listIterator();
        System.out.print("由后向前输出：");
        while(liter.hasNext()){
            String str = liter.next();
            System.out.print(str + "、");
        }
        System.out.println();
        System.out.print("由前向后输出：");
        while(liter.hasPrevious()){
            String str = liter.previous();
            System.out.print(str + "、 ");
        }

    }
}

JAVA新支持：foreach

使用foreach除了可以进行数组的输出，同样可以用于集合的输出。使用foreach的格式为：

for（类 对象 : 集合）{
　　//集合操作
}

示例：使用foreach进行输出

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

public class JavaDemo{
    public static void main(String args[]){
        List<String> list = new ArrayList<String>() ;
        list.add("hello");
        list.add("_");
        list.add("world");
        for(String str : list){
            System.out.println(str + "、");
        }
    }
}

废弃的接口：Enumeration

　　 Enumeration接口是JDK1.0就推出的，之最早的迭代输出接口，最早使用Vector时就是使用Enumeration接口进行输出的。Enumeration接口定义如下：

public interface Enumeration<E>

JDK1.5之后对Enumeration接口进行了扩充，增加了泛型操作，方法为：

方法描述
public boolean hasMoreElements()判断是否有下一个值
public E nextElement()取出当前元素

要想使用此接口输出只能通过Vector类，Vector类定义了以下的方法可以为Enumeration接口实例化。

public Enumeration<E> elements()

范例：使用Enumeration输出

import java.util.Vector;
import java.util.Enumeration;

public class JavaDemo{
    public static void main(String args[]){
        Vector<String> all = new Vector<String>() ;
        all.add("hello");
        all.add("_");
        all.add("world");
        Enumeration<String> enu = all.elements();
        while(enu.hasMoreElements()){
            System.out.print(enu.nextElement() + "、");
        }
    }
}

Map接口

Map接口简介

Map中的每个元素都是以“key - value”的形式储存在集合中。Map的接口定义如下:

public interface Map<K,V>

Map接口中主要的方法为：

1、public void clear() 清空Map集合
2、public boolean containsKey(Object key) 判断指定的key是否存在
3、public boolean containsValue(Object value) 判断指定的value是否存在
4、public Set

Map.Entry接口简介

Map.Entry接口是Map内部定义的一个接口，专门用来保存“key - value”的内容。Map.Entry定义如下：

public static interface Map.Entry<K,V>

本接口提供一下方法：

方法描述
public boolean equals(Object o)对象比较
public K getKey()取得key值
public V getValue()取得value值
public int hashCode()返回哈希码
public V setValue(V value)设置value的值

Map接口常用的子类

Map中常用的子类有：

  • HashMap：无序存放的，是新的操作类，key不允许重复
  • Hashtable：无序存放的，是旧的操作类，key不允许重复
  • TreeMap：可以排序的Map集合，按集合中的key排序，key不允许重复
  • WeakHashMap:弱引用的Map集合，当集合中的某些内容不再使用时清除掉无用的数据，使用gc进行回收
  • identityHashMap:key可以重复的Map集合

HashMap

HashMap是Map的子类，可以直接使用此类为Map接口实例化，HashMap类的定义如下：

public class HashMap<K,V>
    extends AbstractMap<K,V>
        implements Map<K,V>, Cloneable, Serializable

示例：HashMap操作：

import java.util.*;
public class JavaDemo{
    public static void main(String args[]){
        Map<String,String> map = null;
        map = new HashMap<String,String>();
        map.put("name","jack");
        map.put("sex","man");
        map.put("age","four");
        String val = map.get("name");
        System.out.println(val);

        Set<String> keys = map.keySet();
        Iterator<String> ite = keys.iterator();
        System.out.print("输出全部的key  ：  ");
        while(ite.hasNext()){
            String str = ite.next();
            System.out.print(str + "、");
        }
    }
}

HashTable与HashMap的区别

比较点HashMapHashTable
推出时间JDK1.2之后推出，属于新的操作类JDK1.0时候推出，属于旧的操作类
性能采用异步处理方式，性能更高采用同步处理方式，性能较低
线程安全属于非线程安全的操作类3属于线程安全的操作类
空键允许将key设置为null不允许将key设置为null，否则将出现NullPointerException异常
mysql 集合_MySql集合查询
weixin_29416459的博客
01-18 1468
SELECT语句的查询结果是元组的集合，所以多个SELECT语句的结果可进行集合操作。集合操作主要包括并操作UNION、交操作INTERSECT、差操作EXCEPT。注意，参加集合操作的各查询结果的列数必须相同；对应的数据类型也必须相同。本示例中的数据表有student，sc，course三个，数据表的具体内容请看：UNION示例：例子1.1题目：查询计算机科学系的学生及年龄不大于19岁的学生。S...
集合概论
热门推荐
咔咔响
05-13 1万+
1.集合是具有某种特定性质，具体的或抽象的对象汇集的总体2.集合的表示有枚举法和描述法3.集合有三个性质——确定性，无序性，互异性4.集合S的所有元素都属于集合T，称S是T的子集5.如果...
Java集合类
qq_43220266的博客
08-05 146
Collection接口 Collection接口是单个集合保存的最大父接口 只是一个存储数据的标准 我们通常使用其子类 LIst Map List 接口 可以存放重复数据 方法1 list.get(index) 根据索引取得保存数据 方法2 list.set(index,value) 修改数据 由于LIst也是接口，我们想取得实例化对象，就必须有子类，ArrayList，Vector，L...
Programmer Log11[JAVA集合类]_19.10.28
qq_41097894的博客
10-28 103
1.Java类集实际上就属于动态对象数组 Collection接口：public boolean add(E e); 向集合中添加数据 public Iterator iterator(); 取得iterator对象，用于集合的输出 一般情况下会使用其子接口：List(允许数据重复) Set（不允许数据重复） 2.List接口 两个重要的扩充方法： public E get(int inde...
Java 集合反转
u011277123的博客
11-06 5078
java新人学习 2016-11-04 10:21 以下实例演示了如何使用 Collection 和 Listiterator 类的 listIterator() 和 collection.reverse() 方法来反转集合中的元素：/* author by w3cschool.cc Main.java */ import java.util.ArrayList; import
Java集合（二）List集合
jlnu_wanglei的博客
06-20 871
注：原博客 http://www.cnblogs.com/skywang12345/p/3323085.html，我仅是梳理做学习笔记 1.ArrayList集合 （1）ArrayList简介 java.lang.Object ↳ java.util.AbstractCollection ↳ java.util.AbstractList
【Java】ArrayList集合容器
君君的博客
03-05 808
虽然在Java中数组是运算速度最快的容器，但是在实际开发过程中，使用最频繁的数据容器并不是数组，而是ArrayList集合。它同样可以通过索引操作数据，但是方式不同，它比数组更方便，因为他的长度可变，并且可以调用功能强大的方法来满足不同需求。 一、ArrayList简介 1）ArrayList是实战开发中最为常用的持有数据工具。 2）ArrayList是Java集合框架体系(Java Col
python集合
weixin_41312759的博客
09-05 1237
冻结集合（Frozenset）是Python中的一种不可变集合类型。它与普通集合（set）非常相似，但有一个主要的区别：一旦创建了冻结集合，就不能对其进行修改（例如添加或删除元素）。冻结集合的主要用途是在需要确保集合内容不被意外更改的情况下使用，例如作为字典的键或其他集合的元素。由于冻结集合是不可变的，它们可以用作字典的键，而普通集合则不能。创建冻结集合：在这个例子中，我们通过将一个列表传递给函数来创建一个冻结集合。冻结集合的基本操作：# 检查元素是否在冻结集合中。
java集合详解
m0_74890428的博客
11-10 2826
本文主要介绍了集合类体系结构，主要包括Collection概述和使用，List集合的概述和使用，Set集合的概述和使用和Map集合的概述和使用。并且用代码实现了关键的步骤，详细地介绍类各种集合的遍历方法。
python集合是否可变总结
01-01
集合是一个无序的可变的序列。集合中的元素必须是可hash的，即不可变的数据类型。 空集合 a=set() 注意a={}创建的是一个空字典。 set —— 可变集合。集合中的元素可以动态的增加或删除。 frozenset —— 不可变...
大学离散数学实验集合运算.zip
01-06
【实验目的】掌握用计算机求集合的交、并、差和补运算的方法。 【实验内容】编程实现集合的交、并、差和补运算。 【实验原理和方法】 （1）用数组A，B，C，E表示集合。输入数组A，B，E（全集），输入数据时要求检查...
高中数学必修一集合练习题 .doc
11-15
"高中数学必修一集合练习题" 本资源摘要信息是关于高中数学必修一集合练习题的详细解释和知识点总结。 集合的基本概念 在高中数学必修一中，集合是数学中一个基本概念。集合是由一些特定元素组成的集合体，通常用...
c++程序设计实现集合交集并集差集.pdf
11-25
C++程序设计实现集合交集并集差集 本文主要介绍了使用 C++ 语言实现集合的交集、并集和差集运算。该程序设计了一个名为 int_set 的类，用于表示一个整数集合。该类中包含了多个成员函数，用于实现集合的基本运算，...
【算法图解】——集合覆盖问题
12-22
文章目录集合覆盖问题州集合，电台字典电台选择 集合覆盖问题 覆盖问题要求不会重复——采用set（） 假设你要办一个广播电台，要让所有的8个州都听到，你要选择广播电台，如何选择尽可能少的广播电台 州集合，...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 609
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 1109
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
最新发布
qq_36400213的博客
11-04 763
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 435
默认对常规Session的理解和使用，如何使用Set-Cookie。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值