java 集合存储的原理 java中集合的概念

转载

liutao988 2023-08-19 23:23:06

文章标签 java 集合存储的原理 java 中的集合 System bc List 文章分类 Java 后端开发

JAVA中集合，是java中的基础概念，今天接着跟讲课准备课件的机会，重新整理一下关于JAVA中的集合的概念。

集合的概念

java中的集合类是用来存放对象的

集合相当于一个容器，里面包容着一组对象--容器类

其中的每个对象作为集合的一个元素出现

java API提供的集合类位于java.util包中

java中集合和数组的比较

数组也是容器，它是定长，访问较快，但是数组不会自动扩充

数组可以包含基本数据类型或者是引用类型的对象，而集合中只能包含引用类型的对象

为了容纳一组对象，最适宜的选择应当是数组。而且假如容纳的是一系列基本数据类型，更是必须采用数组。当我们编写程序时，通常并不能确切地知道最终需要多少个对象。有些时候甚至想用更复杂的方式来保存对象。为解决这个问题，Java提供了集合框架。

集合的特点：

用于存储对象的容器。

集合长度是可变的

集合中不可以存储基本数据类型值，只能存储对象

集合的学习目标

(1)集合本身是一个存储的容器

(2)必须使用集合存储对象

(3)遍历集合,取出对象

(4)集合体系中有很多的集合，每个集合都有自己的特性，要知道每个集合有什么特点。

集合类型主要有3种：set(集)、list(列表)和map(映射)。

JAVA中的集合框架

java 集合存储的原理 java中集合的概念_List

java 集合存储的原理 java中集合的概念_java 中的集合_02

集合容器因为内部的数据结构不同，有多种具体容器。不断的向上抽取，就形成了集合框架。

java 集合存储的原理 java中集合的概念_System_03

Collection接口

我们先来看集合体系中最顶层的接口 Collection接口

Collection是层次结构中的根接口，Collection表示一组对象，这些对象也称为Collection中的元素，一些collection允许有重复的元素，如List，而有一些是不允许有重复元素，一些事有序的，一些是无序的，List派系的集合就是有序的，而Set接口集合里面的是无序的。

我们先学习他们共性的东西，Collection接口

Collection的功能由它实现类决定

1. List允许重复,有序(先添加在前,后添加的元素位置在后)

2. Set不允许重复,无序(跟添加的先后无关，只跟元素本身的hashCode值)

Collection接口中的方法，这些方法是集合中所有实现类必须拥有的方法 Collection接口中的方法都是抽象方法，所以使用Collection接口的实现类 例如：ArrayList implements List List extends Collection 方法的执行,都是实现的重写
add(); 向集合添加数据
toArray();集合中的元素,转成一个数组中的元素, 集合转成数组
clear(); 清空集合中的所有的元素
remove(); boolean remove(Object o)移除集合中指定的元素
contains(Object obj); 判断对象是否是存在集合中，对象存在返回true size();
我们通过一个简单的例子来演示一下方法的具体的使用
//toArray()方法和clear()方法
private static void function() {
Collection coll = new ArrayList();
coll.add("abc");
coll.add("def");
coll.add("ghi");
coll.add("gkl");
coll.add("mno");
Object[] objs = coll.toArray();
for(int i = 0 ; i < objs.length ; i++){
System.out.println(objs[i]);
}
}
* void clear() 清空集合中的所有元素
public static void function(){
Collection coll = new ArrayList();
coll.add("abc");
coll.add("bcd");
System.out.println(coll);
coll.clear();
System.out.println(coll);
}

Iterator迭代器

在Java中，有很多的数据容器，对于这些的操作有很多的共性。Java采用了迭代器来为各种容器提供了公共的操作接口。这样使得对容器的遍历操作与其具体的底层实现相隔离，达到解耦的效果。使用迭代器我们可以很方便的对集合的元素进行遍历，一次取出集合中的元素。

我们通过查看API可以发现，Iterator中定义了三个方法

java 集合存储的原理 java中集合的概念_List_04

我们通过一个例子来演示Iteraror的使用方法

