java集合的简单理解（小学生都看的懂的巨详细）

最新推荐文章于 2022-09-06 20:25:06 发布

骚气的小学生

最新推荐文章于 2022-09-06 20:25:06 发布

阅读量537

点赞数 12

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/qq_43402310/article/details/105972182

版权

java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

集合
将多个元素组成一个单元的对象
用于存储、检索、操纵和传输数据
集合框架 Java Collection Framework (JCF).
提供用于管理对象集合的接口和类
包括接口、实现类和算法

下图是java中集合的接口层次
在这里插入图片描述

java集合中的类和接口

List , Set, Map都是接口，前两个继承至Collection接口，Map为独立接口
Set下有HashSet，LinkedHashSet，TreeSet
List下有ArrayList，Vector，LinkedList
Map下有Hashtable，LinkedHashMap，HashMap，TreeMap

List

List是位置性集合,加进List中的元素可以加在List中特定位置或加到末尾.
列表的主要特征是其对象以线性方式存储，没有特定顺序，只有一个开头和一个结尾，列表在数据结构中分别表现为：数组和向量、链表、堆栈、队列。

在JCF中两个类实现List接口:
ArrayList
LinkedList
ArrayList(数组表):提供快速的基于索引的成员访问，对尾部成员的增加和删除支持较好，类似于Vector，都用于缩放数组维护集合
LinkedList(链表):是双向链表，每个节点都有两个指针指向上一节点和下一节点，提供快速的增删改
ArrayList
特点:

用Object数组存储对象
默认大小为10
当容量不够时，会自动增大【增大的系数是1.5倍+1】
内容可以重复
有序
优点: 底层数据结构是数组，查询快，增删慢。
缺点: 线程不安全，效率高
案例：

public class ArrayListTest {
    public static void main(String[] agrs){
        //创建ArrayList集合：
        List<String> list = new ArrayList<String>();
        System.out.println("ArrayList集合初始化容量："+list.size());

        //添加功能：
        list.add("Hello");
        list.add("world");
        list.add(2,"!");
        System.out.println("ArrayList当前容量："+list.size());

        //修改功能：
        list.set(0,"my");
        list.set(1,"name");
        System.out.println("ArrayList当前内容："+list.toString());

        //获取功能：
        String element = list.get(0);
        System.out.println(element);

        //迭代器遍历集合：(ArrayList实际的跌倒器是Itr对象)
        Iterator<String> iterator =  list.iterator();
        while(iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }

        //for循环迭代集合：
        for(String str:list){
            System.out.println(str);
        }

        //判断功能：
        boolean isEmpty = list.isEmpty();
        boolean isContain = list.contains("my");

        //长度功能：
        int size = list.size();

        //把集合转换成数组：
        String[] strArray = list.toArray(new String[]{});

        //删除功能：
        list.remove(0);
        list.remove("world");
        list.clear();
        System.out.println("ArrayList当前容量："+list.size());
    }}

LinkedList
特点
1：LinkedList双向链表，实现了List的双向队列接口，实现了所有list可选择性操作，允许存储任何元素(包括null值)
2:所有的操作都可以表现为双向性的，遍历的时候会从首部到尾部进行遍历，直到找到最近的元素位置
优点: 底层数据结构是链表，查询慢，增删快。
缺点: 线程不安全，效率高
案例

public class LinkedListTest {
    public static void main(String[] agrs){
        List<String> linkedList = new LinkedList<String>();
        System.out.println("LinkedList初始容量："+linkedList.size());

        //添加功能：
        linkedList.add("my");
        linkedList.add("name");
        linkedList.add("is");
        linkedList.add("jiaboyan");
        System.out.println("LinkedList当前容量："+ linkedList.size());

        //修改功能:
        linkedList.set(0,"hello");
        linkedList.set(1,"world");
        System.out.println("LinkedList当前内容："+ linkedList.toString());

        //获取功能：
        String element = linkedList.get(0);
        System.out.println(element);

        //遍历集合：(LinkedList实际的跌倒器是ListItr对象)
        Iterator<String> iterator =  linkedList.iterator();
        while(iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }
        //for循环迭代集合：
        for(String str:linkedList){
            System.out.println(str);
        }

        //判断功能：
        boolean isEmpty = linkedList.isEmpty();
        boolean isContains = linkedList.contains("jiaboyan");

        //长度功能：
        int size = linkedList.size();

        //删除功能：
        linkedList.remove(0);
        linkedList.remove("jiaboyan");
        linkedList.clear();
        System.out.println("LinkedList当前容量：" + linkedList.size());
    }}

