JAVA实现栈(stack)与堆(heap)

最新推荐文章于 2025-04-26 15:13:36 发布
原创 最新推荐文章于 2025-04-26 15:13:36 发布 · 124 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

本文详细介绍了Java中栈(stack)与堆(heap)的基本概念、实现方式，并提供了相应的代码示例，帮助开发者理解这两种数据结构的特点和用法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Java实现 栈(stack)与堆(heap)

上次写过一个的，下次记得把代码贴上来

待续...

HeapUtil





import java.util.EmptyStackException;
import java.util.Vector;

/**
 * 
 * 模拟 堆，先进先出
 * 
 * @author 
 * @date 2012-6-27 上午02:19:06
 * 
 * @version 1.0
 */
public class HeapUtil<E> extends Vector<E>
{
    /**
     * Creates an empty Stack.
     */
    public HeapUtil()
    {
    }

    /**
     * Pushes an item onto the top of this stack. This has exactly the same
     * effect as: <blockquote>
     * 
     * <pre>
     * addElement(item)
     * </pre>
     * 
     * </blockquote>
     * 
     * @param item
     *            the item to be pushed onto this stack.
     * @return the <code>item</code> argument.
     * @see java.util.Vector#addElement
     */
    public E push(E item)
    {
        addElement(item);

        return item;
    }

    /**
     * Removes the object at the top of this stack and returns that object as
     * the value of this function.
     * 
     * @return The object at the top of this stack (the last item of the
     *         <tt>Vector</tt> object).
     * @exception EmptyStackException
     *                if this stack is empty.
     */
    public synchronized E pop()
    {
        if (empty())
        {
            return null;
        }
        E obj;
        int len = size();

        obj = peek();
        removeElementAt(0);

        return obj;
    }

    /**
     * Looks at the object at the top of this stack without removing it from the
     * stack.
     * 
     * @return the object at the top of this stack (the last item of the
     *         <tt>Vector</tt> object).
     * @exception EmptyStackException
     *                if this stack is empty.
     */
    public synchronized E peek()
    {
        int len = size();

        if (len == 0)
            throw new EmptyStackException();
        return elementAt(0);
    }

    /**
     * Tests if this stack is empty.
     * 
     * @return <code>true</code> if and only if this stack contains no items;
     *         <code>false</code> otherwise.
     */
    public boolean empty()
    {
        return size() == 0;
    }

    /**
     * Returns the 1-based position where an object is on this stack. If the
     * object <tt>o</tt> occurs as an item in this stack, this method returns
     * the distance from the top of the stack of the occurrence nearest the top
     * of the stack; the topmost item on the stack is considered to be at
     * distance <tt>1</tt>. The <tt>equals</tt> method is used to compare
     * <tt>o</tt> to the items in this stack.
     * 
     * @param o
     *            the desired object.
     * @return the 1-based position from the top of the stack where the object
     *         is located; the return value <code>-1</code> indicates that the
     *         object is not on the stack.
     */
    public synchronized int search(Object o)
    {
        int i = lastIndexOf(o);

        if (i >= 0)
        {
            return size() - i;
        }
        return -1;
    }

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = 1224463164541339165L;
}




StackUtil




/**
 * 
 * 栈 先进后出
 * 
 * @author 
 * @date 2012-6-27 上午08:36:52
 * 
 * @param <E>
 * @version 1.0
 */
public class StackUtil<E> extends Vector<E>
{
    /**
     * Creates an empty Stack.
     */
    public StackUtil()
    {
    }

    /**
     * Pushes an item onto the top of this stack. This has exactly the same
     * effect as: <blockquote>
     * 
     * <pre>
     * addElement(item)
     * </pre>
     * 
     * </blockquote>
     * 
     * @param item
     *            the item to be pushed onto this stack.
     * @return the <code>item</code> argument.
     * @see java.util.Vector#addElement
     */
    public E push(E item)
    {

        addElement(item);

        return item;
    }

    /**
     * Removes the object at the top of this stack and returns that object as
     * the value of this function.
     * 
     * @return The object at the top of this stack (the last item of the
     *         <tt>Vector</tt> object).
     * @exception EmptyStackException
     *                if this stack is empty.
     */
    public synchronized E pop()
    {
        if (empty())
        {
            return null;
        }
        E obj;
        int len = size();

        obj = peek();
        removeElementAt(len - 1);

        return obj;
    }

