java鏈表增刪改查（單鏈表實現增刪改查）

本文目錄一覽：

• 1、Java為鏈表查詢慢，增刪快呢? 增刪的話，不是也要先查詢它前面是誰嗎?
• 2、我想用JAVA實現一個鏈表的插入~刪除等操作~ （要再界面上操作~~~ 就是我按下一個鍵能進行插入刪除的操作的
• 3、java 表格增刪改查
• 4、用JAVA語言解決：編寫一個鏈表類(雙向鏈表),實現插入,刪除,查找操作
• 5、java連接sql數據庫。實現增刪改查怎麼寫。誰有實例

Java為鏈表查詢慢，增刪快呢? 增刪的話，不是也要先查詢它前面是誰嗎?

哈,我來說一下我的理解,在Java裏面數組和鏈表的區別:

拿數組(Array)刪除一個元素來說(以下為JDK源碼):

public E remove(int index) {

    rangeCheck(index);

    modCount++;

    E oldValue = elementData(index);

    int numMoved = size – index – 1;

    if (numMoved  0)

        System.arraycopy(elementData, index+1, elementData, index,

                         numMoved);

    elementData[–size] = null; // clear to let GC do its work

    return oldValue;

}

可以看出數組的刪除某一個元素是:把該元素後面的所有元素都把下標往前移一,那麼比如你數組有1kw個元素,你刪除第一個,後面就要移動900多萬次,這就是數組隨機訪問快,刪除慢的緣故.

然而鏈表的,就是你說的,鏈表隨機訪問慢(查詢某一個元素),但是新增一個元素比如

node1(next – node2),node2(next-node3),node3(next-null)…

如果刪除node2,則只需要改變node1(next-node3)就好了,增加一個元素的時候node4的時候,node3(next-node4)

如有疑問,請留言(最怕誤導別人,如有理解錯誤之處,懇請各路大神指點)

我想用JAVA實現一個鏈表的插入~刪除等操作~ （要再界面上操作~~~ 就是我按下一個鍵能進行插入刪除的操作的

編輯詞條JAVA容器

解釋一：

容器（Container）

Spring 提供容器功能，容器可以管理對象的生命周期、對象與對象之間的依賴關係，您可以使用一個配置文件（通常是XML），在上面定義好對象的名稱、如何產生（Prototype 方式或Singleton 方式）、哪個對象產生之後必須設定成為某個對象的屬性等，在啟動容器之後，所有的對象都可以直接取用，不用編寫任何一行程序代碼來產生對象，或是建立對象與對象之間的依賴關係。

換個更直白點的說明方式：容器是一個Java 所編寫的程序，原先必須自行編寫程序以管理對象關係，現在容器都會自動幫您作好。

常用容器：WebSphere,WebLogic,Resin,Tomcat

———————————-

解釋二：

容器類

Java容器類包含List、ArrayList、Vector及map、HashTable、HashMap

ArrayList和HashMap是異步的，Vector和HashTable是同步的，所以Vector和HashTable是線程安全的，而 ArrayList和HashMap並不是線程安全的。因為同步需要花費機器時間，所以Vector和HashTable的執行效率要低於 ArrayList和HashMap。

Collection

├List 接口

│├LinkedList 鏈表

│├ArrayList 順序結構動態數組類

│└Vector 向量

│ └Stack 棧

└Set

Map

├Hashtable

├HashMap

└WeakHashMap List接口

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

和下面要提到的Set不同，List允許有相同的元素。

除了具有Collection接口必備的iterator()方法外，List還提供一個listIterator()方法，返回一個 ListIterator接口，和標準的Iterator接口相比，ListIterator多了一些add()之類的方法，允許添加，刪除，設定元素， 還能向前或向後遍歷。

實現List接口的常用類有LinkedList，ArrayList，Vector和Stack。

ArrayList類

ArrayList實現了可變大小的數組。它允許所有元素，包括null。ArrayList沒有同步。

size，isEmpty，get，set方法運行時間為常數。但是add方法開銷為分攤的常數，添加n個元素需要O(n)的時間。其他的方法運行時間為線性。