在上面的案例中有一个迭代器遍历，现在我们来看迭代器
Iterator 接口-迭代器
所有实现了Collection接口的容器类都有一个iterator方法用以返回一个实现了Iterator接口的对象
作用: 方便对容器内元素的遍历操作
使用:
boolean hasNext(): 判断是否有元素没有被遍历
Object next(): 返回游标当前位置的元素并将游标移动到下一个位置
void remove(): 删除游标左面的元素，在执行完next之后该操作只能执行一次
凡是能用iterator的方法的对象也能使用foreach

package demo02;
import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;
/*
java.util.Iterator接口:迭代器(对集合进行遍历)
有两个常用的方法
boolean hasNext() 如果仍有元素可以迭代，则返回 true。
判断集合中还有没有下一个元素,有就返回true,没有就返回false
E next() 返回迭代的下一个元素。
取出集合中的下一个元素
Iterator迭代器,是一个接口,我们无法直接使用,需要使用Iterator接口的实现类对象,获取实现类的方式比较特殊
Collection接口中有一个方法,叫iterator(),这个方法返回的就是迭代器的实现类对象
Iterator iterator() 返回在此 collection 的元素上进行迭代的迭代器。

迭代器的使用步骤(重点):
    1.使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)
    2.使用Iterator接口中的方法hasNext判断还有没有下一个元素
    3.使用Iterator接口中的方法next取出集合中的下一个元素

 */public class Demo01Iterator {
    public static void main(String[] args) {
        //创建一个集合对象
        Collection<String> coll = new ArrayList<>();
        //往集合中添加元素
        coll.add("姚明");
        coll.add("科比");
        coll.add("麦迪");
        coll.add("詹姆斯");
        coll.add("艾弗森");

        /*
            1.使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)
            注意:
                Iterator<E>接口也是有泛型的,迭代器的泛型跟着集合走,集合是什么泛型,迭代器就是什么泛型
         */
        //多态  接口            实现类对象
        Iterator<String> it = coll.iterator();
        /*
            发现使用迭代器取出集合中元素的代码,是一个重复的过程
            所以我们可以使用循环优化
            不知道集合中有多少元素,使用while循环
            循环结束的条件,hasNext方法返回false
         */
        while (it.hasNext()) {//使用Iterator接口中的方法hasNext判断还有没有下一个元素
            //使用Iterator接口中的方法next取出集合中的下一个元素
            String e = it.next();
            //没有元素,在取出元素会抛出NoSuchElementException没有元素异常            System.out.println(e);
        }
        System.out.println("----------------------");
        for (Iterator<String> it2 = coll.iterator(); it2.hasNext(); ) {
            String e = it2.next();
            System.out.println(e);
        }

    }
}

Deque队列

就大家看图就能理解这个，使用的方法就查看api文档
在这里插入图片描述

Stack栈

在这里插入图片描述
public class Stackextends VectorStack 类表示后进先出（LIFO）的对象堆栈。它通过五个操作对类 Vector 进行了扩展，允许将向量视为堆栈。它提供了通常的 push 和 pop 操作，以及取堆栈顶点的 peek 方法、测试堆栈是否为空的 empty 方法、在堆栈中查找项并确定到堆栈顶距离的 search 方法。

首次创建堆栈时，它不包含项。
案例

package list;

import java.util.Stack;

public class TestStack {
	
	public static void main(String[] args) {
		
		//栈
		Stack<String> stack=new Stack<String>();
		
		stack.push("1");
		stack.push("2");
		stack.push("3");
		stack.push("4");
		
		//查看堆栈顶部的对象，但不从堆栈中移除它。
		System.out.println(stack.peek());
		
		//不为空则取
		while(!stack.isEmpty()){
			//弹出
			String str=stack.pop();
			System.out.println(str);
		}
		
		
		
	}

}

我们简单的理解就是手枪上子弹和击发子弹的情况

SET

