Java數組

時間  2020-10-05
標籤 java 數組 工具 對象 blog 排序 遞歸 索引 接口 欄目 Java 简体版
原文   原文鏈接

1、方法的多級調用java

  • 案例： 
    public class Demo01 {
	public static void main(String[] args) {
		System.out.println("準備調用show01");
		show01();
		System.out.println("main方法結束啦");
	}

	public static void show01() {
		System.out.println("show01被調用啦");
		
		System.out.println("在show01中調用show02");
		
		show02();
		
		System.out.println("show01調用show02結束");
		System.out.println("show01調用結束啦");
	}

	public static void show02() {
		System.out.println("show02被調用啦");
		
		System.out.println("在show02中調用show03");
		
		show03();
		
		System.out.println("show02調用show03結束");
		System.out.println("show02調用結束啦");
	}

	public static void show03() {
		System.out.println("show03被調用啦");
		
		System.out.println("show03啥也沒幹....");
		
		System.out.println("show03調用結束啦");
	}
}　

2、遞歸數組

  • 在方法中調用方法自己
  • 可能會形成無窮遞歸，須要設置合適的出口
  • 案例： 
    public class Demo03 {
	public static void main(String[] args) {
		int mul = getMul(5);
		System.out.println(mul);
	}

	/**
	 * 獲取階乘的方法
	 * @param num
	 * @return
	 */
	public static int getMul(int num) {
		/**
		 * 5!
		 * 	5*4*3*2*1 ===  
		 * 	5*4!
		 * 		5*4*3!
		 * 			5*4*3*2!
		 * 				5*4*3*2*1!
		 * 
		 */
		System.out.println(num);
		if (num == 1) {
			return 1;
		}
		return num * getMul(num-1);
	}
}

3、方法的重載工具

  • 定義：
    • 在同一個類中,出現了名字相同的方法
    • 他們的參數列表不一樣
    • 和返回值類型無關
  • 案例： 
    public class Demo04 {
	public static void main(String[] args) {
		int sum01 = getSum(3,5);
		
		int sum02 = getSum(2,3,5);
		
		// getSum(int,int)
		/**
		 * 在同一個類中
		 * 出現了名字相同的方法
		 * 他們的參數列表不一樣
		 * 和返回值類型無關
		 */
	}

	public static int getSum(int i, int j) {
		return i + j;
	}
	
	public static int getSum(int a, int b,int c) {
		return a + b + c;
	}
	
	/*
	 * public static void getSum(int a, int b,int c) { System.out.println(a + b +
	 * c);; }
	 */
	
}
  • 參數列表不一樣的狀況
    • 參數列表中的形參數量不一樣
    • 參數列表中的形參數據類型不一樣
    • 參數列表中的參數的數據類型順序不一樣
  • 案例： 
    public class Demo05 {
	public static void main(String[] args) {
		
	}
	
	/**
	 * getSum(int,int)
	 * @param a
	 * @param b
	 * @return
	 */
	public static int getSum(int a,int b) {
		return a+b;
	}
	
	/**
	 * getSum(int,int,int)
	 * @param a
	 * @param b
	 * @return
	 */
	public static int getSum(int a,int b,int c) {
		return a+b+c;
	}
	
	/**
	 * getSum(int,double)
	 * @param a
	 * @param b
	 * @return
	 */
	public static double getSum(int a,double b) {
		return a+b;
	}
	
	/**
	 * getSum(double,int)
	 * @param a
	 * @param b
	 * @return
	 */
	public static double getSum(double a,int b) {
		return a+b;
	}
}　　