每個ArrayList實例都有一個容量（Capacity），即用於存儲元素的數組的大小。這個容量可隨着不斷添加新元素而自動增加，但是增長算法 並沒有定義。當需要插入大量元素時，在插入前可以調用ensureCapacity方法來增加ArrayList的容量以提高插入效率。

和LinkedList一樣，ArrayList也是非同步的（unsynchronized）。

Map接口

請注意，Map沒有繼承Collection接口，Map提供key到value的映射。一個Map中不能包含相同的key，每個key只能映射一個 value。Map接口提供3種集合的視圖，Map的內容可以被當作一組key集合，一組value集合，或者一組key-value映射。

HashMap類

HashMap和Hashtable類似，不同之處在於HashMap是非同步的，並且允許null，即null value和null key。，但是將HashMap視為Collection時（values()方法可返回Collection），其迭代子操作時間開銷和HashMap 的容量成比例。因此，如果迭代操作的性能相當重要的話，不要將HashMap的初始化容量設得過高，或者load factor過低。

Collection接口

Collection是最基本的集合接口，一個Collection代表一組Object，即Collection的元素（Elements）。一些Collection允許相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接繼承自Collection的類，Java SDK提供的類都是繼承自Collection的「子接口」如List和Set。

所有實現Collection接口的類都必須提供兩個標準的構造函數：無參數的構造函數用於創建一個空的Collection，有一個Collection參數的構造函數用於創建一個新的Collection，這個新的Collection與傳入的Collection有相同的元素。後一個構造函數允許用戶複製一個Collection。

如何遍歷Collection中的每一個元素？不論Collection的實際類型如何，它都支持一個iterator()的方法，該方法返回一個迭代子，使用該迭代子即可逐一訪問Collection中每一個元素。典型的用法如下：

Iterator it = collection.iterator(); // 獲得一個迭代子

while(it.hasNext()) {

Object obj = it.next(); // 得到下一個元素

}

由Collection接口派生的兩個接口是List和Set。

Hashtable類

Hashtable繼承Map接口，實現一個key-value映射的哈希表。任何非空（non-null）的對象都可作為key或者value。

添加數據使用put(key, value)，取出數據使用get(key)，這兩個基本操作的時間開銷為常數。

Hashtable通過initial capacity和load factor兩個參數調整性能。通常缺省的load factor 0.75較好地實現了時間和空間的均衡。增大load factor可以節省空間但相應的查找時間將增大，這會影響像get和put這樣的操作。

使用Hashtable的簡單示例如下，將1，2，3放到Hashtable中，他們的key分別是」one」，」two」，」three」：

Hashtable numbers = new Hashtable();

numbers.put(「one」, new Integer(1));

numbers.put(「two」, new Integer(2));

numbers.put(「three」, new Integer(3));

要取出一個數，比如2，用相應的key：

Integer n = (Integer)numbers.get(「two」);

System.out.println(「two = 」 + n);

由於作為key的對象將通過計算其散列函數來確定與之對應的value的位置，因此任何作為key的對象都必須實現hashCode和equals方法。hashCode和equals方法繼承自根類Object，如果你用自定義的類當作key的話，要相當小心，按照散列函數的定義，如果兩個對象相同，即obj1.equals(obj2)=true，則它們的hashCode必須相同，但如果兩個對象不同，則它們的hashCode不一定不同，如果兩個不同對象的hashCode相同，這種現象稱為衝突，衝突會導致操作哈希表的時間開銷增大，所以盡量定義好的hashCode()方法，能加快哈希表的操作。

如果相同的對象有不同的hashCode，對哈希表的操作會出現意想不到的結果（期待的get方法返回null），要避免這種問題，只需要牢記一條：要同時複寫equals方法和hashCode方法，而不要只寫其中一個。

Hashtable是同步的。

HashMap類

HashMap和Hashtable類似，不同之處在於HashMap是非同步的，並且允許null，即null value和null key。，但是將HashMap視為Collection時（values()方法可返回Collection），其迭代子操作時間開銷和HashMap的容量成比例。因此，如果迭代操作的性能相當重要的話，不要將HashMap的初始化容量設得過高，或者load factor過低。

