各位大神，用java swt 怎么實現文本框的氣泡提示，就像QQ一樣，提示用戶名不能為空

氣泡提示解決思路如下：

創新互聯是一家專業提供太和企業網站建設,專注與成都網站建設、做網站、H5網站設計、小程序制作等業務。10年已為太和眾多企業、政府機構等服務。創新互聯專業網站制作公司優惠進行中。

1、非模態彈出對話框。

2、去掉彈出對話框的邊框和標題欄。

3、對話框上用于顯示的控件全部自繪，以達到絢麗的效果。

4、設置對話框彈出位置。

5、定時器控制對話框消失。

Java冒泡排序的原理？

冒泡排序是所欲排序算法里最好理解的了。

1、排序算法：

A)比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。

B)對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。在這一點，最后的元素應該會是最大的數。

C)針對所有的元素重復以上的步驟，除了最后一個。

D)持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。

2、給你一個java的實現代碼：

public class BubbleSort{

public static void main(String[] args){

? ?int score[] = {67, 69, 75, 87, 89, 90, 99, 100};

? ?for (int i = 0; i score.length -1; i++){ //最多做n-1趟排序

? ? ? ?for(int j = 0 ;j score.length - i - 1; j++){ //對當前無序區間score[0......length-i-1]進行排序(j的范圍很關鍵，這個范圍是在逐步縮小的)

? ? ? ? ? ?if(score[j] score[j + 1]){ //把小的值交換到后面

? ? ? ? ? ? ? ?int temp = score[j];

? ? ? ? ? ? ? ?score[j] = score[j + 1];

? ? ? ? ? ? ? ?score[j + 1] = temp;

? ? ? ? ? ?}

? ? ? ?}

? ? ? ?System.out.print("第" + (i + 1) + "次排序結果：");

? ? ? ?for(int a = 0; a score.length; a++){

? ? ? ? ? ?System.out.print(score[a] + "\t");

? ? ? ?}

? ? ? ?System.out.println("");

? ?}

? ? ? ?System.out.print("最終排序結果：");

? ? ? ?for(int a = 0; a score.length; a++){

? ? ? ? ? ?System.out.print(score[a] + "\t");

? }

}

}

Java怎樣實現類似Android/IOS短信界面 微信聊天 QQ空間回復那樣一左一右的氣泡式 界面該怎樣布局

其實就是兩個布局，里面頭像，對話框控件的android:id一樣，然后再adapter中getview()根據用戶判斷選擇不同的加載就OK了，代碼類似于

if (判斷) {

view = LayoutInflater.from(activity).inflate(

R.layout.left, null);//左邊的布局

} else {

view = LayoutInflater.from(activity).inflate(

R.layout.right, null);//右邊的布局

}

ImageView avatar = (ImageView) view.findViewById();//頭像

TextView msg = (TextView) view.findViewById(R.id.);//對話框

java中冒泡排序算法的詳細解答以及程序？

實例說明?

用冒泡排序方法對數組進行排序。?

實例解析?

交換排序的基本思想是兩兩比較待排序記錄的關鍵字，發現兩個記錄的次序相反時即進行交換，直到沒有反序的記錄為止。?

應用交換排序基本思想的主要排序方法有冒泡排序和快速排序。?

冒泡排序?

將被排序的記錄數組 R[1..n] 垂直排列，每個記錄 R[i] 看做是重量為 R[i].key 的氣泡。根據輕氣泡不能在重氣泡之下的原則，從下往上掃描數組 R 。凡掃描到違反本原則的輕氣泡，就使其向上“漂浮”。如此反復進行，直到最后任何兩個氣泡都是輕者在上，重者在下為止。?

(1) 初始， R[1..n] 為無序區。?

(2) 第一趟掃描，從無序區底部向上依次比較相鄰的兩個氣泡的重量，若發現輕者在下、重者在上，則交換二者的位置。即依次比較 (R[n],R[n-1]) 、 (R[n-1],R[n-2]) 、 … 、 (R[2],R[1]); 對于每對氣泡 (R[j+1],R[j]), 若 R[j+1].keyR[j].key, 則交換 R[j+1] 和 R[j] 的內容。?

第一趟掃描完畢時，“最輕”的氣泡就飄浮到該區間的頂部，即關鍵字最小的記錄被放在最高位置 R[1] 上。?

(3) 第二趟掃描，掃描 R[2..n]。掃描完畢時，“次輕”的氣泡飄浮到 R[2] 的位置上 …… 最后，經過 n-1 趟掃描可得到有序區 R[1..n]。?

注意：第 i 趟掃描時， R[1..i-1] 和 R[i..n] 分別為當前的有序區和無序區。掃描仍是從無序區底部向上直至該區頂部。掃描完畢時，該區中最輕氣泡漂浮到頂部位置 R[i] 上，結果是 R[1..i] 變為新的有序區。?

冒泡排序算法?

因為每一趟排序都使有序區增加了一個氣泡，在經過 n-1 趟排序之后，有序區中就有 n-1 個氣泡，而無序區中氣泡的重量總是大于等于有序區中氣泡的重量，所以整個冒泡排序過程至多需要進行 n-1 趟排序。?

