集合框架（理论）

最新推荐文章于 2022-08-26 16:02:37 发布
最新推荐文章于 2022-08-26 16:02:37 发布
阅读量154 收藏
点赞数
分类专栏： 集合 文章标签： Collection List Set Map
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/The_Best_Hacker/article/details/89893215
版权

目录

一、集合

二、List

1.Vector

2.LinkedList

三、Set

1.HashSet

2.TreeSet 

四、Map

一、集合

集合和数组都为容器，有何不同？

  1. 数组虽为容器，但是数组的长度是固定的；集合长度是不固定的。
  2. 数组存储的是基本数据类型，集合存储的是对象（引用数据类型）。

集合特点：集合只存储对象，集合长度是可变的，集合可以存储不同类型的对象。

添加元素，参数类型为Object，以便接收任意类型对象。

集合中存储的都是对象的引用（地址）

打印集合名，eg：System.out.println(list);打印出来的是封装在[ ]之间，以“，”隔开的，已添加在集合中的对象内容。

常用集合分类图 

证实集合中存储的是对象的引用：

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

/**
 *
 * 证实集合中存储的是对象的引用
 */
public class Demo1 {
    public static void main(String[] args) {
        List<Student> list1=new ArrayList<>();
        List<Student> list2=new ArrayList<>();
        Student stu=new Student();
        list1.add(stu);
        list2.add(stu);
        
        for(Student s:list2){
            s.setId(10);
            s.setName("zhangsan");
        }

        for(Student s:list1){
            System.out.println(s.getId()+","+s.getName());
        }
    }
}

public class Student {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

相关基本操作：

添加元素：集合名.add();

删除元素：集合名.remove();

                  集合名.clear();//清空集合

判断长度：集合名.size();

判断元素：集合名.contains(元素);

                  集合名.isEmpty();//判断集合是否为空

取交集：集合1.retainAll(集合2)//集合1中只保留和集合2相同的部分

              集合1.removeAll(集合2)//集合1中只保留和集合2不同的部分

遍历集合：迭代器Iterator

1.
for(Iterator it=集合.iterator();it.hasNext();  ){
    System.out.println(it.next());
}

2.
Iterator it=集合.iterator();
while(集合.hasNext()){
    System.out.println(it.next());

}

二、List

特点：元素有序，元素可以重复，因为该集合体系有索引。

ArrayList——底层数据结构为数组结构；线程不安全

                      特点：查询快，增删慢

LinkedList——底层数据结构是链表结构；线程不安全

                        特点：查询慢，增删快

Vector——底层数据结构是数组结构；线程安全

                  特点：增删查询都比较慢（后被ArrayList代替）

List集合的特有方法（ 凡是可以操作角标的方法都是List集合体系特有的方法）

增：add(index,element)

       addAll(index,Collection)

删：remove(index)

改：set(index,element)

查：get(index)

       subList(from,to)//获取角标from到to这段元素（包含前不包含尾）

       ListIterator();列表迭代器

//获取所有元素
for（int x=0;x<集合.size;x++）{
    System.out.pritnln(集合.get(x));
}

并发访问：在迭代过程中，添加或删除元素，会引发并发修改异常

eg:在集合al中含有元素Java01,Java02,Java03;

Iterator it=al.iterator();

while(it.hasNext()){

            Object obj=it.next();

            if(obj.equals("java2")){

                         al.add("Java0005");

             }

              System.out.println(obj);进行判断

}

由上述示例可知：Iterator有局限性（在遍历过程中，只能进行判断，取出，移除 ）。所以引出了列表迭代器（ListIterator，是Iterator的子接口，List特有的迭代器）。

在迭代时，不可以通过集合对象的方法操作集合中的元素，否则会引起并发修改异。只能使用迭代器的方法操作元素，可是Iterator的方法是有限的，只能对元素进行判断，取出，删除操作。如果想要其他操作（如添加，修改等），就需要使用其子接口ListIterator。

ListIterator的特有方法：hasPrevious()逆向遍历列表。

1.Vector

枚举是Vector特有的方法（其实枚举和迭代是一样的）；

由于枚举的名称以及方法的名称都过于长。

Enumeration en=v.elements();//e为集合名称
while(en.hasMoreElements()){
    System.out.println(en.nextElement());
}

举例说明：

package listPackage;

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

public class Demo2 {
    public static void main(String[] args) {
        Vector<Student> v=new Vector<>();
        Student stu1=new Student(1,"zhangsan");
        Student stu2=new Student(2,"lisi");
        Student stu3=new Student(3,"wangwu");
        v.add(stu1);
        v.add(stu2);
        v.add(stu3);
        Enumeration en=v.elements();
        while(en.hasMoreElements()){
            System.out.println(en.nextElement());
        }
    }
}

public class Student {
    private int id;
    private String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

