java代碼的層次順序 java代碼的層次順序有哪些

學(xué)習(xí)Java分為幾個階段，分別是什么

主要分為5個階段吧！

目前創(chuàng)新互聯(lián)已為超過千家的企業(yè)提供了網(wǎng)站建設(shè)、域名、網(wǎng)絡(luò)空間、網(wǎng)站托管、服務(wù)器租用、企業(yè)網(wǎng)站設(shè)計、澄江網(wǎng)站維護(hù)等服務(wù)，公司將堅持客戶導(dǎo)向、應(yīng)用為本的策略，正道將秉承"和諧、參與、激情"的文化，與客戶和合作伙伴齊心協(xié)力一起成長，共同發(fā)展。

第一階段：Java編程入門

1. Java基礎(chǔ)語法

2. 面向?qū)ο缶幊趟枷?/p>

第二階段：JavaSE進(jìn)階

1. Java常用API

2. 多線程并發(fā)編程

3. 數(shù)據(jù)結(jié)構(gòu)/集合框架

4. IO/網(wǎng)絡(luò)編程/反射/設(shè)計模式

第三階段：主流數(shù)據(jù)庫管理系統(tǒng)

1. MySQL/Oracle

2. JDBC

第四階段：JavaWeb開發(fā)技術(shù)詳解

1. JavaWeb前端

2. JavaWeb基礎(chǔ)

3. JavaWeb高級

第五階段：項目實戰(zhàn)

1. 團(tuán)隊協(xié)作完成

2. 個人實戰(zhàn)完成

java編程的冒泡等排序示例

Java排序算法

1）分類：

1）插入排序（直接插入排序、希爾排序）

2）交換排序（冒泡排序、快速排序）

3）選擇排序（直接選擇排序、堆排序）

4）歸并排序

5）分配排序（箱排序、基數(shù)排序）

所需輔助空間最多：歸并排序

所需輔助空間最少：堆排序

平均速度最快：快速排序

不穩(wěn)定：快速排序，希爾排序，堆排序。

1）選擇排序算法的時候

1.數(shù)據(jù)的規(guī)模 ； 2.數(shù)據(jù)的類型 ； 3.數(shù)據(jù)已有的順序

一般來說，當(dāng)數(shù)據(jù)規(guī)模較小時，應(yīng)選擇直接插入排序或冒泡排序。任何排序算法在數(shù)據(jù)量小時基本體現(xiàn)不出來差距。 考慮數(shù)據(jù)的類型，比如如果全部是正整數(shù)，那么考慮使用桶排序為最優(yōu)。 考慮數(shù)據(jù)已有順序，快排是一種不穩(wěn)定的排序（當(dāng)然可以改進(jìn)），對于大部分排好的數(shù)據(jù)，快排會浪費大量不必要的步驟。數(shù)據(jù)量極小，而起已經(jīng)基本排好序，冒泡是最佳選擇。我們說快排好，是指大量隨機數(shù)據(jù)下，快排效果最理想。而不是所有情況。

3）總結(jié)：

——按平均的時間性能來分：

1）時間復(fù)雜度為O(nlogn)的方法有：快速排序、堆排序和歸并排序，其中以快速排序為最好；

2）時間復(fù)雜度為O(n2)的有：直接插入排序、起泡排序和簡單選擇排序，其中以直接插入為最好，特 別是對那些對關(guān)鍵字近似有序的記錄序列尤為如此；

3）時間復(fù)雜度為O(n)的排序方法只有，基數(shù)排序。

當(dāng)待排記錄序列按關(guān)鍵字順序有序時，直接插入排序和起泡排序能達(dá)到O(n)的時間復(fù)雜度;而對于快速排序而言，這是最不好的情況，此時的時間性能蛻化為O(n2)，因此是應(yīng)該盡量避免的情況。簡單選擇排序、堆排序和歸并排序的時間性能不隨記錄序列中關(guān)鍵字的分布而改變。

——按平均的空間性能來分（指的是排序過程中所需的輔助空間大?。?/p>

1） 所有的簡單排序方法(包括：直接插入、起泡和簡單選擇)和堆排序的空間復(fù)雜度為O(1)；

2） 快速排序為O(logn )，為棧所需的輔助空間;

3） 歸并排序所需輔助空間最多，其空間復(fù)雜度為O(n );

