桶排序java

① java解決: 有一個已經排好序的數組，現輸入一個數，要求按原來的規律將它插入數組中。

importjava.util.ArrayList;
importjava.util.Arrays;
publicclassArrayInsert{
Integer[]array={1,2,3,5,6,7,8,9};
Integer[]resultArray=newInteger[9];
publicArrayInsert(){
System.out.println("Before:"+newArrayList<Integer>(Arrays.asList(array)));
intinsert=4;
intinsertIndex=0;
for(inti=0;i<array.length;i++){
if(array[i]<=insert&&(i+1)<array.length&&array[i+1]>=insert){
insertIndex=i;
}
}
System.array(array,0,resultArray,0,insertIndex+1);
resultArray[insertIndex+1]=insert;
System.out.println("Insert"+insert+"atindex"+(insertIndex+1));
System.array(array,insertIndex+1,resultArray,insertIndex+2,(array.length-(insertIndex+1)));
System.out.println("After:"+newArrayList<Integer>(Arrays.asList(resultArray)));
}
publicstaticvoidmain(String[]args){
newArrayInsert();
}
}

② java 怎麼將List裡面數據排序

不好意思，上午只是粗略地看了一下，沒有細致看，現在詳細回答你的提問。

ArrayList底層是用一個長度為10的Object數組實現，不管添加進去什麼類型的數據，都會轉換成Object對象，除非你用很早以前的JDK版本。這樣就好理解了，像你寫的程序arrayList1中add了String和Integer兩種類型的數據，這兩類對象沒有什麼可比性，就像拿打火機和U盤比一個性質。所以，是沒有辦法進行直接排序的。

你要求的是要按ArrayList裡面的第1、2、4數據進行排序，這個可以。

先來arrayList1

四個數據分別是2、"daas"、6、"1"，第1、2、4數據即2、「daas」、「1」，我選擇按照String類型進行排序，所以第1個數據2轉換成String類型即可。因為第3個數據6不進行排序，remove就好。這是個題還是個什麼，其實還是留了點活路的，因為後面的（你arrayList234下面）代碼都是往arrayList1中添加的，而且還都是String類型。這也是我選擇String類型進行排序的原因。代碼如下：

List arrayList1 = new ArrayList();

arrayList1.add(2); //0

arrayList1.add("daas"); //1

arrayList1.add(6); //2

arrayList1.add("1"); //3

list.add(arrayList1);

//my code

String convert = String.valueOf(arrayList1.get(0));

arrayList1.remove(2);

arrayList1.remove(0);

arrayList1.add(convert);

/此處為你的arrayList234代碼

Collections.sort(arrayList1);

for(int i = 0; i < arrayList1.size(); i++) {

System.out.println(arrayList1.get(i));

}

結果為：

1

2

3

5

8

daas

因為怕你深挖，強調兩點：

第一點，由結果看出Collections.sort(arrayList1)，是以String的ASCII碼進行排序的，為了證明這一點，就要看原代碼，這時你就會發現JDK中String的compareTo方法是個空實現，底層並不是用java寫的，這點沒事，我們可以用一定的方法讓它把特徵暴露出來，然後就可以理解思想。你看我下面寫的小測試程序就會明白。

String a = new String("Z");

String b = new String("A");

System.out.println(a.compareTo(b));

String c = new String("A");

String d = new String("B");

System.out.println(c.compareTo(d));

//看結果，證明String的自然順序比較即比較ASCII值，只是第一步。

//看結果，證明compareTo返回值是後面的ASCII碼減支前面的ASCII碼，第二步。

String e = new String("g");

String f = new String("e");

String h = new String("h");

List<String> list = new ArrayList<String>();

list.add(e);

list.add(f);

list.add(h);

Collections.sort(list);

for(String i : list) {

System.out.println(i);

}

結果為：

25

-1

e

g

h

//證明String的自然排序即ASCII碼從小到大排序，最後一步。

第二點，你的要求是「要按ArrayList裡面的第1、2.4數據進行排序，分別怎麼做啊」，這個問題的描述有問題，或者不詳細，arryList2、arrayList3、arrayList4任何一個裡面一共就add了3個數據，哪來第4個。如果是分別對arrayList234裡面的數據進行排序，兩個選擇，（1）把所有Integer轉換成String類型，再排序，參考arrayList2。（2）運用Integer.valueOf()方法，將內容為數字的String數據轉換成Integer，把原來的remove掉，把內容非數字的String數據remove掉，再排序，桶排序、冒泡排序、快速排序等你隨便選。

講解到這，不管想對哪個list進行排序，你應該都會寫了。

總結：

1. 除非比較ASCII碼，Integer類型和內容為非數字的String類型數據是沒有辦法進行比較的，不管是直接比較，還是間接比較。還是上面那句話，像打火機和U盤沒有可比性一樣，理解這點很重要。

2. 即使用Integer.valueOf()方法對內容為非數字的String類型數據進行轉換沒有用，會報NumberFormatException。說這點意思是如果你想按Integer類型排序，得把所有內容為非數字的String類型數據remove掉。

題外話：這種類型的題我記得上大學的時候有，不知道你是不是學生，今天想來，其實用處真不大，都用泛型，現在寫代碼不用泛型的程序員幾乎是完全不存在了。

祝心情愉快~~

親手打，如果滿意，把分給我吧~~哈哈。。

③ 桶排序（基數排序）中關於如何判斷入哪一個桶的問題

遍歷的時候用多個IF語句判斷應該可以吧

④ JAVA題目

J2EE Java2平台企業版
string是引用數據類型
如何取得年月日，小時分秒
public static void main(String[] args)
{
ActionListener time = new ActionListener() { // 監聽事件,不然實現不了動態改變時間
public void actionPerformed(ActionEvent e) {
//date對象代表當前的系統時間(毫秒)
Date date = new Date();
//format對象是用來以指定的時間格式格式化時間的
SimpleDateFormat from = new SimpleDateFormat(
"yyyy-MM-dd HH:mm:ss"); //這里的格式可以自己設置
//format()方法是用來格式化時間的方法
String times = from.format(date);
System.out.println(times); }
};
Timer tim = new Timer(1000, time); //這里表示1000毫秒更新一下時間
tim.start(); //啟動
}

我這個答案肯定正確啊
下面幫你解釋你的答案吧
Date //是在java.util.Date;裡面
SimpleDateForma //這個是java.text.SimpleDateFormat;用來輸出問本格式的
DateFormat //應該是在java.util.*;裡面吧..應該是的

你那個錯誤是編譯就沒通過啊
public class Test
那你那個編譯寫的因該是
javac Test.java 編譯的應該是類啊而不是javac time.java 請問你的time什麼意思呢,所以你報的異常是找不到time類啊
呵呵...你是初學java吧該答的我都答完了拉!還特地幫你每句都寫

