Arrays工具類&二維數組&可變參數&方法參數

Arrays工具類

作用：主要用於對數組進行排序，查找，填充，比較等的操作
Arrays工具類存在於java.util包下，所以使用的第一步就是導包：import java.util.Arrays;
注意：如果在同一個Java文件中同時使用Scanner和Arrays，則可以向如下方式導包：
import java.util.Scanner;
import java.util.Arrays;
或者簡寫爲：* 所有的類
import java.util.*;

//演示Arrays工具類的使用
package com.qf.day07;

import java.util.Arrays;

/*
 * Arrays工具類的使用
 * 1 二分查找
 * 2 排序
 * 3 複製
 * 4 填充 
 * 5 把數組轉成字符串
 */

public class Demo1 {
	public static void main(String[] args) {
	//	binarySearch();
		//sort();
		//copy();
		//fill();
		toStr();
	}
	//binarySearch 二分查找
	public static void binarySearch() {
		int[] arr=new int[] {5,8,10,20,65,100};	
		int result=Arrays.binarySearch(arr,22);
		if(result>=0) {
			System.out.println("找到了");
		}else {
			System.out.println("沒找到 ");
		}
	}
	//排序
	public static void sort() {
		int[] arr=new int[] {12,8,100,2,9};
		Arrays.sort(arr);
		System.out.println("排序之後:");
		for(int i=0;i<arr.length;i++) {
			System.out.print(arr[i]+" ");	
		}	
	}
	//複製
	public static void copy() {
		int[] arr=new int[] {12,8,100,2,9};
		int[] arr2=Arrays.copyOf(arr, arr.length);
		for(int i=0;i<arr2.length;i++) {
			System.out.println(arr2[i]);
		}
	}
	//填充
	public static void fill() {
		int[] arr=new int[] {12,8,100,2,9};
		Arrays.fill(arr, 10);
		for(int i=0;i<arr.length;i++) {
			System.out.println(arr[i]);
		}
	}
	//把數組轉成字符串
	public static void toStr() {
		int[] arr=new int[] {12,8,100,2,9};
		String s=Arrays.toString(arr);
		System.out.println(s);
	}
	
}

二維數組

方式一：元素類型[][] 數組名稱；

方式二：元素類型 數組名稱[][]；
推薦使用方式一