4）鏈?zhǔn)交鶖?shù)排序需附設(shè)隊列首尾指針，則空間復(fù)雜度為O(rd )。

——排序方法的穩(wěn)定性能：

1） 穩(wěn)定的排序方法指的是，對于兩個關(guān)鍵字相等的記錄，它們在序列中的相對位置，在排序之前和 經(jīng)過排序之后，沒有改變。

2） 當(dāng)對多關(guān)鍵字的記錄序列進(jìn)行LSD方法排序時，必須采用穩(wěn)定的排序方法。

3） 對于不穩(wěn)定的排序方法，只要能舉出一個實例說明即可。

4） 快速排序，希爾排序和堆排序是不穩(wěn)定的排序方法。

4）插入排序：

包括直接插入排序，希爾插入排序。

直接插入排序： 將一個記錄插入到已經(jīng)排序好的有序表中。

1, sorted數(shù)組的第0個位置沒有放數(shù)據(jù)。

2，從sorted第二個數(shù)據(jù)開始處理：

如果該數(shù)據(jù)比它前面的數(shù)據(jù)要小，說明該數(shù)據(jù)要往前面移動。

首先將該數(shù)據(jù)備份放到 sorted的第0位置當(dāng)哨兵。

然后將該數(shù)據(jù)前面那個數(shù)據(jù)后移。

然后往前搜索，找插入位置。

找到插入位置之后講 第0位置的那個數(shù)據(jù)插入對應(yīng)位置。

O(n*n), 當(dāng)待排記錄序列為正序時，時間復(fù)雜度提高至O(n)。

希爾排序（縮小增量排序 diminishing increment sort）：先將整個待排記錄序列分割成若干個子序列分別進(jìn)行直接插入排序，待整個序列中的記錄基本有序時，再對全體記錄進(jìn)行一次直接插入排序。

面試穿什么，這里找答案！

插入排序Java代碼：

public class InsertionSort {

// 插入排序：直接插入排序 ，希爾排序

public void straightInsertionSort(double [] sorted){

int sortedLen= sorted.length;

for(int j=2;jsortedLen;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;jsortedLen;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];

//數(shù)據(jù)結(jié)構(gòu)課本上這個地方?jīng)]有給出判讀，出錯：

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;jnum;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;jarraysize;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;jsorted.length;j++){

System.out.print((int)sorted[j]+" ");

}

System.out.println();

}

}

面試穿什么，這里找答案！

5）交換排序：

包括冒泡排序，快速排序。

冒泡排序法：該算法是專門針對已部分排序的數(shù)據(jù)進(jìn)行排序的一種排序算法。如果在你的數(shù)據(jù)清單中只有一兩個數(shù)據(jù)是亂序的話，用這種算法就是最快的排序算法。如果你的數(shù)據(jù)清單中的數(shù)據(jù)是隨機排列的，那么這種方法就成了最慢的算法了。因此在使用這種算法之前一定要慎重。這種算法的核心思想是掃描數(shù)據(jù)清單，尋找出現(xiàn)亂序的兩個相鄰的項目。當(dāng)找到這兩個項目后，交換項目的位置然后繼續(xù)掃描。重復(fù)上面的操作直到所有的項目都按順序排好。

快速排序：通過一趟排序，將待排序記錄分割成獨立的兩個部分，其中一部分記錄的關(guān)鍵字均比另一部分記錄的關(guān)鍵字小，則可分別對這兩部分記錄繼續(xù)進(jìn)行排序，以達(dá)到整個序列有序。具體做法是：使用兩個指針low,high, 初值分別設(shè)置為序列的頭，和序列的尾，設(shè)置pivotkey為第一個記錄，首先從high開始向前搜索第一個小于pivotkey的記錄和pivotkey所在位置進(jìn)行交換，然后從low開始向后搜索第一個大于pivotkey的記錄和此時pivotkey所在位置進(jìn)行交換，重復(fù)知道low=high了為止。

交換排序Java代碼：