    /**
     * Looks at the object at the top of this stack without removing it from the
     * stack.
     * 
     * @return the object at the top of this stack (the last item of the
     *         <tt>Vector</tt> object).
     * @exception EmptyStackException
     *                if this stack is empty.
     */
    public synchronized E peek()
    {
        int len = size();

        if (len == 0)
            throw new EmptyStackException();
        return elementAt(len - 1);
    }

    /**
     * Tests if this stack is empty.
     * 
     * @return <code>true</code> if and only if this stack contains no items;
     *         <code>false</code> otherwise.
     */
    public boolean empty()
    {
        return size() == 0;
    }

    /**
     * Returns the 1-based position where an object is on this stack. If the
     * object <tt>o</tt> occurs as an item in this stack, this method returns
     * the distance from the top of the stack of the occurrence nearest the top
     * of the stack; the topmost item on the stack is considered to be at
     * distance <tt>1</tt>. The <tt>equals</tt> method is used to compare
     * <tt>o</tt> to the items in this stack.
     * 
     * @param o
     *            the desired object.
     * @return the 1-based position from the top of the stack where the object
     *         is located; the return value <code>-1</code> indicates that the
     *         object is not on the stack.
     */
    public synchronized int search(Object o)
    {
        int i = lastIndexOf(o);

        if (i >= 0)
        {
            return size() - i;
        }
        return -1;
    }

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = 1224463164541339165L;
}




Test



import java.util.Arrays;

public class Test
{
    public static void main(String[] args)
    {

        MyVec<Integer> m = new MyVec<Integer>(5);
        m.push(1);
        m.push(2);
        m.push(3);
        m.push(4);
        m.push(5);

        System.out.println(Arrays.asList(m.get()));
        System.out.println(Arrays.asList(m.get()));
        System.out.println(Arrays.asList(m.get()));
        System.out.println(Arrays.asList(m.get()));
        System.out.println(Arrays.asList(m.get()));
        m.push(6);
        m.push(7);
        m.push(8);
        System.out.println(Arrays.asList(m.get()));
        m.push(9);
        m.push(10);
        System.out.println(Arrays.asList(m.get()));
        System.out.println(Arrays.asList(m.get()));
        System.out.println(Arrays.asList(m.get()));
        System.out.println(Arrays.asList(m.get()));
        // while (!m.empty())
        // {
        // System.out.println(m.pop());
        // }
    }

    public static void main1(String[] args)
    {
        System.out.println("StackUtil......");
        StackUtil<String> s = new StackUtil<String>();
        s.push("1");
        s.push("2");
        s.push("3");

        while (!s.empty())
        {
            System.out.println(s.pop());
        }

        System.out.println("HeapUtil......");
        HeapUtil<String> h = new HeapUtil<String>();
        h.push("1");
        h.push("2");
        h.push("3");
        while (!h.empty())
        {
            System.out.println(h.pop());
        }

        System.out.println("QueueUtil......");
        QueueUtil<String> q = new QueueUtil<String>();

        q.add("1");
        q.add("2");
        q.add("3");

        for (int i = 0; i < 10; i++)
        {
            System.out.println(q.next());
        }

    }
}



MyVec 是我写的另外一个例子

特殊的缓存列表 首先有500的缓存大小用来入数据， 10缓存的大小用来读取数据, 读完后指针及指向后面了



import java.util.ArrayList;
import java.util.EmptyStackException;
import java.util.List;
import java.util.Vector;

/**
 * 
 * 特殊的缓存列表 首先有500的缓存大小用来入数据， 10缓存的大小用来读取数据, 读完后指针及指向后面了,
 * 
 * @author bdk197431
 * @date 2013-1-14 上午12:41:00
 * 
 * @version 1.0
 */
public class MyVec<E> extends Vector<E>
{
    /**
     * 总大小，缓存的申请大小,如500
     */
    private int maxSize;

    /**
     * 读取缓存的大小，如10，这个值要小于maxSize
     */
    private int readBuffMaxSize = 2;

    /**
     * 指针的指向的id
     */
    private int startIndex;

    /**
     * 指针的指向的endId
     */
    private int endIndex;

    public MyVec()
    {

    }

    public MyVec(int maxSize)
    {
        this.maxSize = maxSize;
    }

    public void debug(String s)
    {

        // System.out.println(s);
    }