4、數組ui

  • 定義：
    • 一組連續的存儲空間，存儲多個相同數據類型的值
    • 建立數組時候必須肯定其數據類型和長度
    • 數組中的對象在內存中是連續存在的
    • 數組中的元素都有一個下標索引，下標從0開始到  數組名.Length-1
    • 數組第一個元素的地址及時當前數組的地址
  • 數組建立語法【四種】
    • 先聲明、在分配空間：數據類型 [ ] 數組名；   ==》數組名 =  new 數據類型[長度];
      • 例如：int [ ]  array;   ==>array = new int[10];
    • 聲明並分配空間：數據類型 [ ] 數組名 = new 數據類型[長度];
      • 例如：int  [ ]  array = new int [10];
    • 聲明並賦值（繁）：數據類型 [ ] 數組名 = new 數據類型[ ] {value1,value2,calue3........}
      • int [ ]  array = new int[]{10,20,30,40};
    • 聲明並賦值（簡）：數據類型 [ ] 數組名 = {vallue1,value2,value3....}
      • int [ ] array = {10,20,30,50,60....}
  • 各類類型數組元素的默認值：
    • 整型【byte、short、int、long】: 0
    • 浮點型【float、double】：0.0
    • 布爾型【boolean】：false
    • 字符型【char】：\u0000
    • 引用類型【類、接口、數組】：null
  • 遍歷數組： 
    public class Test01 {
    public static void main(String[] args) {
        String[] names = {"宋江","吳用","盧俊義","公孫勝","秦明"};
        //遍歷數組
        for (int i = 0;i<names.length;i++){
            System.out.println(names[i]);
        }
    }
}
  • 案例【獲取數組中的最大值】 
    • public class Demo07 {
	public static void main(String[] args) {
		// 獲取數字中最大的元素
		int[] arr = new int[] {14234,32,34,344,326235,8454321,9,5565432,42};
		// 假設第一個元素是最大的
		int max = arr[0];
		
		for (int i = 1; i < arr.length; i++) {
			// 使用max和後面的每個元素比較
			if (arr[i] > max) {
				// 若是發現比max更大的元素，更改max的值爲更大的哪一個元素
				max = arr[i];
			}
		}
		System.out.println("數組中最大的元素是:" + max);
	}
}
  • 獲取最大下標 
    • public class Demo08 {
	public static void main(String[] args) {
		// 找到最大值第一次出現的下標
		int[] arr = new int[] {14234,32,34,8454321,8454321,8454321,344,326235,9,5565432,8454321,42};
		
		// 假設最大值的下標是0
		int maxIndex = 0;
		
		for (int i = 0; i < arr.length; i++) {
			// maxIndex位置的元素和後面的全部元素比較,若是發現更大的,修改maxIndex的值
			if (arr[maxIndex] < arr[i]) {
				maxIndex = i;
			}
		}
		System.out.println("最大值的下標在" + maxIndex);
	}
}

5、數組擴容對象

  • 定義：建立大於原數組的長度的新數組、將原數組元素依次複製到新數組中
  • 擴容方式一【循環將原數組中全部元素逐一賦值給新數組】
    • 案例： 
      public static void main(String[] args) {
		String[] shuiHu = {"西門慶","武松","潘金蓮","武大郎"};
		
		String[] xiYou = {"孫悟空","豬八戒","沙僧","白龍馬"};
		
		String[] names = new String[shuiHu.length + xiYou.length];
		
		// 放入shuihu中的人物
		for (int i = 0; i < shuiHu.length; i++) {
			names[i] = shuiHu[i];
		}
		
		// 放入xiyou中的人物
		for (int i = shuiHu.length; i < names.length; i++) {
			names[i] = xiYou[i-shuiHu.length];
		}
		
		System.out.println(Arrays.toString(names));
		
	}
  • 擴容方式二：【使用System.arrayCopy】
    • arrayCopy(sec,srcPos,dest,destPos,length)==>src：數據源；srcPos:數據源中的起始位置；dest：目標數組；destPos：目標數據中的起始位置；length：要複製的數組元素數量
    • 案例： 
      public static void main(String[] args) {
		String[] shuiHu = {"西門慶","武松","潘金蓮","武大郎"};
		String[] xiYou = {"孫悟空","豬八戒","沙僧","白龍馬"};
		String[] names = new String[shuiHu.length + xiYou.length];
		
		// 使用System提供的拷貝的方法複製shuihu
		System.arraycopy(shuiHu, 0, names, 0, shuiHu.length);
		
		System.out.println(Arrays.toString(names));
		
		// 使用System提供的拷貝的方法複製xiyou
		System.arraycopy(xiYou, 0, names, shuiHu.length, xiYou.length);
		System.out.println(Arrays.toString(names));
	}
  • 擴容方式三：【使用Arrays.copyOf】
    • copyOf(orignal,newLength)==>orignal:要複製的數組；newLength：要返回的副本的長度
    • 案例： 
      public static void main(String[] args) {
		String[] shuiHu = {"西門慶","武松","潘金蓮","武大郎"};
		String[] xiYou = {"孫悟空","豬八戒","沙僧","白龍馬"};
		// 建立新的數組，長度是shuiHu.length+xiYou.length，新的數組會帶着ShuiHu中的數據
		String[] names = Arrays.copyOf(shuiHu, shuiHu.length+xiYou.length);
		
		System.out.println(Arrays.toString(names));
		
		// 複製xiYou的數據到新數組中
		System.arraycopy(xiYou, 0, names, shuiHu.length, xiYou.length);
		System.out.println(Arrays.toString(names));
		
	}