靜態初始化：

	語法：元素類型[][] 數組名稱 = new 元素類型[][]{{一維數組1,一維數組2,一維數組3....};
	簡化必須一條語句結束 ：元素類型[][] 數組名稱 ={一維數組1,一維數組2,一維數組3....};

	舉例：int[][] arr = new int[][]{{2,3},{5,2,1},{10,45,22,54}};
	      int[][] arr = {{2,3},{5,2,1},{10,45,22,54}};

	動態初始化：

	語法：元素類型[][] 數組名稱 = new 元素類型[二維數組的長度][一維數組的長度]
	舉例：int[][] arr = new int[3][4];
	說明：定義一個數組arr，二維數組中一維數組的個數爲3個，每個一維數組中元素的個數爲4個

//常見的操作：遍歷二維數組
class TwiceArrayDemo02 
{
	public static void main(String[] args) 
	{
		//如果二維數組中一維數組的元素個數不確定
		//int[][] arr = new int[3][];

		int[][] arr = new int[][]{{2,3},{5,2,1},{10,45,22,54}};

		//遍歷arr
		for(int i = 0;i < arr.length;i++) {
			System.out.println(arr[i]);
		}

		//賦值：給arr中的第1個元素修改值
		arr[1] = new int[2];

		//給arr[0]中的第0個元素修改值
		arr[0][0] = 10;

		//遍歷arr[0]
		for(int i = 0;i < arr[0].length;i++) {
			System.out.println(arr[0][i]);
		}

		//二維數組的遍歷：嵌套for循環
		//簡單for循環
		for(int i = 0;i < arr.length;i++) {
			int[] subArr = arr[i];
			for(int j = 0;j < subArr.length;j++) {
				System.out.println(subArr[j]);
			}
		}

		//增強for循環
		for(int[] subArr1:arr) {
			for(int n:subArr1) {
				System.out.println(n);
			}
		}
	}
}

可變參數

在設計方法時，方法的形參的個數是不確定的
語法
類型… 變量名稱
例如：int… num
好處：不用創建數組，直接寫數組元素
注意：
a.不定長的參數在進行使用的時候被當做數組來進行處理
b.一個方法只能有一個可變參數
c. 可變參數只能方法參數列表最後

package com.qf.day07;
/*
 * 可變參數
 * int...
 * 好處：不用創建數組，直接寫數組元素
 * 注意事項：
 * 1 一個方法只能有一個可變參數
 * 2 可變參數只能方法參數列表最後
 */
public class Demo4 {
	public static void main(String[] args) {
		//調用
		//int[] nums= {10,4,8,20};
		//sort(nums);
		sort(10,4,8,20,1,2); //實際運行是，把這些數據變成數組
		
	}
	public static void sort(int a,int... arr) {
		for(int i=0;i<arr.length-1;i++) {
			for(int j=0;j<arr.length-i-1;j++) {
				if(arr[j]>arr[j+1]) {
					int temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
	}
}

方法參數

基本類型作爲方法的參數

public class Demo2 {
	public static void main(String[] args) {
		int num1=10;
		int num2=20;
		swap(num1, num2);
		System.out.println(num1);
		System.out.println(num2);
	}
	public static void swap(int a,int b) {
		System.out.println("交換之前: a:"+a+" b:"+b);
		int temp=a;
		a=b;
		b=temp;
		System.out.println("交換之後: a:"+a+" b:"+b);
	}
	
}

引用類型作爲方法的參數

import java.util.Arrays;

/*
 * 方法的參數傳遞和返回值
 * 1 交換兩個數字
 * 2 實現數組排序
 * 
 */
public class Demo2 {
	public static void main(String[] args) {
		int[] nums=new int[] {15,8,3,9,20,50};
		sort(nums);
		//遍歷nums
		System.out.println("遍歷nums");
		for(int i=0;i<nums.length;i++) {
			System.out.print(nums[i]+" ");
		}
	}
	
	//2實現數組排序
	public static void sort(int[] arr) {
		//排序之前
		System.out.println("排序之前");
		System.out.println(Arrays.toString(arr));
		//冒泡
		for(int i=0;i<arr.length-1;i++) {
			for(int j=0;j<arr.length-i-1;j++) {
				if(arr[j]>arr[j+1]) {
					int temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
		//排序之後
		System.out.println("排序之後");
		System.out.println(Arrays.toString(arr));
		
	}
}

基本類型作爲方法返回值

public class Demo3 {

	public static void main(String[] args) {
		int result=sum();
		System.out.println(result);
	}
	
	public static int sum() {
		//計算1-100的和
		int sum=0;
		for(int i=0;i<=100;i++) {
			sum+=i;
		}
		return sum;
	}
}

引用類型作爲方法返回值

package com.qf.day07;

import java.util.Arrays;

/*
 * 方法返回值
 * 1 基本類型作爲方法返回值
 * 2 引用類型作爲方法返回值
 */
public class Demo3 {

	public static void main(String[] args) {
		int[] nums2=getNums();
		for(int i=0;i<nums2.length;i++) {
			System.out.println(nums2[i]);
		}
	}

	//把數組中的每個數字加5，再返回一個數組
	public static int[] getNums() {
		int[] arr=new int[] {5,10,15};
		for(int i=0;i<arr.length;i++) {
			arr[i]=arr[i]+5;
		}
		return arr;
	}
}

總結： Java中的方法傳參採用的是傳值的方式。
1 基本類型傳遞的實際數據，對調用方沒有影響
2 引用類型傳遞的是地址，對調用方有影響
總結：方法的返回值如果是基本類型則返回實際數據，如果是引用類型則返回地址。
特殊：String類型傳值方法和返回值遵循基本類型。