07_Java基礎語法_第7天（練習）_講義
今日內容介紹
一、循環練習
二、數組方法練習數組
01奇數求和練習
* A: 奇數求和練習
* a: 題目分析
* 爲了記錄累加和的值，咱們須要定義一個存儲累加和的變量
* 咱們要獲取到1-100範圍內的數
* 判斷當前數是否爲奇數，是奇數，完成累加和操做
* 累加完畢後，最終顯示下累加和的值
* b: 解題步驟
* 定義一個用來記錄累加和的變量
* 使用for循環語句，完成1-100之間每一個數的獲取
* 使用if條件語句，判斷當前數是不是奇數，是奇數，進行累加和操做
* 使用輸出語句，打印累加和變量的值
* c: 案例代碼
public class Test01 {
public static void main(String[] args) {
int sum = 0;
for (int i = 0; i < 100; i++) {
if (i%2==1) {
sum += i;
}
}
System.out.println("累加和的值 " + sum);
}
}
02水仙花練習功能實現
* A: 水仙花練習功能實現
* a: 題目分析
* 明確什麼樣的數就是水仙花數。水仙花數是指一個3位數（100-999之間），其每位數字立方之和等於該3位數自己。
如153 = 1*1*1 + 3*3*3 + 5*5*5，即 3位數自己 = 百位數立方 + 十位數立方 + 個位數立方;
* 獲取水仙花範圍內的全部3位數（100-999之間的每一個3位數）
* 判斷該3位數是否知足水仙花數，知足，打印該3位數
* b: 解題步驟
* 使用for循環，獲得100-999之間的每一個3位數
* 獲取3位數中百位數字、十位數字、個位數字
* 使用if條件語句，判斷該3位數是否知足水仙花數，知足，使用輸出語句，打印該3位數
* c: 案例代碼
public class Test02 {
public static void main(String[] args) {
for (int i = 100; i < 1000; i++) {
int bai = i/100%10;
int shi = i/10%10;
int ge = i%10;
if (i == bai*bai*bai + shi*shi*shi + ge*ge*ge) {
System.out.println(i);
}
}
}
}
03ASCII編碼表
* A: ASCII編碼表
* a: 英文全稱
* American Standard Code for Information Interchange，美國標準信息交換代碼
* b: ASCII編碼表由來
* 計算機中，全部的數據在存儲和運算時都要使用二進制數表示
* a、b、c、d這樣的52個字母（包括大寫）、以及0、1等數字還有一些經常使用的符號, 在計算機中存儲時也要使用二進制數來表示
* 具體用哪些二進制數字表示哪一個符號，固然每一個人均可以約定本身的一套（這就叫編碼）
* 你們若是要想互相通訊而不形成混亂，那麼你們就必須使用相同的編碼規則，因而美國有關的標準化組織就出臺了ASCII編碼，
統一規定了上述經常使用符號用哪些二進制數來表示。
* c: 中文編碼表
* GB2312
* UNICODE
* d: 字符中重要的ASCII碼對應關係
* a : 97
* A : 65
* 0 : 48
04char類型的存儲
* A: char類型的存儲
* a: 取值範圍
* short:佔兩個字節,是有符號數據,取值範圍-32768-32767
* char: 佔兩個字節,是無符號數據,取值範圍0-65536
* b: 類型轉換
* char類型的數據參加運算時要線程程int數據類型
* c: 案例代碼
/*
ASCII編碼表演示
字符Java 數據類型,char
整數Java 數據類型,int
int 類型和 char 數據類型轉換
char 兩個字節, int 四個字節
char轉成int類型的時候,類型自動提示,char數據類型,會查詢編碼表,獲得整數
int轉成char類型的時候,強制轉換,會查詢編碼表
char存儲漢字,查詢Unicode編碼表
char能夠和int計算,提示爲int類型, 內存中兩個字節
char取值範圍是0-65535, 無符號的數據類型
*/
public class ASCIIDemo{
public static void main(String[] args){
char c = 'a';
int i = c + 1;
System.out.println(i);
int j = 90;
char h = (char)j;
System.out.println(h);
System.out.println( (char)6 );
char k = '你';
System.out.println(k);
char m = -1;
}
}
05輸出全部英文字母
* A: 輸出全部英文字母
* a: 題目分析
* 一共26個大小寫字母，那麼，能夠考慮循環26次。在每次循環中，完成指定字母的大小寫打印
* 找出ABCDEFG…XYZ這些字母之間的變化規律
經過ASCII表發現，後面的字母比它前面的字母，ASCII值大1
下一個字母 = 上一個字母 + 1
如： A B C D
65 66 67 68
* 在每次循環中打印上一個字母大小寫，並指定下一個字母
* b: 解題步驟
* 定義初始化大寫變量，值爲’A’； 初始化小寫變量，值爲’a’
* 使用for循環，進行26次循環
* 在每次循環中，打印大寫字母、小寫字母。
每次打印完成後，更新大寫字母值、小寫字母值
* c: 案例代碼
public class Test04 {
public static void main(String[] args) {
char da = 'A';
char xiao = 'a';
for (int i = 0; i < 26; i++) {
System.out.println("大寫字母 "+da+" ,小寫字母 "+xiao);
da++; //更新大寫字母值
xiao++; //更新小寫字母值
}
}
}
0699乘法表的分析
* A: 99乘法表的分析
* a: 打印格式
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
* b: 題目分析
經過觀察發現，若是把1*1=1這樣的內容 看作一顆*的話，那麼打印結果就成了以下效果：
*
**
***
****
…
這樣，就是打印9行星，每行打印星的個數與當前行數相等。
再觀察「1*3=3 2*3=6 3*3=9」得出它們以下的變化規律：
每行第n次 +"*"+ 行號 +"="+ 每行第n次 * 行號
如: 1 +"*"+ 2 +"="+ 1*2; // 至關於1*2=2
2 +"*"+ 2 +"="+ 2*2; // 至關於2*2=4
* c: 解題步驟
* 定義一個外層for循環，初始值從1開始，循環9次。用來控制打印的行數
* 在外層for循環內部，定義一個for循環，初始值從1開始，循環次數與當前行數相等。用來完成每行打印指定次數的乘法公式 如1*1=1
* 在內層for循環中，完成每行指定次數的乘法公式打印 如1*1=1
System.out.print(k +"*"+ j +"="+ j*k +"\t");
// 變量k表明：每行中的第n次
// 變量j表明：行號
* 在外循環中，當每行指定次數的乘法公式打印完畢後，經過System.out.println()切換到下一行。
這樣，再次打印乘法公式時，就在下一行輸出打印了
0799乘法表的功能實現
* A: 99乘法表的功能實現
* a: 案例代碼
/*
利用嵌套for循環,實現99乘法表示
實現步驟:
1. 定義外循環控制行數
2. 內循環控制個數,個數,每次都在遞增
3. 循環中輸出,乘法表的格式 1*3=3
*/
public class Test05 {
public static void main(String[] args) {
for (int j = 1; j < 10; j++) {
for (int k = 1; k <= j; k++) {
System.out.print(k +"*"+ j +"="+ j*k +"\t");
}
System.out.println();
}
}
}
08實現數組的遍歷
* A: 實現數組的遍歷
* a: 題目分析
* 經過循環，咱們能夠完成數組中元素的獲取，數組名[索引]
* 觀察發現，每一個數組元素之間加入了一個逗號」,」進行分隔；而且，整個數組的先後有一對中括號」[]」包裹數組全部元素。
* b: 解題步驟
* 使用輸出語句完成打印 左邊的中括號」[」
* 使用循環，輸出數組元素值。輸出元素值分爲兩種狀況，以下：
* 最後一個數組元素，加上一個右邊的中括號」]」
* 非最後一個數組元素，加上一個逗號」,」
* c: 案例代碼
/*
定義方法,實現數組的遍歷
遍歷中,輸出結果 [11,33,565,66,78,89]
int[] arr = {3,4,45,7};
結果包含字符串, [ ] ,
實現步驟:
1. 定義方法實現數組的遍歷
2. 先打印[ 中括號
3. 遍歷數組
輸出數組的元素和逗號
判斷是否遍歷到了數組的最後一個元素,若是是最後一個元素,輸出]中括號
*/
public class ArrayMethodTest{
public static void main(String[] args){
int[] arr = {11,44,55,33,66};
printArray(arr);
int[] arr2 = {22,88,99,33,66};
printArray(arr2);
}
/*
定義方法,實現功能
返回值: void
方法參數: 數組
*/
public static void printArray(int[] arr){
//輸出一半中括號,不要換行打印
System.out.print("[");
//數組進行遍歷
for(int i = 0 ; i < arr.length ; i++){
//判斷遍歷到的元素,是否是數組的最後一個元素
//如何判斷 循環變量 到達 length-1
if( i == arr.length-1 ){
//輸出數組的元素和]
System.out.print(arr[i]+"]");
}else{
//不是數組的最後一個元素,輸出數組元素和逗號
System.out.print(arr[i]+",");
}
}
System.out.println();
}
}
09數組逆序原理
* A: 數組逆序原理
* a: 題目分析(圖解見day07_source/數組的逆序原理.JPG)
* 經過觀察發現，本題目要實現原數組元素倒序存放操做。即原數組存儲元素爲{11,22,33,44}，
逆序後爲原數組存儲元素變爲{44,33,22,11}。
* 經過圖解發現，想完成數組元素逆序，其實就是把數組中索引爲start與end的元素進行互換。
* 每次互換後，start索引位置後移，end索引位置前移，再進行互換
* 直到start位置超越了end位置，互換結束，此時，數組元素逆序完成。
* b: 解題步驟
* 定義兩個索引變量start值爲0，變量end值爲數組長度減去1（即數組最後一個元素索引）
* 使用循環，完成數組索引start位置元素與end位置元素值互換。
* 在循環換過程當中，每次互換結束後，start位置後移1，end位置前移1
* 在循環換過程當中，最早判斷start位置是否超越了end位置，若已超越，則跳出循環
10數組逆序功能實現
* A：案例代碼
/*
數組的逆序:
數組中的元素,進行位置上的交換
逆序 不等於 反向遍歷
就是數組中最遠的兩個索引,進行位置交換,實現數組的逆序
使用的是數組的指針思想,就是變量,思想,能夠隨時變換索引
反轉 reverse
實現步驟:
1. 定義方法,實現數組的逆序
2. 遍歷數組
實現數組的最遠索引換位置
使用臨時的第三方變量
*/
public class ArrayMethodTest_1{
public static void main(String[] args){
int[] arr = {3,5,7,1,0,9,-2};
//調用數組的逆序方法
reverse(arr);
//看到數組的元素,遍歷
printArray(arr);
}
/*
定義方法,實現數組的逆序
返回值: 沒有返回值
參數: 數組就是參數
*/
public static void reverse(int[] arr){
//利用循環,實現數組遍歷,遍歷過程當中,最遠端換位
//for的第一項,定義2個變量, 最後,兩個變量++ --
for( int min = 0 , max = arr.length-1 ; min < max ; min++,max--){
//對數組中的元素,進行位置交換
//min索引和max索引的元素交換
//定義變量,保存min索引
int temp = arr[min];
//max索引上的元素,賦值給min索引
arr[min] = arr[max];
//臨時變量,保存的數據,賦值到max索引上
arr[max] = temp;
}
}
}
11選擇排序原理
* A: 選擇排序原理
* a: 題目分析(圖解見day07_source/選擇排序原理.JPG)
* 經過觀察發現，本題目要實現把數組元素{13,46,22,65,3}進行排序
* 提到數組排序，就要進行元素值大小的比較，經過上圖發現，咱們想完成排序要通過若干次的比較纔可以完成。
* 上圖中用每圈要比較的第一個元素與該元素後面的數組元素依次比較到數組的最後一個元素，把小的值放在第一個數組元素中，數組循環一圈後，則把最小元素值互換到了第一個元素中。
* 數組再循環一圈後，把第二小的元素值互換到了第二個元素中。按照這種方式，數組循環多圈之後，就完成了數組元素的排序。這種排序方式咱們稱爲選擇排序。
* b: 解題步驟
* 使用for循環（外層循環），指定數組要循環的圈數（經過圖解可知，數組循環的圈數爲數組長度 - 1）
* 在每一圈中，經過for循環（內層循環）完成數組要比較的第一個元素與該元素後面的數組元素依次比較到數組的最後一個元素，把小的值放在第一個數組元素中
* 在每一圈中，要參與比較的第一個元素由第幾圈循環來決定。如上圖所示
* 進行第一圈元素比較時，要比較的第一個元素爲數組第一個元素，即索引爲0的元素
* 進行第二圈元素比較時，要比較的第一個元素爲數組第二個元素，即索引爲1的元素
* 依次類推，得出結論：進行第n圈元素比較時，要比較的第一個元素爲數組第n個元素，即數組索引爲n-1的元素
12選擇排序功能實現
* A: 案例代碼
/*
數組的排序: 通常都是升序排列,元素,小到大的排列
兩種排序的方式
選擇排序: 數組的每一個元素都進行比較
冒泡排序: 數組中相鄰元素進行比較
規則: 比較大小,位置交換
*/
public class ArrayMethodTest_2{
public static void main(String[] args){
int[] arr = {3,1,4,2,56,7,0};
//調用選擇排序方法
//selectSort(arr);
printArray(arr);
}
/*
定義方法,實現數組的選擇排序
返回值: 沒有
參數: 數組
實現步驟:
1.嵌套循環實現排序
外循環,控制的是一共比較了多少次
內循環,控制的是每次比較了多少個元素
2. 判斷元素的大小值
小值,存儲到小的索引
*/
public static void selectSort(int[] arr){
for(int i = 0 ; i < arr.length - 1; i++){
//內循環,是每次都在減小,修改變量的定義
for(int j = i+1 ; j < arr.length ; j++){
//數組的元素進行判斷
if(arr[i] > arr[j]){
//數組的換位
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
/*
定義方法,實現功能
返回值: void
方法參數: 數組
*/
public static void printArray(int[] arr){
//輸出一半中括號,不要換行打印
System.out.print("[");
//數組進行遍歷
for(int i = 0 ; i < arr.length ; i++){
//判斷遍歷到的元素,是否是數組的最後一個元素
//如何判斷 循環變量 到達 length-1
if( i == arr.length-1 ){
//輸出數組的元素和]
System.out.print(arr[i]+"]");
}else{
//不是數組的最後一個元素,輸出數組元素和逗號
System.out.print(arr[i]+",");
}
}
System.out.println();
}
}
13冒泡排序功能實現
* A: 冒泡排序功能實現
* a: 題目分析
* 經過觀察發現，本題目要實現把數組元素{13,46,22,65,3}進行排序
* 提到數組排序，就要進行元素值大小的比較，經過上圖發現，咱們想完成排序要通過若干次的比較纔可以完成。
* 上圖中相鄰的元素值依次比較，把大的值放後面的元素中，數組循環一圈後，則把最大元素值互換到了最後一個元素中。
數組再循環一圈後，把第二大的元素值互換到了倒數第二個元素中。按照這種方式，數組循環多圈之後，
就完成了數組元素的排序。這種排序方式咱們稱爲冒泡排序。
* b: 解題步驟
* 使用for循環（外層循環），指定數組要循環的圈數（經過圖解可知，數組循環的圈數爲數組長度 - 1）
* 在每一圈中，經過for循環（內層循環）完成相鄰的元素值依次比較，把大的值放後面的元素中
* 每圈內層循環的次數，由第幾圈循環來決定。如上圖所示
* 進行第一圈元素比較時，內層循環次數爲數組長度 - 1
* 進行第二圈元素比較時，內層循環次數爲數組長度 - 2
* 依次類推，得出結論：進行第n圈元素比較時，內層循環次數爲數組長度 - n
* c: 案例代碼
/*
數組的排序: 通常都是升序排列,元素,小到大的排列
兩種排序的方式
選擇排序: 數組的每一個元素都進行比較
冒泡排序: 數組中相鄰元素進行比較
規則: 比較大小,位置交換
*/
public class ArrayMethodTest_2{
public static void main(String[] args){
int[] arr = {3,1,4,2,56,7,0};
//調用選擇排序方法
//selectSort(arr);
//調用冒泡排序方法
bubbleSort(arr);
printArray(arr);
}
/*
定義方法,實現數組的冒泡排序
返回值: 沒有
參數: 數組
*/
public static void bubbleSort(int[] arr){
for(int i = 0 ; i < arr.length - 1; i++){
//每次內循環的比較,從0索引開始, 每次都在遞減
for(int j = 0 ; j < arr.length-i-1; j++){
//比較的索引,是j和j+1
if(arr[j] > arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
/*
定義方法,實現功能
返回值: void
方法參數: 數組
*/
public static void printArray(int[] arr){
//輸出一半中括號,不要換行打印
System.out.print("[");
//數組進行遍歷
for(int i = 0 ; i < arr.length ; i++){
//判斷遍歷到的元素,是否是數組的最後一個元素
//如何判斷 循環變量 到達 length-1
if( i == arr.length-1 ){
//輸出數組的元素和]
System.out.print(arr[i]+"]");
}else{
//不是數組的最後一個元素,輸出數組元素和逗號
System.out.print(arr[i]+",");
}
}
System.out.println();
}
}
14數組的折半查找原理
* A: 數組的折半查找原理(圖解見day07_source/折半查找原理.JPG)
* a: 題目分析
* 經過觀察發現，本題目要實現查找指定數值在元素有序的數組中存儲的位置
* （索引），返回該位置（索引）。
* 咱們使用數組最中間位置的元素值與要查找的指定數值進行比較，
* 若相等，返回中間元素值的索引
* 最中間位置的元素值與要查找的指定數值進行比較，若不相等，則根據比較的結果，
* 縮小查詢範圍爲上次數組查詢範圍的一半；
再根據新的查詢範圍，更新最中間元素位置，而後使用中間元素值與要查找的
指定數值進行比較
比較結果相等，返回中間元素值的索引
比較結果不相等，繼續縮小查詢範圍爲上次數組查詢範圍的一半，
更新最中間元素位置，繼續比較，依次類推。
* 當查詢範圍縮小到小於0個元素時，則指定數值沒有查詢到，返回索引值-1。
* b: 解題步驟
* 定義3個用來記錄索引值的變量，變量min記錄當前範圍最小索引值，初始值爲0；
* 變量max記錄當前範圍最大索引值，初始值爲數組長度-1；變量mid記錄當前當前
* 範圍最中間元素的索引值，初始值爲(min+max) / 2
* 使用循環，判斷當前範圍下，最中間元素值與指定查找的數值是否相等
若相等，結束循環，返回當前範圍最中間元素的索引值mid
若不相等，根據比較結果，縮小查詢範圍爲上一次查詢範圍的通常
中間元素值 比 要查詢的數值大，說明要查詢的數值在當前範圍的最小索引
位置與中間索引位置之間，此時，更新查詢範圍爲:
範圍最大索引值 = 上一次中間索引位置 -1；
中間元素值 比 要查詢的數值小，說明要查詢的數值在當前範圍的最大索引位
置與中間索引位置之間，此時，更新查詢範圍爲:
範圍最小索引值 = 上一次中間索引位置 +1；
在新的查詢範圍中，更新中間元素值的位置，再次使用最中間元素值與指定
查找的數值是否相等。
中間索引值 = (範圍最小索引值 +範圍最大索引值) / 2;
* 每次查詢範圍縮小一半後，使用if語句判斷，查詢範圍是否小於0個元素，
* 若小於0個元素，則說明指定數值沒有查詢到，返回索引值-1。
15數組的折半查找代碼實現
* A: 案例代碼
/*
數組的查找功能
在一個數組中,找一個元素,是否存在於數組中,若是存在,就返回索引
普通查詢:
找到元素在數組中出現的索引,若是沒有這個 元素,結果就是負數
*/
public class ArrayMethodTest_3{
public static void main(String[] args){
int[] arr = {1,3,5,7,9,11,15};
int index = binarySearch(arr,10);
System.out.println(index);
}
/*
定義方法,實現,折半查找
返回值: 索引
參數: 數組,被找的元素
實現步驟:
1. 須要的變量定義
三個,三個指針
2. 進行循環折半
能夠折半的條件 min <= max
3. 讓被找元素,和中間索引元素進行比較
元素 > 中間索引 小指針= 中間+1
元素 < 中間索引 大指針= 中間-1
元素 == 中間索引 找到了,結束了,返回中間索引
4. 循環結束,沒法折半
元素沒有找到 ,返回-1
*/
public static int binarySearch(int[] arr, int key){
//定義三個指針變量
int min = 0 ;
int max = arr.length -1 ;
int mid = 0;
//循環折半,條件 min<=max
while( min <= max){
//公式,計算中間索引
mid = (min+max)/2;
//讓被找元素,和中間索引元素進行比較
if(key > arr[mid]){
min = mid + 1;
}else if (key < arr[mid]){
max = mid - 1;
}else{
//找到元素,返回元素索引
return mid;
}
}
return -1;
}
/*
定義方法,實現數組的普通查詢
返回值: 索引
參數: 數組, 被找的元素
實現步驟:
1. 遍歷數組
2. 遍歷過程當中,使用元素和數組中的元素進行比較
若是相同,返回元素在數組中的索引
若是不一樣,返回負數
*/
public static int search(int[] arr, int key){
//遍歷數組
for(int i = 0 ; i < arr.length ; i++){
//數組元素,被查找的元素比較
if(arr[i] == key){
//返回索引
return i;
}
}
return -1;
}
}
做業測試
1.分析如下需求，並用代碼實現：測試
(1)按照從大到小的順序輸出四位數中的個位+百位=十位+千位(3553,2332,1166,8228,3773)的數字及個數 (2)每行輸出5個知足條件的數，之間用空格分隔 (3)如：9999 9988 9977 9966 9955
代碼：編碼
public class HomeWork {
public static void main(String[] args) {
int count = 0;
for (int a = 1000; a <= 9999; a++) {
if (a % 10 + a / 100 % 10 == a / 10 % 10 + a / 1000 % 10){
System.out.print(a+" ");
count ++;
if (count % 5 == 0){
System.out.println();
}
}
}
}
}
效果：線程
1001 1012 1023 1034 1045
1056 1067 1078 1089 1100
1111 1122 1133 1144 1155
1166 1177 1188 1199 1210
1221 1232 1243 1254 1265
1276 1287 1298 1320 1331
1342 1353 1364 1375 1386
1397 1430 1441 1452 1463
1474 1485 1496 1540 1551
1562 1573 1584 1595 1650
1661 1672 1683 1694 1760
1771 1782 1793 1870 1881
1892 1980 1991 2002 2013
2024 2035 2046 2057 2068
2079 2101 2112 2123 2134
2145 2156 2167 2178 2189
2200 2211 2222 2233 2244
....9999
2.分析如下需求，並用代碼實現：指針
(1)倒着打印九九乘法表
代碼:code
public class HomeWork {
public static void main(String[] args) {
for (int a = 9 ; a >= 1 ; a--){
for (int b = 9 ; b >=a ; b--){
System.out.print(a + "*" + b + "="+(a*b)+"\t");
}
System.out.println();
}
}
}
效果：orm
9*9=81
8*9=72 8*8=64
7*9=63 7*8=56 7*7=49
6*9=54 6*8=48 6*7=42 6*6=36
5*9=45 5*8=40 5*7=35 5*6=30 5*5=25
4*9=36 4*8=32 4*7=28 4*6=24 4*5=20 4*4=16
3*9=27 3*8=24 3*7=21 3*6=18 3*5=15 3*4=12 3*3=9
2*9=18 2*8=16 2*7=14 2*6=12 2*5=10 2*4=8 2*3=6 2*2=4
1*9=9 1*8=8 1*7=7 1*6=6 1*5=5 1*4=4 1*3=3 1*2=2 1*1=1
3.分析如下需求，並用代碼實現：排序
(1) 計算15+25+35+....+1005的和
代碼:索引
public class HomeWork {
public static void main(String[] args) {
int sum = 0;
for (int a = 5 ; a <= 1005 ; a += 10){
sum += a;
}
System.out.println(sum);
}
}
效果:內存
51005
4.練習一遍今天的代碼
相關文章
- 1. 07_Java基礎語法_第7天（練習）
- 2. 07_Java基礎語法_第7天（練習）_講義(練習加強+在eclipse中實現)
- 3. 07_Java基礎語法_第7天（練習）_講義(練習增強+在eclipse中實現)
- 4. 05_Java基礎語法_第5天（方法）_講義
- 5. 04_Java基礎語法_第4天（數組）_講義
- 6. python基礎語法練習
- 7. 練習go基礎語法
- 8. 06_Java基礎語法_第6天（自定義類、ArrayList集合）_講義
- 9. JavaScript基礎練習 -- 第六天
- 10. Linux基礎練習題(7)
- 更多相關文章...
- • Kotlin 基礎語法 - Kotlin 教程
- • Scala 基礎語法 - Scala教程
- • Kotlin學習（一）基本語法
- • Kotlin學習（二）基本類型
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