public class ExchangeSort {

public void BubbleExchangeSort(double [] sorted){

int sortedLen= sorted.length;

for(int j=sortedLen;j0;j--){

int end= j;

for(int k=1;kend-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(lowhigh){

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(lowhigh){

while(lowhigh sorted[high]= sorted[0])--high;

sorted[low]= sorted[high];

while(lowhigh 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;jarraysize;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;jsorted.length;j++){

System.out.print((int)sorted[j]+" ");

}

System.out.println();

}

}

6）選擇排序：

分為直接選擇排序， 堆排序

直接選擇排序：第i次選取 i到array.Length-1中間最小的值放在i位置。

堆排序：首先，數(shù)組里面用層次遍歷的順序放一棵完全二叉樹。從最后一個非終端結(jié)點往前面調(diào)整，直到到達(dá)根結(jié)點，這個時候除根節(jié)點以外的所有非終端節(jié)點都已經(jīng)滿足堆得條件了，于是需要調(diào)整根節(jié)點使得整個樹滿足堆得條件，于是從根節(jié)點開始，沿著它的兒子們往下面走（最大堆沿著最大的兒子走，最小堆沿著最小的兒子走）。 主程序里面，首先從最后一個非終端節(jié)點開始調(diào)整到根也調(diào)整完，形成一個heap， 然后將heap的根放到后面去（即：每次的樹大小會變化，但是 root都是在1的位置，以方便計算兒子們的index，所以如果需要升序排列，則要逐步大頂堆。因為根節(jié)點被一個個放在后面去了。 降序排列則要建立小頂堆）

代碼中的問題： 有時候第2個和第3個順序不對（原因還沒搞明白到底代碼哪里有錯）

選擇排序Java代碼：

public class SelectionSort {

public void straitSelectionSort(double [] sorted){

int sortedLen= sorted.length;

for(int j=1;jsortedLen;j++){

int jMin= getMinIndex(sorted,j);

exchange(sorted,j,jMin);

}

}

public void exchange(double [] sorted,int i,int j){

int sortedLen= sorted.length;

if(isortedLen jsortedLen ij 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;jsortedLen;j++){

if(sorted[j]min){

min= sorted[j];

minJ= j;

}

}

return minJ;

}

public void heapAdjust(double [] sorted,int start,int end){

if(startend){

double temp= sorted;

// 這個地方j(luò)end與課本不同，j=end會報錯：

for(int j=2*start;jend;j *=2){

if(j+1end sorted[j]-sorted[j+1]10e-6){

++j;

}

if(temp=sorted[j]){

break;

}

sorted=sorted[j];

start=j;

}

sorted=temp;

}

}

public void heapSelectionSort(double [] sorted){

int sortedLen = sorted.length;

for(int i=sortedLen/2;i0;i--){

heapAdjust(sorted,i,sortedLen);

}

for(int i=sortedLen;i1;--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;jarraysize;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;jsorted.length;j++){

System.out.print((int)sorted[j]+" ");

}

System.out.println();

}

}

面試穿什么，這里找答案！

7）歸并排序：

將兩個或兩個以上的有序表組合成一個新的有序表。歸并排序要使用一個輔助數(shù)組，大小跟原數(shù)組相同，遞歸做法。每次將目標(biāo)序列分解成兩個序列，分別排序兩個子序列之后，再將兩個排序好的子序列merge到一起。

歸并排序Java代碼：

public class MergeSort {

private double[] bridge;//輔助數(shù)組

public void sort(double[] obj){

if (obj == null){

throw new NullPointerException("

The param can not be null!");

}

bridge = new double[obj.length]; // 初始化中間數(shù)組

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){

// 從兩個數(shù)組中取出小的放入中間數(shù)組

if (obj[left]-obj[mid]=10e-6){

bridge[third++] = obj[left++];

} else{

bridge[third++] = obj[mid++];

}

}

// 剩余部分依次置入中間數(shù)組

while (mid = right){

bridge[third++] = obj[mid++];

}

while (left = center){

bridge[third++] = obj[left++];

}

// 將中間數(shù)組的內(nèi)容拷貝回原數(shù)組

copy(obj, tmp, right);

}

private void copy(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）基數(shù)排序：

使用10個輔助隊列，假設(shè)最大數(shù)的數(shù)字位數(shù)為 x， 則一共做 x次，從個位數(shù)開始往前，以第i位數(shù)字的大小為依據(jù)，將數(shù)據(jù)放進(jìn)輔助隊列，搞定之后回收。下次再以高一位開始的數(shù)字位為依據(jù)。

以Vector作輔助隊列，基數(shù)排序的Java代碼：

public class RadixSort {

private int keyNum=-1;

private VectorVectorDouble util;

public void distribute(double [] sorted, int nth){

if(nth=keyNum nth0){

util=new VectorVectorDouble();

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

Vector Double temp= new Vector Double();

util.add(temp);

}

for(int j=0;jsorted.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;j10;j++){

int len= util.get(j).size();

if(len0){

for(int i=0;ilen;i++){

sorted[k++]= util.get(j).get(i);

}

}

}

util=null;

}

public int getKeyNum(double [] sorted){

double max= Double.MIN_VALUE;

for(int j=0;jsorted.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();

}

}

//copy而來

java工作原理

Java工作原理

由四方面組成：

（1）Java編程語言

（2）Java類文件格式

（3）Java虛擬機

（4）Java應(yīng)用程序接口

當(dāng)編輯并運行一個Java程序時，需要同時涉及到這四種方面。使用文字編輯軟件（例如記事本、寫字板、UltraEdit等）或集成開發(fā)環(huán)境（Eclipse、MyEclipse等）在Java源文件中定義不同的類 ，通過調(diào)用類（這些類實現(xiàn)了Java API）中的方法來訪問資源系統(tǒng)，把源文件編譯生成一種二進(jìn)制中間碼，存儲在class文件中，然后再通過運行與操作系統(tǒng)平臺環(huán)境相對應(yīng)的Java虛擬機來運行class文件，執(zhí)行編譯產(chǎn)生的字節(jié)碼，調(diào)用class文件中實現(xiàn)的方法來滿足程序的Java API調(diào)用 。

應(yīng)該怎樣學(xué)習(xí)JAVA？順序是什么？

不知道Java 學(xué)習(xí)順序的話，我提供你一條學(xué)習(xí)線路圖！

按照視頻學(xué)習(xí)的過程中，學(xué)習(xí)方法也是很重要的！一定要記得勤記筆記，整理程思維導(dǎo)圖，方便后續(xù)復(fù)習(xí)方便。

第一部分：JavaSE：Java語言最基本的一套庫

學(xué)習(xí)JavaEE或JavaME之前，JavaSE是必學(xué)的。

* Java開發(fā)環(huán)境搭建

* Java基礎(chǔ)語法

* 面向?qū)ο?/p>

* 數(shù)組

* 異常

* 集合

* 線程

* IO流

* 反射機制

* 注解Annotation

* 網(wǎng)絡(luò)編程

第二部分：數(shù)據(jù)庫 【MySQL + JDBC】

* 只要學(xué)習(xí)編程，數(shù)據(jù)庫是一定要學(xué)習(xí)的，是一門公共的學(xué)科。

* java、C、python、C#等程序員都需要學(xué)習(xí)數(shù)據(jù)庫。

* 數(shù)據(jù)庫產(chǎn)品很多： MySQL、Oracle、SqlServer、DB2......

* 我們動力節(jié)點數(shù)據(jù)庫課程包括：MySQL + Oracle

* Oracle：銀行、政府使用oracle的較多。

* MySQL：互聯(lián)網(wǎng)公司、一般企業(yè)使用MySQL較多。

* Oracle我們是提供視頻的。課堂上不講。

* 我們課堂上講MySQL。

* Java語言鏈接數(shù)據(jù)庫：JDBC

第三部分：WEB前端

* 系統(tǒng)結(jié)構(gòu)：B/S【Browser/Server】 C/S【Client/Server】

* WEB是網(wǎng)站的意思。WEB前端是：網(wǎng)站當(dāng)中的頁面。

* WEB前端程序是運行在瀏覽器當(dāng)中的。

* HTML5 + CSS3 + JavaScript(JS)

* WEB前端也有很多框架：

- jQuery

- Bootstrap

- Vue

- NodeJS

- AugularJS

- RectJS

- LayUI

- EasyUI

.....

第四部分：JavaWEB

* Servlet

* JSP

* AJAX(是JavaScript的一部分語法,專門做頁面局部刷新)

第五部分：JavaWEB項目

* 做一個B/S結(jié)構(gòu)的項目，將WEB前端和JavaWEB內(nèi)容做一個整合練習(xí)。

* 其實到這里為止，所有的系統(tǒng)都可以做了。但是用的技術(shù)很Low。沒有用框架。

分享標(biāo)題：java代碼的層次順序 java代碼的層次順序有哪些
本文來源：http://www.muchs.cn/article12/dohisgc.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供虛擬主機、網(wǎng)站制作、外貿(mào)建站、Google、軟件開發(fā)、定制開發(fā)

廣告

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