6、引用數組類型的參數blog

  • 定義：在方法中定義的形參，數據類型可使用基本類型，也可使用引用類型
  • 基本類型和引用類型當作形參
    • 案例： 
      public class Demo05 {
	public static void main(String[] args) {
		// 基本類型的數據當作參數傳遞，傳遞的是變量的字面值
		int num = 110;
		System.out.println("main:num = " + num);
		
		changeNum(num);
		System.out.println("main:num = " + num);
		
		System.out.println("=====================");
		
		// 引用類型的數據當作參數傳遞，傳遞的是地址值
		int[] arr = {111,222,333};
		System.out.println("main:arr[0] = " + arr[0]);
		System.out.println(arr);
		changeArr(arr);
		System.out.println("main:arr[0] = " + arr[0]);
		System.out.println(arr);
	}

	public static void changeArr(int[] arr) {
		arr[0] = 666;
		System.out.println("changeArr:arr[0] = " + arr[0]);
		System.out.println(arr);
	}

	public static void changeNum(int num) {
		num = num + 10;
		System.out.println("changeNum:num = " + num);
	}
}
  • 引用數據類型當作返回值
    • 案例【合併兩個數組。返回合併後的結果】
    • public class Demo06 {
	public static void main(String[] args) {
		// 編寫一個方法，傳入兩個數組，獲得一個新的、包含原來兩個數組的數組
		String[] shuiHu = { "西門慶", "武松", "潘金蓮", "武大郎" };
		String[] xiYou = { "孫悟空", "豬八戒", "沙僧", "白龍馬" };

		String[] names = mergeArr(shuiHu, xiYou);
		System.out.println(Arrays.toString(names));
	}

	/**
	 * 合併字符串數組的操做
	 * @param shuiHu	原數據數組1
	 * @param xiYou		原數據數組02
	 * @return			合併以後的數組，包含數組1和數組2中全部的數據
	 */
	public static String[] mergeArr(String[] shuiHu, String[] xiYou) {
		String[] names = new String[shuiHu.length + xiYou.length];
		// 合併的操做
		// 先拷貝shuiHu裏面的數據
		System.arraycopy(shuiHu, 0, names, 0, shuiHu.length);

		// 再拷貝xiYou裏面的數據
		System.arraycopy(xiYou, 0, names, shuiHu.length, xiYou.length);

		return names;
	}
}

7、不定長參數排序

  • 定義：使用於不肯定要傳入幾個參數、若是是相同的參數可使用不定長參數來接收同類型的數據
    • 案例： 
      public class Demo02 {
	public static void main(String[] args) {
		// 編寫方法，計算任意個整數的和，獲取結果
		int sum03 = getSum(3,6,9,12);
		int sum04 = getSum(3,6,9,12,15);
		System.out.println(sum04);
	}

	/**
	 * 計算4個整數的和
	 * @param i
	 * @param j
	 * @param k
	 * @param l
	 * @return
	 */
	public static int getSum(int i, int j, int k, int l) {
		return i+j+k+l;
	}
	
	/**
	 * 接收任意個數整數，計算它們的和
	 * @param nums	傳入的全部的整數
	 * @return		整數的結果
	 */
	public static int getSum(int... nums) {
		System.out.println(nums);
		System.out.println(Arrays.toString(nums));
		
		// 記錄整數的和
		int sum = 0;
		
		for (int i = 0; i < nums.length; i++) {
			sum += nums[i];
		}
		return sum;
	}
}

8、冒泡排序遞歸

  • 定義：大的的數值排到後面，小的數字排到前面
  • 圖解：
  • 案例： 
    public static void main(String[] args) {
		int[] arr = {99,69,96,79,85};
		
		// 肯定比較的次數
		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]) {
					// 若是j比j+1位置上的數字大，就交換它們的值
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		
            System.out.println(Arrays.toString(arr));
	}

9、選擇排序索引

  • 定義：
    • 假定一個最小的元素，記錄下標
    • 用這個元素和後面的全部元素比較，若是發現更小的，就記錄那個更小的元素的小標
    • 一輪比較結束後，把原來假設的最小的元素和真正最小的元素交換位置
    • 下一輪從下一個位置開始
  • 案例： 
    	public static void main(String[] args) {
		int[] arr = {99,69,96,79,85};
		
		// 肯定比較的次數
		for (int i = 0; i < arr.length; i++) {
			// 假設每一輪的第一個是最小的元素的下標
			int minIndex = i;
             // 肯定每一輪比較的次數和內容
			for (int j = i; j < arr.length; j++) {
				if (arr[minIndex] > arr[j]) {
					minIndex = j;
				}
			}
			
			// 發現了更小的元素，交換一下
			int temp = arr[i];
			arr[i] = arr[minIndex];
			arr[minIndex] = temp;
		}
		
		System.out.println(Arrays.toString(arr));
	}

