JAVA-02
Java流程控制
用戶互動Scanner
Scanner類
屬于IO流的類如果不關會一直占用資源
常用方法
? 【Scanner scanner = new Scanner(System.in);】
? .next(); 遇到空格就結束接收
? .nextLine(); 遇到enter就結束接收
? .hasNext() 判斷是否有輸入
? .hasNextInt() 判斷是否有整數輸入
? .close(); 關閉
舉例【instance】
package com.xy.base;
import java.util.Scanner;
public class Demo11 {
public static void main(String[] args) {
//創建一個掃描物件，用于接收鍵盤資料
Scanner scanner = new Scanner(System.in);
System.out.println("使用next方式接收：");
//判斷用戶有沒有輸入字串
if(scanner.hasNext()){
//使用next接收
String str = scanner.next();
System.out.println("輸入的內容為："+str);
}
System.out.println("使用nextLine方式接收：");
if(scanner.hasNext()){
//使用next接收
String str1 = scanner.nextLine();
System.out.println("輸入的內容為："+str1);
}
System.out.println("請輸入一個整數:");
//判斷輸入的是否為整數【判斷是否有整數輸入】
if(scanner.hasNextInt()){
int i = scanner.nextInt();
System.out.println("輸入的整數為："+i);
}else{
System.out.println("輸入的不是整數！");
}
//凡是屬于IO流的類如果不關會一直占用資源
scanner.close();
}
}
輸入多個數字，并求其總和與平均值，每輸入一個數字用回車確認，通過輸入非數字來結束并輸出執行結果
package com.xy.base;
import java.util.Scanner;
public class Demo11_instance {
public static void main(String[] args) {
//輸入多個數字，并求其總和與平均值，每輸入一個數字用回車確認，通過輸入非數字來結束并輸出執行結果
int count = 0;
double sum = 0;
Scanner scanner = new Scanner(System.in);
System.out.println("請輸入資料：");
//while判斷是否是數字輸入
while (scanner.hasNextDouble()){
count++;
sum = sum + scanner.nextDouble();
}
System.out.println(count + "個資料總和為：" + sum);
System.out.println(count + "個資料平均數為：" + sum/count);
//關閉！！！！！！不要忘記
scanner.close();
}
}
三種結構（順序、選擇、回圈）
順序結構
- Java最基本的結構，最簡單的演算法結構
- 任何演算法都離不開的
- 一條一條從上到下執行
System.out.println("順序結構！");
System.out.println("順序結構！");
System.out.println("順序結構！");
選擇結構
1. if單選擇結構
if(條件式){
//滿足運算式執行的陳述句
}
2. if...else雙選擇結構
if(條件式){
//滿足運算式執行的陳述句
}else{
//不滿足運算式執行的陳述句
}
3. if...else if多選擇結構
if(條件式1){
//滿足運算式1執行的陳述句
}else if(條件式2){
//滿足運算式2執行的陳述句
}else{
//都不滿足執行的陳述句
}
4. 嵌套的if結構
if(條件式1){
if(條件式1){
//滿足運算式1和2執行的陳述句
}
}else{
//不滿足運算式1執行的陳述句
}
5. switch多選擇結構
-
語法：
switch(expression){ //expression變數 case value: //【可選】判斷變數的值是否等于value值 //陳述句 break; //【可選】 若不選，會有case穿透效果 case value: //陳述句 break; ... default: //【可選】 以上case都不滿足時執行default //陳述句 } -
case穿透效果：如果當前case滿足且結束沒有break陳述句，那么將會執行下面所有的case，直到遇見break陳述句，
-
switch中的變數型別 ：byte、short、int或者char
-
從Java SE7開始支持字串String型別
String x = "注意"; switch (x){ case "注意": System.out.println("注意"); case "協議": System.out.println("協議"); break; default: System.out.println("default"); }
回圈結構
1. while回圈
-
語法
while(布爾運算式){ //回圈內容 }
2. do...while回圈
-
語法
do{ //回圈內容 }while(布爾運算式); -
while和do...while的區別
- while先判斷再執行，do...while先執行在判斷
- do...while至少執行一次，while可以一次也不執行
3. for回圈
-
語法
for(初始化;布爾運算式;更新){ //回圈內容 } -
最有效，最靈活的回圈結構
-
回圈次數是在執行之前就已經確定的
-
fou回圈 ：先初始化，在判斷真偽，若為真則執行回圈體，然后更新；若為假，則跳出回圈
for (int i = 0; i < 5; i++) { System.out.println("i:" + i); System.out.println("第" + i + "次回圈！"); } -
練習：列印九九乘法表
for(int i = 1 ; i < 10 ; i ++){ for (int j = 1 ; j <= i ; j ++){ //輸出乘法并輸出一個tab空格 System.out.print(j + "*" +i +"=" + j*i + "\t"); } //換行 System.out.println(); //等價于 System.out.print("\n"); } -
增強for回圈【遍歷陣列】Java5引入的
int[] num = {10,20,30,40,50}; for(int n:num){ System.out.println(n); }
break&continue
-
break 強制退出回圈
int i = 0; while(i < 100){ i++; if(i == 10){ break; } System.out.println(i); } -
continue 跳出本次回圈，執行下一次【慫】
int j = 0; while (j < 10){ j++; if (j%2 == 0) { continue; } System.out.println(j); }
練習：列印三角形
public class Demo13_instance {
public static void main(String[] args) {
//規定5行
for(int i = 1 ; i <= 5 ; i ++){
//列印空的倒直角三角形
for(int j = 5 ; j >= i ; j --){
System.out.print(" ");
}
//列印正直角三角形
for (int j = 1 ; j <= i ; j ++){
System.out.print("*");
}
//列印關于另一半直角三角形
for(int j = 1 ; j <= i ; j ++){
System.out.print("*");
}
//換行
System.out.println();
}
}
}
運行輸出：
方法（Java只有值傳遞）
介紹
- 方法是解決一類問題的步驟的有序集合
- 方法包含于類或物件中
- 方法在程式中創建，在其他地方被參考
- 一個方法最后只做一個功能，方便擴展
修飾符 回傳值型別 方法名（引數型別 引數名）{
方法體
return 回傳值; //回傳回傳值；終結方法
}
- 形參【形式引數】：在寫方法時，在括號中的引數名，這里其實就是一個**占位符**
- 實參【實際引數】：在使用方法時，給方法傳的引數
方法多載
- 定義：在一個類中，方法名相同，引數【形參】不同，回傳值可同可不同
- 只是回傳值不同，不構成多載
- 在執行時，編譯器會根據呼叫方法的引數個數、引數型別去逐個匹配，如匹配出錯，編譯器報錯
package com.xy.base;
public class Demo21 {
public static void main(String[] args) {
System.out.println(max(10,20));
System.out.println(max(10,20.1));
}
public static double max(double x , double y){
if (x > y){
return x;
}else if (x < y){
return y;
}else {
System.out.println("x=y");
return x;
}
}
public static int max(int x , int y){
if (x > y){
return x;
}else if (x < y){
return y;
}else {
System.out.println("x=y");
return x;
}
}
}
命令列傳參
package com.xy.base;
public class Demo22 {
public static void main(String[] args) {
for (int i=0 ; i < args.length ; i++){
System.out.println("arg[" + i + "]" + args[i]);
}
}
}
? ①編譯檔案
? ②運行檔案這里注意找對檔案位置
? ③傳遞引數
? ④運行結果【列印】
可變引數【jdk1.5 引入】
-
在方法宣告中，指定引數型別后加一個省略號（...）
-
一個方法只能指定一個可變引數，它必須是方法的最后一個引數
package com.xy.base; public class Demo23 { public static void main(String[] args) { Demo23 demo23 = new Demo23(); demo23.test(1,2,3,4,5); } public void test(int... i){ System.out.println(i[0]); } }
遞回
-
自己調自己
-
一定要有出口【不可以一直遞回，Java是堆疊機制，容易堆疊滿】
package com.xy.base; public class Demo24 { //求階乘 public static int f(int n){ if(n == 1){ return 1; }else{ return n*f(n-1); } } public static void main(String[] args) { System.out.println(f(25)); } }
陣列
定義與使用
//定義陣列 int nums2[]; 定義陣列[c/c++風格]
int[] nums;
//分配空間
nums = new int[10];
//賦值
nums[0] = 1;
//二維陣列
int[][] array = {{1,2},{1,3},{1,4}};
//遍歷
for (int i = 0 ; i < array.length ; i ++){
for(int j = 0 ; j < array[i].length ; j ++){
System.out.print(array[i][j]+" ");
}
System.out.println();
}
使用
public class Demo32 {
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
//列印陣列
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
//計算所有元素的和
int sum = 0;
for (int i = 0; i < array.length; i++) {
sum = sum + array[i];
}
System.out.println("sum:"+sum);
//尋找陣列中最大的數
int max = array[0];
for (int i = 1; i < array.length; i++) {
if(array[i] > max){
max = array[i];
}
}
System.out.println("max:"+max);
//forEach jdk1.5沒有下標
for (int i : array) {
System.out.println(i);
}
//反轉陣列
int result[] = new int[array.length];
for(int i=0,j=array.length-1 ; i<array.length ; i++,j--){
result[j]=array[i];
}
//列印陣列
System.out.println(Arrays.toString(result));
}
}
記憶體分析
- 堆：存放new的物件和陣列；所有執行緒共享；不存放別的物件參考
- 堆疊：存放基本變數型別（包含這個基本型別的具體值）；參考物件的變數（會存放這個參考在堆里面的具體地址）
- 方法區：所有執行緒共享；包含所有的class和static變數
舉例分析：
-
首先宣告一個陣列 ——> 堆疊中就有了這個陣列的名字
-
然后給陣列分配空間 ——> 堆中開辟了相應大小的空間
-
最后賦值 ——> 堆中的陣列空間內開始有值
三種初始化狀態
靜態初始化:創建+賦值
int[] a = {1,2,3,4,5,6,7,8,9};
動態初始化
int[] b = new int[5];
b[0] = 1;
陣列默認初始化
陣列是參考型別，他的元素相當于類的實體變數，因此陣列在一分配空間時就已經被默認初始為相應型別的默認值了，
陣列的特點
- 陣列一經創建就長度確定
- 同一陣列元素型別相同
- 陣列中的元素可以是任何資料型別
- 陣列變數屬于參考型別，陣列也可以看成物件
- 陣列物件本身是在堆中的
Arrays類（import java.util.Arrays）
學會使用官方API幫助檔案，這里介紹兩個
int[] array = {1,5,7,33,2,879};
//列印Arrays.toString()
System.out.println(Arrays.toString(array));
//排序
Arrays.sort(array);
System.out.println(Arrays.toString(array));
冒泡排序
public class Demo35_sort {
public static void main(String[] args) {
int[] array = {1,5,7,33,2,879};
sort(array);
System.out.println(Arrays.toString(array));
}
/**
* 冒泡排序
*/
public static int[] sort(int[] array){
int temp = 0;
for(int i = 0 ; i < array.length-1 ; i++){
boolean flag = false; //優化
for (int j = 0 ; j < array.length-1-i ; j++){ //因為經過i輪排序之后，后面的i個資料已經是有序的了，所以減掉i
if(array[j+1] < array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = true;
}
}
if(flag == false){ //優化
break;
}
}
return array;
}
}
稀疏陣列
-
定義：當一個陣列中大部分元素都為0或同一資料時，可以使用稀疏陣列來保存，
-
處理方式：
- 記錄陣列一共有幾行幾列，有多少個不同值
- 把具有不同值的元素的行和列以及值記錄在一個小規模的陣列中，從而縮小程式的規模
public class Demo36 {
public static void main(String[] args) {
//創建一個二維陣列(原陣列) 11*11 0:沒有棋子 1：黑旗 2：白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 1;
System.out.println("輸出原始陣列:");
for(int[] ints : array1){
for(int anInt : ints){
System.out.print(anInt+"\t");
}
System.out.println();
}
//轉換為稀疏陣列保存
//獲取有效值
int sum = 0;
for(int[] ints : array1){
for(int in : ints){
if(in != 0){
sum ++ ;
}
}
}
System.out.println("有效數值個數："+sum);
//創建一個稀疏陣列
int[][] array2 = new int[sum+1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//遍歷陣列，將非零值存放進稀疏陣列
int count = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[1].length; j++) {
if(array1[i][j] != 0){
count ++;
array2[count][0]=i; //二維陣列的第count行的第0列存放資料的橫坐標
array2[count][1]=j; //二維陣列的第count行的第1列存放資料的縱坐標
array2[count][2]=array1[i][j]; //二維陣列的第count行的第3列存放資料的值
}
}
}
//輸出稀疏陣列
System.out.println("稀疏陣列");
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i][0]+"\t"
+array2[i][1]+"\t"
+array2[i][2]+"\t");
}
//還原
//創建陣列
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//讀取資料并存盤
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
//輸出還原得到的陣列
System.out.println("還原得到的陣列：");
for (int i = 0; i < array3.length; i++) {
for (int j = 0; j < array3[i].length; j++) {
System.out.print(array3[i][j]+"\t");
}
System.out.println();
}
}
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/553155.html
標籤：Java
上一篇：解決啟動jar包報錯：錯誤找不到或無法加載主類 jar
下一篇：返回列表