 输出：

Student{id=1, name='zhangsan'}
Student{id=2, name='lisi'}
Student{id=3, name='wangwu'}

2.LinkedList

  • 添加方法：

addFirst()//从链表集合的最前面添加进链表

addLast()//从链表集合的最后面添加进链表

  • 获取元素（不删除元素）

getFirst()//获取链表集合的第一个元素

getLast()//获取链表集合的最后一个元素

如果链表集合中没有元素，会出现NoSuchElementException

  • 获取元素（删除元素）

removeFirst()//返回链表集合的第一个元素（该元素会从链表中移除）

removeLast()//返回链表集合的最后一个元素（该元素会从链表中移除）

如果链表集合中没有元素，会出现NoSuchElementException

在JDK1.6出现了以上方法的替代方法：

  • 添加方法：

offerFirst()//从链表集合的最前面添加进链表

OfferLast()//从链表集合的最后面添加进链表

  • 获取元素（不删除元素）

peekFirst()//获取链表集合的第一个元素

peekLast()//获取链表集合的最后一个元素

如果链表集合中没有元素，会返回Null

  • 获取元素（删除元素）

pollFirst()//返回链表集合的第一个元素（该元素会从链表中移除）

pollLast()//返回链表集合的最后一个元素（该元素会从链表中移除）

如果链表集合中没有元素，会返回Null

遍历元素
while(!link.isEmpty()){
    System.out.println(link.getFirst())
}

利用LinkedList完成队列和堆栈的模拟：

https://blog.csdn.net/The_Best_Hacker/article/details/89954983 

 三、Set

特点：元素是无序的，存入与取出的顺序不一定一致，元素无重复。

HashSet——底层数据结构为哈希表；非线程安全

TreeSet——底层数据结构是二叉树；非线程安全

1.HashSet

HashSet中存入元素，保证元素的无重复，需要：

（1）重写hashCode()方法，改为自定义方法。因为HashSet存值是通过hash码开辟空间存的，所以改写的hashCode需返回同一个hash值。

如：
public int hashCode(){
    return name.hashCode()+age*11;
    //如果两元素哈希值不同，存入集合中； 若相同，调用equals方法，比较其内容是否相同，若相同则不存，            
    //若不同存入集合。  
}

（2）调用equals方法比较

public boolean equals(Object obj){
    if(!obj instanceof Person){
        return false;
    }
    Person p=(Person)obj;
    return this.name.equals(p.name)&&this.age==p.age;
}

举例：

package setPackage;

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

public class Demo1 {
    public static void main(String[] args) {
        Set<Student> set=new HashSet<>();
        Student stu1=new Student(1,"zhangsan");
        Student stu2=new Student(2,"lisi");
        Student stu3=new Student(3,"wangwu");
        Student stu4=new Student(1,"zhangsan");
        set.add(stu1);
        set.add(stu2);
        set.add(stu3);
        set.add(stu4);
        
        for(Student stu:set){
            System.out.println(stu.toString());
        }
    }
    
}


public class Student {
    private int id;
    private String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
    public int hashCode(){
        return id+name.hashCode();
    }
    
    public boolean equals(Object obj){
        if(!(obj instanceof Student)){
            return false;
        }
        Student stu=(Student)obj;
        return this.name.equals(stu.name)&&this.id==stu.id;
    }
}

 输出：

Student{id=2, name='lisi'}
Student{id=1, name='zhangsan'}
Student{id=3, name='wangwu'}

总结：

HashSet如何保证元素的唯一性？

HashSet是通过hashCode方法和equals方法完成的。

对于判断元素是否存在，依赖的是元素的hashCode和equals方法。

2.TreeSet 

可以对Set集合中的元素进行排序。注意：排序时，当主要条件相同时，一定要判断次要条件。TreeSet自身会除掉重复元素，不需要重写方法。

TreeSet排序的第一种方式（Compareable）：让元素自身具备比较性。元素需要实现Comparable接口，覆盖CompareTo方法。这种方式也称为元素的自然排序或者叫做默认排序。

TreeSet排序的第二种方式(Comparator)：当元素自身不具有比较性，或者具备的比较性不是做需要的。这时就需要让集合自身具备比较性(例如：Set<Student> set=new TreeSet<>(new MyComparator))。在集合初始化时，就有了比较方式。定义比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。定义一个类实现Comparator接口，覆盖compare方法。

当两种排序都存在的时候（按元素排序，按集合排序），以比较器Comparator为主。

例如：

package setPackage;

import java.util.Set;
import java.util.TreeSet;

public class Demo3 {
    public static void main(String[] args) {
        
        Set<Person> ts=new TreeSet<>(new MyCompare());
        Person t1=new Person(12,"zhangsan");
        Person t2=new Person(21,"lisi");
        Person t3=new Person(33,"wangwu");
        Person t4=new Person(14,"zhangsan");
        Person t5=new Person(12,"zhangsan");

        ts.add(t1);
        ts.add(t2);
        ts.add(t3);
        ts.add(t4);
        ts.add(t5);
        

        for(Person p:ts){
            System.out.println(p.toString());
        }

    }
}

package setPackage;


public class Person implements Comparable{
//排序方式，按照id的大小排序
    private int id;
    private String sname;

