java代碼抓數據結構

『壹』 java 處理數據結構集

1，聲明兩個list或者verctor和一個計數器
2，獲取rs的行數. 求出 row/2的結果,並加1
3，遍歷rs,當計數器小於等於(row/2+1)的時候,結果放到第一個list裡面,否則放到第二個list裡面即可.

『貳』 Java演算法與數據結構代碼

第1題：我給你搭建演算法框架，具體需求，你只需往裡面寫Code即可：

publicclassProgram{

	privatestaticfinalintN=6;
	publicstaticvoidmain(String[]args){
		Nodehead=newNode(-1,null);//定義頭指針,帶頭結點的單鏈表
for(inti=0;i<N;i++){
	Nodee=newNode(i+1,null);
	tailInsert(head,e);
}

//Test
Nodep=head;
while(p.getNext()!=null){
	p=p.getNext();
}
	}
	
	/**
	*@paramhead實施尾插法演算法的單鏈表頭指針
	*@parame所需的元素
	*/
	privatestaticvoidtailInsert(Nodehead,Nodee){
		Nodep=head;
		while(p.getNext()!=null){
			p=p.getNext();//尋訪單鏈表,直至到達單鏈表末尾
		}
		//實施尾插法
		p.setNext(e);
	}
}

classNode{
	privateintid;//編號
	privateNodenext;//單鏈表後繼指針
	privateStringvote;//選票
	
	publicNode(){}
	publicNode(intid,Nodenext){
		super();
		this.id=id;
		this.next=next;
	}
	publicNode(intid,Nodenext,Stringvote){
		super();
		this.id=id;
		this.next=next;
		this.vote=vote;
	}
	@Override
	publicStringtoString(){
		return"Node[id="+id+",next="+next+"]";
	}
	publicintgetId(){
		returnid;
	}
	publicvoidsetId(intid){
		this.id=id;
	}
	publicNodegetNext(){
		returnnext;
	}
	publicvoidsetNext(Nodenext){
		this.next=next;
	}
}

第2題：參看我以前的回答：https://..com/question/431512924412893084

演算法思想已經寫的清楚得不能在清楚了。轉成Java就是小菜一碟。

『叄』 如何使用Java抓取網頁上指定部分的內容

1. 你可以選擇用Java代碼來找到整個網頁的html代碼，如下
(注意在處理網頁方面的內容時，需要導入htmlparser包來支持)

import org.htmlparser.util.ParserException;
import org.htmlparser.visitors.HtmlPage;
import org.htmlparser.Parser;
import org.htmlparser.filters.HasAttributeFilter;
import org.htmlparser.util.NodeList;

public class htmlmover {
public static void main(String[] args){
NodeList rt= getNodeList("http://forex.hexun.com/rmbhl/");
System.out.println(rt.toHtml());
}
public static NodeList getNodeList(String url){
Parser parser = null;
HtmlPage visitor = null;
try {
parser = new Parser(url);
parser.setEncoding("GBK");
visitor = new HtmlPage(parser);
parser.visitAllNodesWith(visitor);
} catch (ParserException e) {
e.printStackTrace();
}
NodeList nodeList = visitor.getBody();
return nodeList;
}
}

以上代碼，public static NodeList getNodeList(String url) 為主體
傳入需要分析網頁的 url(String類型)，返回值是網頁Html節點List(Nodelist類型)
這個方法我沒有什麼要說的，剛開始的時候沒看懂（沒接觸過），後來用了幾次也懂點皮毛了
注意： parser.setEncoding("GBK"); 可能你的工程編碼格式是UTF-8,有錯誤的話需要改動

運行該程序

2.通過瀏覽器工具直接查看 IE是按F12 （剛開始沒發現這個方法，於是傻乎乎地找上面的代碼）

分析你所獲得的html代碼讓人眼花繚亂，不要緊，找到自己需要趴取的內容，找到它上下文有特徵的節點

