java資料庫排序
1. java中怎樣實現數據排序。
public class test {
public static void main(String[] args) {
String str="1.0 34908.88823466623 24.8 2.0 39630.961058839486 20.0 3.0 29856.65765600835 25.9 4.0 38859.980988644864 25.3 5.0 47423.10173210188 23.8 6.0 19849.168161290105 20.8 7.0 29328.50106736126 18.9 8.0 29654.31232056705 19.4 9.0 21008.940395882488 16.8 1.0 34926.3790840164 24.8 2.0 39660.28500738808 20.0 3.0 29851.443257036703 25.9 4.0 38868.554962563765 25.3 5.0 47445.38630797819 23.8 6.0 19879.09643860034 20.8 7.0 29348.43050519415 18.9 8.0 29680.180199684346 19.4 9.0 20980.839899721435 16.8";
str=str.replaceAll("\\s+", " ");//把多個空格合並成一個空格
String[] org=str.split(" ");//按照空格進行分割
double[][] dou=new double[org.length/3][3];//將一維數組分到三維數組里邊
for(int i=0;i<org.length;i++){
dou[(i-i%3)/3][i%3]=Double.valueOf(org[i]);
}
double midd = 0;//冒泡排序法根據第二列對二維數組前9行進行排序
for (int i=0;i<9;i++){
for(int j=0;j<9-i-1;j++){
if(dou[j][1]>dou[j+1][1]){//判斷第二列是否比前一個大，如果是則調換位置
for(int k=0;k<3;k++){
midd=dou[j+1][k];
dou[j+1][k]=dou[j][k];
dou[j][k]=midd;
}
}
}
}
for(int i=0;i<dou.length;i++){//列印輸出數值
for(int j=0;j<dou[i].length;j++)
System.out.print(dou[i][j]+" ");
System.out.println();
}
}
}
好了，給你寫好了，記得採納加分，親！
2. Java如何排序資料庫表的數據內容
兩種方式：
3. java 怎麼將List裡面數據排序
importjava.util.ArrayList;
importjava.util.Collections;
importjava.util.Comparator;
importjava.util.List;
publicclassArrayListOrder{
publicstaticvoidmain(String[]args){
List<List<Integer>>list=newArrayList<List<Integer>>();
List<Integer>arrayList1=newArrayList<Integer>();
arrayList1.add(2);
arrayList1.add(5);
arrayList1.add(6);
list.add(arrayList1);
List<Integer>arrayList2=newArrayList<Integer>();
arrayList2.add(2);
arrayList2.add(4);
arrayList2.add(6);
list.add(arrayList2);
List<Integer>arrayList3=newArrayList<Integer>();
arrayList3.add(2);
arrayList3.add(6);
arrayList3.add(6);
list.add(arrayList3);
List<Integer>arrayList4=newArrayList<Integer>();
arrayList4.add(2);
arrayList4.add(1);
arrayList4.add(6);
list.add(arrayList4);
for(List<Integer>tmpList:list){
System.out.print(tmpList.get(1)+"");
}
System.out.println("");
//排序
Collections.sort(list,newComparator<List<Integer>>(){
publicintcompare(List<Integer>list1,List<Integer>list2){
//比較每個ArrayList的第二個元素
if(list1.get(1)==list2.get(1)){
return0;
}elseif(list1.get(1)>list2.get(1)){
return1;
}else{
return-1;
}
}
});
for(List<Integer>tmpList:list){
System.out.print(tmpList.get(1)+"");
}
}
}
4. java對資料庫獲取統計數和排序
您好，提問者：
用SQL查詢排序就好了。。
SELECT
?,?,?
FROM
表名
WHERE
條件
ORDER
BY
要排序的欄位
ASC;//ASC是升序，也就是從小到大//DESC是降序，從大到小
5. JAVA中有哪幾種常用的排序方法
最主要的是冒泡排序、選擇排序、插入排序以及快速排序
1、冒泡排序
冒泡排序是一個比較簡單的排序方法。在待排序的數列基本有序的情況下排序速度較快。若要排序的數有n個，則需要n-1輪排序，第j輪排序中，從第一個數開始，相鄰兩數比較，若不符合所要求的順序，則交換兩者的位置；直到第n+1-j個數為止，第一個數與第二個數比較，第二個數與第三個數比較，......，第n-j個與第n+1-j個比較，共比較n-1次。此時第n+1-j個位置上的數已經按要求排好，所以不參加以後的比較和交換操作。
例如：第一輪排序：第一個數與第二個數進行比較，若不符合要求的順序，則交換兩者的位置，否則繼續進行二個數與第三個數比較......。直到完成第n-1個數與第n個數的比較。此時第n個位置上的數已經按要求排好，它不參與以後的比較和交換操作；第二輪排序：第一個數與第二個數進行比較，......直到完成第n-2個數與第n-1個數的比較；......第n-1輪排序：第一個數與第二個數進行比較，若符合所要求的順序，則結束冒泡法排序；若不符合要求的順序，則交換兩者的位置，然後結束冒泡法排序。
共n-1輪排序處理，第j輪進行n-j次比較和至多n-j次交換。
從以上排序過程可以看出，較大的數像氣泡一樣向上冒，而較小的數往下沉，故稱冒泡法。
public void bubbleSort(int a[])
{
int n = a.length;
for(int i=0;i<n-1;i++)
{
for(int j=0;j<n-i-1;j++)
{
if(a[j] > a[j+1])
{
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}
2、選擇排序
選擇法的原理是先將第一個數與後面的每一個數依次比較,不斷將將小的賦給第一個數,從而找出最小的,然後第二個數與後面的每一個數依次比較,從而找出第二小的,然後第三個數與後面的每一個數依次比較,從而找出第三小的.....直到找到最後一個數。
public void sort(int x[])
{
int n=x.length;
int k,t;
for(int i=0;i<n-1;i++)
{
k=i;
for(int j=i+1;j=n;j++)
{
if(x[j]>x[k])k=j;
if(k!=i)
{
t=x[i];
x[i]=x[k];
x[k]=t;
}
}
}
}
3、插入排序
插入排序的原理是對數組中的第i個元素，認為它前面的i-1個已經排序好，然後將它插入到前面的i-1個元素中。插入排序對少量元素的排序較為有效.
public void sort(int obj[])
{
for(int j=1;j<obj.length;j++)
{
int key=obj[j];
int i=j-1;
while(i>=0&&obj[i]>key)
{
obj[i+1]=obj[i];
i--;
}
obj[i+1]=key;
}
}
4、快速排序
快速排序是對冒泡排序的一種改進。它的基本思想是：通過一次排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按次方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此大道整個數據變成有序序列。
public void quickSort(int obj[],int low,int high)
{
int i=low;
int j=high;
int keyValue=obj[i];
while(i<j)
{
int temp=0;
while(i<j&&obj[j]>=keyValue)
{
j=j-1;
}
temp=obj[j];
obj[j]=obj[i];
obj[i]=temp;
while(i<j&&obj[i]<=keyValue)
{
i=i+1;
}
temp=obj[j];
obj[j]=ojb[i];
obj[i]=temp;
}
obj[i]=keyValue;
if(low<i-1)
{
quickSort(obj,low,i-1);
}
if(high>i+1)
{
quickSort(obj,i+1,high);
}
}
6. Java資料庫排序
如果你不清楚一個方法的用法，首先應該想到查API文檔啊：
內容如下：
int
executeUpdate(String
sql)
執行給定
SQL
語句，該語句可能為
INSERT、UPDATE
或
DELETE
語句，或者不返回任何內容的
SQL
語句（如
SQL
DDL
語句）。
-------------------------
但我不理解的是，
rs=stmt.executeQuery("Select
*
From
StuInfo
ORDER
BY
Num");
這已經執行查詢了你還用executeUpdate(String
sql)做什麼啊？
進行數據更新？
我覺得你下一步應該是輸出排序後的欄位吧？
while(rs.next()){……}這樣吧？
7. 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
8. 在java中如何給數據進行大小排序
privateList<Integer>mList=newArrayList<>();
mList.add(1);
mList.add(5);
mList.add(7);
mList.add(9);
mList.add(8);
mList.add(3);
//排序前
Log.d(TAG,"onCreate:"+mList.toString());
Collections.sort(mList);
//排序後
Log.d(TAG,"onCreate:"+mList.toString());
列印的Log：
[1,5,7,9,8,3]
[1,3,5,7,8,9]
9. 用java如何將對mysql排序
兩種方式：
直接在mysql中排序， 查看一下SQL語句的order by 使用
查詢出來的數據，利用排序演算法，在內存中排序。什麼插入排序，冒泡排序，快速排序等等。
個人建議，直接在資料庫中排序，簡單高效。
10. 幾種經典的數據排序及其Java實現
數據排序方法有很多，比如選擇排序、冒泡法、插入排序、希爾排序、快速排序、歸並排序等，下面給你著重介紹3種：
1、選擇排序
思想
n個記錄的文件的直接選擇排序可經過n-1趟直接選擇排序得到有序結果：
①初始狀態：無序區為R[1..n]，有序區為空。
②第1趟排序
在無序區R[1..n]中選出關鍵字最小的記錄R[k]，將它與無序區的第1個記錄R[1]交換，使R[1..1]和R[2..n]分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。
……
③第i趟排序
第i趟排序開始時，當前有序區和無序區分別為R[1..i-1]和R(i..n）。該趟排序從當前無序區中選出關鍵字最小的記錄 R[k]，將它與無序區的第1個記錄R交換，使R[1..i]和R分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。
排序實例
初始關鍵字 [49 38 65 97 76 13 27 49]
第一趟排序後 13 [38 65 97 76 49 27 49]
第二趟排序後 13 27 [65 97 76 49 38 49]
第三趟排序後 13 27 38 [97 76 49 65 49]
第四趟排序後 13 27 38 49 [76 97 65 49 ]
第五趟排序後 13 27 38 49 49 [97 65 76]
第六趟排序後 13 27 38 49 49 65 [97 76]
第七趟排序後 13 27 38 49 49 65 76 [97]
最後排序結果 13 27 38 49 49 65 76 97
2、冒泡法
原理
冒泡排序演算法的運作如下：
比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。
針對所有的元素重復以上的步驟，除了最後一個。
持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。
演算法分析
演算法穩定性
冒泡排序就是把小的元素往前調或者把大的元素往後調。比較是相鄰的兩個元素比較，交換也發生在這兩個元素之間。所以，如果兩個元素相等，我想你是不會再無聊地把他們倆交換一下的；如果兩個相等的元素沒有相鄰，那麼即使通過前面的兩兩交換把兩個相鄰起來，這時候也不會交換，所以相同元素的前後順序並沒有改變，所以冒泡排序是一種穩定排序演算法。
3、插入排序
插入排序（Insertion Sort）的演算法描述是一種簡單直觀的排序演算法。它的工作原理是通過構建有序序列，對於未排序數據，在已排序序列中從後向前掃描，找到相應位置並插入。插入排序在實現上，通常採用in-place排序（即只需用到O(1)的額外空間的排序），因而在從後向前掃描過程中，需要反復把已排序元素逐步向後挪位，為最新元素提供插入空間。
演算法描述一般來說，插入排序都採用in-place在數組上實現。具體演算法描述如下：從第一個元素開始，該元素可以認為已經被排序取出下一個元素，在已經排序的元素序列中從後向前掃描如果該元素（已排序）大於新元素，將該元素移到下一位置重復步驟3，直到找到已排序的元素小於或者等於新元素的位置將新元素插入到該位置後重復步驟2~5如果比較操作的代價比交換操作大的話，可以採用二分查找法來減少比較操作的數目。該演算法可以認為是插入排序的一個變種，稱為二分查找排序。