    public Person(int id, String sname) {
        this.id = id;
        this.sname = sname;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", sname='" + sname + '\'' +
                '}';
    }

    public int compareTo(Object obj){
        if(!(obj instanceof Person)){
            throw new RuntimeException("非人类信息");
        }
        Person stu=(Person)obj;
        if(this.id>stu.id){
            return 1;
        }
        if(this.id==stu.id){
            return this.sname.compareTo(stu.sname);
        }
        return -1;
    }
}

package setPackage;

import java.util.Comparator;

public class MyCompare implements Comparator {
//排序方式：按照人名的字母排序
    public int compare(Object obj1,Object obj2){
        
        if(!((obj1 instanceof Person)||(obj2 instanceof Person))){
            throw new RuntimeException("含有不属于人的信息");
        }
        Person t1=(Person)obj1;
        Person t2=(Person)obj2;
        
        int num=t1.getSname().compareTo(t2.getSname());
        if(num==0){
            return t1.getId()-t2.getId();
        }
        return num;
    }
}

输出：

Student{id=21, sname='lisi'}
Student{id=33, sname='wangwu'}
Student{id=12, sname='zhangsan'}
Student{id=14, sname='zhangsan'} 

具体示例见：https://blog.csdn.net/The_Best_Hacker/article/details/89970061

若要输出集合（怎样加进去，怎样输出来，即：先入先出）
public int compareTo(Object obj){
    return 1;
}
若要输出集合（先入后出）
public int compareTo(Object obj){
    return -1;
}

四、Map

Map集合：该集合存储键值对。一对一对的存，而且要保证键的唯一性。（键与值之间用=相连）。

HashTable——底层数据结构是哈希表，不可以存入null作为键值。（同步安全，效率低）

HashMap——底层数据结构是哈希表，可以存入null键和null值。（不同步不安全，效率高）

TreeMap——底层数据结构是二叉树，可以用于给Map中的键进行排序。（不同步不安全，效率高）

常用方法：

  • 1.添加

put(k,v)：返回键对应的原来值，刚开始添加的时候，返回的是null，若是同一键值，则后添加的会覆盖原有的键值，并返回被覆盖的值

putAll(Map<? extends K,? extends Value>  m)：向集合中添加元素，元素为集合类型

  • 2.删除

clear()//清空集合

remove(Object obj)//删除键对应的元素，若集合不存在key，则返回null

  • 3.判断

containsValue(Object value)//判断集合是否存在value

containsKey(Object key)//判断集合是否存在key

isEmpty()//判断集合是否为空

  • 4.获取

get(Object key)//可以通过get方法返回值判断一个值是否存在，通过返回null来判断。

size()//获取集合的大小，包含多少个元素

values()//返回的是一个包含所有value的集合

遍历集合

keySet：将map中所有键存入Set集合中，因为Set集合具备迭代器。

               Set<String> keySet=map.keySet();

               Iterator it=keySet.iterator();

               while(it.hasNext()){

                              System.out.println(map.get(it.next()));

               }

               Map集合的取出原理：将map集合转成set集合，再通过迭代器取出。

entrySet:将map集合的映射关系存入到Set集合，而这个关系的数据类型为Map.Entry

               Set<Map.Entry<String,String>> entrySet=map.entrySet();

               Iterator<Map.Entry<String,String>> it=entrySet.iterator();

               while(it.hasNext()){

                              Map.Entry<String,String>   me=it.next();

                              System.out.println(me.getKey()+"...."+me.getValue());

               }

