⑴ java用数组实现队列
1.1. 队列的数据结构
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。
1.2. Java实现
QueueTest
package ch04;
public class QueueTest {
public static void main(String[] args) {
ArrayQueue queue = new ArrayQueue(10);
System.out.println(queue.isEmpty());
for (int i = 0; i < 10; i++) {
queue.insert(i);
}
System.out.println(queue.isFull());
while (!queue.isEmpty()) {
System.out.println(queue.remove());
}
}
}
class ArrayQueue {
private int[] arrInt;// 内置数组
private int front;// 头指针
private int rear;// 尾指针
public ArrayQueue(int size) {
this.arrInt = new int[size];
front = 0;
rear = -1;
}
/**
* 判断队列是否为空
*
* @return
*/
public boolean isEmpty() {
return front == arrInt.length;
}
/**
* 判断队列是否已满
*
* @return
*/
public boolean isFull() {
return arrInt.length - 1 == rear;
}
/**
* 向队列的队尾插入一个元素
*/
public void insert(int item) {
if (isFull()) {
throw new RuntimeException("队列已满");
}
arrInt[++rear] = item;
}
/**
* 获得对头元素
*
* @return
*/
public int peekFront() {
return arrInt[front];
}
/**
* 获得队尾元素
*
* @return
*/
public int peekRear() {
return arrInt[rear];
}
/**
* 从队列的对头移除一个元素
*
* @return
*/
public int remove() {
if (isEmpty()) {
throw new RuntimeException("队列为空");
}
return arrInt[front++];
}
}
运行结果如下:
false
true
0
1
2
3
4
5
6
7
8
9
⑵ java如何实现打印功能
Print.java－－打印内容定义
[code]
import java.awt.*;
import java.awt.event.*;
import java.awt.print.*;
import java.awt.image.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.border.*;
import javax.swing.event.*;
import java.util.*;
import java.io.*;
public class Print implements Printable{
int m_wPage;
int m_hPage;
int m_orientation;
Printable m_target;
int maxNumPage=1;
String title="数据表格打印";
Font titleFont=new Font("黑体",Font.BOLD,14);
boolean hasTail=true;
int tailAlign=0;
int headAlign=0;
int topSpace=0;
int leftSpace=0;
int yStart=0;
int yEnd=0;
int xStart=topSpace;
int xEnd=0;
int x=0,y=0;
String strTemp="打印内容";
public void doPrint(){
try{
m_orientation=PageFormat.PORTRAIT;
//设置打印对象，默认纸张
PrinterJob prnJob=PrinterJob.getPrinterJob();
PageFormat pageFormat=prnJob.defaultPage();
pageFormat.setOrientation(m_orientation);
m_wPage=(int)(pageFormat.getWidth());
m_hPage=(int)(pageFormat.getHeight());
//将待打印的窗体根据默认纸张设置传入打印对象
prnJob.setPrintable(this,pageFormat);
if(!prnJob.printDialog()) return;
prnJob.print();
}catch(PrinterException ex){
ex.printStackTrace();
System.err.println("打印错误："+ex.toString());
}
}
/**
* 初始化打印参数
*/
public void initPrintParameter()
{
}
/**
*构造打印内容，以送打印机打印
*/
public int print(Graphics pg,PageFormat pageFormat,
int pageIndex) throws PrinterException{
//初始化打印参数
initPrintParameter();
//将画布设置为页面大小
pg.translate((int)pageFormat.getImageableX(),
(int)pageFormat.getImageableY());
int wPage=0;
int hPage=0;
//根据打印机页面设置调整画布大小
if(pageFormat.getOrientation()==pageFormat.PORTRAIT){
wPage=(int)pageFormat.getImageableWidth();
hPage=(int)pageFormat.getImageableHeight();
}
else{
wPage=(int)pageFormat.getImageableWidth();
wPage+=wPage/2;
hPage=(int)pageFormat.getImageableHeight();
pg.setClip(0,0,wPage,hPage);
}
wPage=wPage-2*leftSpace;
hPage=hPage-2*topSpace;
xStart=leftSpace;
xEnd=wPage-2;
//为画布设置颜色和字体
int y=topSpace;
pg.setFont(titleFont);
pg.setColor(Color.black);
//画标题，并使其居中
Font fn=pg.getFont();
FontMetrics fm=pg.getFontMetrics();
y+=fm.getAscent();
alignText(title,pg,y,xStart,xEnd,headAlign);
y+=30;
x=leftSpace+2;
Font headerFont=new Font("宋体",Font.BOLD,14);
pg.setFont(headerFont);
fm=pg.getFontMetrics();
int h=fm.getAscent();
yStart=y-1;
y+=h;
pg.setFont(headerFont);
fm=pg.getFontMetrics();
int header=y;
h=fm.getHeight();
//计算行高，每页行数，总行数和指定页码的起始行、结束行
int rowH=Math.max(h,10);
int tailH=rowH+30;
int rowPerPage=0;
int leftPix=0;
if(hasTail){
rowPerPage=(hPage-header-tailH)/rowH;
leftPix=(hPage-header-tailH)%rowH;
yEnd=hPage-leftPix-tailH+2;
}
else{
rowPerPage=(hPage-header)/rowH;
leftPix=(hPage-header)%rowH;
yEnd=hPage-leftPix+2;
}
pg.drawString(strTemp,x,y);
//画表格边框
pg.drawLine(xStart,yStart,xStart,yEnd);
pg.drawLine(xStart,yStart,xEnd,yStart);
pg.drawLine(xEnd,yStart,xEnd,yEnd);
pg.drawLine(xStart,yEnd,xEnd,yEnd);
//打印页码
if(hasTail){
int pageNumber=pageIndex+1;
String s="第"+pageNumber+"页";
alignText(s,pg,yEnd+30,xStart,xEnd,tailAlign);
}
System.gc();
return PAGE_EXISTS;
}
/**
* 文字排列，坐标在y处,显示范围（start-end）
* 0表示居中显示，1表示左对齐，2表示右对齐
*/
private void alignText(String s,Graphics pg,int y,int start,
int end,int mode){
Font fn=pg.getFont();
FontMetrics fm=pg.getFontMetrics();
int wString=fm.stringWidth(s);
int x=start;
switch(mode)
{
case 0:
if((end-start-wString)>0) x=start+(end-start-wString)/2;
break;
case 1:
break;
case 2:
if((end-start-wString)>0) x=start+(end-start-wString);
break;
}
pg.drawString(s,x,y);
}
public static void main(String[] args){
Print p=new Print();
p.doPrint();
}
}
[code]
运行方法：
>javac -d . Print.java
>java Print
自己运行一下
⑶ Java语言没有指针，怎样实现链表
Java语言中的对象引用实际上是一个指针（这里的指针均为概念上的意义，而非语言提供的数据类型），所以我们可以编写这样的类来实现链表中的结点。
程序代码：
class Node
{
Object data;
Node next;//指向下一个结点
}
将数据域定义成Object类是因为Object类是广义超类，任何类对象都可以给其赋值，增加了代码的通用性。为了使链表可以被访问还需要定义一个表头，表头必须包含指向第一个结点的指针和指向当前结点的指针。为了便于在链表尾部增加结点，还可以增加一指向链表尾部的指针，另外还可以用一个域来表示链表的大小，当调用者想得到链表的大小时，不必遍历整个链表。
链表的数据结构我们可以用类List来实现链表结构，用变量Head、Tail、Length、Pointer来实现表头。存储当前结点的指针时有一定的技巧，Pointer并非存储指向当前结点的指针，而是存储指向它的前趋结点的指针,当其值为null时表示当前结点是第一个结点，因为当删除当前结点后仍需保证剩下的结点构成链表，如果Pointer指向当前结点，则会给操作带来很大困难。如何得到当前结点呢？我们定义了一个方法cursor(),返回值是指向当前结点的指针。类List还定义了一些方法来实现对链表的基本操作，通过运用这些基本操作我们可以对链表进行各种操作。例如reset()方法使第一个结点成为当前结点。insert(Object d)方法在当前结点前插入一个结点，并使其成为当前结点。remove()方法删除当前结点同时返回其内容，并使其后继结点成为当前结点，如果删除的是最后一个结点，则第一个结点变为当前结点。
链表类List的源代码如下：
package cn.javatx; import java.io.IOException;/**
* @author ljfan
*
*/
public class List {
private Node Head = null;
private Node Tail = null;
private Node Pointer = null;
private int Length = 0;public void deleteAll() {
Head = null;
Tail = null;
Pointer = null;
Length = 0;
}public void reset() {
Pointer = null;
}public boolean isEmpty() {
return (Length == 0);
}public boolean isEnd() {
if (Length == 0)
throw new java.lang.NullPointerException();
else if (Length == 1)
return true;
else
return (cursor() == Tail);
}public Object nextNode() {
if (Length == 1)
throw new java.util.NoSuchElementException();
else if (Length == 0)
throw new java.lang.NullPointerException();
else {
Node temp = cursor();
Pointer = temp;
if (temp != Tail)
return (temp.next.data);
else
throw new java.util.NoSuchElementException();
}
}public Object currentNode() {
Node temp = cursor();
return temp.data;
}public void insert(Object d) {
Node e = new Node(d);
if (Length == 0) {
Tail = e;
Head = e;
} else {
Node temp = cursor();
e.next = temp;
if (Pointer == null)
Head = e;
else
Pointer.next = e;
}
Length++;
}public int size() {
return (Length);
}public Object remove() {
Object temp;
if (Length == 0)
throw new java.util.NoSuchElementException();
else if (Length == 1) {
temp = Head.data;
deleteAll();
} else {
Node cur = cursor();
temp = cur.data;
if (cur == Head)
Head = cur.next;
else if (cur == Tail) {
Pointer.next = null;
Tail = Pointer;
reset();
} else
Pointer.next = cur.next;
Length--;
}
return temp;
}private Node cursor() {
if (Head == null)
throw new java.lang.NullPointerException();
else if (Pointer == null)
return Head;
else
return Pointer.next;
}public static void main(String[] args) {
List a = new List();
for (int i = 1; i <= 10; i++)
a.insert(new Integer(i));
System.out.println(a.currentNode());
while (!a.isEnd())
System.out.println(a.nextNode());
a.reset();
while (!a.isEnd()) {
a.remove();
}
a.remove();
a.reset();
if (a.isEmpty())
System.out.println("There is no Node in List n");
System.out.println("You can press return to quitn");
try {
System.in.read();
} catch (IOException e) {
}
}
}class Node {
Object data;
Node next;Node(Object d) {
data = d;
next = null;
}
}
当然，双向链表基本操作的实现略有不同。链表和双向链表的实现方法，也可以用在堆栈和队列的实现中
⑷ Java语言没有指针，怎样实现链表
Java语言中的对象引用实际上是一个指针（这里的指针均为概念上的意义，而非语言提供的数据类型），所以我们可以编写这样的类来实现链表中的结点。
程序代码：
classNode
{
Objectdata;
Nodenext;//指向下一个结点
}
将数据域定义成Object类是因为Object类是广义超类，任何类对象都可以给其赋值，增加了代码的通用性。为了使链表可以被访问还需要定义一个表头，表头必须包含指向第一个结点的指针和指向当前结点的指针。为了便于在链表尾部增加结点，还可以增加一指向链表尾部的指针，另外还可以用一个域来表示链表的大小，当调用者想得到链表的大小时，不必遍历整个链表。
链表的数据结构我们可以用类List来实现链表结构，用变量Head、Tail、Length、Pointer来实现表头。存储当前结点的指针时有一定的技巧，Pointer并非存储指向当前结点的指针，而是存储指向它的前趋结点的指针,当其值为null时表示当前结点是第一个结点，因为当删除当前结点后仍需保证剩下的结点构成链表，如果Pointer指向当前结点，则会给操作带来很大困难。如何得到当前结点呢？我们定义了一个方法cursor(),返回值是指向当前结点的指针。类List还定义了一些方法来实现对链表的基本操作，通过运用这些基本操作我们可以对链表进行各种操作。例如reset()方法使第一个结点成为当前结点。insert(Object d)方法在当前结点前插入一个结点，并使其成为当前结点。remove()方法删除当前结点同时返回其内容，并使其后继结点成为当前结点，如果删除的是最后一个结点，则第一个结点变为当前结点。
链表类List的源代码如下：
packagecn.javatx;importjava.io.IOException;/**
*@authorljfan
*
*/
publicclassList{
privateNodeHead=null;
privateNodeTail=null;
privateNodePointer=null;
privateintLength=0;publicvoiddeleteAll(){
Head=null;
Tail=null;
Pointer=null;
Length=0;
}publicvoidreset(){
Pointer=null;
}publicbooleanisEmpty(){
return(Length==0);
}publicbooleanisEnd(){
if(Length==0)
thrownewjava.lang.NullPointerException();
elseif(Length==1)
returntrue;
else
return(cursor()==Tail);
}publicObjectnextNode(){
if(Length==1)
thrownewjava.util.NoSuchElementException();
elseif(Length==0)
thrownewjava.lang.NullPointerException();
else{
Nodetemp=cursor();
Pointer=temp;
if(temp!=Tail)
return(temp.next.data);
else
thrownewjava.util.NoSuchElementException();
}
}publicObjectcurrentNode(){
Nodetemp=cursor();
returntemp.data;
}publicvoidinsert(Objectd){
Nodee=newNode(d);
if(Length==0){
Tail=e;
Head=e;
}else{
Nodetemp=cursor();
e.next=temp;
if(Pointer==null)
Head=e;
else
Pointer.next=e;
}
Length++;
}publicintsize(){
return(Length);
}publicObjectremove(){
Objecttemp;
if(Length==0)
thrownewjava.util.NoSuchElementException();
elseif(Length==1){
temp=Head.data;
deleteAll();
}else{
Nodecur=cursor();
temp=cur.data;
if(cur==Head)
Head=cur.next;
elseif(cur==Tail){
Pointer.next=null;
Tail=Pointer;
reset();
}else
Pointer.next=cur.next;
Length--;
}
returntemp;
}privateNodecursor(){
if(Head==null)
thrownewjava.lang.NullPointerException();
elseif(Pointer==null)
returnHead;
else
returnPointer.next;
}publicstaticvoidmain(String[]args){
Lista=newList();
for(inti=1;i<=10;i++)
a.insert(newInteger(i));
System.out.println(a.currentNode());
while(!a.isEnd())
System.out.println(a.nextNode());
a.reset();
while(!a.isEnd()){
a.remove();
}
a.remove();
a.reset();
if(a.isEmpty())
System.out.println("ThereisnoNodeinListn");
System.out.println("Youcanpressreturntoquitn");
try{
System.in.read();
}catch(IOExceptione){
}
}
}classNode{
Objectdata;
Nodenext;Node(Objectd){
data=d;
next=null;
}
}
当然，双向链表基本操作的实现略有不同。链表和双向链表的实现方法，也可以用在堆栈和队列的现实中。
⑸ 用Java如何实现获取linux控制台的输出（分很多）
import java.io.*;
public class Linux {
public static void main(String[] args) throws IOException {
//将根目录下的文件列出并将结果写入 /tmp/list.out
Process p = Runtime.getRuntime().exec("ls -al /");
InputStream in = p.getInputStream();
OutputStream out = new FileOutputStream("/tmp/list.out");
byte[] b = new byte[1024];
int r;
while((r=in.read(b))>-1)
out.write(b,0,r);
out.flush();
out.close();
}
}
⑹ 用Java语言实现单向链表
1.先定义一个节点类
package com.buren;
public class IntNode {
//定义一个节点类
int
info;
//定义属性，节点中的值
IntNode next;
//定义指向下一个节点的属性
public IntNode(int
i){ //构造一个next为空的节点
this(i,null);
}
public IntNode(int i,IntNode
n){ //构造值为i指向n的节点
info=i;
next=n;
}
}
2.再定义一个链表类，这是主要部分
package com.buren;
public class IntSLList {
private IntNode head,tail;
//定义指向头结点和尾结点的指针，
//如果大家看着这个不像指针的话，那就需要对指针有更深刻的了解
public
IntSLList(){
//定义一个空节点
head=tail=null;
}
public boolean
isEmpty(){
//判断节点是否为空
return
head==null;
//这行代码看起来似乎很神奇，其实真的很神奇，偶是服了
}
public void addToHead(int el){
//将el插入到头结点前
head=new
IntNode(el,head);
//将节点插入到头结点前，作为新的投节点
if(head==tail){
//给空链表插入节点时
tail=head;
//头结点和尾结点指向同一个节点
}
}
public void addToTail(int
el){
//向链表的尾部增加结点
if(!isEmpty()){
//判断链表是否为空
tail.next=new
IntNode(el);
//新建立一个值为el的节点，将链表的尾结点指向新节点
tail=tail.next;
//更新尾指针的指向
}else{
head=tail=new
IntNode(el);
//如果链表为空，新建立一个节点，将头尾指针同时指向这个节点
}
}
public int
deleteFromHead(){
//删除头结点，将节点信息返回
int
el=head.info;
//取出节点信息
if(head==tail){
//如果链表中只有一个节点
head=tail=null;
//删除这一个节点
}else{
head=head.next;
//如果链表中不止一个节点，将头结点的下一个节点作为头结点
}
return
el;
//返回原头结点的值
}
public int
deleteFromTail(){
//删除尾结点，返回尾结点的信息
int
el=tail.info;
//取出尾结点的值
if(head==tail){
// 如果链表中只有一个节点
head=tail=null;
//删除这个节点
}else{
IntNode
temp;
//定义中间变量
for(temp=head;temp.next!=tail;temp=temp.next);
//找出尾结点的前一个节点，注意最后的分号，
//这个for循环是没有循环体的，目的在于找出尾结点的前一个节点
//在整个程序中用了很多次这样的写法，相当经典啊
tail=temp;
//将找出来的节点作为尾结点，删除原来的尾结点
tail.next=null;
//将新尾结点的指向设为空
}
return
el;
//返回原尾结点的信息
}
public void
printAll(){
//打印链表中所有节点的信息
if(isEmpty()){
//如果链表为空
System.out.println("This
list is
empty!");
//输出提示信息
return;
//返回到调用的地方
}
if(head==tail){
//当链表中只有一个节点时
System.out.println(head.info);
//输出这个节点的信息，就是头结点的信息
return;
}
IntNode
temp;
//定义一个中间变量
for(temp=head;temp!=null;temp=temp.next){
//遍历整个链表
System.out.print(temp.info+"
");
//输出每个节点的信息
}
System.out.println();
//输出一个换行，可以没有这一行
}
public boolean isInList(int
el){
//判断el是否存在于链表中
IntNode
temp;
//定义一个中间变量
for(temp=head;temp!=null
&&
temp.info!=el;temp=temp.next);
//将el找出来，注意最后的分
return
temp!=null;
// 如果存在返回true，否则返回flase，这两行代码很有思想
}
public void delete(int
el){
//删除链表中值为el的节点
if(head.info==el
&&
head==tail){
//如果只有一个节点，并且节点的值为el
head=tail=null;
//删除这个节点
}else
if(head.info==el){
// 不止一个节点，而头结点的值就是el
head=head.next;
//删除头结点
}else{
IntNode
pred,temp;
//定义两个中间变量
for(pred=head,temp=head.next;temp.info!=el
&&
temp.next!=null;pred=pred.next,temp=temp.next);
//跟上面的类似，自己琢磨吧，也是要注意最后的分号
pred.next=temp.next;
//将temp指向的节点删除，最好画一个链表的图，有助于理解
if(temp==tail){
//如果temp指向的节点是尾结点
tail=pred;
//将pred指向的节点设为尾结点，
}
}
}
//下面这个方法是在链表中值为el1的节点前面插入一个值为el2的节点，
//用类似的思想可以再写一个在链表中值为el1的节点后面插入一个值为el2的节点
public boolean insertToList(int el1,int
el2){
//定义一个插入节点的方法，插入成功返回true，否则返回false
IntNode
pred,temp; //定义两个中间变量
if(isEmpty()){
//判断链表是否为空
return
false;
//如果链表为空就直接返回false
}
if(head.info==el1
&&
head==tail){
//如果链表中只有一个节点，并且这个节点的值是el1
head=new
IntNode(el2,head);
//新建立一个节点
return
true;
}else if(head.info==el1){
IntNode t=new
IntNode(el2);
t.next=head;
head=t;
return
true;
}else{
for(pred=head,temp=head.next;temp!=null
&&
temp.info!=el1;pred=pred.next,temp=temp.next);
if(temp!=null){
IntNode
a=new IntNode(el2);
pred.next=a;
a.next=temp;
return
true;
}else{
System.out.println(el1+"
NOT EXEISTS!");
return
false;
}
}
}
3.下面是测试代码
public static void main(String[] args){
IntSLList test=new
IntSLList();
//test.addToHead(7);
test.addToTail(7);
System.out.println(test.insertToList(7,5));
test.printAll();
System.out.println(test.isInList(123));
}
}
⑺ Java璇瑷娌℃湁鎸囬拡锛屾庢牱瀹炵幇阈捐〃
Java璇瑷涓镄勫硅薄寮旷敤瀹为檯涓婃槸涓涓鎸囬拡锛堣繖閲岀殑鎸囬拡鍧囦负姒傚康涓婄殑镒忎箟锛岃岄潪璇瑷鎻愪緵镄勬暟鎹绫诲瀷锛夛纴镓浠ユ垜浠鍙浠ョ紪鍐栾繖镙风殑绫绘潵瀹炵幇阈捐〃涓镄勭粨镣广
privatestaticclassEntry<E>{
Eelement;//褰揿墠瀛桦偍鍏幂礌
Entry<E>next;//涓嬩竴涓鍏幂礌鑺傜偣
Entry<E>previous;//涓娄竴涓鍏幂礌鑺傜偣
Entry(Eelement,Entry<E>next,Entry<E>previous){
this.element=element;
this.next=next;
this.previous=previous;
}
}