学java第五天

到线性表。先搞这个迭代器，大概是这样的一个使用例子

import java.util.ArrayList;  
import java.util.Iterator;  
import java.util.List;  
public class IteratorExample {  
    public static void main(String[] args) {  
        List<String> list = new ArrayList<>();  
        list.add("Apple");  
        list.add("Banana");  
        list.add("Cherry");  
        Iterator<String> it = list.iterator();  
        while (it.hasNext()) {  
            String fruit = it.next();  
            System.out.println(fruit);  
        }  
    }  
}

线性表的理解就是数列，先从顺序表开始

线性表大概的代码（截下来的）

List<Integer> arrayList= new ArrayList<>();

arrayList.add(1);

arrayList.add(2);

arrayList.add(3);

arrayList.add(1);

arrayList.add(10);

arrayList.add(4);

arrayList.add(0,10);

arrayList.add(3,30);

System.out.println(arrayList);

LinkedList<Object> linkedList=new LinkedList<Object>(arrayList);

linkedList.removeLast();

linkedList.addFirst("Green");

ListIterator<Object> listIterator = linkedList.listIterator();

while(listIterator.hasNext()) {

System.out.println(listIterator.next());

}

System.out.println("\n");

listIterator= linkedList.listIterator(linkedList.size());

while(listIterator.hasPrevious()) {

System.out.println(listIterator.previous());

}}

中间还有一堆方法 稍微过了下后面有链表 先跳过后面学

然后过栈、队列和优先队列

搬了一下这三个东西的概念跟区别。

栈（Stack）

概念解释：

栈是一种遵循后进先出（LIFO, Last In First Out）原则的数据结构。它只允许在栈顶进行添加（push）或删除（pop）元素的操作。栈是一种运算受限的线性表，其限制是仅允许在表的一端（称为栈顶）进行插入和删除运算。栈的应用场景广泛，如函数调用、递归实现、括号问题的求解、深度优先搜索遍历等。

核心特点：

• 后进先出（LIFO）
• 只能在栈顶进行插入和删除操作
• 可以通过顺序表（如数组）或链表实现

队列（Queue）

概念解释：

队列是一种遵循先进先出（FIFO, First In First Out）原则的数据结构。它允许在队列的一端（称为队尾）进行插入操作，在另一端（称为队首）进行删除操作。队列的应用场景包括计算机系统中各种资源的管理、消息缓冲器的管理，以及广度优先遍历等。

核心特点：

• 先进先出（FIFO）
• 只能在队尾插入元素，在队首删除元素
• 可以通过顺序表（如数组）或链表实现

优先队列（Priority Queue）

概念解释：

优先队列是一种特殊的队列，其中的元素按照优先级顺序进行排序。与普通队列不同，优先队列中的元素并不是按照它们进入队列的顺序进行处理，而是根据优先级来确定处理顺序。优先队列常用于任务调度、最短路径算法、堆排序等场景。

核心特点：

• 元素按照优先级顺序进行排序
• 插入元素时，根据优先级确定其在队列中的位置
• 删除元素时，移除并返回优先级最高的元素
• 常用的实现方式包括使用堆（Heap）数据结构

栈、队列和优先队列之间的区别

	栈（Stack）	队列（Queue）	优先队列（Priority Queue）
操作原则	后进先出（LIFO）	先进先出（FIFO）	按优先级排序
插入位置	栈顶	队尾	根据优先级确定
删除位置	栈顶	队首	优先级最高处
应用场景	函数调用、递归、括号匹配等	资源管理、消息缓冲、广度优先遍历等	任务调度、最短路径算法、堆排序等
实现方式	顺序表（数组）、链表	顺序表（数组）、链表	堆（二叉堆等）

import java.util.Deque;  
import java.util.ArrayDeque;  

//栈
public class StackExample {  
    public static void main(String[] args) {  
        Deque<Integer> stack = new ArrayDeque<>();  
        // 入栈  
        stack.push(1);  
        stack.push(2);  
        stack.push(3);  
        // 查看栈顶元素  
        System.out.println("栈顶元素: " + stack.peek());  
        // 出栈  
        while (!stack.isEmpty()) {  
            System.out.println(stack.pop());  
        }  
    }  
}

import java.util.Queue;  
import java.util.LinkedList;  
  //队列
public class QueueExample {  
    public static void main(String[] args) {  
        Queue<Integer> queue = new LinkedList<>();  
        queue.offer(1);  
        queue.offer(2);  
        queue.offer(3);  
         System.out.println("队首元素: " + queue.peek());  
        while (!queue.isEmpty()) {  
            System.out.println(queue.poll());  
        }  
    }  
}

import java.util.PriorityQueue;  
  //优先队列
public class PriorityQueueExample {  
    public static void main(String[] args) {  
        PriorityQueue<Integer> pq = new PriorityQueue<>();  
  
        // 添加元素  
        pq.offer(3);  
        pq.offer(1);  
        pq.offer(2);  
  
        // 移除并返回队列头部的元素
        while (!pq.isEmpty()) {  
            System.out.println(pq.poll());  
        }  
        PriorityQueue<String> pqWithCustomComparator = new PriorityQueue<>((s1, s2) -> s2.compareTo(s1));  
        pqWithCustomComparator.offer("Banana");  
        pqWithCustomComparator.offer("Apple");  
        pqWithCustomComparator.offer("Cherry");  
        while (!pqWithCustomComparator.isEmpty()) {  
            System.out.println(pqWithCustomComparator.poll());  
        }  
    }  
}内容有点多稍微消化会。保持学习&&更新ing。。。