请用LinkedList模拟栈数据结构的集合，并使用。

package cn.itcast_03;
import java.util.LinkedList;
/*
* 自定义栈使用
* add
* get
*/
public class MyStack {
       private LinkedList link;
         public MyStack() {
               link = new LinkedList();
          }
         public void add(Object obj) {
          link.addFirst(obj);
        }
      public Object get() {
        return link.removeFirst();
        }
       public boolean isEmpty() {
            return link.isEmpty();
      }
}
public class MyStackDemo {
     public static void main(String[] args) {
     // 创建集合对象
       MyStack my = new MyStack();
      // 添加元素
         my.add("hello");
         my.add("world");
         my.add("java");
        // 获取元素
       // System.out.println(my.get());
  
         while (!my.isEmpty()) {
            System.out.println(my.get());
         }
     }
}

这个就是首先了解 栈（这种数据结构）的特点，然后知道 linkList中 addFirst/addLast 以及removeFirst/removeLast这几个特有方法的使用。

堆栈结构是先进后出，你那两个都用添加和移除都是  frist  是先进先出的说

你可以想象是在摘水果，你摘的第一水果是在篮子最下面吧，你买摘一个就会一个一个压着，这就是压栈，你拿出你的苹果，是不是先从最上面的拿，就是出栈。先进后出

1. //ArratList 模拟堆栈 和 列队
   
2. public class Test020 {
   
3. 
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 List<Integer> list = new ArrayList<Integer>();
   
7.                 list.add(21);
   
8.                 list.add(32);
   
9.                 list.add(54);
   
10.                
    
11.                 print1(list);
    
12.                 System.out.println("-----------");
    
13.                 print2(list);
    
14.                
    
15.         }
    
16.        
    
17.         public static void print1(List<Integer> list)        //堆栈，先进后出
    
18.         {
    
19.                 for(int i=list.size()-1; i>=0; i--)
    
20.                 {
    
21.                         System.out.println(list.get(i));
    
22.                 }
    
23.         }
    
24.        
    
25.         public static void print2(List<Integer> list)        //队列，先进先出
    
26.         {
    
27.                 for(int i=0; i<list.size(); i++ )
    
28.                 {
    
29.                         System.out.println(list.get(i));
    
30.                 }
    
31.         }
    
32. 
    
33. }
    
34. 
    
35. 我还是发一下。虽然不能帮助你

复制代码

谢谢大家，有待慢慢理解……

mysouffle 发表于 2014-8-17 23:32
谢谢大家，有待慢慢理解……

public class Stack {
//声明一个LinkedList引用
        private LinkedList list;                                               
        public Stack() {
  //当调用构造方法的时候,创建LinkedList对象
             list = new LinkedList();                                 
     }
          //模拟进栈的方法
public void in(Object obj) {   
           //向集合中添加元素               
             list.addLast(obj);                                             
        }
              //模拟出栈的方法
            public Object out() {     
             //从集合删除元素                              
              return list.removeLast();                                
        }
           //模拟集合中是否有元素的方法   
        public boolean isEmpty() {
                 //判断集合是否为空                                    
                return list.isEmpty();                                       
        }
}

妹姊好萌,43期Android,有事不懂联系哈

要先搞清栈神马，他的原理类似于弹夹，最后压进去的先弹出来

恣意的豆腐 发表于 2014-8-18 07:57
要先搞清栈神马，他的原理类似于弹夹，最后压进去的先弹出来

原理明白，就是进栈压栈，获取的时候先进后出，但是就是不知道代码怎么写出来的，需要代码的解析

还是不能理解，有没有哪位能清楚的解析一下，我发上去的代码的