<!--中行牌價 開始-->
<div id="sw01_con1">
<table width="655" border="0" cellspacing="0" cellpadding="0" class="hgtab">
<thead>
<tr>
<th width="85" align="center" class="th_l">交易幣種</th>
<th width="80" align="center">交易單位</th>
<th width="130" align="center">現價(人民幣)</th>
<th width="80" align="center">賣出價</th>
<th width="100" align="center">現匯買入價</th>
<th width="95" align="center">現鈔買入價</th>
</tr>
</thead>
<tbody>
<tr align="center">
<td> 英鎊</td>
<td>100</td>
<td>992.7</td>
<td>1001.24</td>
<td>993.26</td>
<td class="no">962.6</td>
</tr>
<tr align="center" bgcolor="#f2f3f4">
<td> 港幣</td>
<td>100</td>
<td>81.54</td>
<td>82.13</td>
<td>81.81</td>
<td class="no">81.16</td>
</tr>
<tr align="center">
<td> 美元</td>
<td>100</td>
<td>635.49</td>
<td>639.35</td>
<td>636.8</td>
<td class="no">631.69</td>
</tr>
<tr align="center" bgcolor="#f2f3f4">
<td> 瑞士法郎</td>
<td>100</td>
<td>710.89</td>
<td>707.78</td>
<td>702.14</td>
<td class="no">680.46</td>
</tr>
<tr align="center">
<td> 新加坡元</td>
<td>100</td>
<td>492.45</td>
<td>490.17</td>
<td>486.27</td>
<td class="no">471.25</td>
</tr>
<tr align="center" bgcolor="#f2f3f4">
<td> 瑞典克朗</td>
<td>100</td>
<td>93.66</td>
<td>93.79</td>
<td>93.04</td>
<td class="no">90.17</td>
</tr>
<tr align="center">
<td> 丹麥克朗</td>
<td>100</td>
<td>116.43</td>
<td>115.59</td>
<td>114.67</td>
<td class="no">111.13</td>
</tr>
<tr align="center" bgcolor="#f2f3f4">
<td> 挪威克朗</td>
<td>100</td>
<td>110.01</td>
<td>109.6</td>
<td>108.73</td>
<td class="no">105.37</td>
</tr>
<!--{2011-10-01 23:16:00}-->
</tbody>
</table>
</div>
<!--中行牌價 結束-->

大家可以看到這是一段很有規律，書寫非常規范的Html代碼（這只是第一部分，中行牌價，可以想像，接下來還會有並列的 相似的3部分）

大家想截取這些節點中的數據
以下代碼仍需導入htmlparser Java支持包
import java.util.ArrayList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.htmlparser.Node;
import org.htmlparser.NodeFilter;
import org.htmlparser.Parser;
import org.htmlparser.util.NodeList;
import org.htmlparser.util.ParserException;

public class Currencyrate {
public static void main(String[] args){
String url="http://forex.hexun.com/rmbhl/";
ArrayList<String> rt= getNodeList(url);
for (int i = 0; i < rt.size(); i++){
System.out.println(rt.get(i));
}
}

public static ArrayList<String> getNodeList(String url){
final ArrayList<String> result=new ArrayList<String>();
Parser parser = null;
NodeList nodeList=null;
try {
parser = new Parser(url);
parser.setEncoding("GBK");

nodeList = parser.parse(
new NodeFilter(){
@Override
public boolean accept(Node node){
Node need=node;
if(getStringsByRegex(node.getText())){
for(int i=0;i<6;i++){
result.add(need.toPlainTextString()); need=need.getPreviousSibling().getPreviousSibling();
}
return true;
}
return false;
}
}
);
}catch (ParserException e) {
e.printStackTrace();
}
return result;
}

public static boolean getStringsByRegex(String txt) {
String regex="td class=\"no\"";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(txt);
if (m.find()){
return true;
}
return false;
}
}

廢話不多說，
public static ArrayList<String> getNodeList(String url) 主要方法
parser.setEncoding("GBK"); 需要注意，代碼編碼格式

