0
点赞
收藏
分享

微信扫一扫

.net 下的身份认证与授权的实现

【面试干货】Java集合类详解:List、Set、Queue、Map、Stack的特点与用法


💖The Begin💖点点关注,收藏不迷路💖

在Java中,集合类(Collections Framework)是一个非常重要的部分,它提供了多种数据结构的实现,以便我们在开发中更方便地管理和操作数据。

本文将详细介绍Java中的几种主要集合类:List、Set、Queue、Map和Stack的特点和用法。

1、Map

Map是一个键值对集合,键(Key)唯一不能重复,一个键对应一个值(Value),值可以重复。

在Map中,可以通过KeySet()方法将所有的键抽取成一个Set集合,这样就可以方便地遍历所有的键;而Values()方法则可以将Map中所有的值抽取成一个集合,同样便于对值进行遍历操作。

1.1 特点

1、键(Key)唯一不能重复。

2、可以将Key和Value单独抽取出来,例如keySet()和values()方法。

3、TreeMap可以保证顺序,HashMap不保证顺序。

1.2 用法

Map<String, Integer> map = new HashMap<>();  
	map.put("One", 1);  
	map.put("Two", 2);  
System.out.println(map.get("One")); // 输出 1

1.3 常见的实现类

1、HashMap:基于哈希表实现,不保证顺序。

2、LinkedHashMap:基于链表和哈希表实现,维护插入顺序。

3、TreeMap:基于红黑树实现,保证键的自然顺序或自定义排序。

Map<String, Integer> hashMap = new HashMap<>();
         hashMap.put("a", 1);
         hashMap.put("b", 2);

Map<String, Integer> treeMap = new TreeMap<>();
        treeMap.put("c", 3);
        treeMap.put("d", 4);

 Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("e", 5);
        linkedHashMap.put("f", 6);
        linkedHashMap.put("g", 7);

2、Set

Set是一个不包含重复元素的集合。

2.1 特点

1、元素唯一不重复。

2、Set中最多包含一个null元素。

3、只能使用Iterator实现单项遍历。

4、Set 中没有同步方法。

2.2 用法

Set<String> set = new HashSet<>();  
	set.add("Apple");  
	set.add("Banana");  
	set.add("Apple"); // 不会添加重复元素  
for (String fruit : set) {  
    System.out.println(fruit);  
}

2.3 常见的实现类

1、HashSet:基于哈希表实现,不保证顺序。

2、LinkedHashSet:基于链表和哈希表实现,维护插入顺序。

3、TreeSet:基于红黑树实现,保证元素的自然顺序或自定义排序。

用法示例:

Set<String> hashSet = new HashSet<>();
	hashSet.add("one");
	hashSet.add("two");

Set<String> treeSet = new TreeSet<>();
	treeSet.add("three");
	treeSet.add("four");


Set<String> linkedHashSet = new LinkedHashSet<>();
     linkedHashSet.add("five");
     linkedHashSet.add("six");
     linkedHashSet.add("seven");

3、List

List是一个有序的可重复集合。

3.1 特点

1、元素有序。
2、元素可重复。
3、可以在任意位置增加、删除元素。
4、List可以使用Iterator进行单向遍历,也可以使用ListIterator进行双向遍历。

遍历示例:

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

public class ListIteratorExample {
    public static void main(String[] args) {
        // 创建一个列表并添加一些元素
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");

        // 使用 Iterator 进行单向遍历
        System.out.println("使用 Iterator 遍历列表:");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.print(element + " ");
        }
        System.out.println();

        // 使用 ListIterator 进行双向遍历
        System.out.println("\n使用 ListIterator 进行双向遍历:");
        ListIterator<String> listIterator = list.listIterator();

        // 向前遍历列表
        System.out.println("向前遍历:");
        while (listIterator.hasNext()) {
            String element = listIterator.next();
            System.out.print(element + " ");
        }
        System.out.println();

        // 向后遍历列表
        System.out.println("向后遍历:");
        while (listIterator.hasPrevious()) {
            String element = listIterator.previous();
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

在这里插入图片描述

3.2 用法

List<String> list = new ArrayList<>();  
	list.add("First");  
	list.add("Second");  
	list.add(1, "Inserted"); // 在索引1处插入元素  
System.out.println(list.get(1)); // 输出 Inserted

3.3 常见的实现类

1、ArrayList:基于动态数组,支持快速随机访问。

2、LinkedList:基于双向链表,适合需要频繁插入和删除元素的场景。

用法示例:

List<Integer> arrayList = new ArrayList<>();
	arrayList.add(1);
	arrayList.add(2);

List<Integer> linkedList = new LinkedList<>();
	linkedList.add(3);
	linkedList.add(4);

4、Queue

Queue是一个遵循先进先出(FIFO)原则的集合。

4.1 特点

1、遵循FIFO原则。

2、使用offer()添加元素,poll()移除元素,可以通过返回值判断操作是否成功。

3、通常不允许插入null元素。

4.2 用法

Queue<String> queue = new LinkedList<>();  
	queue.offer("First");  
	queue.offer("Second");  
System.out.println(queue.poll()); // 输出 First

4.3 常见的实现类

1、LinkedList:可以作为队列使用,支持双端队列。

2、PriorityQueue:基于优先级堆实现,元素按优先级顺序出队。

Queue<Integer> linkedList= new LinkedList<>();
	queue.offer(1);
	queue.offer(2);
Integer head = linkedList.poll();

Queue<Integer> priorityQueue = new PriorityQueue<>();

 // 添加元素到优先级队列
  priorityQueue.offer(5);
  priorityQueue.offer(1);
  priorityQueue.offer(3);
  
// 获取并移除队列头部的元素
Integer head = priorityQueue.poll();

5、Stack

Stack是一个遵循后进先出(LIFO)原则的集合。

5.1 特点

1、遵循LIFO原则。

2、提供了push()、pop()、peek()等方法。

3、Stack继承自Vector,但通常不建议直接使用Stack,因为Vector是同步的,而Stack的方法并不是线程安全的。

5.2 用法(但不建议直接使用Stack类)

Deque<String> stack = new ArrayDeque<>(); // 使用Deque实现Stack的功能  
	stack.push("First");  
	stack.push("Second");  
System.out.println(stack.pop()); // 输出 Second

尽管Stack类存在,但在实际开发中,建议使用Deque接口及其实现类(如ArrayDeque)来代替,因为Deque提供了更丰富的功能和更好的性能。

6、用法总结建议

1、如果涉及堆栈或队列操作,建议使用List或Deque。

2、对于快速插入和删除元素,建议使用LinkedList。

3、如果需要快速随机访问元素,建议使用ArrayList。

但实际上:如果涉及堆栈,队列等操作,对于Stack和Queue,应该使用专门为此设计的集合类(如Deque和Queue接口的实现类),因为它们提供了更适合这些数据结构操作的方法。

对于快速插入和删除元素的场景,LinkedList是一个很好的选择,因为它在列表的任意位置插入和删除元素的时间复杂度都是O(1)。

如果需要快速随机访问元素,则应该使用ArrayList,因为ArrayList是基于数组实现的,可以通过索引快速访问元素。
在这里插入图片描述


💖The End💖点点关注,收藏不迷路💖

举报

相关推荐

0 条评论