本文目录一览：

1、怎么编写一个简单的java队列? 2、JAVA里链队怎么移动指针 3、java中的队列用什么实现 4、求用Java的LinkedList类创建一个链队列（LinkedQueue）类 5、java：编写数据访问接口，再分别以堆栈和队列的形式实现

怎么编写一个简单的java队列?

import java.util.*;
public class MyQueue<T> {
    private LinkedList<T> list = new LinkedList<T>();
    public void addLast(T v) {
        list.addLast(v); // 队尾插入
    }
    public T getFirst() {
        return list.getFirst(); // 取得队首元素
    }
    public void remove() {
        list.removeFirst(); // 移除队首元素
    }
    // 类似功能自己扩展下
    public static void main(String[] args) {
        MyQueue<String> mq = new MyQueue<String>();
        mq.addLast("hello world");
        mq.addLast("hello world2");
        System.out.println(mq.getFirst());
        mq.remove();
        System.out.println(mq.getFirst());
    }
}

JAVA里链队怎么移动指针

循环条件或者判断语句。为了和队列的定义保持一致，所以要指明尾指针，链式队列只是队列的一种实现方式，还要把握住队列的本质，至于尾指针指向是尾结点还是尾结点的下一个结点，这个只是实现的一点区别，没有强制的要求。要根据自己的具体实现选择，不同的应用这两种会有些微小的区别，比如循环条件，判空等。判断依据是根据栈和堆解决，栈是后进先出，用链表的话在头部操作即可，没必要再加个尾指针，队列是先进先出，头尾都要有指针记忆位置，但是循环链表的话，尾节点的下一个便是头结点，所以只要有个尾指针即可，头指针省略不用。

java中的队列用什么实现

队列的实现单纯的是数据结构的问题，既可以用链表结构实现队列，也可以用数组实现。这和语言不是紧密关系，java可以这样实现，C、C++ 也可以。

求用Java的LinkedList类创建一个链队列（LinkedQueue）类

LinkedQueue类代码：

import java.util.LinkedList;
public class LinkedQueue {
    private LinkedList list;
    private LinkedQueue() {
    }
    public LinkedQueue(LinkedList list) {
        this.list = list;
    }
    // 入队
    public void add(Object obj) {
        this.list.add(obj);
    }
    // 获取队首元素
    public Object get() {
        return this.list.getFirst();
    }
    // 出队
    public void next() {
        this.list.removeFirst();
    }
    // 判定为空
    public boolean isEmpty() {
        return this.list.isEmpty();
    }
    // 获取当前队列长度
    public int size() {
        return this.list.size();
    }
}

测试类代码：

import java.util.LinkedList;
public class Test {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add("no1");
        list.add("2");
        list.add("215");
        // 获取初始linkedqueue;
        LinkedQueue lq = new LinkedQueue(list);
        System.out.println("获取队头元素 ： " + lq.get());
        lq.add("add");
        System.out.println("入队后队列长度：： " + lq.size());
        lq.next();
        System.out.println("出队队列长度 ： " + lq.size());
        System.out.println("出队后队头元素 ： " + lq.get());
        System.out.println("判定为空 ： " + lq.isEmpty());
    }
}

java：编写数据访问接口，再分别以堆栈和队列的形式实现

链队列的定义：

队列的链式存储结构简称为链队列。它是限制仅在表头删除和表尾插入的单链表。

链队列的数据存储形式：

链队列基本运算的实现：

package study_02.datastructure.queue;
/**
 * 链队列
 * @author WWX
 */
public class LinkQueue<T> {
    // 链的数据结构
    private class Node {
        public T data;
        public Node next;
        // 无参构造函数
        public Node(){}
        public Node(T data, Node next){
            this.data = data;
            this.next = next;
        }
    }
    // 队列头指针
    private Node front;
    // 队列尾指针
    private Node rear;
    // 队列长度
    private int size = 0;
    public LinkQueue(){
        Node n = new Node(null, null);
        n.next = null;
        front = rear = n;
    }
    /**
     * 队列入队算法
     * @param data
     * @author WWX
     */
    public void enqueue(T data){
        // 创建一个节点
        Node s = new Node(data, null);
        // 将队尾指针指向新加入的节点，将s节点插入队尾
        rear.next = s;
        rear = s;
        size++;
    }
    /**
     * 队列出队算法
     * @return
     * @author WWX
     */
    public T dequeue(){
        if(rear == front){
            try {
                throw new Exception("堆栈为空");
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        } else {
            // 暂存队头元素
            Node p = front.next;
            T x = p.data;
            // 将队头元素所在节点摘链
            front.next = p.next;
            // 判断出队列长度是否为1
            if(p.next == null)
                rear = front;
            // 删除节点
            p = null;
            size--;
            return x;
        }
    }
    /**
     * 队列长度
     * @return
     * @author WWX
     */
    public int size(){
        return size;
    }
    /**
     * 判断队列是否为空
     * @return
     * @author WWX
     */
    public boolean isEmpty(){
        return size == 0;
    }
    public String toString() {
        if(isEmpty()){
            return "[]";
        } else {
            StringBuilder sb = new StringBuilder("[");
            for(Node current = front.next; current != null; current = current.next){
                sb.append(current.data.toString() + ", ");
            }
            int len = sb.length();
            return sb.delete(len - 2, len).append("]").toString();
        }
    }
    // 测试
    public static void main(String[] args) {
        LinkQueue<Integer> queue = new LinkQueue<Integer>();
        queue.enqueue(1);
        queue.enqueue(2);
        queue.enqueue(3);
        queue.enqueue(4);
        queue.enqueue(5);
        queue.enqueue(6);
        System.out.println(queue);
        System.out.println("出队：" + queue.dequeue());
        System.out.println("队列长度=" + queue.size());
        System.out.println(queue);
        System.out.println("出队：" + queue.dequeue());
        System.out.println("队列长度=" + queue.size());
        System.out.println(queue);
        System.out.println("出队：" + queue.dequeue());
        System.out.println("队列长度=" + queue.size());
        System.out.println(queue);
    }
}

输出结果：

[1, 2, 3, 4, 5, 6]
出队：1
队列长度=5
[2, 3, 4, 5, 6]
出队：2
队列长度=4
[3, 4, 5, 6]
出队：3
队列长度=3
[4, 5, 6]

链队列java实现,JAVA的队列