nodeList = parser.parse(
new NodeFilter(){
@Override
public boolean accept(Node node){
}
｝
);
nodelist是html節點的列表，現在使用NodeFilter ( 節點過濾器 )實例， 重載NodeFilter類中的accept()方法
在parser這個Parser類訪問整個html頁面的時候，每遇到一個html節點，就會訪問這個
accept()方法，返回True的話就會將這個節點 放進nodelist中，否則就不會將這個節點放進去。這個就是NodeFilter功能。
代碼段一獲取整個html頁面時候 parser.visitAllNodesWith(visitor); 就是獲取所有節點

所以現在我們要趴取網頁上的內容，只要告訴accept()這個方法，哪些節點要放進nodelist去，即 遇到哪些節點需要返回true。
於是
public boolean accept(Node node){
Node need=node;
if(getStringsByRegex(node.getText())){
for(int i=0;i<6;i++){
result.add(need.toPlainTextString()); need=need.getPreviousSibling().getPreviousSibling();
}
return true;
}
return false;
}
Parser類在遇到節點，就把這個節點拿過去問accept()，於是accept()方法分析，如果滿足getStringsByRegex(node.getText())就要了

接下來分析getStringsByRegex()，只剩下最後一步了，大家堅持啊！

String regex="td class=\"no\"";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(txt);
if (m.find()){
return true;
}
return false;
}
大家可以發現我們索要的每一段都是
<tr align="center">
<td> 英鎊</td>
<td>100</td>
<td>992.7</td>
<td>1001.24</td>
<td>993.26</td>
<td class="no">962.6</td>
</tr>
所以只要找到<td class="no">這個節點就行了，我們用正則表達式去比較
String regex="td class=\"no\""; 這個是比較標准（正則表達式 td class=」no」 其中兩個引號需要作為轉義字元來表示 成\「 ）
變數txt是我們傳過去的需要比較的節點的node.getText()，如果符合的話m.find就是true,於是getStringsByRegex()返回true，說明這個節點就是我們所需要的哪些節點，於是
for(int i=0;i<6;i++){
result.add(need.toPlainTextString()); need=need.getPreviousSibling().getPreviousSibling();
}
每一段html，6個為一組，先是962.6，然後是993.26，1001.24，992.7，100，英鎊分別被add進result這個ArrayList<String>中去，返回，這個ArrayList裝的就是我們需要抓取的數據

大家可以把我們所獲得的String數據數出來試試看，是不是我們需要的順序，main()函數獲得ArrayList<String>，就可以顯示到我們所需要的Java widget上去了

『肆』 JAVA數據結構有哪幾種

JAVA數據結構有以下幾種：

1、List：

List是有序的Collection，使用此介面能夠精確的控制每個元素插入的位置。用戶能夠使用索引（元素在List中的位置，類似於數組下 >標）來訪問List中的元素，這類似於Java的數組。

2、Vector：

基於數組（Array）的List，其實就是封裝了數組所不具備的一些功能方便我們使用，所以它難易避免數組的限制，同時性能也不可能超越數組。

另外很重要的一點就是Vector是線程同步的(sychronized)的，這也是Vector和ArrayList 的一個的重要區別。

3、ArrayList：

同Vector一樣是一個基於數組上的鏈表，但是不同的是ArrayList不是同步的。所以在性能上要比Vector好一些，但是當運行到多線程環境中時，可需要自己在管理線程的同步問題。

4、LinkedList：

LinkedList不同於前面兩種List，它不是基於數組的，所以不受數組性能的限制。 它每一個節點（Node）都包含兩方面的內容：節點本身的數據（data），下一個節點的信息（nextNode）。

所以當對LinkedList做添加，刪除動作的時候就不用像基於數組的ArrayList一樣，必須進行大量的數據移動。只要更改nextNode的相關信息就可以實現了，這是LinkedList的優勢。

5、HashSet：

雖然Set同List都實現了Collection介面，但是他們的實現方式卻大不一樣。List基本上都是以Array為基礎。

但是Set則是在 HashMap的基礎上來實現的，這就是Set和List的根本區別。HashSet的存儲方式是把HashMap中的Key作為Set的對應存儲項。

6、HashMap：

基於哈希表的 Map 介面的實現。此實現提供所有可選的映射操作，並允許使用 null 值和 null 鍵。(除了不同步和允許使用 null 之外，HashMap 類與 Hashtable 大致相同。)此類不保證映射的順序，特別是它不保證該順序恆久不變。

7、HashTable：

Hashtable 是一個散列表，它存儲的內容是鍵值對(key-value)映射。Hashtable 繼承於Dictionary，實現了Map、Cloneable、java.io.Serializable介面。

Hashtable 的函數都是同步的，這意味著它是線程安全的。它的key、value都不可以為nul

『伍』 數據結構（java版）

packagegame24.datastructure.list;