如何讀寫文件
StringBuffer sb = new StringBuffer();
//File file = new FileWindow().load();
File file;
file = new File("F:/jtest/from.txt");
TextReader tr = new TextReader(file);
sb.append(tr.readAll());
Out.println(sb.toString());
String [] tags = {"\"", " ", "'"};
String str;
str = sb.toString();
for(String reg: tags) {
Out.println(reg);

str = str.replaceAll(reg, "");
}
Out.println(str);
抽象類和介面的區別
聲明方法的存在而不去實現它的類被叫做抽象類（abstract class），它用於要創建一個體現某些基本行為的類，並為該類聲明方法，但不能在該類中實現該類的情況。不能創建abstract 類的實例。然而可以創建一個變數，其類型是一個抽象類，並讓它指向具體子類的一個實例。不能有抽象構造函數或抽象靜態方法。Abstract 類的子類為它們父類中的所有抽象方法提供實現，否則它們也是抽象類為。取而代之，在子類中實現該方法。知道其行為的其它類可以在類中實現這些方法。
介面（interface）是抽象類的變體。在介面中，所有方法都是抽象的。多繼承性可通過實現這樣的介面而獲得。介面中的所有方法都是抽象的，沒有一個有程序體。介面只可以定義static final成員變數。介面的實現與子類相似，除了該實現類不能從介面定義中繼承行為。當類實現特殊介面時，它定義（即將程序體給予）所有這種介面的方法。然後，它可以在實現了該介面的類的任何對象上調用介面的方法。由於有抽象類，它允許使用介面名作為引用變數的類型。通常的動態聯編將生效。引用可以轉換到介面類型或從介面類型轉換，instanceof 運算符可以用來決定某對象的類是否實現了介面。
主鍵是確定資料庫中的表的記錄的唯一標識欄位，可以是表中的一個欄位，也可以是表中的多個欄位組成的。一旦確定為主鍵，則該欄位不可為空也不可以重復。比如學生表中的學號就可以定義成該表的欄位
外鍵的定義是相對於主鍵而言的，比如另有一張成績表，表中也出現了學生表中的對應學號欄位，則相對於學生表，學號就是成績表的外鍵
String和StringBuffer的區別
STRING的長度是不可變的，STRINGBUFFER的長度是可變的。如果你對字元串中的內容經常進行操作，特別是內容要修改時，那麼使用StringBuffer，如果最後需要String，那麼使用StringBuffer的toString()方法
try{}catch(){}finally{}結構，try{}內出現異常，try{}內剩下尚未執行的代碼還執行嗎，finally{}內的代碼呢？finally{}後面的代碼呢
執行 finally{}內的代碼最後執行
排序演算法

所謂排序，就是使一串記錄，按照其中的某個或某些關鍵字的大小，遞增或遞減的排列起來的操作。

分類

在計算機科學所使用的排序演算法通常被分類為：

計算的復雜度（最差、平均、和最好表現），依據串列（list）的大小（n）。一般而言，好的表現是O。(n log n)，且壞的行為是Ω(n2)。對於一個排序理想的表現是O(n)。僅使用一個抽象關鍵比較運算的排序演算法總平均上總是至少需要Ω(n log n)。

記憶體使用量（以及其他電腦資源的使用）

穩定度：穩定排序演算法會依照相等的關鍵（換言之就是值）維持紀錄的相對次序。也就是一個排序演算法是穩定的，就是當有兩個有相等關鍵的紀錄R和S，且在原本的串列中R出現在S之前，在排序過的串列中R也將會是在S之前。

一般的方法：插入、交換、選擇、合並等等。交換排序包含冒泡排序（bubble sort）和快速排序（quicksort）。選擇排序包含shaker排序和堆排序（heapsort）。

當相等的元素是無法分辨的，比如像是整數，穩定度並不是一個問題。然而，假設以下的數對將要以他們的第一個數字來排序。

(4, 1) (3, 1) (3, 7) (5, 6)

在這個狀況下，有可能產生兩種不同的結果，一個是依照相等的鍵值維持相對的次序，而另外一個則沒有：

(3, 1) (3, 7) (4, 1) (5, 6) (維持次序)

(3, 7) (3, 1) (4, 1) (5, 6) (次序被改變)

不穩定排序演算法可能會在相等的鍵值中改變紀錄的相對次序，但是穩定排序演算法從來不會如此。不穩定排序演算法可以被特別地時作為穩定。作這件事情的一個方式是人工擴充鍵值的比較，如此在其他方面相同鍵值的兩個物件間之比較，就會被決定使用在原先資料次序中的條目，當作一個同分決賽。然而，要記住這種次序通常牽涉到額外的空間負擔。

排列演算法列表

在這個表格中，n是要被排序的紀錄數量以及k是不同鍵值的數量。

穩定的

冒泡排序（bubble sort） — O(n2)

雞尾酒排序 (Cocktail sort, 雙向的冒泡排序) — O(n2)

插入排序 （insertion sort）— O(n2)

桶排序 （bucket sort）— O(n); 需要 O(k) 額外 記憶體

計數排序 (counting sort) — O(n+k); 需要 O(n+k) 額外 記憶體

歸並排序 （merge sort）— O(n log n); 需要 O(n) 額外記憶體

原地歸並排序 — O(n2)

二叉樹排序 （Binary tree sort） — O(n log n); 需要 O(n) 額外記憶體

鴿巢排序 (Pigeonhole sort) — O(n+k); 需要 O(k) 額外記憶體

基數排序 （radix sort）— O(n·k); 需要 O(n) 額外記憶體

Gnome sort — O(n2)

Library sort — O(n log n) with high probability, 需要 (1+ε)n 額外記憶體

不穩定

選擇排序 （selection sort）— O(n2)

希爾排序 （shell sort）— O(n log n) 如果使用最佳的現在版本

Comb sort — O(n log n)

堆排序 （heapsort）— O(n log n)

Smoothsort — O(n log n)

快速排序 （quicksort）— O(n log n) 期望時間, O(n2) 最壞情況; 對於大的、亂數串列一般相信是最快的已知排序

Introsort — O(n log n)

Patience sorting — O(n log n + k) 最外情況時間, 需要 額外的 O(n + k) 空間, 也需要找到最長的遞增子序列（longest increasing subsequence）

不實用的排序演算法

Bogo排序 — O(n × n!) 期望時間, 無窮的最壞情況。

Stupid sort — O(n3); 遞回版本需要 O(n2) 額外記憶體

Bead sort — O(n) or O(√n), 但需要特別的硬體

Pancake sorting — O(n), 但需要特別的硬體

排序的演算法