WeakHashMap類

WeakHashMap是一種改進的HashMap，它對key實行「弱引用」，如果一個key不再被外部所引用，那麼該key可以被GC回收。

總結

如果涉及到堆棧，隊列等操作，應該考慮用List，對於需要快速插入，刪除元素，應該使用LinkedList，如果需要快速隨機訪問元素，應該使用ArrayList。

如果程序在單線程環境中，或者訪問僅僅在一個線程中進行，考慮非同步的類，其效率較高，如果多個線程可能同時操作一個類，應該使用同步的類。

要特別注意對哈希表的操作，作為key的對象要正確複寫equals和hashCode方法。

盡量返回接口而非實際的類型，如返回List而非ArrayList，這樣如果以後需要將ArrayList換成LinkedList時，客戶端代碼不用改變。這就是針對抽象編程。

同步性

Vector是同步的。這個類中的一些方法保證了Vector中的對象是線程安全的。而ArrayList則是異步的，因此ArrayList中的對象並不是線程安全的。因為同步的要求會影響執行的效率，所以如果你不需要線程安全的集合那麼使用ArrayList是一個很好的選擇，這樣可以避免由於同步帶來的不必要的性能開銷。

數據增長

從內部實現機制來講ArrayList和Vector都是使用數組(Array)來控制集合中的對象。當你向這兩種類型中增加元素的時候，如果元素的數目超出了內部數組目前的長度它們都需要擴展內部數組的長度，Vector缺省情況下自動增長原來一倍的數組長度，ArrayList是原來的50%,所以最後你獲得的這個集合所佔的空間總是比你實際需要的要大。所以如果你要在集合中保存大量的數據那麼使用Vector有一些優勢，因為你可以通過設置集合的初始化大小來避免不必要的資源開銷。

使用模式

在ArrayList和Vector中，從一個指定的位置（通過索引）查找數據或是在集合的末尾增加、移除一個元素所花費的時間是一樣的，這個時間我們用O(1)表示。但是，如果在集合的其他位置增加或移除元素那麼花費的時間會呈線形增長：O(n-i)，其中n代表集合中元素的個數，i代表元素增加或移除元素的索引位置。為什麼會這樣呢？以為在進行上述操作的時候集合中第i和第i個元素之後的所有元素都要執行位移的操作。這一切意味着什麼呢？

這意味着，你只是查找特定位置的元素或只在集合的末端增加、移除元素，那麼使用Vector或ArrayList都可以。如果是其他操作，你最好選擇其他的集合操作類。比如，LinkList集合類在增加或移除集合中任何位置的元素所花費的時間都是一樣的?O(1)，但它在索引一個元素的使用缺比較慢－O(i),其中i是索引的位置.使用ArrayList也很容易，因為你可以簡單的使用索引來代替創建iterator對象的操作。LinkList也會為每個插入的元素創建對象，所有你要明白它也會帶來額外的開銷。

最後，在《Practical Java》一書中Peter Haggar建議使用一個簡單的數組（Array）來代替Vector或ArrayList。尤其是對於執行效率要求高的程序更應如此。因為使用數組(Array)避免了同步、額外的方法調用和不必要的重新分配空間的操作。

理解集合類

集合類存放於java.util包中。

集合類存放的都是對象的引用，而非對象本身，出於表達上的便利，我們稱集合中的對象就是指集合中對象的引用（reference)。