若在某一趟排序中未發現氣泡位置的交換，則說明待排序的無序區中所有氣泡均滿足輕者在上，重者在下的原則，因此，冒泡排序過程可在此趟排序后終止。為此，在下面給出的算法中，引入一個布爾量 exchange, 在每趟排序開始前，先將其置為 FALSE 。若排序過程中發生了交換，則將其置為 TRUE 。各趟排序結束時檢查 exchange, 若未曾發生過交換則終止算法，不再進行下趟排序。

具體算法如下：?

void BubbleSort(SeqList R){?

//R(1..n) 是待排序的文件，采用自下向上掃描，對 R 做冒泡排序?

int i,j;?

Boolean exchange; // 交換標志?

for(i=1;in;i++){ // 最多做 n-1 趟排序?

exchange=FALSE; // 本趟排序開始前，交換標志應為假?

for(j=n-1;j=i;j--) // 對當前無序區 R[i..n] 自下向上掃描?

if(R[j+1].keyR[j].key){ // 交換記錄?

R[0]=R[j+1]; //R[0] 不是哨兵，僅做暫存單元?

R[j+1]=R[j];?

R[j]=R[0];?

exchange=TRUE; // 發生了交換，故將交換標志置為真?

}?

if(!exchange) // 本趟排序未發生交換，提前終止算法?

return;?

} //endfor( 外循環 )?

}//BubbleSort

public?class?BubbleSort?{

public?static?void?main(String[]?args)?{

//?TODO?Auto-generated?method?stub

ListInteger?lstInteger?=?new?ArrayListInteger();

lstInteger.add(1);

lstInteger.add(1);

lstInteger.add(3);

lstInteger.add(2);

lstInteger.add(1);

for(int?i?=?0;?ilstInteger.size();?i++){

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

}

System.out.println("排序之后-----------------");

lstInteger?=?sortList(lstInteger);

for(int?i?=?0;?ilstInteger.size();?i++){

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

}

}

public?static?ListInteger?sortList(ListInteger?lstInteger){

int?i,j,m;

boolean?blChange;

int?n?=?lstInteger.size();

for(i=0;in;i++){

blChange?=?false;

for(j?=?n-1;?ji?;?j--?){

if(lstInteger.get(j)lstInteger.get(j-1)){

m?=?lstInteger.get(j-1);

lstInteger.set(j-1,?lstInteger.get(j));

lstInteger.set(j,?m);

blChange?=?true;

}

}

if(!blChange){

return?lstInteger;

}

}

return?lstInteger;

}

}

歸納注釋?

算法的最好時間復雜度:?若文件的初始狀態是正序的,?一趟掃描即可完成排序。所需的關鍵字比較次數?C?和記錄移動次數?M?均達到最小值，即?C(min)=n-1,?M(min)=?0?。冒泡排序最好的時間復雜度為?O(n)。?

算法的最壞時間復雜度:?若初始文件是反序的，需要進行?n-1?趟排序。每趟排序要進行?n-1?次關鍵字的比較?(1=i=n-1),?且每次比較都必須移動記錄?3?次。在這種情況下，比較和移動次數均達到最大值，即?C(max)=n(n-1)/2=O(n?^2?)，M(max)=3n(n-1)/2=O(n?^2?)。冒泡排序的最壞時間復雜度為?O(n^2?)。?

算法的平均時間復雜度為?O(n^2?)。雖然冒泡排序不一定要進行?n-1?趟，但由于它的記錄移動次數較多，故平均時間性能比直接插入排序要差得多。?

算法穩定性：冒泡排序是就地排序，且它是穩定的。?

算法改進：上述的冒泡排序還可做如下的改進，①?記住最后一次交換發生位置?lastExchange?的冒泡排序(?該位置之前的相鄰記錄均已有序?)。下一趟排序開始時，R[1..lastExchange-1]?是有序區，?R[lastExchange..n]?是無序區。這樣，一趟排序可能使當前有序區擴充多個記錄，從而減少排序的趟數。②?改變掃描方向的冒泡排序。冒泡排序具有不對稱性。能一趟掃描完成排序的情況，只有最輕的氣泡位于?R[n]?的位置，其余的氣泡均已排好序，那么也只需一趟掃描就可以完成排序。如對初始關鍵字序列?12、18、42、44、45、67、94、10?就僅需一趟掃描。需要?n-1?趟掃描完成排序情況，當只有最重的氣泡位于?R[1]?的位置，其余的氣泡均已排好序時，則仍需做?n-1?趟掃描才能完成排序。比如對初始關鍵字序列：94、10、12、18、42、44、45、67?就需?7?趟掃描。造成不對稱性的原因是每趟掃描僅能使最重氣泡“下沉”一個位置，因此使位于頂端的最重氣泡下沉到底部時，需做?n-1?趟掃描。在排序過程中交替改變掃描方向，可改進不對稱性

網站欄目：java氣泡代碼 安卓氣泡代碼
文章網址：http://vcdvsql.cn/article48/dopghhp.html

成都網站建設公司_創新互聯，為您提供網站內鏈、手機網站建設、面包屑導航、App設計、網站排名、網站制作

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