day10-数组

2.1 数组的遍历

​ 遍历：依次访问，从第一个元素，访问到最后一个元素。

1、使用循环来遍历数组：
for(int i = 0;i < arr.length; i++){
	arr[i] = i;//赋值
	System.out.println(arr[i]);//获取数值
}

2.1.1 for-each循环

for-each循环：【扩展】
增强for循环：JDK1.5的版本出现的。
特定的用法：专门用于获取数组中的每一个元素的值。
语法结构：
for(数据类型 变量名 : 数组名){
    System.out.println(变量名);
}
工作原理：
for(int e :arr){
    System.out.println(e);
}
int e，定义变量e，
	依次获取数组的元素，赋值给e
注意点：
    A：for-each只能获取数组的数据，但是不能给数组进行赋值
    B：for-each，在代码这个层面，不能操作下标。

2.2 数组中的默认值

数组的引用存在栈内存中，数组本身存在堆内存中。

	数组中是有默认值的
		整数：0
		小数：0.0
		字符：\u0000
		布尔：false
		他：null

2.3 创建数组的其他语法

//动态创建数组：先创建数组，然后再根据下标一个一个存储数据。

    A：先声明，再创建(分配内存空间)
    数据类型 [] 数组名;
    数组名 = new 数据类型[长度];

    B：声明并创建
    数据类型 [] 数组名 = new 数据类型[长度];
    数据类型  数组名[] = new 数据类型[长度];

//静态创建数组：声明，创建，赋值一起写完。

    C：声明，创建，并赋值
    数据类型[] 数组名 = {数值1,数值2,数值3,数值4.。。。};
    //=左边声明数组，=右边，会先根据{}中数据的个数，然后再将{}中数据，按照顺序存储进去。

完成了几件事：
1.先声明：int[] c
2.根据{}中数组值的个数，开辟堆内存
3.将{}中的数组值，依次按照顺序存入数组中

    D：声明，创建，并赋值
    数据类型[] 数组名 = new 数据类型[]{数值1,数值2,数值3,数值4.。。。}

2.4 数组地址的转移

基本类型：操作的都是数值本身。

引用类型：操作的是地址。

//示例代码：
class Test4ArrayAddress{
	public static void main(String[] args){
		/*
		数组：引用类型的数据
			数组名，存储是引用地址。
		*/

		int[] a = new int[3];
		System.out.println(a.length);//3
		System.out.println(a);//a数组的地址
		System.out.println(a[0]);//0

		a[0] = 1;
		a[1] = 2;
		a[2] = 3;

		int[] b = {4,5,6,7};
		System.out.println(b.length);//4
		System.out.println(b);//b的地址
		System.out.println(b[0]);//4

		int[] c = a;//将a的值赋值给c，就是将a存储的数组的地址赋值给c
		//a和c存储的地址相同，那么就指向了同一个数组
		System.out.println(c.length);//3
		System.out.println(c);//a的地址
		System.out.println(c[0]);//1

		c[0] = 100;
		System.out.println(a[0]);
		System.out.println(b[0]);
		System.out.println(c[0]);


		b = c;

		b[1] = 200;
		System.out.println(a[1]);//200
		System.out.println(b[1]);//200
		System.out.println(c[1]);//200

		System.out.println("Hello World!");
	}
}

2.5 数组作为参数

数组是引用类型，传递的是地址，方法结束的时候，参数就销毁了。

class Test5ArrayMethod {
	//设计一个方法，用于打印数组
	public static void printArray(int[] arr){//int[] arr = a;a的地址给了arr，那么arr和
       // a指向同一块内存的数组
		for(int e : arr){
			System.out.print(e +"\t");
		}
		System.out.println();
	}

	public static void main(String[] args) {
		int[] a = {1,2,3,4,5};
		//设计一个方法，用于打印数组
		printArray(a);//将a的地址，传递给arr
		System.out.println("Hello World!");
	}
}

2.6 数组作为返回值

实例代码：

//设计一个方法，用于创建一个数组， 并赋值。数组要返回给调用处
public static int[] createArray(int len){
	int[] arr = new int[len];
	for(int i = 0;i <arr.length;i++){
		arr[i] = i * 2;
	}
	return arr;
}

2.7 可变参数（拓展内容）

​ 概念：一个方法可以接收的参数的数量不定(0-多个)，但是类型固定。

​ 语法：数据类型 … 参数名，可变参数在方法中当数组使用。

​ 注意事项：

1、如果参数列表中，除了可变参数还有其他的参数，可变参数要写在整个参数列表的最后。
2、一个方法最多只能有一个可变参数。

实例代码：

class Test6Array {
	//求一组int类型的数据的和
	public static void getSum(int ... nums ){
		int sum = 0;
		for(int i = 0;i <nums.length;i++){
			sum += nums[i];
		}
		System.out.println("结果：" + sum);
	}
	public static void main(String[] args) 
	{
		/*
		可变参数：同一种类型的参数，类型固定的，但是个数不固定。
		语法的支持：
			数据类型 ... 参数名
			可变参数，类型固定，个数可变。0-多个
		在方法中可变参数当数组使用
		*/
		getSum(1,2,3);
		getSum(1,2,3,4,5,6,7,8,9,10);
		System.out.println("Hello World!");
	}
}

2.8 数组的排序

​ 排序：

​ 数组是存储一组数据，而且这些数据是有顺序的。但是数值本身可能是无序的。通过算法来实现给数组进行排序，升序(数值从小到大)，降序(数值从大到小)。

​ 冒泡排序：

1、冒泡排序：Bubble Sort
原理：比较相邻的两个数，将较大的数，向后移动。   
class Test7BubbleSort{
	public static void main(String[] args){
		int[] arr = {15,23,8,10,7};
		for(int i= 1; i<arr.length;i++){//控制轮数：
			//i=1,2,3,4
			/*
			i=1,	j<4
			i=2,	j<3
			i=3,	j<2
			*/
			for(int j = 0;j < arr.length - i;j++){
				if(arr[j] > arr[j+1]){
					//交换
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}

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