package com.sxt.day1207.array;

import java.util.Arrays;

public class Demo2 {

/* 0:陣列的概念
 *   陣列是相同型別資料的有序集合.
 *   相同型別的若干個資料,按照一定先後次序排列組合而成。
 *   其中,每一個數據稱作一個數組元素
 *   每個陣列元素可以通過一個下標來訪問它們.
 *   陣列的特點：
 *     其長度是確定的。陣列一旦被建立，它的大小就是不可以改變的。  （缺點）
 *     其元素必須是相同型別,不允許出現混合型別。(除過Object以外)
 *     陣列中的元素可以是任何資料型別，包括基本型別和引用型別。
 *     陣列中可以存放重複的元素
 * 1:陣列的定義以及初始化
 *   1.1 ：動態初始化
 *     資料型別[]  陣列名  = new 資料型別[陣列長度];
 *   1.2:靜態初始化
 *     資料型別[]  陣列名  = new 資料型別[]{元素1,元素2..};  
 *   1.3:靜態初始化
 *     資料型別[]  陣列名  = {元素1,元素2..};  
 * 2:獲取元素
 *    根據陣列的下標獲取元素  陣列名[下標]  
 *    注意：下標從0開始，到陣列長度-1結束
 *    [0,陣列.length-1] 
 * 3:獲取陣列的長度  （長度是陣列的屬性）
 *      陣列名.length  
 * 4:陣列的遍歷:陣列的迭代，依次將陣列中的元素獲取
 *   4.1 :普通for迴圈
 *    for(int i = 0;i<陣列.length;i++){
 *      System.out.println(arr[i]);
 *    }
 *   4.2 ：for-each  jdk1.5新特性
 *    for(陣列的資料型別   變數名:陣列名){
 *      System.out.println(變數名);
 *    }
 *   普通for迴圈和for-each迴圈的區別
 *   1：共同點：都可以依次遍歷元素
 *   2：不同點
 *      2.1：for-each遍歷的效率比普通for迴圈高
 *      2.2： 普通for迴圈根據下標獲取元素
 *           for-each沒有下標，宣告一個臨時的變數來儲存元素
 *      2.3：普通for迴圈在遍歷的同時還可以對陣列做修改     
 *          for-each迴圈在遍歷的同時不可以對陣列做修改     
 *      2.4：for-each只有一個功能：就是遍歷元素    
 *    
 *   
 * 5:陣列的記憶體分析
 * 
 * 
 */
public static void main(String[] args) {
	
	//1：宣告陣列
	  int[] score;//宣告一個整型的陣列，陣列名叫score
	  //int score2[];
	//2:初始化陣列
	  score = new int[5];  //建立一個長度為5的陣列 （在堆記憶體中開闢一塊大小為5的空間）
	 //3:給陣列儲存資料 
	  score[0] = 100;
	  score[1] = 99;
	  score[2] = 98;
	  score[3] = 97;
	  score[4] = 100;
	 // score[5] = 85;//第六個  ArrayIndexOutOfBoundsException  陣列下標越界
	  
	  //4:定義陣列，並初始化  動態初始化 （根據陣列的長度來確定元素的個數）
	  String[] str = new String[3];
	  str[0] = "a";
	  str[1] = "b";
	  str[2] = "c";
	  //5:定義陣列，並初始化 靜態初始化 (根據元素的個數來確定陣列的長度)
	  String[] str2 = new String[]{"a","b","c"};
	  //6:定義陣列，並初始化 靜態初始化 (根據元素的個數來確定陣列的長度)  直接賦值法
	  String[] str3 = {"a","b","c"};
	  //7:獲取陣列的元素 （根據下標獲取陣列元素）
	  System.out.println(str3[2]);
	  System.out.println(str3[1]);
	  System.out.println(str3[0]);
	  //8:獲取陣列的長度
	  System.out.println(str3.length);
	 // String[] str3 = new String[3]{"a","b","c"};//錯誤，不能同時寫長度以及元素
	  //9：遍歷陣列
	  int[] arr = {10,20,30,40,50,100};
	 /* System.out.println(arr[0]);
	  System.out.println(arr[1]);
	  System.out.println(arr[2]);
	  System.out.println(arr[3]);
	  System.out.println(arr[4]);
	  System.out.println(arr[5]);
	  */
	  //從下標為length-1開始迴圈，倒迴圈
		for(int i= arr.length-1;i>=0;i--){
			 System.out.println(arr[i]);
		}
		System.out.println("-------------------");
		
		
		
		
		
		
		//從下標為0開始迴圈
	/*	for(int i = 0;i<arr.length;i++){
			System.out.println(arr[i]);
			arr[i] = 300; //修改  重新賦值
		}
		*/
		
		System.out.println("-------------------");
	   //for--each迴圈
		for(int a:arr){
			System.out.println(a);
			a = 200;
		}
	  
		System.out.println(Arrays.toString(arr));
		
	 /* int i = 0;
	  while(i<arr.length){
		  System.out.println(arr[i]);
		  i++;
	  }
	*/
	
	
}

}

***** 陣列的記憶體分析****
public class Demo3 {

/*
 * 陣列的記憶體分析
 * JVM記憶體
 *   JVM記憶體結構主要有三大塊：堆記憶體、方法區和棧。
 *   1：堆記憶體是JVM中最大的一塊由年輕代和老年代組成，而年輕代記憶體又被分成三部分，Eden空間、From Survivor空間、To Survivor空間,預設情況下年輕代按照8:1:1的比例來分配；
 *   2：方法區儲存類資訊、常量、靜態變數等資料，是執行緒共享的區域，為與Java堆區分，方法區還有一個別名Non-Heap(非堆)；
 *   3：棧又分為java虛擬機器棧和本地方法棧主要用於方法的執行。
 *   
 *   陣列:是java中的引用型別
 *    執行列印陣列的變數名：引用地址符
 *    引用地址符=資料型別[email protected]+hashCode16進位制
 *    通過棧中的地址符找到堆中實際的記憶體空間,指向頭地址（下標為0的元素的地址符）
 *    
 *   在堆中開闢好空間之後，陣列有預設值
 *    整型陣列：0
 *    浮點型:0.0
 *    char:0
 *    布林型別:false
 *    引用型別：null 
 *    
 * 
 */

public static void a(){
	System.out.println("aaa");
}
public static void main(String[] args) {
	//宣告一個int型別的變數
	int[] arr;
	//初始化陣列  （在堆記憶體中開闢空間）
	arr = new int[5];
	//列印這個陣列的變數  [[email protected]  引用地址符=資料型別[email protected]+hashCode16進位制
	System.out.println(arr);
	
	for(int i = 0;i<arr.length;i++){
		System.out.println(arr[i]);
	}
	
	
	double[] d = new double[2];
	System.out.println(Arrays.toString(d));
	
	boolean[] b = new boolean[2];
	System.out.println(Arrays.toString(b));
	
	String[] s = new String[2];
	System.out.println(Arrays.toString(s));
	
	
	
	
	
	
	
	
	
}

}