學習Java分為幾個階段，分別是什么

主要分為5個階段吧！

目前創新互聯已為超過千家的企業提供了網站建設、域名、網絡空間、網站托管、服務器租用、企業網站設計、澄江網站維護等服務，公司將堅持客戶導向、應用為本的策略，正道將秉承"和諧、參與、激情"的文化，與客戶和合作伙伴齊心協力一起成長，共同發展。

第一階段：Java編程入門

1. Java基礎語法

2. 面向對象編程思想

第二階段：JavaSE進階

1. Java常用API

2. 多線程并發編程

3. 數據結構/集合框架

4. IO/網絡編程/反射/設計模式

第三階段：主流數據庫管理系統

1. MySQL/Oracle

2. JDBC

第四階段：JavaWeb開發技術詳解

1. JavaWeb前端

2. JavaWeb基礎

3. JavaWeb高級

第五階段：項目實戰

1. 團隊協作完成

2. 個人實戰完成

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;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];

//數據結構課本上這個地方沒有給出判讀，出錯：

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）交換排序：

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

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

快速排序：通過一趟排序，將待排序記錄分割成獨立的兩個部分，其中一部分記錄的關鍵字均比另一部分記錄的關鍵字小，則可分別對這兩部分記錄繼續進行排序，以達到整個序列有序。具體做法是：使用兩個指針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;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位置。

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

代碼中的問題： 有時候第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;

// 這個地方jend與課本不同，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）歸并排序：

將兩個或兩個以上的有序表組合成一個新的有序表。歸并排序要使用一個輔助數組，大小跟原數組相同，遞歸做法。每次將目標序列分解成兩個序列，分別排序兩個子序列之后，再將兩個排序好的子序列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++];

}

// 將中間數組的內容拷貝回原數組

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）基數排序：

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

以Vector作輔助隊列，基數排序的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應用程序接口

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

應該怎樣學習JAVA？順序是什么？

不知道Java 學習順序的話，我提供你一條學習線路圖！

按照視頻學習的過程中，學習方法也是很重要的！一定要記得勤記筆記，整理程思維導圖，方便后續復習方便。

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

學習JavaEE或JavaME之前，JavaSE是必學的。

* Java開發環境搭建

* Java基礎語法

* 面向對象

* 數組

* 異常

* 集合

* 線程

* IO流

* 反射機制

* 注解Annotation

* 網絡編程

第二部分：數據庫 【MySQL + JDBC】

* 只要學習編程，數據庫是一定要學習的，是一門公共的學科。

* java、C、python、C#等程序員都需要學習數據庫。

* 數據庫產品很多： MySQL、Oracle、SqlServer、DB2......

* 我們動力節點數據庫課程包括：MySQL + Oracle

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

* MySQL：互聯網公司、一般企業使用MySQL較多。

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

* 我們課堂上講MySQL。

* Java語言鏈接數據庫：JDBC

第三部分：WEB前端

* 系統結構：B/S【Browser/Server】 C/S【Client/Server】

* WEB是網站的意思。WEB前端是：網站當中的頁面。

* WEB前端程序是運行在瀏覽器當中的。

* HTML5 + CSS3 + JavaScript(JS)

* WEB前端也有很多框架：

- jQuery

- Bootstrap

- Vue

- NodeJS

- AugularJS

- RectJS

- LayUI

- EasyUI

.....

第四部分：JavaWEB

* Servlet

* JSP

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

第五部分：JavaWEB項目

* 做一個B/S結構的項目，將WEB前端和JavaWEB內容做一個整合練習。

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

分享標題：java代碼的層次順序 java代碼的層次順序有哪些
本文來源：http://www.yijiale78.com/article12/dohisgc.html

成都網站建設公司_創新互聯，為您提供虛擬主機、網站制作、外貿建站、Google、軟件開發、定制開發

廣告

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