    public String toString()
    {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < size(); i++)
        {
            sb.append(elementAt(i));
            if (i != size() - 1)
            {
                sb.append(",");
            }
        }

        sb.append("]");
        return sb.toString();
    }

    public List<E> get()
    {
        debug("get");
        List<E> list = new ArrayList<E>();

        for (int i = startIndex; i < endIndex; i++)
        {

            list.add(get(i));
        }

        if (startIndex + readBuffMaxSize > endIndex)
        {
            startIndex = endIndex;
        } else
        {
            startIndex += readBuffMaxSize;
            endIndex += readBuffMaxSize;
        }

        if (endIndex >= maxSize)
        {
            endIndex = maxSize;
        }
        // readBuffSize = 0;
        debug("start:" + startIndex + " end:" + endIndex);
        debug(this.toString());
        return list;
    }

    public E get(int index)
    {
        if (index >= this.maxSize && index <= endIndex)
        {
            index = index % this.maxSize;
        }

        return elementAt(index);
    }

    /**
     * 
     * 增加 读取缓存的大小
     * 
     * @author
     * @date 2013-1-14 上午03:22:11
     */
    private void addReadBuffSize()
    {
        endIndex++;

        if (endIndex - startIndex > readBuffMaxSize)
        {
            endIndex = startIndex + readBuffMaxSize;
        }

        if (startIndex > 0)
        {
            moveIndex(-1);
        }
    }

    private void moveIndex(int num)
    {
        startIndex += num;
        endIndex += num;
        if (endIndex > maxSize)
        {
            moveIndex(-1);
        }
    }

    /**
     * Pushes an item onto the top of this stack. This has exactly the same
     * effect as: <blockquote>
     * 
     * <pre>
     * addElement(item)
     * </pre>
     * 
     * </blockquote>
     * 
     * @param item
     *            the item to be pushed onto this stack.
     * @return the <code>item</code> argument.
     * @see java.util.Vector#addElement
     */
    public E push(E item)
    {

        debug("push");
        addElement(item);
        if (this.size() > maxSize)
        {
            removeElementAt(0);
            // 指针整体移动一位
            moveIndex(1);

        }
        addReadBuffSize();
        debug("start:" + startIndex + " end:" + endIndex);
        return item;
    }

    /**
     * Removes the object at the top of this stack and returns that object as
     * the value of this function.
     * 
     * @return The object at the top of this stack (the last item of the
     *         <tt>Vector</tt> object).
     * @exception EmptyStackException
     *                if this stack is empty.
     */
    public synchronized E pop()
    {
        if (empty())
        {
            return null;
        }
        E obj;
        int len = size();

        obj = peek();
        removeElementAt(len - 1);

        return obj;
    }

    /**
     * Looks at the object at the top of this stack without removing it from the
     * stack.
     * 
     * @return the object at the top of this stack (the last item of the
     *         <tt>Vector</tt> object).
     * @exception EmptyStackException
     *                if this stack is empty.
     */
    public synchronized E peek()
    {
        int len = size();

        if (len == 0)
            throw new EmptyStackException();
        return elementAt(len - 1);
    }

    /**
     * Tests if this stack is empty.
     * 
     * @return <code>true</code> if and only if this stack contains no items;
     *         <code>false</code> otherwise.
     */
    public boolean empty()
    {
        return size() == 0;
    }

    /**
     * Returns the 1-based position where an object is on this stack. If the
     * object <tt>o</tt> occurs as an item in this stack, this method returns
     * the distance from the top of the stack of the occurrence nearest the top
     * of the stack; the topmost item on the stack is considered to be at
     * distance <tt>1</tt>. The <tt>equals</tt> method is used to compare
     * <tt>o</tt> to the items in this stack.
     * 
     * @param o
     *            the desired object.
     * @return the 1-based position from the top of the stack where the object
     *         is located; the return value <code>-1</code> indicates that the
     *         object is not on the stack.
     */
    public synchronized int search(Object o)
    {
        int i = lastIndexOf(o);

        if (i >= 0)
        {
            return size() - i;
        }
        return -1;
    }

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = 1224463164541339165L;
}