排序的演算法有很多，對空間的要求及其時間效率也不盡相同。下面列出了一些常見的排序演算法。這裡面插入排序和冒泡排序又被稱作簡單排序，他們對空間的要求不高，但是時間效率卻不穩定；而後面三種排序相對於簡單排序對空間的要求稍高一點，但時間效率卻能穩定在很高的水平。基數排序是針對關鍵字在一個較小范圍內的排序演算法。

插入排序

冒泡排序

選擇排序

快速排序

堆排序

歸並排序

基數排序

希爾排序

插入排序

插入排序是這樣實現的：

首先新建一個空列表，用於保存已排序的有序數列（我們稱之為"有序列表"）。

從原數列中取出一個數，將其插入"有序列表"中，使其仍舊保持有序狀態。

重復2號步驟，直至原數列為空。

插入排序的平均時間復雜度為平方級的，效率不高，但是容易實現。它藉助了"逐步擴大成果"的思想，使有序列表的長度逐漸增加，直至其長度等於原列表的長度。

冒泡排序

冒泡排序是這樣實現的：

首先將所有待排序的數字放入工作列表中。

從列表的第一個數字到倒數第二個數字，逐個檢查：若某一位上的數字大於他的下一位，則將它與它的下一位交換。

重復2號步驟，直至再也不能交換。

冒泡排序的平均時間復雜度與插入排序相同，也是平方級的，但也是非常容易實現的演算法。

選擇排序

選擇排序是這樣實現的：

設數組內存放了n個待排數字，數組下標從1開始，到n結束。

i=1

從數組的第i個元素開始到第n個元素，尋找最小的元素。

將上一步找到的最小元素和第i位元素交換。

如果i=n－1演算法結束，否則回到第3步

選擇排序的平均時間復雜度也是O(n²)的。

快速排序

現在開始，我們要接觸高效排序演算法了。實踐證明，快速排序是所有排序演算法中最高效的一種。它採用了分治的思想：先保證列表的前半部分都小於後半部分，然後分別對前半部分和後半部分排序，這樣整個列表就有序了。這是一種先進的思想，也是它高效的原因。因為在排序演算法中，演算法的高效與否與列表中數字間的比較次數有直接的關系，而"保證列表的前半部分都小於後半部分"就使得前半部分的任何一個數從此以後都不再跟後半部分的數進行比較了，大大減少了數字間不必要的比較。但查找數據得另當別論了。

堆排序

堆排序與前面的演算法都不同，它是這樣的：

首先新建一個空列表，作用與插入排序中的"有序列表"相同。

找到數列中最大的數字，將其加在"有序列表"的末尾，並將其從原數列中刪除。

重復2號步驟，直至原數列為空。

堆排序的平均時間復雜度為nlogn,效率高（因為有堆這種數據結構以及它奇妙的特徵，使得"找到數列中最大的數字"這樣的操作只需要O(1)的時間復雜度，維護需要logn的時間復雜度），但是實現相對復雜（可以說是這里7種演算法中比較難實現的）。

看起來似乎堆排序與插入排序有些相像，但他們其實是本質不同的演算法。至少，他們的時間復雜度差了一個數量級，一個是平方級的，一個是對數級的。

平均時間復雜度

插入排序 O(n2)

冒泡排序 O(n2)

選擇排序 O(n2)

快速排序 O(n log n)

堆排序 O(n log n)

歸並排序 O(n log n)

基數排序 O(n)

希爾排序 O(n1.25)
一、術語session
在我的經驗里，session這個詞被濫用的程度大概僅次於transaction，更加有趣的是transaction與session在某些語境下的含義是相同的。

session，中文經常翻譯為會話，其本來的含義是指有始有終的一系列動作/消息，比如打電話時從拿起電話撥號到掛斷電話這中間的一系列過程可以稱之為一個session。有時候我們可以看到這樣的話「在一個瀏覽器會話期間，...」，這里的會話一詞用的就是其本義，是指從一個瀏覽器窗口打開到關閉這個期間①。最混亂的是「用戶（客戶端）在一次會話期間」這樣一句話，它可能指用戶的一系列動作（一般情況下是同某個具體目的相關的一系列動作，比如從登錄到選購商品到結賬登出這樣一個網上購物的過程，有時候也被稱為一個transaction），然而有時候也可能僅僅是指一次連接，也有可能是指含義①，其中的差別只能靠上下文來推斷②。

然而當session一詞與網路協議相關聯時，它又往往隱含了「面向連接」和/或「保持狀態」這樣兩個含義，「面向連接」指的是在通信雙方在通信之前要先建立一個通信的渠道，比如打電話，直到對方接了電話通信才能開始，與此相對的是寫信，在你把信發出去的時候你並不能確認對方的地址是否正確，通信渠道不一定能建立，但對發信人來說，通信已經開始了。「保持狀態」則是指通信的一方能夠把一系列的消息關聯起來，使得消息之間可以互相依賴，比如一個服務員能夠認出再次光臨的老顧客並且記得上次這個顧客還欠店裡一塊錢。這一類的例子有「一個TCP session」或者「一個POP3 session」③。

而到了web伺服器蓬勃發展的時代，session在web開發語境下的語義又有了新的擴展，它的含義是指一類用來在客戶端與伺服器之間保持狀態的解決方案④。有時候session也用來指這種解決方案的存儲結構，如「把xxx保存在session里」⑤。由於各種用於web開發的語言在一定程度上都提供了對這種解決方案的支持，所以在某種特定語言的語境下，session也被用來指代該語言的解決方案，比如經常把Java里提供的javax.servlet.http.HttpSession簡稱為session⑥。

鑒於這種混亂已不可改變，本文中session一詞的運用也會根據上下文有不同的含義，請大家注意分辨。
在本文中，使用中文「瀏覽器會話期間」來表達含義①，使用「session機制」來表達含義④，使用「session」表達含義⑤，使用具體的「HttpSession」來表達含義⑥

二、HTTP協議與狀態保持
HTTP協議本身是無狀態的，這與HTTP協議本來的目的是相符的，客戶端只需要簡單的向伺服器請求下載某些文件，無論是客戶端還是伺服器都沒有必要紀錄彼此過去的行為，每一次請求之間都是獨立的，好比一個顧客和一個自動售貨機或者一個普通的（非會員制）大賣場之間的關系一樣。

然而聰明（或者貪心？）的人們很快發現如果能夠提供一些按需生成的動態信息會使web變得更加有用，就像給有線電視加上點播功能一樣。這種需求一方面迫使HTML逐步添加了表單、腳本、DOM等客戶端行為，另一方面在伺服器端則出現了CGI規范以響應客戶端的動態請求，作為傳輸載體的HTTP協議也添加了文件上載、cookie這些特性。其中cookie的作用就是為了解決HTTP協議無狀態的缺陷所作出的努力。至於後來出現的session機制則是又一種在客戶端與伺服器之間保持狀態的解決方案。

