B006-数组&数组遍历

数组

数组的基本定义

/**
 * 数组：
 *   内存中一段连续的内存空间，用来存放同种类型的0个或者多个数据
 *   长度一旦确定不能更改；
 * 四要素：数组名、数组长度、数组元素、数组索引
 * 语法 定义方式：
 *   动态创建：
 *    数据类型[] 数组名 = new 数据类型[数组长度];
 *   静态创建：创建的时候同时存放元素
 *    数据类型[] 数组名 = {v1,v2,v3};
 */
public class _01_ArrayDemo {
	public static void main(String[] args) {
		//定义一个int类型的数组
		int[] arr1 = new int[5];
		//静态创建一个char数组
		char[] arr2 = {'A','b','e'};
		int[] arr = {};
	}
}

数组的基本使用

/**
 *  //获取数组的长度 根据数组的length属性可以获取
 */
public class _02_ArrayDemo2 {

	public static void main(String[] args) {
		//定义一个int类型的数组
		int[] arr1 = new int[5];
		System.out.println(arr1.length);
		//静态创建一个char数组
		char[] arr2 = {'A','b','e','e','r','d','u'};
		//length属性获取长度
		int len = arr2.length;
		System.out.println(len);
		
		//定义一个int类型数组
		int[] arr3 = {34,35,36,37};
		//通过数组名找到对用索引位置的元素
		int a = arr3[2];
		System.out.println(a);
		//赋值  会覆盖原来索引位置的数据
		arr3[2] = 69;
		int a1 = arr3[2];
		System.out.println(a1);
	}
}

数组的默认值和数组索引越界异常

/**
 * 数组：
 * 语法 定义方式：
 *   动态创建：
 *    数据类型[] 数组名 = new 数据类型[数组长度];
 *    	动态创建的数组  数组元素具有默认值，默认值与数据类型有关系
 *    		整数类型默认值： 0
 *    		浮点数：0.0
 *    		布尔类型：false
 *    		字符类型：空
 *    		引用数据类型： null
 *   静态创建：创建的时候同时存放元素
 *    数据类型[] 数组名 = {v1,v2,v3};
 */
public class _03_ArrayDemo3 {

	public static void main(String[] args) {
		//定义一个int类型的数组  动态创建
		int[] arr = new int[5];
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
		//定义一个布尔类型数组
		boolean[] barr = new boolean[6];
		System.out.println(barr[0]);
		System.out.println(barr[1]);
		System.out.println(barr[2]);
		//定义String类型数组
		String[] sarr = new String[2];
		System.out.println(sarr[0]);
		System.out.println(sarr[1]);
		System.out.println(sarr[2]);//ArrayIndexOutOfBoundsException 数组越界异常 超出了索引的范围
	}
}

数组的其他创建方式

/**
 * 语法 常规定义方式：
 *   动态创建：
 *    数据类型[] 数组名 = new  数据类型[数组长度];
 *    
 *   静态创建：创建的时候同时存放元素
 *    数据类型[] 数组名 = {v1,v2,v3};
 */
public class _04_ArrayDemo4 {

	public static void main(String[] args) {
		//特殊创建数组的方式
		int arr[] = new int[4];
		System.out.println(arr[0]);
		int[] arr1 = new int[]{34,342,34,234,324};
		System.out.println(arr1[0]);
	}
}

数组的堆栈存放分析

数组的遍历方式

for循环遍历

/**
 * 数组遍历: 1.数组的索引从0开始 2.判断条件为小于数组的长度
 */
public class _06_ArrayPrint {
	public static void main(String[] args) {

		int[] arr = { 12, 45, 78, 89, 34, 342, 45, 56, 76, 86465};

		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
        
         //练习
		int[] nums = new int[] { 11, 22, 33, 44, -22, 22, -55 };
		
		// 需求 1：找出数组中元素 22 第一次出现的索引位置
		// 遍历数组拿到每一个元素
		for (int i = 0; i < nums.length; i++) {
			int x = nums[i];
			if (x == 22) {
				System.out.println(i);
				break;
			}
		}
		
		// 需求 2：求出 int 类型数组中最小元素值
		int min = nums[0];
		for (int i = 0; i < nums.length; i++) {
			if (nums[i] < min) {
				min = nums[i];
			}
		}
		System.out.println(min);
	}
}

foreach 增强for循环

/**
 *  foreach  增强for循环
 *  语法:
 *  	for(源中的数据类型   变量名 :  需要遍历的源(数组 集合)){
 *  	}
 *  	变量名 就代表了源中的每一个元素
 */
public class _07_ForEachDemo {

	public static void main(String[] args) {
		// 定义数组
		int[] arr = {2,5,8,3,6,9};
		
		//使用foreach
		for(int e : arr){//e element元素
			System.out.println(e);
		}
	}
}

for 和 foreach 使用场景

/**
 *  for: 会使用到索引，因此可以通过索引去排出一些元素
 *  foreach:因为没有使用索引，对每一个元素都会进行操作
 */
public class _07_ForEachDemo {

	public static void main(String[] args) {
		// 定义数组
		int[] arr = {2,5,8,3,6,9};
		
		//使用foreach
		for(int e : arr){//e element元素
			System.out.println(e);
		}
		
		//遍历数组 for 索引  长度
		for (int i = 0; i < arr.length; i++) {
			if(i != 1){
				System.out.println(arr[i]);
			}
		}
	}
}

练习

public class _08_Practice {

	public static void main(String[] args) {
		// 定义一个数组
		int[] arr = { 2, 5, 8, 3, 6, 9 };// 希望 输出的结果是[2,5,8,3,6,9]
		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			// 判断是否为最后一位 如果为最后一位 不需要,
			if (i == arr.length - 1) {
				System.out.print(arr[i]);
			} else {
				System.out.print(arr[i] + ",");
			}
		}
		System.out.print("]");
	}
}