使用LinkedList模拟一个堆栈或者队列数据结构。
堆栈：先进后出  
队列：先进先出
思路：
1 建立一个队列类描述队列和堆栈
2 在主函数中测试

1. import java.util.*;
   
2. //队列类
   
3. class DuiLie
   
4. {
   
5.         //使用LinkedList建立队列
   
6.         private LinkedList link;
   
7. 
   
8.         //构造函数建立一个链表
   
9.         DuiLie()
   
10.         {
    
11.                 link = new LinkedList();
    
12.         }
    
13. 
    
14.         //1 队列添加方法
    
15.         public void add(Object obj)
    
16.         {
    
17.                 //用LinkedList特有的添加方法:头插法
    
18.                 link.offerFirst(obj);
    
19.         }
    
20. 
    
21.         //2 队列取出方法
    
22.         public Object get()
    
23.         {
    
24.                 //用LinkedList特有的获取方法
    
25.                 return link.pollLast();
    
26.         }
    
27. 
    
28.         //3 队列判空方法
    
29.         public boolean isEmpty()
    
30.         {
    
31.                 //调用LinkedList判空方法
    
32.                 return link.isEmpty();
    
33.         }
    
34. 
    
35.         //4 打印当前队列元素
    
36.         public void print()
    
37.         {
    
38.                 System.out.println("队列内容："+link);
    
39.         }
    
40. }
    
41. 
    
42. //堆栈类
    
43. class duiZhan
    
44. {
    
45.         private LinkedList link;
    
46. 
    
47.         duiZhan()
    
48.         {
    
49.                 link = new LinkedList();
    
50.         }
    
51. 
    
52.         //堆栈添加方法
    
53.         public void add(Object obj)
    
54.         {
    
55.                 link.offerFirst(obj);
    
56.         }
    
57. 
    
58.         //堆栈获取方法
    
59.         public Object get()
    
60.         {
    
61.                 return link.pollFirst();
    
62.         }
    
63. 
    
64.         //堆栈判空方法
    
65.         public boolean isEmpty()
    
66.         {
    
67.                 return link.isEmpty();
    
68.         }
    
69. 
    
70.         //4 打印当前堆栈元素
    
71.         public void print()
    
72.         {
    
73.                 System.out.println("堆栈内容："+link);
    
74.         }       
    
75. }
    
76. class LinkedListTest
    
77. {
    
78.         public static void main(String[] args)
    
79.         {
    
80.                 //队列测试
    
81.                 duiLieDemo();
    
82. 
    
83.                 //堆栈测试
    
84.                 duiZhanDemo();
    
85.                
    
86.         }
    
87. 
    
88.         //队列测试
    
89.         public static void duiLieDemo()
    
90.         {
    
91.                 //建立一个队列
    
92.                 DuiLie dl = new DuiLie();
    
93. 
    
94.                 //调用添加方法
    
95.                 dl.add("num01");
    
96.                 dl.add("num02");
    
97.                 dl.add("num03");
    
98.                 dl.add("num04");
    
99.                
    
100.                 //打印当前队列
     
101.                 dl.print();
     
102. 
     
103.                 //调用队列取出方法
     
104.                 while(!dl.isEmpty())
     
105.                         System.out.println(dl.get()+"--出队");               
     
106.         }
     
107. 
     
108.         //堆栈测试
     
109.         public static void duiZhanDemo()
     
110.         {
     
111.                 //建立一个堆栈
     
112.                 duiZhan dz = new duiZhan();
     
113. 
     
114.                 //调用堆栈添加方法
     
115.                 dz.add("num05");
     
116.                 dz.add("num06");
     
117.                 dz.add("num07");
     
118.                 dz.add("num08");
     
119. 
     
120.                 //打印当前堆栈
     
121.                 dz.print();
     
122. 
     
123.                 //调用堆栈取出方法
     
124.                 while(!dz.isEmpty())
     
125.                         System.out.println(dz.get()+"--出栈");
     
126.         }
     
127. }
     

复制代码

这不是毕姥爷讲的么！？

恩呢，挺好，能够看完视频再自己独立的敲出来，值得我们去学习