java:堆栈,队列,枚举,链表

Stack类

栈:(水杯喝水,先进后出)

栈是一种数据结构,是只能在某一端插入和删除的特殊线性表。他按照先进后出的原则存储数据

Enumeration(枚举)

1,hasMoreElements()    测试此枚举是否包含更多的元素

2,nextElements()    如果此枚举对象至少还有一个可提供的元素,则返回此枚举的下一个元素

-----------------------------

代码演示:

package day07;

import java.util.Date;

import java.util.Enumeration;

import java.util.Stack;

/*****

* 栈,堆,队列,链表演示

* @author yw.wang

*

*/

public class Test06 {

public static void main(String[] args) {

Stack ss = new Stack();

ss.push(1);

ss.push(‘a‘);

ss.push(12.3f);

ss.push(145.6d);

Date dd = new Date();

ss.push(dd);

//System.out.println(ss);

//pop()方法表示移除栈顶部的对象,并作为函数的值返回该对象,所以每打印一次,元素少一个

/*System.out.println(ss.pop());

System.out.println(ss.pop());

System.out.println(ss.pop());

//peek:    查看 堆栈顶部的对象,但是不从堆栈中移除它

System.out.println(ss.peek());

//empty    :    测试堆栈是否为空,是空返回true

System.out.println(ss.empty());

*/

Enumeration item = ss.elements();//得到stack中的枚举对象

while(item.hasMoreElements())//显示枚举中的所有元素

{//遍历输出

Object oo = item.nextElement();

System.out.println(oo);

}

}

}

------------------------------------------------------

队列:

队列(Queue)简称队,他也是一种运算受限的线性表,其限制是仅仅允许在表的一端经行插入,而在表的另一端经行删除,我们把经行插入的一端当做队尾,经行删除的一端当做队首

向队列中插入新的元素称为进队或者入队,新元素进队后就称为新的队尾元素,元素离队后,其后继元素就成为队首元素

Queue类:

offer()    添加一个元素并返回true,如果队列已满,则返回false

poll()    移除并返回队列头部的元素,如果队列为空,则返回null

peek()    返回队列头部的元素,如果队列为空,则返回null

-----------------------------

代码演示:

package day07;

import java.util.LinkedList;

import java.util.Queue;

/***

*  队列演示

* @author yw.wang

*

*/

public class Test07 {

public static void main(String[] args) {

Queue qq = new LinkedList();

//offer:添加一个元素

qq.offer(1);

qq.offer(12.3d);

qq.offer("abcd");

//移除并查看第一个元素

System.out.println(qq.poll());

System.out.println(qq.poll());

// 查看不移除第一个元素

System.out.println(qq.peek());

System.out.println(qq.peek());

}

}

------------------------------------------------------------------------------------

链表:

链表是一种物理存储单元上非连续,非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的,聊表由一系列节点组成,(链表中的每个元素称为节点),节点可以在运行时动态生成,每个节点包括两个部分:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。相比线性表顺序结构,操作复杂。

-------------------------

代码演示:

package day07;

import java.util.LinkedList;

/******

* 用linkedList演示链表

* @author yw.wang

*

*/

public class Test08 {

public static void main(String[] args) {

LinkedList ll = new LinkedList();

ll.add(1);

ll.add(‘a‘);

ll.add("niemii");

ll.add("");

ll.add(6);

ll.add("fuck");

System.out.println(ll);

ll.add(1,"fuckyou ");

System.out.println(ll);

ll.addFirst("first");

ll.addLast("sheet");

System.out.println(ll);

//删除链表中的所有节点,使当前链表成为空链表

//ll.clear();

//    System.out.println(ll);

//删除指定位置index上的节点

ll.remove(1);

System.out.println(ll);

//删除首次出现含有数据o的结点

ll.remove("fuck");

System.out.println(ll);

ll.removeFirst();//删除第一个节点,并返回这个节点中的对象

ll.removeLast();//删除最后一个节点,并返回这个节点中的对象

}

}

来自为知笔记(Wiz)

时间: 2024-11-07 14:15:16

java:堆栈,队列,枚举,链表的相关文章

Java算法入门-数组&链表&队列