10、使用Arrays提供的排序方法接口

  • 定義：
    • JDK內置的數組工具類Arrays是專門操做數組的一個工具類
    • 提供了複製、轉換、排序的方法
    • sort方法就是對能夠比較的數組進行排序
  • 案例： 
    public class ArraysSort {
	public static void main(String[] args) {
		int[] arr = {99,69,96,79,85};
		System.out.println("排序前的arr:" + Arrays.toString(arr));
		
		// 升序排序
		Arrays.sort(arr);
		System.out.println("排序後的arr:" + Arrays.toString(arr));
		
               //升序的基礎上在降序
                for (int i = 0;i<arr.length/2;i++){
            int temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-i-1] = temp;
        }
        System.out.println(Arrays.toString(arr));
        
	}
}

11、二維數組

  • 定義：數組的嵌套，數組中在嵌套數組
  • 二維數組的建立語法：
    • 先聲明、在分配空間：數據類型[ ] [ ] 數組名； 數組名 = new 數據類型 [ 高維長度] [低維長度]；
      • 例如：int [ ] [ ] arr;  arr = new int [5] [5];
    • 聲明並分配空間： 數據類型[ ] [ ] = new 數據類型 [ 高維長度] [低維長度]；
      • 例如：int [][] arr= new int [5][10];
    • 聲明並賦值（繁）：數據類型 [] [] 數組名 = new 數據類型[5][]; //不規則數組，自行new低維數組
      • 例如：int [][] erwei = new int [5][];
    • 聲明並賦值（簡）：數據類型 [] [] 數組名 = {{v1,v2},{v1,v2}}; //顯示初始化
      • 例如：int [] [] arrv = {{10,20},{10,20}};
  • 動態建立二維數組
    • 案例： 
      public static void main(String[] args) {
		/**
		 * new int[3][5];	
		 * 	第一個方括號表示二維數組的長度是3---裏面能存放3個一維數組
		 * 	第二個方括號的表示每個一維數組的長度都是5
		 */
		int[][] arr = new int[3][5];
		// 輸出二維數組的長度
		System.out.println(arr.length);
		
		// 輸出一維數組的長度
		System.out.println(arr[0].length);
		System.out.println(arr[1].length);
		System.out.println(arr[2].length);
		
		
		// 動態建立
		int[] arr01 = new int[5];
		
		/**
		 * new int[][]
		 * 	第一個方括號表示二維數組的長度--這個二維數組中能夠存放幾個一維數組
		 * 	第二個方括號表示每個一維數組的長度，建立的時候能夠省略，後面須要使用的時候在實例化
		 */
		int[][] arrr01 = new int[3][];
		System.out.println(arrr01.length);
		for (int i = 0; i < arrr01.length; i++) {
			System.out.println(arrr01[i]);
		}
		
		// 給二維數組中的一維數組賦值
		arrr01[0] = new int[2];
		arrr01[1] = new int[3];
		arrr01[2] = new int[4];
		for (int i = 0; i < arrr01.length; i++) {
			System.out.println(arrr01[i]);
		}
	}
  • 案例【二維數組遍歷】： 
    public static void main(String[] args) {
		String[][] names = {
					{"西遊記","奔波兒灞","霸波爾奔","金角大王","銀角大王"},
					{"三國演義","馬超","馬岱","馬騰","馬謖"},
					{"水滸傳","李逵","李鬼","扈三娘","王英"},
					{"紅樓夢","賈寶玉","林黛玉","薛寶釵","王熙鳳"}
				};
		/**
		 * 遍歷
		 * 	先取出每個一維數組
		 * 		再遍歷每個一維數組
		 */
		// 遍歷二維數組，獲取每個一維數組
		for (int i = 0; i < names.length; i++) {
			String[] name = names[i];
			
			// 遍歷一維數組，獲取每個元素
			for (int j = 0; j < name.length; j++) {
				System.out.println(name[j]);
			}
		}
		
		System.out.println(names[1][2]);
	}
  • 圖解【二維數組的分配】：

5、字符串相關練習

  • 案例【使用startsWith、charAt、equals】
  • public class Demo10 {
	public static void main(String[] args) {
		// 輸出班級中張姓學員的名字
		String[] names = {"張三","李四","王五","張柳","田七","張八","週一"};
		// 遍歷names，獲取每個人的名字
		for (int i = 0; i < names.length; i++) {
			String name = names[i];
			// 獲取姓氏
			char c = name.charAt(0);
			
			// 比較姓氏是否是張
			if (c == '張') {
				System.out.println(name);
			}
		}
		
		System.out.println("===============");
		
		for (int i = 0; i < names.length; i++) {
			// 獲取每個人的名字
			String name = names[i];
			// 使用字符串的startWith方法斷定是否是以張開頭
			if (name.startsWith("張")) {
				System.out.println(name);
			}
		}
		
		System.out.println("==============");
		
		// 查找names中有沒有張八這我的
		for (int i = 0; i < names.length; i++) {
			// 判斷有沒有張八這個元素
			String name = names[i];
			if (name.equals("張八")) {
				System.out.println(name);
			}
		}
	}
}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程