Java方法及陣列相關原理解析
方法
設計方法的原則：方法的本意是功能塊，就是實現某個功能的語句塊的集合。我們設計的方法，最好保持方法的原子性，就是一個方法只完成1個功能，有利於後期的擴充套件。
方法過載
過載就是在一個類中，有相同的函式名稱，但引數不同的函式
過載規則：
- 方法名稱必須相同
- 引數列表必須不同（個數不同、型別不同、引數排序順序不同）
- 方法返回值型別可相同也可不相同
- 僅僅返回型別不同不足以成為方法的過載
實現原理：
方法名稱相同時，編譯器會根據呼叫方法的引數個數、引數型別等去逐個匹配，以選擇對應的方法，如果匹配失敗，則編譯器報錯。
命令列傳參
public static void main(String[] args) {
for (int i=0;i<args.length;i++){
System.out.println("args["+i+"]:"+args[i]);
}
}//傳遞命令列引數給main函式要在 cmd 介面下才能執行！！！
可變引數
JDK 1.5開始，Java支援傳遞同類型的可變引數給一個方法。
在方法宣告中，在指定引數型別後加一個省略號(..)。
一個方法中只能指定一個可變引數，它必須是方法的最後一個引數。任何普通的引數必須在它之前宣告。
public static void main(String[] args) {
//呼叫
printMax(34,3,2,56.5);
printMax(new double[]{1,3});
}
public static void printMax(double... numbers){//可變引數
if (numbers.length==0){
System.out.println("No argument passed");
return;
}
double result=numbers[0];
//排序
for (int i = 1; i < numbers.length; i++) {
if(numbers[i]>result){
result=numbers[i];
}
}
System.out.println("The max value is "+result);
}遞迴
A方法呼叫A方法！自己呼叫自己！
遞迴結構包括兩個部分:
遞迴頭:什麼時候不呼叫自身方法。如果沒有頭，將陷入死迴圈。
遞迴體:什麼時候需要呼叫自身方法
public static int f(int n){
if(n==1){
return 1;
}else {
return n*f(n-1);
}
}
陣列
陣列是相同型別資料的有序集合.
陣列描述的是相同型別的若干個資料,按照一定的先後次序排列組合而成。
其中,每一個數據稱作一個數組元素,每個陣列元素可以通過一個下標來訪問它們.
陣列的宣告
int[] nums=new int[5];
nums[0]=1;nums[1]=2;nums[2]=3;nums[3]=4;nums[4]=5;
陣列的三種初始化
//1靜態初始化
int[] a={1,4,5,6,7,8};
System.out.println(a[0]);//2動態初始化 ：包含3預設初始化
int[] b=new int[10];
b[0]=10;
b[1]=10;
System.out.println(b[0]);
System.out.println(b[1]);
System.out.println(b[2]);//預設初始化，輸出結果為0
陣列的四個基本特點
- 其長度是確定的。陣列一旦被建立，它的大小就是不可以改變的。
- 其元素必須是相同型別,不允許出現混合型別。
- 陣列中的元素可以是任何資料型別，包括基本型別和引用型別。
- 陣列變數屬引用型別，陣列也可以看成是物件，陣列中的每個元素相當於該物件的成員變數。陣列本身就是物件，Java中物件是在堆中的，因此陣列無論儲存原始型別還是其他物件型別,陣列物件本身是在堆中的。
陣列邊界
陣列的應用
//反轉陣列
public static int[] reverse(int[] arrays){
int[] result = new int[arrays.length];
for (int i = 0,j=result.length-1; i <arrays.length ; i++,j--) {
result[j]=arrays[i];
}
return result;
}
多維陣列
int a[][]=new int[2][5];//以上二維陣列可以看成一個兩行五列的陣列
Array類
檢視 JDK 幫組文件！！！
常用功能：
給陣列賦值：fill
給陣列排序：sort
比較陣列：equals 比較陣列中元素值是否相等
查詢陣列元素：binarySearch 方法能對排序好的陣列進行二分查詢法操作
氣泡排序
public static int[] sort(int[] array){
// 氣泡排序
int temp=0;
for (int i = 0; i < array.length-1; i++) {
for (int j = 0; j < array.length-1-i; j++) {//i表示已經排好的數字個數，所以在內層迴圈時減去i，減少比較次數
if(array[j+1]<array[j]){
temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
return array;
}
稀疏陣列
稀疏陣列的處理方式是:
記錄陣列一共有幾行幾列,有多少個不同值
把具有不同值的元素和行列及值記錄在一個小規模的陣列中，從而縮小程式的規模
//看程式碼才能看懂
public static void main(String[] args) {
//稀疏陣列
int[][] array1=new int[11][11];
array1[1][2]=1;
array1[2][3]=2;
System.out.println("輸出原始資料：");
for (int[] ints:array1) {
for(int anint:ints){
System.out.print(anint+"\t");
//輸出原始陣列
}
System.out.println();
}
System.out.println("================");
//轉換為稀疏陣列
//獲取陣列中有效值
int sum= 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if(array1[i][j]!=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[i].length; j++) {//二維陣列每一行的長度
//形成稀疏陣列
if(array1[i][j]!=0){
count++;
array2[count][0]=i;
array2[count][1]=j;
array2[count][2]=array1[i][j];
}
}
}
//輸出稀疏陣列
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");
}
System.out.println("================");
System.out.println("還原");
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[] ints:array3) {
for(int anint:ints){
System.out.print(anint+"\t");
//輸出還原陣列
}
System.out.println();
}
}
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支援我們。