public classIteratorDemo {public static voidmain(String[] args) {
Collection coll = new ArrayList();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
coll.add("abc4");//迭代器,对集合ArrayList中的元素进行取出//调用集合的方法iterator()获取出,Iterator接口的实现类的对象
Iterator it =coll.iterator();//接口实现类对象,调用方法hasNext()判断集合中是否有元素
boolean b =it.hasNext();
System.out.println(b);//接口的实现类对象,调用方法next()取出集合中的元素String s = it.next();
System.out.println(s);//迭代是反复内容,使用循环实现,循环的条件,集合中没元素, hasNext()返回了false
while(it.hasNext()){
String s=it.next();
System.out.println(s);
}}
}

在Iterator中主要是使用一个面向接口编程的思想

Iterator是一个接口，我们要找他的实现类。Collection中定义了一个方法Iterator iterator()方法，在使用的时候ArrayList会重写方法iterator()返回了Iterator接口的实现类的对象。使用ArrayList集合的对象，Iterator it = array.iterator(),运行结果就是Iterator接口的实现类的对象。it是接口的实现类对象,调用方法hasNext和next集合元素迭代

增强for循环

这里介绍的增强for循环也是一种遍历集合的方式

jdk1.5出现的新特性---->增强for循环，JDK1.5版本后,出现新的接口 java.lang.Iterable，Collection开是继承Iterable，Iterable作用,实现增强for循环

增强for循环的作用：

简化迭代器的书写格式。(注意：增强for循环的底层还是使用了迭代器遍历。)

增强for循环的适用范围：如果是实现了Iterable接口的对象或者是数组对象都可以使用增强for循环。