扩展Collection接口, 没有引入新方法，所以Set就是一个Collection，只不过其行为不同
不允许重复元素
对 add()、equals() 和 hashcode() 方法添加了限制
HashSet和TreeSet是Set的实现
HashSet

特点：
根据hash值来确定位置
无序
不可重复
外部无序地遍历成员.基于散列表的集，加进散列表的元素要实现hashCode()方法
如果加入的是对象则要重写hashCode和equals方法
案例
偷个懒直接放代码截图

TreeSet

底层数据结构是红黑树。(唯一，有序)

如何保证元素排序的呢?
自然排序
比较器排序
2.如何保证元素唯一性的呢?
根据比较的返回值是否是0来决定

LinkedHashSet

底层数据结构是链表和哈希表。(FIFO插入有序,唯一)
1.由链表保证元素有序
2.由哈希表保证元素唯一
案例代码省略
我们来看最后一个

Map

映射
用于关键字/数值对，像个Dictionary。
Map接口不是Collection接口的继承。Map接口用于维护键/值对(key/value pairs)。该接口描述了从不重复的键到值的映射。
Map 集合的特点
能够存储唯一的列数据（唯一，不可重复）set
能够存储可以重复的数据（可重复）list
值的顺序取决于键的顺序
键和值都是可以存储 null 元素的
一个映射不能包含重复的键，每个键最多只能映射一个值
他是一个键值对的集合
Map集合的每一个元素都是成对存在的。Map<K,V>两个泛型，K键，V值，K和V可以相同，也可不同。K是唯一的，V可以重复

Map接口有三个比较重要的实现类，分别是HashMap、TreeMap和HashTable。

TreeMap是有序的，HashMap和HashTable是无序的。
Hashtable的方法是同步的，HashMap的方法不是同步的。这是两者最主要的区别。
这样也就是
Hashtable是线程安全的，HashMap不是线程安全的。
HashMap效率较高，Hashtable效率较低。
如果对同步性或与遗留代码的兼容性没有任何要求，建议使用HashMap。查看Hashtable的源代码就可以发现，除构造函数外，Hashtable的所有 public 方法声明中都有 synchronized关键字，而HashMap的源码中则没有。
Hashtable不允许null值，HashMap允许null值（key和value都允许）
父类不同：Hashtable的父类是Dictionary，HashMap的父类是AbstractMap

hashMap

案例

package map;

import java.util.HashMap;

/**
 * 测试hashMap
 * 特点：
 * 	key键无序
 * 	key不能重复
 *  value可重复
 *  key-value键值对方式
 * @author wenber
 *
 */
public class TestHashMap2 {
	
	public static void main(String[] args) {
		//创建
		HashMap map=new HashMap();//初始大小 默认为16
		//添加内容
		map.put("name", "wenber");
		//2
		HashMap map2=new HashMap(18);//指定大小18
		//3
		HashMap map3=new HashMap(18,1);//指定容器大小和加载因子【大家查阅资料】
		HashMap m=new HashMap();
		m.put("age", 18);
		//4 
		HashMap map4=new HashMap(m);//将其它map传入作为参数
		System.out.println(map4.get("age"));
		
	}
}

TreeMap

案例

package map;


import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

public class TestTreeMap {
	
	public static void main(String[] args) {
		
		TreeMap map=new TreeMap();
		map.put("1", "11");
		map.put("A", "22");
		map.put("3", "33");
		
		
		Set set=map.keySet();
		Iterator it=set.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
		System.out.println("===========");
		while(!map.isEmpty()){
			Entry entry=(Entry) map.pollLastEntry();
			System.out.println(entry.getKey()+"=="+entry.getValue());
		}
		
	}
}

以上是我对java集合的理解，希望能帮助大家对java集合能更好的理解

骚气的小学生

关注

12
点赞
踩
2

收藏

觉得还不错? 一键收藏
4
评论
java集合的简单理解（小学生都看的懂的巨详细）

集合将多个元素组成一个单元的对象用于存储、检索、操纵和传输数据集合框架 Java Collection Framework (JCF).提供用于管理对象集合的接口和类包括接口、实现类和算法下图是java中集合的接口层次java集合中的类和接口List , Set, Map都是接口，前两个继承至Collection接口，Map为独立接口Set下有HashSet，LinkedHas...
复制链接

扫一扫