实例185 - 使用泛型实现栈结构

秘笈心法：泛型的优势。

除了在使用栈中的元素时不需要进行强制类型转换外，还可以让程序在编译过程中进行类型检查。例如，在本实例中，首先限制了栈只能保存String类型的元素。如果向栈中保存其他类型的元素，则编译时会报错。泛型的魅力在于让程序有更好的可读性和安全性。

package com.mingrisoft.generic;

import java.util.LinkedList;

public class Stack<T> {
    
    private LinkedList<T> container = new LinkedList<T>();
    
    public void push(T t) {
        container.addFirst(t);
    }
    
    public T pop() {
        return container.removeFirst();
    }
    
    public boolean empty() {
        return container.isEmpty();
    }
}

 

package com.mingrisoft.generic;

public class StackTest {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<String>();
        System.out.println("向栈中增加字符串：");
        System.out.println("视频学Java");
        System.out.println("细说Java");
        System.out.println("Java从入门到精通(第2版)");
        stack.push("视频学Java");  //向栈中增加字符串
        stack.push("细说Java");   //向栈中增加字符串
        stack.push("Java从入门到精通(第2版)"); //向栈中增加字符串
        System.out.println("从栈中取出字符串：");
        while (!stack.empty()) {
            System.out.println(stack.pop());//删除栈中全部元素并进行输出
        }
    }
}

 运行结果：

向栈中增加字符串：
视频学Java
细说Java
Java从入门到精通(第2版)
从栈中取出字符串：
Java从入门到精通(第2版)
细说Java
视频学Java

 技巧：泛型参数的命名一般使用单个的大写字母，如对于任意类型可以使用字母T等。

 

补充知识：

 java.util.LinkedList

 

 

Doubly-linked list implementation of the List and Deque interfaces. Implements all optional list operations, and permits all elements (including null). 

 

All of the operations perform as could be expected for a doubly-linked list. Operations that index into the list will traverse the list from the beginning or the end, whichever is closer to the specified index. 

 

Note that this implementation is not synchronized. If multiple threads access a linked list concurrently, and at least one of the threads modifies the list structurally, it must be synchronized externally. (A structural modification is any operation that adds or deletes one or more elements; merely setting the value of an element is not a structural modification.) This is typically accomplished by synchronizing on some object that naturally encapsulates the list. If no such object exists, the list should be "wrapped" using the Collections.synchronizedList method. This is best done at creation time, to prevent accidental unsynchronized access to the list:

 

   List list = Collections.synchronizedList(new LinkedList(...));

The iterators returned by this class's iterator and listIterator methods are fail-fast: if the list is structurally modified at any time after the iterator is created, in any way except through the Iterator's own remove or add methods, the iterator will throw a ConcurrentModificationException. Thus, in the face of concurrent modification, the iterator fails quickly and cleanly, rather than risking arbitrary, non-deterministic behavior at an undetermined time in the future. 

 

Note that the fail-fast behavior of an iterator cannot be guaranteed as it is, generally speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent modification. Fail-fast iterators throw ConcurrentModificationException on a best-effort basis. Therefore, it would be wrong to write a program that depended on this exception for its correctness: the fail-fast behavior of iterators should be used only to detect bugs. 

 

This class is a member of the Java Collections Framework.

 

Parameters:

<E> the type of elements held in this collection

Since:

1.2

Author:

Josh Bloch

See Also:

List

ArrayList