Java中的堆（Heap）和栈（Stack）：深入解析与对比
05-29 475
在Java的内存管理中，堆（Heap）和栈（Stack）是两个至关重要的概念。它们各自扮演着不同的角色，对于理解和编写高效的Java程序至关重要。以下，我们将从技术难点、面试官关注点、回答吸引力和代码举例等方面详细探讨Java中的堆和栈。
java native堆_JVM内存模型——堆(heap)、栈(stack)和方法区(method)
weixin_36296827的博客
02-16 1380
JAVA的JVM的内存可分为3个区：堆(heap)、栈(stack)和方法区(method)堆区:堆内存用于存放由new创建的对象和数组。堆是JVM管理的内存中最大的一块，堆被所有线程共享，目的是为了存放对象实例，几乎所有的对象实例都在这里分配。1.存储的全部是对象，每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令)2.jvm只有一个堆区(heap)被所有线程共享，堆...
java数据结构基础－利用Heap（堆）实现PriorityQueue（优先队列）
congou2379的博客
01-27 288
首先做一个优先队列的接口：import java.util.List;public interface PriorityQueue {void add(Object o);void addAll(List elements)...
java 栈与堆的区别_java中栈(stack)和堆(heap)的区别
weixin_34413326的博客
03-07 199
java中栈(stack)和堆(heap)的区别鉴于网上对Java的堆栈区分，众说纷纭，有的把C++的堆栈也混进来，有的没有分清Stack，Heap的中文翻译，搞得我把Stack当作堆，Heap当作栈，混乱了！昨天参加一外企的笔试，选择英文答案时，选错了，知道答案是堆，却选择了Stack！今天，决定把两者区分清楚！首先分清楚Stack，Heap的中文翻译：Stack—栈，Heap—堆。在中文里，S...
堆（Heap）与栈（Stack）详解
最新发布
qq_62784677的博客
04-26 1122
• 栈的起始地址通常在高位（如0x7fffffff），堆在低位（如0x10000000），具体因系统而异。• 写时复制（Copy-on-Write）：进程fork时共享父进程内存，仅在修改时复制。• 用户级线程：由运行时库调度（如早期Java线程），内核不可见（轻量但无法利用多核）。• 线程私有：每个线程拥有独立的栈空间（默认大小通常为几MB，如Linux下8MB）。• 栈（Stack）：每个线程有独立的栈，存储局部变量、函数调用链。• 动态分配：需手动管理（C/C++）或依赖GC（Java/Go）。
解释内存中的栈stack、堆heap和方法区method area 的用法
weixin_41290863的博客
02-28 404
解释内存中的栈stack、堆heap和方法区method area 的用法 答： 通常我们定一个基本数据类型的变量，一个对象的引用，还有就是函数调用的现场保存都使用JVM中的栈空间； 而，通过 new关键字和构造器创建的对象，则放在堆空间， 堆是垃圾收集器管理的主要区域，由于现在的垃圾收集器都采用分代收集算法，所以堆空间还可以细分为新生代和老生代，再具体一点可以分为Eden、Survivor（又可以分为From Survivor和to Survivor）、Tenured； 方法区和堆都是各个线程
java heap stack_Java中Heap与Stack的区别
weixin_30686891的博客
02-12 266
1) Heap是 Stack的一个子集.------扩展—>从内存观点考虑。2)Stack存取速度仅次于寄存器，存储效率比heap高，可共享存储数据，但是其中数据的大小和生存期必须在运行前确定。3)Heap是运行时可动态分配的数据区，从速度看比Stack慢，Heap里面的数据不共享，大小和生存期都可以在运行时再确定。4) new关键字是运行时在Heap里面创建对象,每new一次都一定会创建新...
堆（Heap）和栈（Stack）
weixin_61468920的博客
06-07 618
堆和栈的主要区别在于它们存储的数据类型、生命周期、内存分配方式、访问速度和内存大小等方面。堆主要用于存储对象实例，而栈主要用于存储基本数据类型和对象的引用。堆中的对象生命周期是不确定的，而栈中的数据生命周期与线程的执行周期相同。堆的大小可以动态扩展和缩小，而栈的大小在创建线程时就已经确定，无法动态扩展。访问堆中的数据通常比访问栈中的数据更慢，因为需要通过引用（在栈中）来访问堆中的数据。
设置java栈（stack）和堆（heap）大小
m0_60721514的博客
04-12 1836
java -X 是非标准输出 1，java的栈空间设置 -------------------- java -X //输出java的非标准选项 java -Xss xxx //设置stack大小 java -Xss512k … //stack默认大小是1m java -Xss256k … //1k java -Xss256k … //1k java -Xss128k … //1k java -Xss64k … //1k java栈默认是1m，至少是108k，通过 java -Xss64k …有错误提示。 调
java heap和stack区别_Java 中 Stack(栈) 与 Heap(堆)
weixin_36438989的博客
02-24 138
布景Java中Stack(栈)与Heap(堆)是面试中被常常问到的一个话题。有没有对Java中Stack(栈)与Heap(堆)纯熟于心的童鞋，请举手！！！(怎么没人举手…)这个时分蜗牛哥的目标弱弱的举起了小手(这个目标不是new出来的哈)女朋友：牛哥，谁要怼咱呀？我要不要先打个摇摇灵？蜗牛哥：Heap(堆)与Stack(栈)是两种内存区域，不是要干架(没文化真可怕…)蜗牛哥：今日就来给你讲讲Jav...
深入理解 Java 内存栈与堆（Stack & Heap）
codingexpert404的博客
02-09 848
Java 作为一种面向对象的编程语言，其内存管理机制是理解 Java 运行机制的基础。内存管理不仅影响程序性能，还关系到程序的可靠性。Java 将内存划分为不同的区域，其中最为重要的便是栈（Stack）和堆（Heap）。本文将详细介绍 Java 内存栈与堆的基础概念、使用方法、常见实践以及最佳实践，帮助读者深入理解并高效使用这两个关键的内存区域。
深入Java虚拟机中的Stack和Heap
08-10
在Java虚拟机（JVM）中，内存分为两个部分：Stack（栈）和Heap（堆）。Stack是JVM的内存指令区，管理很简单，push一定长度字节的数据或者指令，Stack指针压栈相应的字节位移；pop一定字节长度数据或者指令，Stack...
基于java中stack与heap的区别,java中的垃圾回收机制的相关介绍
09-08
在Java中，内存主要分为两个区域：栈（Stack）和堆（Heap），以及垃圾回收机制（Garbage Collection）。 栈是程序执行过程中的临时数据存储区域，主要用于存储基本类型（如int、char）和对象的引用。每当一个方法被...
堆（heap）与栈（stack）的区别
05-11
堆（heap）与栈（stack）是计算机内存管理中的两种基本数据结构，用于存储程序运行时产生的临时变量。在C语言中，这两种内存区域有非常明确的区分，对于理解程序的内存分配和回收具有重要意义。 首先，栈是一种特殊...
asm jar包冲突的问题和解决方法(转)
bdk82924
11-03 673
asm jar包冲突的问题和解决方法 在用Spring+Hibernate做项目时候遇到 java.lang.NoSuchMethodError: org.objectweb.asm.ClassVisitor.visit 网上查得答案 环境：Spring2.0 Hibernate3.1.x/Hibernate3.2 在使用Spring的AOP编程时，会用到这几个l...
QPID学习
bdk82924
03-09 582
最近在看QPID 首先看下QPID是什么，他是个消息队列，用他有什么好处呢 ，可以跨平台使用，比如业务部分用C实现，把需要共享的信息通过QPID来传递，然后JAVA侧再从QPID接受消息 QPID官网： http://qpid.apache.org/download.html JAVA开发的话可以先在官网上下载一个 Java broker, client & tools ...
短网址的原理和实现
bdk82924
01-22 528
微博上经常会看到类似 http://t.cn/Afafhe 这样的短地址 那么实现原理是什么呢 其实很简单 ，系统把一个长的地址 如 http://www.xxx.com/ddd/xxx/a.html?dsada 首先用一个算法转换成 短地址 http://t.cn/Afafhe 然后把 Afafhe-->http://www.xxx.com/ddd/xxx/a.html?ds...
Jav解析soap的xml
bdk82924
05-17 505
解析xml import org.dom4j.Document; import org.dom4j.DocumentHelper; import org.dom4j.Element; import org.dom4j.io.SAXReader; import org.dom4j.xpath.DefaultXPath; &lt;soapenv:Envelope xmlns:soapen...
利用HttpClient 下载图片到本地
bdk82924
07-26 329
public static void main(String[] args) throws IOException { try { // hasActive(); HttpClient client = new HttpClient(); GetMethod get = ne...
深入理解Java栈与堆的区别
"关于Java栈与堆的思考" 在Java编程语言中，内存管理是至关重要的一个方面，它涉及到程序的性能和稳定性。Java内存主要分为两个区域：栈（Stack）和堆（Heap）。理解这两者的区别和作用对于优化代码和避免内存泄漏...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值