Java集合详解（一）：Collection

2024-06-01 11:08
文章标签 java collection 详解 集合

本文主要是介绍Java集合详解（一）：Collection，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Java集合详解（一）：Collection

 

 

 

 



 

1.集合简介

集合类的由来：

对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定。就使用集合容器进行存储。

 

 

 

集合的特点：

  1. 用于存储对象的容器。
  2. 集合的长度是可变的。
  3. 集合中不可以存储基本数据类型值。

 

集合容器因为内部的数据结构不同，有多种具体容器。

不断的向上抽取，就形成了集合框架。

 

 

集合体系：

  •    集合是对各个容器不断向上抽取产生的一个体系框架
  •    集合的长度是可变的，集合可以存储多种类型的对象。
  •    创建集合对象的时候要使用具体的子类。
  •    抽取的过程中形成顶级父类是抽象，是接口；子类可以提供更加 丰富的方法。

 

 

 

Collection框架图：

 

 

 

 

Collection集合子类比较：

Collection

 |--List: 可以存放有序的对象，并且对象可以重复

     |--ArrayList:   底层实现是数组，查询效率要高（因为有索引下标），线程不安全，jdk1.2， 增长是50%（即如果越界，则底层数组增加原来的50%）

     |--vector:   底层实现也是数组，线程安全，所以查询效率要比ArrayList要低，jdk1.0 出现

          使用ArrayList来对我们的vector进行了升级，所以建议大家使用ArrayList； 100%增长（即如果越界，则底层数组增加原来的100%）

     |--LinkedList:   底层实现是链表，查询效率要比ArrayList低

      ArrayList： 查询快，增删慢

      LinkedList： 查询慢，增删快

      Vector： 两个都慢

 |--Set:  存放的元素是没有顺序的，元素不能重复

 

 

 

 

 

 

 

 

2.Collection子类代码示例：

List:

  • ArryList
  • LinkedList
  • Vector


ArrayList