讓我們用幾個例子來描述一下cookie和session機制之間的區別與聯系。筆者曾經常去的一家咖啡店有喝5杯咖啡免費贈一杯咖啡的優惠，然而一次性消費5杯咖啡的機會微乎其微，這時就需要某種方式來紀錄某位顧客的消費數量。想像一下其實也無外乎下面的幾種方案：
1、該店的店員很厲害，能記住每位顧客的消費數量，只要顧客一走進咖啡店，店員就知道該怎麼對待了。這種做法就是協議本身支持狀態。
2、發給顧客一張卡片，上面記錄著消費的數量，一般還有個有效期限。每次消費時，如果顧客出示這張卡片，則此次消費就會與以前或以後的消費相聯系起來。這種做法就是在客戶端保持狀態。
3、發給顧客一張會員卡，除了卡號之外什麼信息也不紀錄，每次消費時，如果顧客出示該卡片，則店員在店裡的紀錄本上找到這個卡號對應的紀錄添加一些消費信息。這種做法就是在伺服器端保持狀態。

由於HTTP協議是無狀態的，而出於種種考慮也不希望使之成為有狀態的，因此，後面兩種方案就成為現實的選擇。具體來說cookie機制採用的是在客戶端保持狀態的方案，而session機制採用的是在伺服器端保持狀態的方案。同時我們也看到，由於採用伺服器端保持狀態的方案在客戶端也需要保存一個標識，所以session機制可能需要藉助於cookie機制來達到保存標識的目的，但實際上它還有其他選擇。

三、理解cookie機制
cookie機制的基本原理就如上面的例子一樣簡單，但是還有幾個問題需要解決：「會員卡」如何分發；「會員卡」的內容；以及客戶如何使用「會員卡」。

正統的cookie分發是通過擴展HTTP協議來實現的，伺服器通過在HTTP的響應頭中加上一行特殊的指示以提示瀏覽器按照指示生成相應的cookie。然而純粹的客戶端腳本如JavaScript或者VBScript也可以生成cookie。

而cookie的使用是由瀏覽器按照一定的原則在後台自動發送給伺服器的。瀏覽器檢查所有存儲的cookie，如果某個cookie所聲明的作用范圍大於等於將要請求的資源所在的位置，則把該cookie附在請求資源的HTTP請求頭上發送給伺服器。意思是麥當勞的會員卡只能在麥當勞的店裡出示，如果某家分店還發行了自己的會員卡，那麼進這家店的時候除了要出示麥當勞的會員卡，還要出示這家店的會員卡。

cookie的內容主要包括：名字，值，過期時間，路徑和域。
其中域可以指定某一個域比如.google.com，相當於總店招牌，比如寶潔公司，也可以指定一個域下的具體某台機器比如www.google.com或者froogle.google.com，可以用飄柔來做比。
路徑就是跟在域名後面的URL路徑，比如/或者/foo等等，可以用某飄柔專櫃做比。
路徑與域合在一起就構成了cookie的作用范圍。
如果不設置過期時間，則表示這個cookie的生命期為瀏覽器會話期間，只要關閉瀏覽器窗口，cookie就消失了。這種生命期為瀏覽器會話期的cookie被稱為會話cookie。會話cookie一般不存儲在硬碟上而是保存在內存里，當然這種行為並不是規范規定的。如果設置了過期時間，瀏覽器就會把cookie保存到硬碟上，關閉後再次打開瀏覽器，這些cookie仍然有效直到超過設定的過期時間。

存儲在硬碟上的cookie可以在不同的瀏覽器進程間共享，比如兩個IE窗口。而對於保存在內存里的cookie，不同的瀏覽器有不同的處理方式。對於IE，在一個打開的窗口上按Ctrl-N（或者從文件菜單）打開的窗口可以與原窗口共享，而使用其他方式新開的IE進程則不能共享已經打開的窗口的內存cookie；對於Mozilla Firefox0.8，所有的進程和標簽頁都可以共享同樣的cookie。一般來說是用javascript的window.open打開的窗口會與原窗口共享內存cookie。瀏覽器對於會話cookie的這種只認cookie不認人的處理方式經常給採用session機制的web應用程序開發者造成很大的困擾。

下面就是一個goolge設置cookie的響應頭的例子
HTTP/1.1 302 Found
Location: http://www.google.com/intl/zh-CN/
Set-Cookie: PREF=ID=0565f77e132de138:NW=1:TM=1098082649:LM=1098082649:S=KaeaCFPo49RiA_d8; expires=Sun, 17-Jan-2038 19:14:07 GMT; path=/; domain=.google.com
Content-Type: text/html

這是使用HTTPLook這個HTTP Sniffer軟體來俘獲的HTTP通訊紀錄的一部分

瀏覽器在再次訪問goolge的資源時自動向外發送cookie

使用Firefox可以很容易的觀察現有的cookie的值
使用HTTPLook配合Firefox可以很容易的理解cookie的工作原理。

IE也可以設置在接受cookie前詢問

這是一個詢問接受cookie的對話框。

四、理解session機制
session機制是一種伺服器端的機制，伺服器使用一種類似於散列表的結構（也可能就是使用散列表）來保存信息。

當程序需要為某個客戶端的請求創建一個session的時候，伺服器首先檢查這個客戶端的請求里是否已包含了一個session標識 - 稱為session id，如果已包含一個session id則說明以前已經為此客戶端創建過session，伺服器就按照session id把這個session檢索出來使用（如果檢索不到，可能會新建一個），如果客戶端請求不包含session id，則為此客戶端創建一個session並且生成一個與此session相關聯的session id，session id的值應該是一個既不會重復，又不容易被找到規律以仿造的字元串，這個session id將被在本次響應中返回給客戶端保存。

保存這個session id的方式可以採用cookie，這樣在交互過程中瀏覽器可以自動的按照規則把這個標識發揮給伺服器。一般這個cookie的名字都是類似於SEEESIONID，而。比如weblogic對於web應用程序生成的cookie，JSESSIONID=!-145788764，它的名字就是JSESSIONID。

由於cookie可以被人為的禁止，必須有其他機制以便在cookie被禁止時仍然能夠把session id傳遞回伺服器。經常被使用的一種技術叫做URL重寫，就是把session id直接附加在URL路徑的後面，附加方式也有兩種，一種是作為URL路徑的附加信息，表現形式為http://...../xxx;jsessionid=!-145788764
另一種是作為查詢字元串附加在URL後面，表現形式為http://...../xxx?jsessionid=!-145788764
這兩種方式對於用戶來說是沒有區別的，只是伺服器在解析的時候處理的方式不同，採用第一種方式也有利於把session id的信息和正常程序參數區分開來。
為了在整個交互過程中始終保持狀態，就必須在每個客戶端可能請求的路徑後面都包含這個session id。