/**
*鏈表的結點
*@authorluoweifu
*
*/
classNode{
	Objectdata;	//數據元素
	Nodenext;		//後驅結點
	publicNode(){
		this(null);
	}
	publicNode(Objectdata){
		this.data=data;
		this.next=null;
	}
}
/**
*帶頭結點的鏈式鏈表,下標從0開始;
*@authorAdministrator
*
*/
publicclassSinglyLinkedList<E>{
	Nodehead;	//頭結點
	intsize;	//鏈表的大小
	publicSinglyLinkedList(){
		head=newNode();
		size=0;
	}
	publicSinglyLinkedList(E[]datas){
		intn=datas.length;
		head=newNode();
		Nodep=head;
		for(inti=0;i<n;i++){
			p.next=newNode(datas[i]);
			p=p.next;
		}
		size=n;
	}
	publicSinglyLinkedList(SinglyLinkedListlist){
		head=list.head;
		size=list.size();
	}
	publicvoidadd(Objecte){
		Nodep;
		if(0==size){
			p=head;
		}else{
			p=index(size-1);
		}
		p.next=newNode(e);
		size++;
	}
	
	publicvoidconcat(SinglyLinkedListlist){
		NodelastNode=this.index(size-1);
		lastNode.next=list.index(0);
		size+=list.size();
	}

	publicvoidclear(){
		head.next=null;
		size=0;
	}

	publicObjectget(inti){
		Nodep=index(i);
		returnp.data;
	}
	
	privateNodeindex(inti){
		Nodep=null;
		if(i>=0&&i<size){
			p=head;
			for(intj=0;j<=i;j++){
				p=p.next;
			}
		}
		returnp;
	}

	publicintindexOf(Objecte){
		Nodep=head.next;
		inti=0;
		while(!p.data.equals(e)){
			p=p.next;
			i++;
		}
		if(i<size)
			returni;
		else
			return-1;
	}

	publicvoidinsert(inti,Objecte){
		Nodep=index(i);
		Nodep2=newNode(e);
		p2.next=p.next;
		p.next=p2;
		size++;
	}

	publicbooleanisEmpty(){
		if(size==0)
			returntrue;
		else
			returnfalse;
	}

	publicintlastIndexOf(Objecte){
		inti=size-1;
		while(!get(i).equals(e)){
			i--;
		}
		if(i>=0)
			returni;
		else
			return-1;
	}

	publicvoidremove(inti){
		if(i>=0&&i<size){
			Nodep=null;
			if(i==0)
				p=head;
			else{
				p=index(i-1);
			}
			p.next=index(i).next;
		}
		size--;
	}

	publicvoidset(inti,Objecte){
		Nodep=index(i);
		p.data=e;
	}

	publicintsize(){
		returnsize;
	}
	@Override
	publicbooleanequals(Objectobj){
		SinglyLinkedListlist=(SinglyLinkedList)obj;
		if(this==obj&&size==list.size){
			returntrue;
		}
		returnfalse;
	}
	/**
	*測試線性表
	*@paramargs
	*/
	publicstaticvoidmain(Stringargs[]){
		//Listlist=newLinkList();
		//Listlist=newDoubleLinkList();
		SinglyLinkedListlist1=newSinglyLinkedList();
		for(inti=0;i<10;i++){
			list1.add(newInteger(i));
		}
		Integer[]a={101,102,103,104,105,106,107,108,109,110};
		SinglyLinkedListlist=newSinglyLinkedList(a);
		list.remove(9);
		System.out.print("size:"+list.size()+"
");
		System.out.println("isEmpty:"+list.isEmpty());
		System.out.print("第7個位置的元素："+list.get(7)+"
");	
		list.concat(list1);
		for(inti=0;i<list.size();i++){
			System.out.print(list.get(i)+"");
		}
		
		list.add(21);
		list.add(22);
		list.insert(3,newInteger(5));
		System.out.print("size:"+list.size()+"
");
		System.out.print("第一次出現5的索引："+list.indexOf(5)+"
");
		System.out.print("最後一次出現5的索引："+list.lastIndexOf(5)+"
");
		list.set(0,newInteger(30));
		for(inti=0;i<list.size();i++){
			System.out.print(list.get(i)+"");
		}
		
		SinglyLinkedListlist2=list;
		System.out.println("
isequels?"+list2.equals(list));
	}
}

『陸』 java數據結構

B.push(A.pop());
A.pop()；

解釋:
A.pop() 去掉A的最後一個，即4， 變成1,2,3。而且返回這個4
A.pop() 去掉3
B.push() 接受一個值，放在最後。
因為push接受的是A.pop()返回的4，所以，B就變成 5,6,7,8,4

『柒』 用java實現一個數據結構！

import java.io.IOException;
import java.util.Scanner;

public class LinkList {
private static Scanner san = new Scanner(System.in);

public static void main(String[] args) throws IOException {
List list = new List();
for (int i = 1; i <= 10; i++) {
System.out.print("請輸入第" + i + "個數: ");
list.add(san.nextInt());
list.print();
}
System.out.println("輸入的數據如下: ");
list.print();
}
}

class node {
int data;
node next = this; // 指向自己
}

class List {
private node header = new node();

// 循環鏈表的尾部添加數據
public node add(int data) {
node current = new node();
node temp = header;
while (temp.next != header)
temp = temp.next;
current.data = data;
current.next = temp.next;
temp.next = current;
return current;
}

// 查詢某個數字的位置 如果不在 返回-1；
public int search(int data) {
node temp = header;

int n = 0;
while (temp.next != header) {
temp = temp.next;
n++;
if (temp.data == data)
break;
}
if (temp.data == data)
return n;
else
return -1;
}

// 列印出整個鏈表
public void print() {
node temp = header;
while (temp.next != header) {

temp = temp.next;
System.out.print(temp.data + " ");
}
System.out.println();
}

// 插入數據
public node Insert(int pos, int data) {
node temp = header;
node current = new node();
for (int i = 0; i < pos - 1; i++) {
if (temp.next != header) {
temp = temp.next;
} else
return null;
}
current.data = data;
if (temp.next != header) {
current.next = temp.next;
}
temp.next = current;
return current;
}

// 刪除某個數據
public node del(int data) {
node temp = header;
node oldtemp = null;
node current = null;
while (temp.next != header) {
oldtemp = temp;
temp = temp.next;
if (temp.data == data) {
current = temp;
break;
}
}
if (current == header)
return null;
oldtemp.next = current.next;
return current;
}
}

『捌』 求程序代碼（java版的數據結構）

3個class，運行UI.java。
******
public class CircuitException extends Exception {public CircuitException(){}}
*****
import java.util.LinkedList;
public class GPS {
public static final int MAX = 65535;
public GPS(int maxSize){
graph = new Graph(maxSize);
}
public GPS(){
graph = new Graph();
}
public Graph graph;
public static void main(String args[]){
GPS gps = new GPS();
try {
gps.graph.addEdge("a", "b", 1);
gps.graph.addEdge("a", "c", 1);
gps.graph.addEdge("b","d" , 1);
gps.graph.addEdge("c","d" , 1);
gps.graph.addEdge("d","e" , 1);
gps.graph.addEdge("d","f" , 1);
gps.graph.addEdge("e","t" , 2);
gps.graph.addEdge("f","t" , 1);
LinkedList list = gps.graph.getPath("a", "d");
for(int i = 0 ; i < list.size() ; i++){
System.out.print(list.get(i));

}System.out.println();
} catch (CircuitException e) {
System.out.println("出現了自環！");
}
gps.graph.showGraph();
System.out.println(gps.graph.gap);
}
public class Graph{
public int Zuida = 50;
public int chang = 0;
public Jiao[] vertex;
public double gap;
public Graph(){
vertex = new Jiao[Zuida];
}
public Graph(int maxSize){
this.Zuida = maxSize;
vertex = new Jiao[maxSize];
}
public void addVertex(String name){
vertex[chang++] = new Jiao(name);
}
public void addEdge(String v1, String v2,double edge) throws CircuitException{
//先找到v1；
if(v1.equals(v2))
throw new CircuitException();
Jiao from = null;
Jiao to = null;
for(int i = 0 ; i < chang ; i++){
if(vertex[i].name.equals(v1)){
from = vertex[i];
}else if(vertex[i].name.equals(v2)){
to = vertex[i];
}
}
if(from == null){
this.addVertex(v1);
from = this.vertex[chang-1];
}
if(to == null){
this.addVertex(v2);
to = this.vertex[chang-1];
}//已經找到v1和v2；
//沒有檢測是否v1 v2邊已經存在！
//加入邊。
Jiao v1adj = new Jiao(v2);
v1adj.edge = edge;
Jiao v2adj = new Jiao(v1);
v2adj.edge = edge;
//添加聯系
//檢查聯系是否已經存在
Jiao temp = from;
while(temp.next!=null){
Jiao temppar = temp;
temp = temp.next;
if(temp.name.equals(v1adj.name)){
temppar.next = temp.next;
}
}
v1adj.next = from.next;
from.next = v1adj;
//v2adj.next = to.next;
//to.next = v2adj;
}
//假設要找的必然存在，不用想是否不在
public LinkedList getPath(String v1 ,String v2){
int count = 0;
//System.out.println(count++);
boolean found[] = new boolean[chang];
double distance[] = new double[chang];
int to = 0;
Jiao from = null;
for(int i = 0 ; i < chang ; i++){
found[i] = false;
distance[i] = MAX;
}
for(int i = 0 ; i < chang ; i++){
if(vertex[i].name.equals(v1)){//找到始發地
from = vertex[i];
distance[i] = 0;
found[i] = true;
//System.out.println(count++);
}
if(vertex[i].name.equals(v2)){//找到目的地
to = i;
//System.out.println(count++);
}
}
//必須先准備好路徑！
Jiao forCount = from;
int degree = 0;
while(forCount!=null){
degree++;
forCount=forCount.next;
}
LinkedList[] list = new LinkedList[degree];
int [] mark = new int[degree];
for(int i = 0 ; i < degree ; i++){
list[i]=new LinkedList();
mark[i]=MAX;
}
int test=0;
int count2 = 0;
int count3 = 0;
//System.out.println(count+++"xx");
while(!found[to]&&test++<100){
//System.out.println(count+++"FIRST");

//開始時from到所有都是最大值。
//找到標記了的節點
//找標記了的節點鄰接的未標記的節點。
//得到最短的邊，並標記。
//更新現有路徑
double min = MAX;
int address = -1;
int father = -1;
for(int i = 0 ; i < chang ; i++){//對於已經找到的頂點尋找最小的往後的距離。
if(found[i]){//找到了的。
Jiao temp = vertex[i];
while(temp!=null){//vertex的鄰接頂點~~

//先看temp的號碼~
int tempNumber = -1;
for(int j = 0 ; j < chang ; j++){
if(vertex[j].name.equals(temp.name)){
tempNumber = j;
break;
}
}
if(!found[tempNumber]){//如果是還沒有找到的~
double dist = distance[i]+temp.edge;
if(dist < min){
min = dist;
father = i;
//System.out.println(" "+min);
address = tempNumber;
}
}
temp = temp.next;
}

}

}found[address] = true;
distance[address] = min;
//添加到已有路徑中去！
//知道father
for(int i = 0 ; i < degree ; i++){
if(list[i].isEmpty()||list[i].getLast().equals(vertex[father].name)){
list[i].addLast(vertex[address].name);
break;
}
}
}
for(int i = 0 ; i < degree ; i++){
if(list[i].isEmpty())
continue;
else{
if(list[i].getLast().equals(v2)){
gap=0;
//先求出gap
Jiao pre = from;
Jiao nex = null;
for(int j = 0 ; j < list[i].size() ; j++){
for(int k = 0 ; k < chang ; k++){
if(vertex[k].name.equals(list[i].get(j))){
nex = vertex[k];break;
}
}

while(pre.next!=null){//找到下一個的長度
pre = pre.next;
//System.out.println(nex.name +"nex.name");
if(pre.name.equals(nex.name)){
gap+=pre.edge;
//System.out.println(" gap2 "+gap);
}
}
pre = nex;
}
//System.out.println(gap+"gap");
return list[i];
}
}
}
return null;
}
public void showGraph(){
Jiao temp;
for(int i = 0 ; i < chang ; i++){
temp = vertex[i];
while(temp!=null){
System.out.print(temp.name+temp.edge+" ");
temp = temp.next;
}System.out.println();
}System.out.println("Show Over!");
}
}

public class Jiao{
public String name;
public Jiao next = null;
public double edge;
public Jiao(String name){
this.name = name;
}
}
}
******
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.LinkedList;
import javax.swing.JButton;
import javax.swing.DefaultListModel;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JSeparator;
import javax.swing.JTextField;
import javax.swing.SwingConstants;

public class UI extends JFrame implements ActionListener{

private JTextField textField_5;
private JTextField textField_4;
private JList list_1;
private JList list;
private JTextField textField_1;
private JTextField textField_3;
private JTextField textField_2;
private JTextField textField;
private DefaultListModel model = new DefaultListModel();
private DefaultListModel model_1 = new DefaultListModel();
/**
* Launch the application
* @param args
*/
public static void main(String args[]) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
UI frame = new UI();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

/**
* Create the frame
*/
public UI() {
super();
setTitle("GPS尋路");
getContentPane().setLayout(null);
setBounds(100, 100, 500, 375);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

final JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(11, 36, 221, 193);
getContentPane().add(scrollPane);

list = new JList(model);
scrollPane.setViewportView(list);

final JScrollPane scrollPane_1 = new JScrollPane();
scrollPane_1.setBounds(253, 36, 218, 193);
getContentPane().add(scrollPane_1);

list_1 = new JList(model_1);
scrollPane_1.setViewportView(list_1);

final JLabel label = new JLabel();
label.setText("從");
label.setBounds(10, 249, 24, 18);
getContentPane().add(label);

final JLabel label_1 = new JLabel();
label_1.setText("到");
label_1.setBounds(11, 273, 24, 18);
getContentPane().add(label_1);

textField = new JTextField();
textField.setBounds(50, 247, 103, 22);
getContentPane().add(textField);

textField_2 = new JTextField();
textField_2.setBounds(50, 271, 103, 22);
getContentPane().add(textField_2);

final JLabel label_2 = new JLabel();
label_2.setText("距離");
label_2.setBounds(11, 297, 37, 18);
getContentPane().add(label_2);

textField_3 = new JTextField();
textField_3.setBounds(50, 295, 103, 22);
getContentPane().add(textField_3);

final JButton button = new JButton();
button.setText("添加");
button.setBounds(155, 250, 73, 28);
getContentPane().add(button);

final JButton button_1 = new JButton();
button_1.setText("刪除");
button_1.setBounds(155, 285, 73, 28);
getContentPane().add(button_1);

final JLabel label_3 = new JLabel();
label_3.setText("距離：");
label_3.setBounds(253, 297, 39, 18);
getContentPane().add(label_3);

textField_1 = new JTextField();
textField_1.setBounds(293, 295, 86, 22);
getContentPane().add(textField_1);

final JButton button_2 = new JButton();
button_2.setText("顯示路徑");
button_2.setBounds(385, 249, 86, 68);
getContentPane().add(button_2);

final JLabel label_4 = new JLabel();
label_4.setText("路徑表示");
label_4.setBounds(11, 10, 66, 18);
getContentPane().add(label_4);

final JLabel label_5 = new JLabel();
label_5.setText("最佳路徑");
label_5.setBounds(253, 12, 66, 18);
getContentPane().add(label_5);
//
button.addActionListener(this);
button_1.addActionListener(this);
button_2.addActionListener(this);

final JLabel label_6 = new JLabel();
label_6.setText("從");
label_6.setBounds(253, 249, 24, 18);
getContentPane().add(label_6);

textField_4 = new JTextField();
textField_4.setBounds(293, 247, 86, 22);
getContentPane().add(textField_4);

final JLabel label_7 = new JLabel();
label_7.setText("到");
label_7.setBounds(253, 273, 24, 18);
getContentPane().add(label_7);

textField_5 = new JTextField();
textField_5.setBounds(293, 271, 86, 22);
getContentPane().add(textField_5);

final JSeparator separator = new JSeparator();
separator.setOrientation(SwingConstants.VERTICAL);
separator.setBounds(239, 10, 8, 317);
getContentPane().add(separator);
}

@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
if(e.getActionCommand().equals("添加")){

try{String from = textField.getText();
String to = textField_2.getText();
if(from.equals(to)){
JOptionPane.showMessageDialog(null, "始點與終點不能相同");
return;
}
if(from.equals("")||to.equals("")){
JOptionPane.showMessageDialog(null, "添加不能為空");
return;
}for(int i = 0 ; i < model.size() ; i ++){
if(model.get(i).toString().substring(0, model.get(i).toString().indexOf(":")).equals(
from+"->"+to))
model.remove(i);
}
double length = Double.parseDouble(textField_3.getText());
model.addElement(from+"->"+to+": "+length);

}catch(Exception e1){
JOptionPane.showMessageDialog(null, "距離為數字值");
}
}
if(e.getActionCommand().equals("刪除")){
for(int i = 0 ; i < model.size() ; i++){
if(list.isSelectedIndex(i))
model.remove(i);
}
}
if(e.getActionCommand().equals("顯示路徑")){
try{
model_1.removeAllElements();
GPS gps = new GPS();
String full,from,to;
double length;
for(int i = 0 ; i < model.size() ; i++){
full = model.get(i).toString();
from = full.substring(0,full.indexOf("-"));
to = full.substring(full.indexOf("-")+2,full.lastIndexOf(":"));
length = Double.parseDouble(full.substring(full.indexOf(":")+1, full.length()-1));
//System.out.println(from);
//System.out.println(to);
try {
gps.graph.addEdge(from, to, length);
System.out.println(from +" "+ to);
} catch (CircuitException e1) {
System.out.println("有環存在");
}
}LinkedList list = gps.graph.getPath(textField_4.getText(), textField_5.getText());
model_1.addElement(textField_4.getText());
for(int i = 0 ; i < list.size() ; i++){
model_1.addElement(list.get(i));
}//計算路徑長度
textField_1.setText(""+gps.graph.gap);
}catch(Exception e1){
JOptionPane.showMessageDialog(null, "沒有找到有關節點");
}
}
}
}

『玖』 關於數據結構（java）的一個代碼

描述棧抽象數據類型的SStack介面的聲明
public interfaceSStack<E> //棧介面
{
boolean isEmpty(); //判斷是否空棧，若空棧返回true
boolean push(E element); //元素element入棧，若操作成功返回true
E pop(); //出棧，返回當前棧頂元素，若棧空返回null
E get(); //取棧頂元素值，未出棧，若棧空返回null
}
順序棧類具體操作方法的聲明：

importdataStructure.linearList.SStack;

public classSeqStack<E> implements SStack<E>
//順序棧類

{
private Object value[]; //存儲棧的數據元素
private int top; //top為棧頂元素下標

public SeqStack(int capacity) //構造指定容量的空棧
{
this.value = newObject[Math.abs(capacity)];
this.top=-1;
}
public SeqStack() //構造默認容量的空棧
{
this(10);
}

public boolean isEmpty() //判斷是否空棧，若空棧返回true
{
return this.top==-1;
}

public boolean push(E element) //元素element入棧，若操作成功返回true
{
if (element==null)
return false; //空對象（null）不能入棧

if (this.top==value.length-1) //若棧滿，則擴充容量
{
Object[] temp = this.value;
this.value = newObject[temp.length*2];
for (int i=0; i<temp.length;i++)
this.value[i] = temp[i];
}
this.top++;
this.value[this.top] = element;
return true;
}

public E pop() //出棧，返回當前棧頂元素，若棧空返回null
{
if (!isEmpty())
return (E)this.value[this.top--];
else
return null;
}

public E get() //取棧頂元素值，未出棧，棧頂元素未改變
{
if (!isEmpty())
return (E)this.value[this.top];
else
return null;
}

public String toString() //返回棧中各元素的字元串描述
{
String str="{";
if (this.top!=-1)
str +=this.value[this.top].toString();
for (int i=this.top-1; i>=0; i--)
str += ","+this.value[i].toString();
return str+"} ";
}
實例引用public static void main(String args[])
{
SeqStack<String> stack = newSeqStack<String>(20);
System.out.print("Push: ");
char ch='a';
for(int i=0;i<5;i++)
{
String str =(char)(ch+i)+"";
stack.push(str);
System.out.print(str+" ");
}
System.out.println("\n"+stack.toString());

System.out.print("Pop : ");
while(!stack.isEmpty()) //全部出棧
System.out.print(stack.pop().toString()+" ");
System.out.println();
}