集合類型主要有3種：set(集）、list(列表）和map(映射)。

(1)集

集（set）是最簡單的一種集合，它的對象不按特定方式排序，只是簡單的把對象加入集合中，就像往口袋裡放東西。

對集中成員的訪問和操作是通過集中對象的引用進行的，所以集中不能有重複對象。

集也有多種變體，可以實現排序等功能，如TreeSet，它把對象添加到集中的操作將變為按照某種比較規則將其插入到有序的對象序列中。它實現的是SortedSet接口，也就是加入了對象比較的方法。通過對集中的對象迭代，我們可以得到一個升序的對象集合。

(2)列表

列表的主要特徵是其對象以線性方式存儲，沒有特定順序，只有一個開頭和一個結尾，當然，它與根本沒有順序的集是不同的。

列表在數據結構中分別表現為：數組和向量、鏈表、堆棧、隊列。

關於實現列表的集合類，是我們日常工作中經常用到的，將在後邊的筆記詳細介紹。

(3)映射

映射與集或列表有明顯區別，映射中每個項都是成對的。映射中存儲的每個對象都有一個相關的關鍵字（Key）對象，關鍵字決定了對象在映射中的存儲位置，檢索對象時必須提供相應的關鍵字，就像在字典中查單詞一樣。關鍵字應該是唯一的。

關鍵字本身並不能決定對象的存儲位置，它需要對過一種散列(hashing)技術來處理，產生一個被稱作散列碼(hash code)的整數值，散列碼通常用作一個偏置量，該偏置量是相對於分配給映射的內存區域起始位置的，由此確定關鍵字/對象對的存儲位置。理想情況下，散列處理應該產生給定範圍內均勻分佈的值，而且每個關鍵字應得到不同的散列碼。

集合類簡介

java.util中共有13個類可用於管理集合對象，它們支持集、列表或映射等集合，以下是這些類的簡單介紹

集：

HashSet： 使用HashMap的一個集的實現。雖然集定義成無序，但必須存在某種方法能相當高效地找到一個對象。使用一個HashMap對象實現集的存儲和檢索操作是在固定時間內實現的.

TreeSet： 在集中以升序對對象排序的集的實現。這意味着從一個TreeSet對象獲得第一個迭代器將按升序提供對象。TreeSet類使用了一個TreeMap.

列表：

Vector： 實現一個類似數組一樣的表，自動增加容量來容納你所需的元素。使用下標存儲和檢索對象就象在一個標準的數組中一樣。你也可以用一個迭代器從一個Vector中檢索對象。Vector是唯一的同步容器類??當兩個或多個線程同時訪問時也是性能良好的。

Stack: 這個類從Vector派生而來，並且增加了方法實現棧??一種後進先出的存儲結構。

LinkedList: 實現一個鏈表。由這個類定義的鏈表也可以像棧或隊列一樣被使用。

ArrayList: 實現一個數組，它的規模可變並且能像鏈表一樣被訪問。它提供的功能類似Vector類但不同步。

映射：

HashTable： 實現一個映象，所有的鍵必須非空。為了能高效的工作，定義鍵的類必須實現hashcode()方法和equal()方法。這個類是前面java實現的一個繼承，並且通常能在實現映象的其他類中更好的使用。

HashMap： 實現一個映象，允許存儲空對象，而且允許鍵是空（由於鍵必須是唯一的，當然只能有一個）。

WeakHashMap： 實現這樣一個映象：通常如果一個鍵對一個對象而言不再被引用，鍵/對象對將被捨棄。這與HashMap形成對照，映象中的鍵維持鍵/對象對的生命周期，儘管使用映象的程序不再有對鍵的引用，並且因此不能檢索對象。

TreeMap： 實現這樣一個映象，對象是按鍵升序排列的。

Set和List都是由公共接口Collection擴展而來，所以它們都可以使用一個類型為Collection的變量來引用。這就意味着任何列表或集構成的集合都可以用這種方式引用，只有映射類除外（但也不是完全排除在外，因為可以從映射獲得一個列表。）所以說，把一個列表或集傳遞給方法的標準途徑是使用Collection類型的參數。

另外,站長團上有產品團購,便宜有保證

java 表格增刪改查

import java.util.*;

import java.text.*;

import java.io.*;

import jxl.*;

public class jxl

{

public static void main(String[] args)

{

String fileName = “c://signupcheckin.xls”;

InputStream is = null;

FileInputStream fn = null;

int cs = 0;

int rs = 0;

try{

fn = new FileInputStream(fileName);

is = fn;

Workbook rb = Workbook.getWorkbook(is);

Sheet s = rb.getSheet(0);//此處只讀取第一個sheet內容

Cell a2=s.getCell(0,1); //此處是獲取單個單元格的數據

Cell c4=s.getCell(2,3);

String sa2=a2.getContents();

String sc4=c4.getContents();

System.out.println(sa2+” “+sc4);

System.out.print(“\n\n\n”);

cs = s.getColumns();

rs = s.getRows();

for(int j=0;jrs;j++){

Cell[] c = s.getRow(j);

for(int x=0;xc.length;x++){

System.out.print(c[x].getContents()+”\t”);

}

System.out.print(“\r\n”);

}

System.out.println(“Columns:”+cs+” Rows:”+rs);

}catch(Exception e){

System.out.println(e.toString());

}finally{

try{

fn.close();

is.close();

}catch(Exception e){

System.out.println(e.toString());

}

}

}

}

用JAVA語言解決：編寫一個鏈表類(雙向鏈表),實現插入,刪除,查找操作

public class DoubleLinkedList

{

// 節點類Node

private static class Node

{

Object value;

Node prev = this;

Node next = this;

Node(Object v)

{

value = v;

}

public String toString()

{

return value.toString();

}

}

private Node head = new Node(null); // 頭節點

private int size; // 鏈表大小

// 以下是接口方法

public boolean addFirst(Object o)

{

addAfter(new Node(o), head);

return true;

}

public boolean addLast(Object o)

{

addBefore(new Node(o), head);

return true;

}

public boolean add(Object o)

{

return addLast(o);

}

public boolean add(int index, Object o)

{

addBefore(new Node(o), getNode(index));

return true;

}

public boolean remove(int index)

{

removeNode(getNode(index));

return true;

}

public boolean removeFirst()

{

removeNode(head.next);

return true;

}

public boolean removeLast()

{

removeNode(head.prev);

return true;

}

public Object get(int index)

{

return getNode(index).value;

}

public int size()

{

return size;

}

public String toString()

{

StringBuffer s = new StringBuffer(“[“);

Node node = head;

for (int i = 0; i size; i++)

{

node = node.next;

if (i 0)

s.append(“, “);

s.append(node.value);

}

s.append(“]”);

return s.toString();

}

private Node getNode(int index)

{

if (index 0 || index = size)

throw new IndexOutOfBoundsException();

Node node = head.next;

for (int i = 0; i index; i++)

node = node.next;

return node;

}

private void addBefore(Node newNode, Node node)

{

newNode.next = node;

newNode.prev = node.prev;

newNode.next.prev = newNode;

newNode.prev.next = newNode;

size++;

}

private void addAfter(Node newNode, Node node)

{

newNode.prev = node;

newNode.next = node.next;

newNode.next.prev = newNode;

newNode.prev.next = newNode;

size++;

}

private void removeNode(Node node)

{

node.prev.next = node.next;

node.next.prev = node.prev;

node.prev = null;

node.next = null;

size–;

}

}

//測試類：

public class Test

{

public static void main(String[] args)

{

DoubleLinkedList dll = new DoubleLinkedList();

//添加

dll.add(“張三”);

dll.add(“李四”);

dll.add(“王五”);

System.out.println(dll);

//添加到最前

dll.addFirst(“孫七”);

System.out.println(dll);

//添加到最後，同添加

dll.addLast(“趙六”);

System.out.println(dll);

//添加到指定位置

dll.add(4, “王祖賢”);

System.out.println(dll);

//移除最前的

dll.removeFirst();

System.out.println(dll);

//移除最後的

dll.removeLast();

System.out.println(dll);

//移除指定位置上的

dll.remove(2);

System.out.println(dll);

//返回指定位置上的元素

System.out.println(dll.get(1));

}

}

java連接sql數據庫。實現增刪改查怎麼寫。誰有實例

java連接數據庫，你可以用一些框架，比如hibernate，iBATIS等，這樣方便一點，否則你就用JDBC吧，自己寫sql語句：

JDBC連接數據庫

•創建一個以JDBC連接數據庫的程序，包含7個步驟：

1、加載JDBC驅動程序：

在連接數據庫之前，首先要加載想要連接的數據庫的驅動到JVM（Java虛擬機），

這通過java.lang.Class類的靜態方法forName(String className)實現。

例如：

try{

//加載MySql的驅動類

Class.forName(“com.mysql.jdbc.Driver”) ;

}catch(ClassNotFoundException e){

System.out.println(“找不到驅動程序類 ，加載驅動失敗！”);

e.printStackTrace() ;

}

成功加載後，會將Driver類的實例註冊到DriverManager類中。

2、提供JDBC連接的URL

•連接URL定義了連接數據庫時的協議、子協議、數據源標識。

•書寫形式：協議：子協議：數據源標識

協議：在JDBC中總是以jdbc開始

子協議：是橋連接的驅動程序或是數據庫管理系統名稱。

數據源標識：標記找到數據庫來源的地址與連接端口。

例如：（MySql的連接URL）

jdbc:mysql:

//localhost:3306/test?useUnicode=truecharacterEncoding=gbk ;

useUnicode=true：表示使用Unicode字符集。如果characterEncoding設置為

gb2312或GBK，本參數必須設置為true 。characterEncoding=gbk：字符編碼方式。

3、創建數據庫的連接

•要連接數據庫，需要向java.sql.DriverManager請求並獲得Connection對象，

該對象就代表一個數據庫的連接。

•使用DriverManager的getConnectin(String url , String username ,

String password )方法傳入指定的欲連接的數據庫的路徑、數據庫的用戶名和

密碼來獲得。

例如：

//連接MySql數據庫，用戶名和密碼都是root

String url = “jdbc:mysql://localhost:3306/test” ;

String username = “root” ;

String password = “root” ;

try{

Connection con =

DriverManager.getConnection(url , username , password ) ;

}catch(SQLException se){

System.out.println(“數據庫連接失敗！”);

se.printStackTrace() ;

}

4、創建一個Statement

•要執行SQL語句，必須獲得java.sql.Statement實例，Statement實例分為以下3

種類型：

1、執行靜態SQL語句。通常通過Statement實例實現。

2、執行動態SQL語句。通常通過PreparedStatement實例實現。

3、執行數據庫存儲過程。通常通過CallableStatement實例實現。

具體的實現方式：

Statement stmt = con.createStatement() ;

PreparedStatement pstmt = con.prepareStatement(sql) ;

CallableStatement cstmt =

con.prepareCall(“{CALL demoSp(? , ?)}”) ;

5、執行SQL語句

Statement接口提供了三種執行SQL語句的方法：executeQuery 、executeUpdate

和execute

1、ResultSet executeQuery(String sqlString)：執行查詢數據庫的SQL語句

，返回一個結果集（ResultSet）對象。

2、int executeUpdate(String sqlString)：用於執行INSERT、UPDATE或

DELETE語句以及SQL DDL語句，如：CREATE TABLE和DROP TABLE等

3、execute(sqlString):用於執行返回多個結果集、多個更新計數或二者組合的

語句。

具體實現的代碼：

ResultSet rs = stmt.executeQuery(“SELECT * FROM …”) ;

int rows = stmt.executeUpdate(“INSERT INTO …”) ;

boolean flag = stmt.execute(String sql) ;

6、處理結果

兩種情況：

1、執行更新返回的是本次操作影響到的記錄數。

2、執行查詢返回的結果是一個ResultSet對象。

• ResultSet包含符合SQL語句中條件的所有行，並且它通過一套get方法提供了對這些

行中數據的訪問。

• 使用結果集（ResultSet）對象的訪問方法獲取數據：

while(rs.next()){

String name = rs.getString(“name”) ;

String pass = rs.getString(1) ; // 此方法比較高效

}

（列是從左到右編號的，並且從列1開始）

7、關閉JDBC對象

操作完成以後要把所有使用的JDBC對象全都關閉，以釋放JDBC資源，關閉順序和聲

明順序相反：

1、關閉記錄集

2、關閉聲明

3、關閉連接對象

if(rs != null){ // 關閉記錄集

try{

rs.close() ;

}catch(SQLException e){

e.printStackTrace() ;

}

}

if(stmt != null){ // 關閉聲明

try{

stmt.close() ;

}catch(SQLException e){

e.printStackTrace() ;

}

}

if(conn != null){ // 關閉連接對象

try{

conn.close() ;

}catch(SQLException e){

e.printStackTrace() ;

}

}