另一種技術叫做表單隱藏欄位。就是伺服器會自動修改表單，添加一個隱藏欄位，以便在表單提交時能夠把session id傳遞回伺服器。比如下面的表單
<form name="testform" action="/xxx">
<input type="text">
</form>
在被傳遞給客戶端之前將被改寫成
<form name="testform" action="/xxx">
<input type="hidden" name="jsessionid" value="!-145788764">
<input type="text">
</form>
這種技術現在已較少應用，筆者接觸過的很古老的iPlanet6(SunONE應用伺服器的前身)就使用了這種技術。
實際上這種技術可以簡單的用對action應用URL重寫來代替。

在談論session機制的時候，常常聽到這樣一種誤解「只要關閉瀏覽器，session就消失了」。其實可以想像一下會員卡的例子，除非顧客主動對店家提出銷卡，否則店家絕對不會輕易刪除顧客的資料。對session來說也是一樣的，除非程序通知伺服器刪除一個session，否則伺服器會一直保留，程序一般都是在用戶做log off的時候發個指令去刪除session。然而瀏覽器從來不會主動在關閉之前通知伺服器它將要關閉，因此伺服器根本不會有機會知道瀏覽器已經關閉，之所以會有這種錯覺，是大部分session機制都使用會話cookie來保存session id，而關閉瀏覽器後這個session id就消失了，再次連接伺服器時也就無法找到原來的session。如果伺服器設置的cookie被保存到硬碟上，或者使用某種手段改寫瀏覽器發出的HTTP請求頭，把原來的session id發送給伺服器，則再次打開瀏覽器仍然能夠找到原來的session。

恰恰是由於關閉瀏覽器不會導致session被刪除，迫使伺服器為seesion設置了一個失效時間，當距離客戶端上一次使用session的時間超過這個失效時間時，伺服器就可以認為客戶端已經停止了活動，才會把session刪除以節省存儲空間。

五、理解javax.servlet.http.HttpSession
HttpSession是Java平台對session機制的實現規范，因為它僅僅是個介面，具體到每個web應用伺服器的提供商，除了對規范支持之外，仍然會有一些規范里沒有規定的細微差異。這里我們以BEA的Weblogic Server8.1作為例子來演示。

首先，Weblogic Server提供了一系列的參數來控制它的HttpSession的實現，包括使用cookie的開關選項，使用URL重寫的開關選項，session持久化的設置，session失效時間的設置，以及針對cookie的各種設置，比如設置cookie的名字、路徑、域，cookie的生存時間等。

一般情況下，session都是存儲在內存里，當伺服器進程被停止或者重啟的時候，內存里的session也會被清空，如果設置了session的持久化特性，伺服器就會把session保存到硬碟上，當伺服器進程重新啟動或這些信息將能夠被再次使用，Weblogic Server支持的持久性方式包括文件、資料庫、客戶端cookie保存和復制。

復制嚴格說來不算持久化保存，因為session實際上還是保存在內存里，不過同樣的信息被復制到各個cluster內的伺服器進程中，這樣即使某個伺服器進程停止工作也仍然可以從其他進程中取得session。

cookie生存時間的設置則會影響瀏覽器生成的cookie是否是一個會話cookie。默認是使用會話cookie。有興趣的可以用它來試驗我們在第四節里提到的那個誤解。

cookie的路徑對於web應用程序來說是一個非常重要的選項，Weblogic Server對這個選項的默認處理方式使得它與其他伺服器有明顯的區別。後面我們會專題討論。

關於session的設置參考[5] http://e-docs.bea.com/wls/docs70/webapp/weblogic_xml.html#1036869

~~我要200分~~

⑤ java編程的冒泡等排序示例