增强for循环的格式： for(数据类型变量名 :数组或集合) { //数据类型变量名:声明一个变量用来接收遍历目标遍历后的元素}

我们也通过一个例子，来具体的演示一下

*实现for循环,遍历数组public static voidfunction(){int[] arr = {4,2,9,0};for(inti : arr){
System.out.println(i);
}System.out.println(arr[0]);
}public static voidfunction_2(){
ArrayList array = new ArrayList();
array.add(new Person("a",20));
array.add(new Person("b",10));for(Person p : array){
System.out.println(p); 打印P就是打印P中的toString()方法，如果没有tostring 就是直接打印的是地址
}
}

好处: 代码少了,方便对容器遍历弊端: 没有索引,不能操作容器里面的元素，因为东数组是需要索引的，所以不能用折半查找，排序就不行了

List接口

我们通过集合体系框架图可以发现，List是Collection下的接口，和Collection是继承关系。List下主要有两个实现类，ArrayList、和LinkedList

java 集合存储的原理 java中集合的概念_java 集合存储的原理_05

java 集合存储的原理 java中集合的概念_java 集合存储的原理_06

List接口中的抽象方法,有一部分方法和他的父接口Collection是一样

List接口的自己特有的方法, 带有索引的功能

add(int index,E) 将元素插入到列表的指定索引上

E remove(int index) 移除指定索引上的元素,返回被删除之前的元素

E set(int index, E) 修改指定索引上的元素,返回被修改之前的元素

我们通过一个案例来具体的演示一下List的使用方式。

指定索引添加元素

public static voidfunction(){
List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
System.out.println(list);
list.add(1, "zzu");
System.out.println(list);
}移除索引上的元素public static voidfunction_1(){
List list = new ArrayList();
list.add(1.1);
list.add(1.2);
list.add(1.3);
list.add(1.4);
Double d= list.remove(0);
System.out.println(d);
System.out.println(list);
}修改索引上的元素public static voidfunction_2(){
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
Integer i= list.set(0, 5);
System.out.println(i);
System.out.println(list);
}

Set(集)接口

Set是最简单的集合，集合中的对象不按照特定的方式排序，并且没有重复的对象。

Set接口主要有两个实现类：HashSet和TreeSet。

Set集合是没有索引的，set集合取出元素的方式可以采用：迭代器、增强for循环。

Set集合中存放的是对象，并且没有重复对象。

Set接口的实现类，HashSet(哈希表)

特点：无序集合,存储和取出的顺序不同,没有索引,不存储重复元素

代码：代码的编写上,和ArrayList完全一致

hashSet

HashSet类按照哈希算法来存取集合中的对象，具有很好的存取和查找性能。

底层数据结构：哈希表

■当向集合中加入一个对象时，HashSet会调用对象的hashCode()方法来获得哈希码，然后根据哈希码进一步计算出对象在集合中的位置。

底层原理：

java 集合存储的原理 java中集合的概念_java 集合存储的原理_07

我们通过一个简单的例子来演示一下使用方法
public classHashSetDemo {public static voidmain(String[] args) {
Set set = new HashSet();
set.add("cn");set.add("zzu");
set.add("java");
set.add("java");
set.add("computer");Iterator it =set.iterator();while(it.hasNext()){
System.out.println(it.next());
}
System.out.println("======================");for(String s : set){
System.out.println(s);
}
}
}
HashSet不能存放重复元素public static voidmain(String[] args) {
HashSet set = new HashSet();
set.add(new String("abc"));
set.add(new String("abc"));
set.add(new String("bbc"));
set.add(new String("bbc"));
System.out.println(set);
}
Map(键值对映射)
Map(映射集合中的每一个元素包含一对键对象和值对象，集合中没有重复的键对象，值对象可以重复。
Map集合中，元素是成对存在的，每个元素都由健与值两部分组成，通过健可以找到所对应的值。
向Map集合中加入元素时，必须提供一对键对象和值对象。
Map中常用的集合为HashMap集合，LinkedHashMap集合
使用Map接口的实现类 HashMap V put(K,V) K 作为键的对象, V作为值的对象，返回值为V
public static voidfunction(){//创建集合对象,HashMap,存储对象,键是字符串,值是整数
Map map = new HashMap();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);
System.out.println(map);
}
使用Map接口的实现类 HashMap V get(K) ，如果集合中没有这个键,返回null
public static voidfunction(){//创建集合对象,HashMap,存储对象,键是字符串,值是整数
Map map = new HashMap();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);
System.out.println(map);
}
Map集合的遍历
Map集合的遍历：利用键获取值，Map接口中定义方法keySet，取出所有的键,存储到Set集合
1.调用map集合的方法keySet,所有的键存储到Set集合中， Map集合不能直接遍历，必须借助一个第三方的集 合Set，先存储健
2. 遍历Set集合,获取出Set集合中的所有元素 (Map中的键)
3. 调用map集合方法get,通过键获取到值 程序演示
public static voidmain(String[] args) {Map map = new HashMap();
map.put("a", 11);
map.put("b", 12);
map.put("c", 13);
map.put("d", 14);//1. 调用map集合的方法keySet,所有的键存储到Set集合中
Set set =map.keySet();//2. 遍历Set集合,获取出Set集合中的所有元素 (Map中的键)
Iterator it =set.iterator();while(it.hasNext()){//it.next返回是Set集合元素,也就是Map中的键//3. 调用map集合方法get,通过键获取到值
String key =it.next();
Integer value=map.get(key);
System.out.println(key+"...."+value);
}
使用增强for循环进行遍历，增强for不能遍历Map 但是可以遍历set集合，取值
System.out.println("=======================");for(String key : map.keySet()){
Integer value=map.get(key);
System.out.println(key+"...."+value);
}
}
Entry键值对对象
在Map类设计的时候，提供了一个嵌套接口：Entry。
Entry将健值对的对应关系封装成了对象，即键值对对象，这样我们在遍历Map集合时，就可以从每一个健值对Entry对象中获取对应的健与对应的值。
Map集合获取方式--entrySet方法,键值对映射关系获取
实现步骤:
1. 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合 Set >
2. 迭代Set集合
3. 获取出的Set集合的元素,是映射关系对象
4. 通过映射关系对象方法 getKet, getValue获取键值对
public static voidmain(String[] args) {
Map map = new HashMap();
map.put(1, "abc");
map.put(2, "bcd");
map.put(3, "cde");//1. 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
Set > set =map.entrySet();//2. 迭代Set集合
Iterator > it =set.iterator();while(it.hasNext()){//3. 获取出的Set集合的元素,是映射关系对象
Map.Entry entry =it.next();//4. 通过映射关系对象方法 getKet, getValue获取键值对
Integer key =entry.getKey();
String value=entry.getValue();
System.out.println(key+"...."+value);
}
System.out.println("=========================");for(Map.Entryentry : map.entrySet()){
System.out.println(entry.getKey()+"..."+entry.getValue());
}
}

本文主要是简单的介绍一下集合中部分的方法的使用，以及一些实现类的使用。是对平时学习集合这一章节的总结，如有写错欢迎大家批评指正。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。