【Java→一维数组、for-each循环】懒惰的小黑笔记05（小白一名，请大家多指点）

第六章 数组

声明： 此笔记通过观看【尚学堂】+《Java程序设计（赖小平主编）清华大学出版社》感悟整理得出， 若有抄袭，请注明来源联系作者！

6.1数组的概念

数组（array）是一种用一个名字来标识一组有序且类型相同的数据组成的派生数据类型，它占有一片连串的内存空间。

特征：
1、 类型相同
2、 java数组元素的位置用方括号中的序号表示，称为下标，下标都以0起始。
3、 数组类型可以是任何类型数据，包括基本类型和引用类型。（可以是类、接口、enum枚举等类型）
4、 数组变量应该起一个复数名称，如：nums、people等

=注：数组变量属引用类型，数组也可以看作对象，数组中的每个元素相当于该对象的成员变量

6.1.1 一维数组声明

• 数组的两种声明：

1、 type arr_name[];
2、 type[] arr_name; //一般使用这种方式

• 分配内存的格式：

arr_name = new 数据类型[个数];
//分配内存给数组 数组命名时，尽量使用有意义的英文单词

- 声明数组时即时分配内存：

类型 [] 数组名 =new 数据类型[数组长度];

例如：声明一个学生身高的数组

1、 声明数组：int[] Height;
2、 分配内存：Height = new int[40] →表示创建具有40个int型元素的数组，并被Height数组变量引用。（也可声明数组即时分配对象：int[] Height = new int[40]）

【实例 测试基本类型数组】

package cn.gdlgxy.arryTest;
/**
 * 创建基本类型的一维数组
 * @author 卟淡
 *
 */
public class ArrTest {
	public static void main(String[] args) {
		//创建具有10个int型元素的Height，声明时即时分配内存
		int[] Height = new int[10];
		//索引下标【0，length-1】：0,1,2,3,4,5,6,7,8,9
		
		Height[0] = 160;
		Height[1] = 170;
		//Height[10] = 190; 
		//java.lang.ArrayIndexOutOfBoundsException:
		//出现数组索引越界
		
		//通过循环初始化数组
		for(int i=0;i<Height.length;i++) {
			Height[i] = i*10;
			System.out.println(Height[i]);//输出数组元素的值
		}
	}
}

【内存分析】

【执行结果：】

【实例 测试引用数据类型数组】

package cn.gdlgxy.arryTest;
/**
 * 创建引用类型数组
 * @author 卟淡
 *
 */
class User{
	private String name;
	private int id;
	public User(String name,int id) {
		this.name = name;
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getInfo() {
		return "姓名："+getName()+"\n学号："+getId();
	}
}
public class ArrTest02 {
	public static void main(String[] args) {
		/*
		User[] arrs01 = new User[5];//创建具有5个User类型对象的数组arr
		User us01 = new User("小黑",51551);//创建实例化对象
		User us02 = new User("小白",51551);
		
		arrs01[0] = us01;//给引用类型数组元素赋值
		arrs01[1] = us02;
		*/
		
		//与上述表达一样
		User[] arrs02 = new User[2];//创建具有5个User类型对象的数组arr
		arrs02[0] = new User("小黑",151552);//直接创建对象给引用数组元素赋值
		arrs02[1] = new User("小白",151553);
		
		//单独输出
		System.out.println(arrs02[0].getInfo());
		
		//利用循环输出每个元素的值
		for(int i=0;i<arrs02.length;i++) {
			//System.out.println(arr02[i]);//输出的是引用类型的地址
			System.out.println(arrs02[i].getInfo());//输出方法
			System.out.println(arrs02[i].getName());//只输出名字
		}
	}
}

【执行结果：】

【内存分析：】

6.1.2 一维数组的初始化

• 数组的初始化分为：

静态初始化、动态初始化、默认初始化

• 【实例 静态初始化】
  静态初始化，声明数组的同时赋值

		//静态初始化，声明数组的同时赋值
		int[] a = {20,60,51}; 
		//引用类型数组静态初始化
		User[] c = {new User("小二",154811),
					new User("小三",154812),
					new User("小四",154813)
					};

• 【实例 动态初始化】
  动态初始化，数组定义跟赋值分开操作

		//动态初始化，数组定义跟赋值分开操作
		int[] b = new int[3];
		b[0] = 10;
		b[1] =12;
		b[2] = 19;

• 【实例 默认初始化】

		//数组的默认初始化，数组一经分配空间，将其中每一个元素都以实例变量
		//同样的方式进行隐式初始化
		int[] b1 = new int[3];//默认值为：0,0,0
		boolean[] d = new boolean[3];//默认值：false,false,false

【实例 数组的遍历输出】

//数组的遍历，数组的下标范围【0,length-1】，可以通过下标来遍历数组的元素，
		//遍历时可以读取元素的值或修改元素的值
		
		//初始化化数组元素的值
		for(int i=0;i<b.length;i++) {
			b[i] = 10*i;
		//读取元素的值	
		}
		for(int i=0;i<b.length;i++) {
			System.out.println(b[i]);
		}

6.1.3 for-each循环

for-each循环(也叫增强for循环),用于读取数组，比较方便，但不能修改数组元素的值。

【实例 for-each循环】

//引用类型数组静态初始化
		User[] c = {new User("小二",154811),
					new User("小三",154812),
					new User("小四",154813)
					};
		
		//动态初始化，数组定义跟赋值分开操作
		int[] b = new int[3];
		b[0] = 10;
		b[1] =12;
		b[2] = 19;
		
		//数组的遍历，数组的下标范围【0,length-1】，可以通过下标来遍历数组的元素，
		//遍历时可以读取元素的值或修改元素的值
		