代码示例：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;public class MyArrayListDemo {public static void main(String[] args) {List list = new ArrayList();        //创建一个ArrayList对象listlist.add("zhangsan");        //往list内添加元素list.add("lisi");list.add("wangwu");printList(list);}public static void printList(List list) {Iterator itr = list.iterator();    //使用list的迭代器进行list内元素的遍历while (itr.hasNext()) {            //判断迭代器中是否还有元素System.out.println(itr.next());     //如果迭代器有元素，则取出这个元素并打印}}
}


 

LinkedList

代码示例：

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;public class MyArrayListDemo {public static void main(String[] args) {LinkedList list = new LinkedList();        //创建一个LinkedList对象list.add("zhangsan");        //往list内添加元素list.add("lisi");list.add("wangwu");printList(list);}public static void printList(List list) {Iterator itr = list.iterator();    //使用list的迭代器进行list内元素的遍历while (itr.hasNext()) {            //判断迭代器中是否还有元素System.out.println(itr.next());     //如果迭代器有元素，则取出这个元素并打印}}
}

 

Vector

代码示例:

import java.util.Enumeration;
import java.util.Vector;public class MyArrayListDemo {public static void main(String[] args) {Vector vector = new Vector();       //创建Vector对象vectorvector.addElement("zhangsan");      //往vector中添加对象vector.addElement("lisi");vector.addElement("wangwu");printVector(vector);}/*** 这是Vector中特有的遍历方式。当然，也可以使用之前的迭代器方法遍历* @param vector*/public static void printVector(Vector vector) {Enumeration elems = vector.elements();     //获取vector中所有元素while (elems.hasMoreElements()) {           //判断vector中是否还有元素System.out.println(elems.nextElement());      //如果有，则打印这个元素}}
}



Set:

  • HashSet
  • TreeSet


HashSet

代码示例：

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;public class MyArrayListDemo {public static void main(String[] args) {Set hashSet = new HashSet();//创建HashSet对象hashSethashSet.add("java01");//往hashSet中添加对象hashSet.add("java02");hashSet.add("java02");hashSet.add("java03");sop(hashSet);}/*** set：set集合中的数据没有顺序（存入的顺序和取出后的顺序没有关系），没有重复的元素*        只能使用Iterator的方式来遍历其中的元素*  |--HashSet：底层是有哈希表hash表来维护，*/public static void sop(Collection col) {Iterator it = col.iterator();       //使用col的迭代器while(it.hasNext()) {	//判断是否还有元素System.out.println(it.next());	//如果有元素则取出打印}}
}

由于Set集合中数据没有顺序 ，所以打印结果不确定。

 

 

TreeSet

代码示例：

import java.util.Collection;
import java.util.Iterator;
import java.util.TreeSet;public class MyArrayListDemo {public static void main(String[] args) {TreeSet treeset = new TreeSet();	//初始化一个TreeSet对象treesettreeset.add("java03");	//往treeset中添加元素treeset.add("java02");treeset.add("java04");treeset.add("java01");sop(treeset);}/*** |--TreeSet：可以对我们Set集合进行排序。*       用String做例子，我们发现，这种排序是对字符串进行的自然排序*/public static void sop(Collection col) {Iterator it = col.iterator();      //使用col的迭代器while(it.hasNext()) {//判断是否还有元素System.out.println(it.next());//如果有元素则取出打印}}
}

打印结果为：

java01

java02

java03

java04

 

 

 

3.List中contains()和remove()方法原理

 

           List比较两个元素相等，实际上比较的是元素的hashCode()和equals()方法。remove()/contains()都比较的是hashCode()和equals()方法。比较时程序会先比较hashCode()，若不同，则两个对象不同，若hashCode()相同，则继续比较equals()方法。

我们可以通过重写hashCode()和equals()方法，实现List判断是否存在相同的对象，例如Person(name,age)。

 

代码示例：

@Override
public int hashCode() {//hashCode值定义为相同的值System.out.println(this.name + "---------");return name.hashCode() + age * 31;
}@Override
/*** obj  : 要比较的对象*/
public boolean equals(Object obj) {if (obj == null) {return false;}if (!(obj instanceof Person)) {return false;}Person p = (Person) obj;return this.name.equalsIgnoreCase(p.name) && this.age == p.age;
}


 

4.TreeSet中的比较器

TreeSet中可以使用Comparable和Comparator来实现Set集合的排序。

 Comparable和Comparator区别：

 

在jdk的位置：

  •  Comparable是在java.lang包下的一个接口
  •  Comparator是在java.util包下的一个接口

 

使用场景：

  •   如果要让我们的对象（集合元素）具备一个比较性，这个时候就需要用到了Comparable接口
  •   如果要让我们的集合能够比较集合中的元素，这时就需要使用Comparator

 

 

Comparable代码示例：

import java.util.Collection;
import java.util.Iterator;
import java.util.TreeSet;public class MyArrayListDemo {public static void main(String[] args) {TreeSet tst = new TreeSet();        //初始化TreeSet对象tsttst.add(new Employee("zs06", 18));  //往tst中添加元素tst.add(new Employee("zs02", 17));tst.add(new Employee("zs03", 48));tst.add(new Employee("zs01", 18));tst.add(new Employee("zs02", 28));tst.add(new Employee("zs01", 28));sop(tst);}//打印集合内的元素public static void sop(Collection col) {Iterator it = col.iterator();while (it.hasNext()) {Employee p = (Employee) it.next();System.out.println(p.getAge() + "\t" + p.getName());}}}/*** 创建一个实现了Comparable接口比较器方法的Employee类*/
class Employee implements Comparable {private String name;private int age;public Employee() {}public Employee(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Override           //重写Comparable接口中的ComparaTo方法，使得Employee对象能够相互比较public int compareTo(Object obj) {if (obj == null) {throw new RuntimeException("没有对象");}if (!(obj instanceof Employee)) {throw new RuntimeException("不是同一种类型");}Employee employee = (Employee) obj;int num = this.age - employee.age;//先按照年龄进行排序，如果相等，就再按照name的字典顺序排序if (num == 0) {num = this.name.compareTo(employee.name);}return num;}
}


 

Comparator代码示例：

import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;public class MyArrayListDemo {public static void main(String[] args) {TreeSet tst = new TreeSet(new MyComParator());        //初始化TreeSet对象tsttst.add(new Employee("zs06", 18));  //往tst中添加元素tst.add(new Employee("zs02", 17));tst.add(new Employee("zs03", 48));tst.add(new Employee("zs01", 18));tst.add(new Employee("zs02", 28));tst.add(new Employee("zs01", 28));sop(tst);}public static void sop(Collection col) {Iterator it = col.iterator();   //通过使用迭代器打印出集合中的元素while (it.hasNext()) {Employee employee = (Employee) it.next();System.out.println(employee.getAge() + "\t" + employee.getName());}}}class Employee {private String name;private int age;public Employee() {}public Employee(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}//通过实现Comparator接口构造一个比较器MyComparator
class MyComParator implements Comparator {@Overridepublic int compare(Object o1, Object o2) {Employee em1 = (Employee) o1;Employee em2 = (Employee) o2;int result = new Integer(em1.getAge()).compareTo(new Integer(em2.getAge()));//先比较年龄，如果年龄相同，则比较姓名if (result == 0) {result = em1.getName().compareTo(em2.getName());}return result;}
}

 


5.应用

使用LinkedList实现自己的堆栈：

/*** 使用LinkedList实现堆栈*/
class MyStack {private LinkedList list;//初始化堆栈public MyStack() {list = new LinkedList();}//存入数据public void myPush(Object obj) {   list.addLast(obj);}//取出数据public Object myPop() {return list.removeLast();   //此处若改为list.removeFirst() ，则为队列结构}//判断堆栈是否为空public boolean isNull() {return list.isEmpty();}
}


 

 

6.集合常见方法

框架的顶层Collection接口：

Collection的常见方法：

1，添加。

boolean add(Object obj):
boolean addAll(Collection coll):

2，删除。

boolean remove(object obj):boolean removeAll(Collection coll);
void clear();

3，判断：

boolean contains(object obj):boolean containsAll(Colllection coll);boolean isEmpty():  //判断集合中是否有元素。

4，获取：

int size():Iterator iterator():  //取出元素的方式：迭代器。


该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。

所以该迭代器对象是在容器中进行内部实现的。

对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的 对象即可，也就是iterator方法。

Iterator接口就是对所有的Collection容器进行元素取出的公共接口。

5，其他：

boolean retainAll(Collection coll);//取交集。Object[] toArray(): //将集合转成数组。

 

Collection

|--List：有序(存入和取出的顺序一致),元素都有索引(角标)，元素可以重复。

|--Set：元素不能重复,无序。

 

List:特有的常见方法：

有一个共性特点就是都可以操作角标。

1，添加

void add(index,element);void add(index,collection);

2，删除；

Object remove(index):

3，修改：

Object set(index,element);

4，获取：

Object get(index);int indexOf(object);int lastIndexOf(object);List subList(from,to);

list 集合是可以完成对元素的增删改查。

 

 

 

LinkedList特有方法：

1，添加： jdk1.6以后

addFirst(); offerFirst();addLast(); offerLast();

2,获取： jdk1.6以后

getFirst(): peekFirst();getLast(); peekLast();
获取元素，集合的长度不改变。

如果集合中没有元素，那么该方法会发生异常NoSuchElementException

如果集合元素没有，该方法不会抛出异常，而是返回null。


3，删除： jdk1.6以后

removeFirst(): pollFirst();removeLast(); pollLast();
获取元素，但是该元素会被删除出集合，集合的长度会改变。

如果集合中没有元素，那么该方法会发生异常NoSuchElementException

如果集合元素没有，该方法不会抛出异常，而是返回null。

 

 

List集合子类-Vector

Vector已经不常用了，我们就说里面的一个方法，Elements方法。这个方法的返回值是枚举接口，里面有两个方法，判断和获取。

Vector中提供了一个独特的取出方式，就是枚举Enumeration。此接口Enumeration的功能与 Iterator 接口的功能是重复的。

Enumeration的名称和方法的名称过程，书写很麻烦。所以被Iterator所取代。

 

 

 

7.总结

List:

  • |--Vector: 内部是数组数据结构，是同步的。增删，查询都很慢！. 100%增长
  • |--ArrayList: 内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。50%增长
  • |--LinkedList: 内部是链表数据结构，是不同步的。增删元素的速度很快。

2：数组和链表的区别

当向数组中插入一个元素的时候，插入位置后面的元素都要往后移一位。元素越多越慢。

如果是链表的话，插入一个新元素，只需要让插入的元素记住前一个元素的位置，后一个元素记住插入元素的位置即可，非常简单快速。

删除也特别简单，只需要让后一个元素记住前一个元素的位置即可。中间的元素就删掉了。

总结：

  • 链表：增删快，查询慢
  • 数组：增删慢，查询快

 

 

 

Set:

元素不可以重复，是无序。

Set接口中的方法和Collection一致。

注意：set集合取出元素的方法只有迭代器。

|--HashSet: 内部数据结构是哈希表 ，是不同步的。


如何保证该集合的元素唯一性：

  • 是通过对象的hashCode和equals方法来完成对象唯一性的。
  • 如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。
  • 如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
  • 如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存 储。


记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。

一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖 equals，hashCode方法。

建立对象判断是否相同的依据。

Set常用的子类是HashSet和TreeSet

应用场景：假设要存储的元素必须是唯一的，这个时候就可以使用set集合。

 

 

 

 

 

 

 

 

 

这篇关于Java集合详解（一）：Collection的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1020831。

相关文章

Java五子棋之坐标校正

Java五子棋之坐标校正

上篇针对了Java项目中的解构思维，在这篇内容中我们不妨从整体项目中拆解拿出一个非常重要的五子棋逻辑实现：坐标校正，我们如何使漫无目的鼠标点击变得有序化和可控化呢？ 目录 一、从鼠标监听到获取坐标 1.MouseListener和MouseAdapter 2.mousePressed方法 二、坐标校正的具体实现方法 1.关于fillOval方法 2.坐标获取 3.坐标转换 4.坐
阅读更多...
Spring Cloud：构建分布式系统的利器

Spring Cloud：构建分布式系统的利器

引言 在当今的云计算和微服务架构时代，构建高效、可靠的分布式系统成为软件开发的重要任务。Spring Cloud 提供了一套完整的解决方案，帮助开发者快速构建分布式系统中的一些常见模式（例如配置管理、服务发现、断路器等）。本文将探讨 Spring Cloud 的定义、核心组件、应用场景以及未来的发展趋势。 什么是 Spring Cloud Spring Cloud 是一个基于 Spring
阅读更多...
Javascript高级程序设计(第四版)--学习记录之变量、内存

Javascript高级程序设计(第四版)--学习记录之变量、内存

原始值与引用值 原始值：简单的数据即基础数据类型，按值访问。 引用值：由多个值构成的对象即复杂数据类型，按引用访问。 动态属性 对于引用值而言，可以随时添加、修改和删除其属性和方法。 let person = new Object();person.name = 'Jason';person.age = 42;console.log(person.name,person.age);//'J
阅读更多...
java8的新特性之一（Java Lambda表达式）

java8的新特性之一（Java Lambda表达式）

1：Java8的新特性 Lambda 表达式： 允许以更简洁的方式表示匿名函数（或称为闭包）。可以将Lambda表达式作为参数传递给方法或赋值给函数式接口类型的变量。 Stream API： 提供了一种处理集合数据的流式处理方式，支持函数式编程风格。 允许以声明性方式处理数据集合（如List、Set等）。提供了一系列操作，如map、filter、reduce等，以支持复杂的查询和转
阅读更多...
Java面试八股之怎么通过Java程序判断JVM是32位还是64位

Java面试八股之怎么通过Java程序判断JVM是32位还是64位

怎么通过Java程序判断JVM是32位还是64位 可以通过Java程序内部检查系统属性来判断当前运行的JVM是32位还是64位。以下是一个简单的方法： public class JvmBitCheck {public static void main(String[] args) {String arch = System.getProperty("os.arch");String dataM
阅读更多...
详细分析Springmvc中的@ModelAttribute基本知识（附Demo）

详细分析Springmvc中的@ModelAttribute基本知识（附Demo）

目录 前言1. 注解用法1.1 方法参数1.2 方法1.3 类 2. 注解场景2.1 表单参数2.2 AJAX请求2.3 文件上传 3. 实战4. 总结 前言 将请求参数绑定到模型对象上，或者在请求处理之前添加模型属性 可以在方法参数、方法或者类上使用 一般适用这几种场景： 表单处理：通过 @ModelAttribute 将表单数据绑定到模型对象上预处理逻辑：在请求处理之前
阅读更多...
eclipse运行springboot项目，找不到主类

eclipse运行springboot项目，找不到主类

解决办法尝试了很多种，下载sts压缩包行不通。最后解决办法如图： help--->Eclipse Marketplace--->Popular--->找到Spring Tools 3---->Installed。
阅读更多...
JAVA读取MongoDB中的二进制图片并显示在页面上

JAVA读取MongoDB中的二进制图片并显示在页面上

1：Jsp页面： <td><img src="${ctx}/mongoImg/show"></td> 2：xml配置： <?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001
阅读更多...
Java面试题：通过实例说明内连接、左外连接和右外连接的区别

Java面试题：通过实例说明内连接、左外连接和右外连接的区别

在 SQL 中，连接（JOIN）用于在多个表之间组合行。最常用的连接类型是内连接（INNER JOIN）、左外连接（LEFT OUTER JOIN）和右外连接（RIGHT OUTER JOIN）。它们的主要区别在于它们如何处理表之间的匹配和不匹配行。下面是每种连接的详细说明和示例。 表示例 假设有两个表：Customers 和 Orders。 Customers CustomerIDCus
阅读更多...
22.手绘Spring DI运行时序图

22.手绘Spring DI运行时序图

1.依赖注入发生的时间 当Spring loC容器完成了 Bean定义资源的定位、载入和解析注册以后,loC容器中已经管理类Bean 定义的相关数据，但是此时loC容器还没有对所管理的Bean进行依赖注入，依赖注入在以下两种情况 发生： 、用户第一次调用getBean()方法时，loC容器触发依赖注入。 、当用户在配置文件中将＜bean＞元素配置了 lazy-init二false属性,即让
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2