Java排序演算法
1）分類：
1）插入排序（直接插入排序、希爾排序）
2）交換排序（冒泡排序、快速排序）
3）選擇排序（直接選擇排序、堆排序）
4）歸並排序
5）分配排序（箱排序、基數排序）
所需輔助空間最多：歸並排序
所需輔助空間最少：堆排序
平均速度最快：快速排序
不穩定：快速排序，希爾排序，堆排序。
1）選擇排序演算法的時候
1.數據的規模 ； 2.數據的類型 ； 3.數據已有的順序
一般來說，當數據規模較小時，應選擇直接插入排序或冒泡排序。任何排序演算法在數據量小時基本體現不出來差距。 考慮數據的類型，比如如果全部是正整數，那麼考慮使用桶排序為最優。 考慮數據已有順序，快排是一種不穩定的排序（當然可以改進），對於大部分排好的數據，快排會浪費大量不必要的步驟。數據量極小，而起已經基本排好序，冒泡是最佳選擇。我們說快排好，是指大量隨機數據下，快排效果最理想。而不是所有情況。
3）總結：
——按平均的時間性能來分：
1）時間復雜度為O(nlogn)的方法有：快速排序、堆排序和歸並排序，其中以快速排序為最好；
2）時間復雜度為O(n2)的有：直接插入排序、起泡排序和簡單選擇排序，其中以直接插入為最好，特 別是對那些對關鍵字近似有序的記錄序列尤為如此；
3）時間復雜度為O(n)的排序方法只有，基數排序。
當待排記錄序列按關鍵字順序有序時，直接插入排序和起泡排序能達到O(n)的時間復雜度;而對於快速排序而言，這是最不好的情況，此時的時間性能蛻化為O(n2)，因此是應該盡量避免的情況。簡單選擇排序、堆排序和歸並排序的時間性能不隨記錄序列中關鍵字的分布而改變。
——按平均的空間性能來分（指的是排序過程中所需的輔助空間大小）：
1） 所有的簡單排序方法(包括：直接插入、起泡和簡單選擇)和堆排序的空間復雜度為O(1)；
2） 快速排序為O(logn )，為棧所需的輔助空間;
3） 歸並排序所需輔助空間最多，其空間復雜度為O(n );
4）鏈式基數排序需附設隊列首尾指針，則空間復雜度為O(rd )。
——排序方法的穩定性能：
1） 穩定的排序方法指的是，對於兩個關鍵字相等的記錄，它們在序列中的相對位置，在排序之前和 經過排序之後，沒有改變。
2） 當對多關鍵字的記錄序列進行LSD方法排序時，必須採用穩定的排序方法。
3） 對於不穩定的排序方法，只要能舉出一個實例說明即可。
4） 快速排序，希爾排序和堆排序是不穩定的排序方法。
4）插入排序：
包括直接插入排序，希爾插入排序。
直接插入排序： 將一個記錄插入到已經排序好的有序表中。
1, sorted數組的第0個位置沒有放數據。
2，從sorted第二個數據開始處理：
如果該數據比它前面的數據要小，說明該數據要往前面移動。
首先將該數據備份放到 sorted的第0位置當哨兵。
然後將該數據前面那個數據後移。
然後往前搜索，找插入位置。
找到插入位置之後講 第0位置的那個數據插入對應位置。
O(n*n), 當待排記錄序列為正序時，時間復雜度提高至O(n)。
希爾排序（縮小增量排序 diminishing increment sort）：先將整個待排記錄序列分割成若干個子序列分別進行直接插入排序，待整個序列中的記錄基本有序時，再對全體記錄進行一次直接插入排序。
面試穿什麼，這里找答案！
插入排序Java代碼：
public class InsertionSort {
// 插入排序：直接插入排序 ，希爾排序
public void straightInsertionSort(double [] sorted){
int sortedLen= sorted.length;
for(int j=2;j<sortedLen;j++){
if(sorted[j]<sorted[j-1]){
sorted[0]= sorted[j];//先保存一下後面的那個
sorted[j]=sorted[j-1];// 前面的那個後移。
int insertPos=0;
for(int k=j-2;k>=0;k--){
if(sorted[k]>sorted[0]){
sorted[k+1]=sorted[k];
}else{
insertPos=k+1;
break;
}
}
sorted[insertPos]=sorted[0];
}
}
}
public void shellInertionSort(double [] sorted, int inc){
int sortedLen= sorted.length;
for(int j=inc+1;j<sortedLen;j++ ){
if(sorted[j]<sorted[j-inc]){
sorted[0]= sorted[j];//先保存一下後面的那個

int insertPos=j;
for(int k=j-inc;k>=0;k-=inc){
if(sorted[k]>sorted[0]){
sorted[k+inc]=sorted[k];
//數據結構課本上這個地方沒有給出判讀，出錯：
if(k-inc<=0){
insertPos = k;
}
}else{
insertPos=k+inc;
break;
}
}
sorted[insertPos]=sorted[0];
}
}
}
public void shellInsertionSort(double [] sorted){
int[] incs={7,5,3,1};
int num= incs.length;

int inc=0;
for(int j=0;j<num;j++){
inc= incs[j];
shellInertionSort(sorted,inc);
}
}
public static void main(String[] args) {
Random random= new Random(6);

int arraysize= 21;
double [] sorted=new double[arraysize];
System.out.print("Before Sort:");
for(int j=1;j<arraysize;j++){
sorted[j]= (int)(random.nextDouble()* 100);
System.out.print((int)sorted[j]+" ");
}
System.out.println();

InsertionSort sorter=new InsertionSort();
// sorter.straightInsertionSort(sorted);
sorter.shellInsertionSort(sorted);

System.out.print("After Sort:");
for(int j=1;j<sorted.length;j++){
System.out.print((int)sorted[j]+" ");
}
System.out.println();
}
}
面試穿什麼，這里找答案！
5）交換排序：
包括冒泡排序，快速排序。
冒泡排序法：該演算法是專門針對已部分排序的數據進行排序的一種排序演算法。如果在你的數據清單中只有一兩個數據是亂序的話，用這種演算法就是最快的排序演算法。如果你的數據清單中的數據是隨機排列的，那麼這種方法就成了最慢的演算法了。因此在使用這種演算法之前一定要慎重。這種演算法的核心思想是掃描數據清單，尋找出現亂序的兩個相鄰的項目。當找到這兩個項目後，交換項目的位置然後繼續掃描。重復上面的操作直到所有的項目都按順序排好。
快速排序：通過一趟排序，將待排序記錄分割成獨立的兩個部分，其中一部分記錄的關鍵字均比另一部分記錄的關鍵字小，則可分別對這兩部分記錄繼續進行排序，以達到整個序列有序。具體做法是：使用兩個指針low,high, 初值分別設置為序列的頭，和序列的尾，設置pivotkey為第一個記錄，首先從high開始向前搜索第一個小於pivotkey的記錄和pivotkey所在位置進行交換，然後從low開始向後搜索第一個大於pivotkey的記錄和此時pivotkey所在位置進行交換，重復知道low=high了為止。
交換排序Java代碼：
public class ExchangeSort {
public void BubbleExchangeSort(double [] sorted){
int sortedLen= sorted.length;
for(int j=sortedLen;j>0;j--){
int end= j;
for(int k=1;k<end-1;k++){
double tempB= sorted[k];
sorted[k]= sorted[k]<sorted[k+1]?
sorted[k]:sorted[k+1];
if(Math.abs(sorted[k]-tempB)>10e-6){
sorted[k+1]=tempB;
}
}
}
}
public void QuickExchangeSortBackTrack(double [] sorted,
int low,int high){
if(low<high){
int pivot= findPivot(sorted,low,high);
QuickExchangeSortBackTrack(sorted,low,pivot-1);
QuickExchangeSortBackTrack(sorted,pivot+1,high);
}
}
public int findPivot(double [] sorted, int low, int high){
sorted[0]= sorted[low];
while(low<high){
while(low<high && sorted[high]>= sorted[0])--high;
sorted[low]= sorted[high];
while(low<high && sorted[low]<=sorted[0])++low;
sorted[high]= sorted[low];
}
sorted[low]=sorted[0];
return low;
}
public static void main(String[] args) {
Random random= new Random(6);

int arraysize= 21;
double [] sorted=new double[arraysize];
System.out.print("Before Sort:");
for(int j=1;j<arraysize;j++){
sorted[j]= (int)(random.nextDouble()* 100);
System.out.print((int)sorted[j]+" ");
}
System.out.println();

ExchangeSort sorter=new ExchangeSort();
// sorter.BubbleExchangeSort(sorted);
sorter.QuickExchangeSortBackTrack(sorted, 1, arraysize-1);
System.out.print("After Sort:");
for(int j=1;j<sorted.length;j++){
System.out.print((int)sorted[j]+" ");
}
System.out.println();
}
}
6）選擇排序：
分為直接選擇排序， 堆排序
直接選擇排序：第i次選取 i到array.Length-1中間最小的值放在i位置。
堆排序：首先，數組裡面用層次遍歷的順序放一棵完全二叉樹。從最後一個非終端結點往前面調整，直到到達根結點，這個時候除根節點以外的所有非終端節點都已經滿足堆得條件了，於是需要調整根節點使得整個樹滿足堆得條件，於是從根節點開始，沿著它的兒子們往下面走（最大堆沿著最大的兒子走，最小堆沿著最小的兒子走）。 主程序裡面，首先從最後一個非終端節點開始調整到根也調整完，形成一個heap， 然後將heap的根放到後面去（即：每次的樹大小會變化，但是 root都是在1的位置，以方便計算兒子們的index，所以如果需要升序排列，則要逐步大頂堆。因為根節點被一個個放在後面去了。 降序排列則要建立小頂堆）
代碼中的問題： 有時候第2個和第3個順序不對（原因還沒搞明白到底代碼哪裡有錯）
選擇排序Java代碼：
public class SelectionSort {
public void straitSelectionSort(double [] sorted){
int sortedLen= sorted.length;
for(int j=1;j<sortedLen;j++){
int jMin= getMinIndex(sorted,j);
exchange(sorted,j,jMin);
}
}
public void exchange(double [] sorted,int i,int j){
int sortedLen= sorted.length;
if(i<sortedLen && j<sortedLen && i<j && i>=0 && j>=0){
double temp= sorted[i];
sorted[i]=sorted[j];
sorted[j]=temp;
}
}
public int getMinIndex(double [] sorted, int i){
int sortedLen= sorted.length;

int minJ=1;
double min= Double.MAX_VALUE;
for(int j=i;j<sortedLen;j++){
if(sorted[j]<min){
min= sorted[j];
minJ= j;
}
}
return minJ;
}

public void heapAdjust(double [] sorted,int start,int end){
if(start<end){
double temp= sorted[start];
// 這個地方j<end與課本不同，j<=end會報錯：
for(int j=2*start;j<end;j *=2){
if(j+1<end && sorted[j]-sorted[j+1]>10e-6){
++j;
}
if(temp<=sorted[j]){
break;
}
sorted[start]=sorted[j];
start=j;
}
sorted[start]=temp;
}
}
public void heapSelectionSort(double [] sorted){
int sortedLen = sorted.length;

for(int i=sortedLen/2;i>0;i--){
heapAdjust(sorted,i,sortedLen);
}
for(int i=sortedLen;i>1;--i){
exchange(sorted,1,i);
heapAdjust(sorted,1,i-1);
}
}
public static void main(String [] args){
Random random= new Random(6);

int arraysize=9;
double [] sorted=new double[arraysize];
System.out.print("Before Sort:");
for(int j=1;j<arraysize;j++){
sorted[j]= (int)(random.nextDouble()* 100);
System.out.print((int)sorted[j]+" ");
}
System.out.println();

SelectionSort sorter=new SelectionSort();
// sorter.straitSelectionSort(sorted);
sorter.heapSelectionSort(sorted);

System.out.print("After Sort:");
for(int j=1;j<sorted.length;j++){
System.out.print((int)sorted[j]+" ");
}
System.out.println();
}
}
面試穿什麼，這里找答案！
7）歸並排序：
將兩個或兩個以上的有序表組合成一個新的有序表。歸並排序要使用一個輔助數組，大小跟原數組相同，遞歸做法。每次將目標序列分解成兩個序列，分別排序兩個子序列之後，再將兩個排序好的子序列merge到一起。
歸並排序Java代碼：
public class MergeSort {
private double[] bridge;//輔助數組
public void sort(double[] obj){
if (obj == null){
throw new NullPointerException("
The param can not be null!");
}
bridge = new double[obj.length]; // 初始化中間數組
mergeSort(obj, 0, obj.length - 1); // 歸並排序
bridge = null;
}
private void mergeSort(double[] obj, int left, int right){
if (left < right){
int center = (left + right) / 2;
mergeSort(obj, left, center);
mergeSort(obj, center + 1, right);
merge(obj, left, center, right);
}
}
private void merge(double[] obj, int left,
int center, int right){
int mid = center + 1;
int third = left;
int tmp = left;
while (left <= center && mid <= right){
// 從兩個數組中取出小的放入中間數組
if (obj[left]-obj[mid]<=10e-6){
bridge[third++] = obj[left++];
} else{
bridge[third++] = obj[mid++];
}
}

// 剩餘部分依次置入中間數組
while (mid <= right){
bridge[third++] = obj[mid++];
}
while (left <= center){
bridge[third++] = obj[left++];
}
// 將中間數組的內容拷貝回原數組
(obj, tmp, right);
}
private void (double[] obj, int left, int right)
{
while (left <= right){
obj[left] = bridge[left];
left++;
}
}
public static void main(String[] args) {
Random random = new Random(6);

int arraysize = 10;
double[] sorted = new double[arraysize];
System.out.print("Before Sort:");
for (int j = 0; j < arraysize; j++) {
sorted[j] = (int) (random.nextDouble() * 100);
System.out.print((int) sorted[j] + " ");
}
System.out.println();

MergeSort sorter = new MergeSort();
sorter.sort(sorted);

System.out.print("After Sort:");
for (int j = 0; j < sorted.length; j++) {
System.out.print((int) sorted[j] + " ");
}
System.out.println();
}
}
面試穿什麼，這里找答案！

8）基數排序：
使用10個輔助隊列，假設最大數的數字位數為 x， 則一共做 x次，從個位數開始往前，以第i位數字的大小為依據，將數據放進輔助隊列，搞定之後回收。下次再以高一位開始的數字位為依據。
以Vector作輔助隊列，基數排序的Java代碼：
public class RadixSort {
private int keyNum=-1;
private Vector<Vector<Double>> util;

public void distribute(double [] sorted, int nth){
if(nth<=keyNum && nth>0){
util=new Vector<Vector<Double>>();
for(int j=0;j<10;j++){
Vector <Double> temp= new Vector <Double>();
util.add(temp);
}
for(int j=0;j<sorted.length;j++){
int index= getNthDigit(sorted[j],nth);
util.get(index).add(sorted[j]);
}
}
}
public int getNthDigit(double num,int nth){
String nn= Integer.toString((int)num);
int len= nn.length();
if(len>=nth){
return Character.getNumericValue(nn.charAt(len-nth));
}else{
return 0;
}
}
public void collect(double [] sorted){
int k=0;
for(int j=0;j<10;j++){
int len= util.get(j).size();
if(len>0){
for(int i=0;i<len;i++){
sorted[k++]= util.get(j).get(i);
}
}
}
util=null;
}
public int getKeyNum(double [] sorted){
double max= Double.MIN_VALUE;
for(int j=0;j<sorted.length;j++){
if(sorted[j]>max){
max= sorted[j];
}
}
return Integer.toString((int)max).length();
}
public void radixSort(double [] sorted){
if(keyNum==-1){
keyNum= getKeyNum(sorted);
}
for(int i=1;i<=keyNum;i++){
distribute(sorted,i);
collect(sorted);
}
}
public static void main(String[] args) {
Random random = new Random(6);

int arraysize = 21;
double[] sorted = new double[arraysize];
System.out.print("Before Sort:");
for (int j = 0; j < arraysize; j++) {
sorted[j] = (int) (random.nextDouble() * 100);
System.out.print((int) sorted[j] + " ");
}
System.out.println();

RadixSort sorter = new RadixSort();
sorter.radixSort(sorted);

System.out.print("After Sort:");
for (int j = 0; j < sorted.length; j++) {
System.out.print((int) sorted[j] + " ");
}
System.out.println();
}
}

//而來

⑥ java排序演算法有多少種

演算法和語言無關吧，語言只是把具體的演算法實現出來而已。據我了解的排序演算法11-13種。排序演算法嘛 主要就是個思想而已。不同的演算法時間復雜度不一樣，空間復雜度也不一樣，當然執行的效率也不一樣。當然採用哪種演算法還取決於你要實現什麼樣的功能。就好比說：要同時盡快的找出最大最小，或者盡快的找出最值的位置等等。冒泡排序（bubble sort） — O(n2)
雞尾酒排序 (Cocktail sort, 雙向的冒泡排序) — O(n2)
插入排序 （insertion sort）— O(n2)
桶排序 （bucket sort）— O(n); 需要 O(k) 額外 記憶體
計數排序 (counting sort) — O(n+k); 需要 O(n+k) 額外 記憶體
歸並排序 （merge sort）— O(n log n); 需要 O(n) 額外記憶體
原地歸並排序 — O(n2)
二叉樹排序 （Binary tree sort） — O(n log n); 需要 O(n) 額外記憶體
鴿巢排序 (Pigeonhole sort) — O(n+k); 需要 O(k) 額外記憶體
基數排序 （radix sort）— O(n·k); 需要 O(n) 額外記憶體
Gnome sort — O(n2)
Library sort — O(n log n) with high probability, 需要 (1+ε)n 額外記憶體不穩定
選擇排序 （selection sort）— O(n2)
希爾排序 （shell sort）— O(n log n) 如果使用最佳的現在版本
Comb sort — O(n log n)
堆排序 （heapsort）— O(n log n)
Smoothsort — O(n log n)
快速排序 （quicksort）— O(n log n) 期望時間, O(n2) 最壞情況; 對於大的、亂數串列一般相信是最快的已知排序
等。

⑦ Java排序一共有幾種

日常操作中，常見的排序方法有：冒泡排序、快速排序、選擇排序、插入排序、希爾排序，甚至還有基數排序、雞尾酒排序、桶排序、鴿巢排序、歸並排序等。

各類排序方法代碼如圖：

⑧ Java中冒泡排序和選擇排序有什麼不同

冒泡排序（BubbleSort）的基本概念是：依次比較相鄰的兩個數，將小數放在前面，大數放在後面。即在第一趟：首先比較第1個和第2個數，將小數放前，大數放後。然後比較第2個數和第3個數，將小數放前，大數放後，如此繼續，直至比較最後兩個數，將小數放前，大數放後。至此第一趟結束，將最大的數放到了最後。在第二趟：仍從第一對數開始比較（因為可能由於第2個數和第3個數的交換，使得第1個數不再小於第2個數），將小數放前，大數放後，一直比較到倒數第二個數（倒數第一的位置上已經是最大的），第二趟結束，在倒數第二的位置上得到一個新的最大數（其實在整個數列中是第二大的數）。如此下去，重復以上過程，直至最終完成排序。
public class Paixu {
public static void main(String[] args) {
int [] a = {2,6,4,5,1,7,3};
int i = 0;
int j = 0;
int n = 0;
for(i= 0;i<a.length-1;i++){
for(j=0;j<a.length-i-1;j++){
if(a[j]>a[j+1]){
n = a[j];
a[j] = a[j+1];
a[j+1] = n;
}
}
}
for ( i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
}
直接選擇排序(Straight Select Sorting) 也是一種簡單的排序方法，它的基本思想是：第一次從R[0]~R[n-1]中選取最小值，與R[0]交換，第二次從R{1}~R[n-1]中選取最小值，與R[1]交換，....， 第i次從R[i-1]~R[n-1]中選取最小值，與R[i-1]交換，.....，第n-1次從R[n-2]~R[n-1]中選取最小值，與R[n-2]交換,總共通過n-1次,得到一個按排序碼從小到大排列的有序序列.
public class Paixu {
public static void main(String[] args) {
int [] a = {2,6,4,5,1,7,3};
int i = 0;
int j = 0;
int n = 0;
for(i= 0;i<a.length;i++){
for(j=i+1;j<a.length;j++){
if(a[i]>a[j]){
n = a[i];
a[j] = a[i];
a[i] = n;
}
}
}
for ( i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
}

⑨ java怎麼實現排序

Java實現幾種常見排序方法

日常操作中常見的排序方法有：冒泡排序、快速排序、選擇排序、插入排序、希爾排序，甚至還有基數排序、雞尾酒排序、桶排序、鴿巢排序、歸並排序等。
以下常見演算法的定義
1. 插入排序：插入排序基本操作就是將一個數據插入到已經排好序的有序數據中，從而得到一個新的、個數加一的有序數據，演算法適用於少量數據的排序，時間復雜度為O(n^2)。是穩定的排序方法。插入排序的基本思想是：每步將一個待排序的紀錄，按其關鍵碼值的大小插入前面已經排序的文件中適當位置上，直到全部插入完為止。
2. 選擇排序：選擇排序（Selection sort）是一種簡單直觀的排序演算法。它的工作原理是每一次從待排序的數據元素中選出最小（或最大）的一個元素，存放在序列的起始位置，直到全部待排序的數據元素排完。 選擇排序是不穩定的排序方法。
3. 冒泡排序：冒泡排序（Bubble Sort），是一種計算機科學領域的較簡單的排序演算法。它重復地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個演算法的名字由來是因為越大的元素會經由交換慢慢「浮」到數列的頂端。
4. 快速排序：快速排序（Quicksort）是對冒泡排序的一種改進。它的基本思想是：通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
5. 歸並排序：歸並排序是建立在歸並操作上的一種有效的排序演算法,該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用。將已有序的子序列合並，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合並成一個有序表，稱為二路歸並。
6. 希爾排序：希爾排序(Shell Sort)是插入排序的一種。也稱縮小增量排序，是直接插入排序演算法的一種更高效的改進版本。希爾排序是非穩定排序演算法。希爾排序是把記錄按下標的一定增量分組，對每組使用直接插入排序演算法排序；隨著增量逐漸減少，每組包含的關鍵詞越來越多，當增量減至1時，整個文件恰被分成一組，演算法便終止。
https://www.cnblogs.com/wangmingshun/p/5635292.html