算法就是解决问题的步骤,在一般的项目中可能用不上,但是一旦涉及到高并发,高性能时,就不得不考虑算法的优劣. 设计原则和特性 设计原则:正确性,可读性,健壮性,高效率和低存储 特性:有穷性,确定性,可行性,有输入,有输出. 算法题入门体验 如何判断是一个数是2的整数次幂?常规方法使用循环,但是在学习了二进制的基础知识后,发现可以使用模运算来实现. 1 import java.util.Scanner; 2 3 public class base { 4 5 public static void m

java 阻塞队列 LinkedBlockingQueue ArrayBlockingQueue 分析

BlockingQueue是阻塞队列接口类,该接口继承了Queue接口 BlockingQueue实现类常见的有以下几种. ArrayBlockingQueue:ArrayBlockingQueue 是一个有界的阻塞队列,其内部实现是将对象放到一个数组里.有界也就意味着,它不能够存储无限多数量的元素.它有一个同一时间能够存储元素数量的上限.你可以在对其初始化的时候设定这个上限,但之后就无法对这个上限进行修改了(译者注:因为它是基于数组实现的,也就具有数组的特性:一旦初始化,大小就无法修改). D

atitit. java queue 队列体系and自定义基于数据库的队列总结o7t

atitit. java queue 队列体系and自定义基于数据库的队列总结o7t 1. 阻塞队列和非阻塞队列 1 2. java.util.Queue接口, 1 3. ConcurrentLinkedQueue 2 4. BlockingQueue阻塞队列 2 4.1. 1. ArrayBlockingQueue 3 4.2. 2. LinkedBlockingQueue 3 4.3. 3. DelayQueue 3 4.4. 4. PriorityBlockingQueue 3 4.5. 

java数据结构队列

队列类似于现实生活中的排队.队列是先进先出的原则,只允许在队列头部去除元素,队列尾部添加元素. 下面是分别用数组和链表为存储结构实现的队列 public interface Queue<T> { int size(); T remove(); void add(T element); boolean isEmpty(); void clear(); boolean hasElement(); } public class ArrayQueue<T> implements Queue

atitit. java queue 队列体系and自己定义基于数据库的队列总结o7t

atitit. java queue 队列体系and自己定义基于数据库的队列总结o7t 1. 堵塞队列和非堵塞队列 1 2. java.util.Queue接口. 1 3. ConcurrentLinkedQueue 2 4. BlockingQueue堵塞队列 2 4.1. 1. ArrayBlockingQueue 3 4.2. 2. LinkedBlockingQueue 3 4.3. 3. DelayQueue 3 4.4. 4. PriorityBlockingQueue 3 4.5.

Java阻塞队列实现原理分析-ArrayBlockingQueue和LinkedBlockingQueue

Java中的阻塞队列接口BlockingQueue继承自Queue接口. BlockingQueue接口提供了3个添加元素方法. add:添加元素到队列里,添加成功返回true,由于容量满了添加失败会抛出IllegalStateException异常 offer:添加元素到队列里,添加成功返回true,添加失败返回false put:添加元素到队列里,如果容量满了会阻塞直到容量不满 3个删除方法. poll:删除队列头部元素,如果队列为空,返回null.否则返回元素. remove:基于对象找到

FIFO 队列的链表和数组实现

FIFO (First-in, First-out,先进先出)队列:当执行delete操作时删除那些呆在队列中时间最长的元素. FIFO 队列是这样一个ADT,包含两个基本操作:插入(put)一个新的项.删除(get)一个最早插入的项. 一.FIFO队列的链表实现 FIFO 队列和下堆栈的区别在于新项的插入是在尾部,而不是在头部.因此实现程序要保存一个指向链表最后一个节点的尾指针tail ,因此当Put操作时,将tail 指针指向的next 指向新节点,然后更新tail指针,让它指向那个新的节点

数据结构(栈,队列,链表,二叉树)

栈 栈作为一种数据结构,用途十分广泛.在回调函数等许多场景中都有应用.我们需要了解它的基本用途,那就是先进后出和队列的先进先出正好相反. 最近在学习数据结构和算法,于是自己来实现.我特别喜欢C语言的指针,我发现很好用,于是用C++来实现一个简单的范例. 主要实现就是函数就是Pop,Push Push将数据放到一个到顶层位置. Pop将数据从已有的数据中取出来. Stack.h文件,主要描述里面的数据,数据我用整形来处理,这个也可以是其他,只是示范 typedef struct mData { i

java基础——队列

目录 前言 基础 实现: 两个队列模拟一个堆栈 前言 java已经提供了堆和栈的相对应的类,这里只是模拟一下队列. 队列是一种先进先出的线性表. 基础 java5中新增加了java.util.Queue接口,用以支持队列的常见操作 LinkedList类实现了Queue接口 使用offer()来加入元素,使用poll()来获取并移出元素 实现: public class ceshi { public static void main(String[] args) { //add()和remove

洛谷P1160 队列安排 链表

洛谷P1160 队列安排   链表 1 #include <cstdio> 2 #include <cstring> 3 #include <cmath> 4 #include <cstdlib> 5 #include <string> 6 #include <algorithm> 7 #include <iomanip> 8 #include <iostream> 9 using namespace std