               Map集合的取出原理：先获取Map.Entry关系，在通过Map.Entry中的getKey()和getValue()方法获取关系中的键和值。

举例：

package mapPackage;

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

public class Demo1 {
    public static void main(String[] args) {
        Map<Integer,String> map=new Hashtable<>();
        map.put(1,"我爱学习");
        map.put(2,"沉迷学习");
        map.put(3,"无法自拔");
        map.put(1,"学习爱我");
        
       /* //遍历集合:通过迭代器遍历
        Set<Integer> set=map.keySet();
        Iterator it=set.iterator();
        while(it.hasNext()){
            System.out.println(map.get(it.next()));
        }
        无法自拔
        沉迷学习
        学习爱我

        */
        
        //entrySet:将map集合的映射关系存入到Set集合，而这个关系的数据类型为Map.Entry
        Set<Map.Entry<Integer,String>> entry=map.entrySet();
        Iterator<Map.Entry<Integer,String>> it=entry.iterator();
        while(it.hasNext()){
            Map.Entry<Integer,String> me=it.next();
            System.out.println(me.getKey()+","+me.getValue());
        }
    }
}

 输出：

3,无法自拔
2,沉迷学习
1,学习爱我

The_Best_Hacker
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA 用集合框架完成电话本管理系统
08-08
在Java编程中，集合框架是处理对象集合的重要工具，它为数据存储、操作和管理提供了高效且灵活的方式。电话本管理系统是一个典型的示例，利用集合框架可以实现对联系人信息的有效管理和检索。在这个项目中，我们将...
学士后Java集合框架和泛型课后习题答案
02-28
10. **CollectionHomework**：这个文件可能包含了关于集合框架和泛型的习题解答，涵盖了上述各个知识点的实际应用，通过解题可以帮助巩固理论知识并提升实践能力。 通过学习和练习这些内容，你可以深入理解Java集合...
STL(标准模板库)理论基础
一路向北
03-20 489
10.1.1基本概念 STL（Standard Template Library，标准模板库)是惠普实验室开发的一系列软件的统称。现然主要出现在C++中，但在被引入C++之前该技术就已经存在了很长的一段时间。 STL的从广义上讲分为三类：algorithm（算法）、container（容器）和iterator（迭代器），容器和算法通过迭代器可以进行无缝地连接。几乎所有的代码都采 用了模板类和模...
Django框架之templates（模板）系统
MS1997的博客
03-29 314
一、什么是模板？ 只要是在html里面有模板语法就不是html文件了，这样的文件就叫做模板。 二、常用语法 只需要记两种特殊符号： {{ }}和{% %} 变量相关的用{{}}，逻辑相关的用{%%}。 变量 在Django的模板语言中按此语法使用：{{ 变量名 }}。 当模版引擎遇到一个变量，它将计算这个变量，然后用结果替换掉它本身。（可以理解为模板页面中先...
Java集合框架的概述
自强博客
06-17 451
概述： 主要介绍java的集合类（不含线程安全的部分）。它是一个使用很频繁的工具，同时还涉及相应的数据结构和算法知识。因此彻底掌握还是很有必要的。作为介绍集合框架的开篇，我想是从整个框架结构上去做一下简单的介绍。因此，这一部分可以先做个了结。学完之后，回过头来可以再根据自己的理解结合这一部分自己去总结。 一、关于java集合涉及到的基本数据结构和算法的理论（这里只是稍微提
Java—集合框架图
一朵花花
09-15 951
Java集合框架图 关系： 接口与接口：extends； 类和接口：implements 注意： Collection ：用来存储管理一组对象 objects ，这些对象一般被成为元素 elements Set : 元素不能重复，背后隐含着查找 / 搜索的语义，若有重复，只算一个 SortedSet : 一组有序的不能重复的元素 List : 线性结构 Queue : 队列 Deque : 双端队列 Map : 键值对 Key-Value-Pair ，背后隐含着查找/搜索的语
Java集合框架知多少?
极客星云-CSDN博客
10-24 1640
Java 集合框架理论篇
集合框架学习
m0_59788935的博客
08-15 1118
集合框架学习
java集合框架面试
琼华
04-13 2379
Java集合框架（例如基本的数据结构）里包含了最常见的Java常见面试问题。很好地理解集合框架，可以帮助你理解和利用Java的一些高级特性。下面是面试Java核心技术的一些很实用的问题。 Q：最常见的数据结构有哪些，在哪些场景下应用它们？ A. 大部分人都会遗漏树和图这两种数据结构。树和图都是很有用的数据结构。如果你在回答中提及到它们的话，面试者可能会对你进行进一步进行的考核。
Java岗大厂面试百日冲刺 - 日积月累，每日三题【Day19】—— 集合框架3
热门推荐
陈哈哈的菜园子
07-05 1万+
百日闭关修炼，每日三道高频面试题。一起冲进大厂！看什么看？快上车！
贝叶斯理论框架综述
最新发布
就很秃然
08-26 3557
对高效全局优化(Efficient Global Optimization,EGO)有了更全面的理解，该优化方法与贝叶斯推理有着密切的联系。文章从所应用的数据类型(离散和连续)出发，回顾了贝叶斯方法在离散空间和在连续空间中具有代表性的应用方法。在离散空间中，贝叶斯往往依赖于频率统计和先验条件的假设，文章简要描述了离散条件下贝叶斯推理的应用场景和先置条件。在对数据类型为连续型的背景中，贝叶斯推理方法更依赖于对连续分布的建立，文章侧重的探讨了贝叶斯似然函数是否可计算的两种情况中的推理原理，以及应用背景和区别。.
JAVA 笔记（三） 从源码深入浅出集合框架
LaterEqualsNever
05-25 5232
集合框架概述以Java来说，我们日常所做的编写代码的工作，其实基本上往往就是在和对象打交道。 但显然有一个情况是，一个应用程序里往往不会仅仅只包含数量固定且生命周期都是已知的对象。 所以，就需要通过一些方式来对对象进行持有，那么通常是通过怎么样的方式来持有对象呢？ 通过数组是最简单的一种方式，但其缺陷在于：数组的尺寸是固定的，即数组在初始化时就必须被定义长度，且无法改变。 也就说，通过数组来
08-《集合框架-1》.rar
09-17
在Java编程语言中，集合框架是开发者日常工作中不可或缺的一部分，它提供了一种高效管理对象的方式。本教程“08-《集合框架-1》”旨在深入讲解Java集合框架的基础概念和核心类，帮助学习者掌握如何在实际项目中有效...
NET理论集合
06-30
.NET理论集合是一个全面涵盖.NET框架基础和进阶概念的知识资源，非常适合初学者和有经验的开发者深入理解.NET技术栈。这个资料集包含了丰富的.NET理论，包括但不限于编程模型、类库、运行时环境、垃圾回收机制、多...
java集合框架全面进阶[归纳].pdf
10-12
集合框架的概念源于数学中的集合理论。集合是一组独特的元素，不允许重复，这对应于Java中的Set接口及其实现。映射则是一种特殊的集合，其中每个元素都是一个键值对，代表一个从一个元素到另一个元素的单向映射，...
针对LinkedList的四种遍历方法
The_Best_Hacker的博客
08-02 1万+
【题目要求】请编写程序，将自定义对象存储到LinkedList集合，使用泛型并遍历                      a) 使用迭代器遍历                      b) 使用列表迭代器遍历                      c) 使用size()和get()方法遍历                      d) 使用增强for遍历 Linked...
针对Vector集合的四种遍历方法
The_Best_Hacker的博客
08-02 1824
【题目要求】请编写程序，将自定义对象存储到Vector集合，使用泛型并遍历                     a) 使用迭代器遍历                     b) 使用Vector特有的迭代器遍历                     c) 使用size()和get()方法遍历                     d) 使用增强for遍历 Vector:...
ArrayList练习：存入对象到ArrayList集合中，去除对象中的重复元素
The_Best_Hacker的博客
05-08 1573
【需求】：存入对象到ArrayList集合中，去除对象中的重复元素 对象：Person 条件：同名同年龄视为同一对象 【分析】： 首先判断姓名，姓名不同则为不同元素。 如果姓名相同，则判断年龄，如果年龄相同，则为同一元素；反之，为不同元素。 实现——原集合为集合1，新集合为集合2 创建...
ArrayList练习：去除集合中的重复元素
The_Best_Hacker的博客
05-08 1106
【需求】：去除集合中的重复元素 【分析】：去除集合中的重复元素，只需要新建一个集合，将原集合的元素在加入新集合的过程中进行判断，判断新集合中是否包含该即将加入的元素，如果不包含则加入。最后返回新集合即可。 【代码实现】： import java.util.*; class ArrayListDemo { public static List singleElement(ArrayLis...
Java集合框架详解与实战应用
这份笔记的价值在于它不仅包含代码实例，还强调了理论知识的讲解，帮助学习者理解和掌握Java集合框架的精髓，从而更好地应用于实际开发中。如果你对视频课程感兴趣，可以通过私聊获取更多资源。尽管积分不高，但笔记...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值