		//初始化化数组元素的值
		for(int i=0;i<b.length;i++) {
			b[i] = 10*i;
		//读取元素的值	
		}
		for(int i=0;i<b.length;i++) {
			System.out.println(b[i]);
		}
		System.out.println("======");
		//for-each循环(也叫增强for循环),用于读取数组，
		//不能修改数组元素的值
		//把数组b中的元素的值给m打印输出
		for(int m:b) {
			System.out.println(m);
			
		}
		System.out.println("======");
		//eg：基本类型
		String[] st = {"张三","李四","老五"};
		for(String m1:st) {
			System.out.println(m1);
			
		}
		
		System.out.println("======");
		//eg：引用类型数组---读取的是每个对象的地址
		for(User n:c) {
			System.out.println(n);
			
		}

6.1.4一维数组获取最值与元素逆序

1. 数组获取最值(获取数组中的最大值最小值和平均值)

分析：
A:定义一个数组，并对数组的元素进行静态初始化。
B:从数组中任意的找一个元素作为参照物(一般取第一个),默认它就是最大值。
C:然后遍历其他的元素，依次获取和参照物进行比较，如果大就留下来，如果小，就离开。
D:最后参照物里面保存的就是最大值。

注：与基本类型变量的比较一样

【实例 数组获取最值】

• 方法一：

package cn.gdlgxy.arryTest;
/**
 * 测试数组的最大值
 * @author 卟淡
 *
 */
public class ArrFinalTest {
	public static void main(String[] args) {
		int[] a = {15,16,62,12,32};
		
		//测试最大值
		/*
		 * 先取出一个数组元素的值，利用for循环
		 * 与下一个值进行比较，如果大于前面的值则赋回给max，
		 * 再依次与后面的值做比较。比较到最后为最大值输出。
		 * 最小值同等道理
		 */
		int max = a[0]; 
		for(int i=1;i<a.length;i++) {
			if(a[i]>max) {
				max = a[i];
			}
		}
		System.out.println("最大值为："+max);
		
		//测试最小值
		int min = a[0];
		for(int i=1;i<a.length;i++) {
			if(a[i]<min) {
				min = a[i];
			}
		}
		System.out.println("最小值为："+min);
		
		//求平均值
		int sum = a[0];
		for(int i=1;i<a.length;i++) {
			sum+=a[i];
		}
		System.out.println("平均值为："+sum/5);
	}

}

• 方法二：

package cn.gdlgxy.arryTest;

public class Array1_2 {
	public static void main(String[] args) {
		int[] a={55,99,77,88,33};
		Array1_2.p1(a);  //使用类名调用静态方法
		
	}
	public static void p1(int[] a){
		int max=a[0];
		for(int i=1;i<a.length;i++){
			if(a[i]>max){
				max=a[i];
			}
		}
		int min=a[0];
		for(int j=1;j<a.length;j++){
			if(a[j]<min){
				min=a[j];
			}
		}
		int sum=0;
		for(int k=0;k<a.length;k++){
			sum+=a[k];
		}
		System.out.println("最大值为："+max);
		System.out.println("最小值为："+min);
		System.out.println("平均值："+ sum/a.length);
         }
}

2. 数组元素逆序 (就是把元素对调)

分析：
	A:定义一个数组，并进行静态初始化。
	B:思路
		把0索引和arr.length-1的数据交换
		把1索引和arr.length-2的数据交换
		...
		只要做到arr.length/2的时候即可。

过程：把第一个位置拿出来，再把最后一个拿出来放在第一位，然后把拿出来的第一个放到最后一个位置

【实例 数组元素的逆序】

• 方法一：

package cn.gdlgxy.arryTest;
/**
 * 数组元素的逆序
 * @author 卟淡
 *
 */
public class ArryFinalTest02 {
	public static void main(String[] args) {
		int[] a = {15,51,59,32,10,4};
		
		int temp = 0;			//先定义一个整数初始化
		for(int i=0;i<a.length/2;i++) {	//i<6/2=3
			temp = a[a.length-1-i];	//取出最后一个元素赋给temp
			a[a.length-1-i] = a[i];	//把第一个元素移到最后一个元素的位置
			a[i] = temp;	//再把temp（最后一个元素）赋回给第一个元素的位置
							//再循环判断
		}
		//输出数组
		System.out.print("[");
		
		for(int i=0;i<a.length;i++) {
			if(i==a.length -1) {
				System.out.print(a[i] + "]");
			}else {
				System.out.print(a[i] + ",");
			}
		}
	}
}

结果：

• 方法二：

package cn.gdlgxy.arryTest;

public class ArryFinalTest03{
	public static void main(String[] args) {
		int[] a= {1, 4, 6, 7, 8};
		ArryFinalTest03.reverse(a);//（可根据类名.静态方法名）调用静态方法，不用 new 创建对象
		ArryFinalTest03.print(a);
		
	}
	
	public static void reverse(int[] a) { //定义一个for循环 
		for (int i= 0; i<a.length/2;i++) { //i=2.5 即int i<2   
			int temp=0;                 //定义一个整型temp
			temp = a[a.length - 1 -i]; //temp=a[5-1-0] 把a[4]放进temp内
			a[a.length -1 -i] =a[i];   //把a[0]附给a[4]位置   
			a[i] =temp;                //把temp中的8放在a[0]位置
		}
	}
	public static void print(int[] a) {
		System.out.print("[");
		for(int i=0; i < a.length; i++) {
			if(i==a.length -1) {
				System.out.println(a[i] + "]");
			}else {
				System.out.print(a[i] + ",");
			}
		}
		System.out.println();
	}
}