day05数组的创建，赋值、缩容、扩容，遍历，冒泡排序

###1.数组的创建

Array 数组

1.2 创建数组
数组的创建方式一般分为动态初始化和静态初始化

动态初始化
int[] a = new int[5];
静态初始化
int[] b = new int[]{1,2,3,4,5};
int[] c = {1,2,3,4,5};
1.3 创建数组过程分析
程序创建数组 int[] a = new int[5]; 时发生了什么?

在内存中开辟连续的空间,用来存放数据,长度是5
给数组完成初始化过程,给每个元素赋予默认值,int类型默认值是0
数组完成初始化会分配一个唯一的地址值
把唯一的地址值交给引用类型的变量a去保存
数组名是个引用类型的变量,它保存着的是数组的地址,不是数组中的数据

1.4 数组的长度
数组的长度用 length属性来表示,数组一旦创建，长度不可改变
数组的长度允许为0

package cn.tedu.array;

import java.util.Arrays;

/*本类用于练习数组的创建*/
public class TestArray {
	public static void main(String[] args) {
		//需求：分别用数组创建的3中方式，创建char类型的数组，存入单词hello
		//1.1静态创建--创建时不仅直到数组的类型，还知道每个位置上的具体元素
		char[] c1 = {'h','e','l','l','o'};
		System.out.println(c1);//helle
		
		char[] c2 = new char[] {'h','e','l','l','o'};
		System.out.println(c2);
		
		char[] c3 = new char[5];
		System.out.println(c3);
		c3[0] = 'h'; //给数组中第1个元素赋值
		c3[1] = 'e'; //给数组中第2个元素赋值
		c3[2] = 'l'; //给数组中第3个元素赋值
		c3[3] = 'l'; //给数组中第4个元素赋值
		c3[4] = 'o'; //给数组中第5个元素赋值
		System.out.println(c3);
		
		//1.创建数组
		//1.1静态创建--数组类型 数组中具体的元素
		char[] a1 = {'h','e','l','l','o'};
		char[] a2 = new char[] {'h','e','l','l','o'};
		//1.2动态数组--数组类型 数组的长度，后续再给数组中每个位置赋值
		char[] a3 = new char[5];
		//给数组中每个元素动态赋值
		/**我们通过数组的下表来操作数组中的每一个元素
		 * 注意：数组的下标从0开始，最大下标为数组的长度-1
		 */
		a3[0] = 'h';
		a3[1] = 'e';
		a3[2] = 'l';
		a3[3] = 'l';
		a3[4] = 'o';
		
		//2.查看创建好的三个数组
		System.out.println(a1);
		System.out.println(a2);
		System.out.println(a3);
		
		String[] s1 = {"a","b","c"};
		String[] s2 = new String[] {"a","b","c"};
		String[] s3 = new String[3];
		s3[0] = "a";
		s3[1] = "b";
		s3[2] = "c";
		
		/**
		 * char类型的数组底层中做了处理，可以直接打印数组中的具体元素
		 * 但除了char类型以外的数组，如果想要查看数组中的具体元素需要使用：
		 * Arrays。toString(数组名)，注意：Arrays需要导包
		 */
		System.out.println(s1);//[Ljava.lang.String;@6d06d69c 打印出来的是数组对应的地址值
		System.out.println(Arrays.toString(s1));//
		System.out.println(Arrays.toString(s2));
		System.out.println(Arrays.toString(s3));
		
		//查看数组的长度
		/*数组一旦创建，长度不可改变
		 * 如果想要增加或者删除数组中的元素，只能先创建一个新长度的新数组
		 * 在将原来的数据赋值过去*/
		System.out.println(c1.length);
		System.out.println(s1.length);
		
		int[] i = {5,35,0,65,56,154};
		System.out.println(Arrays.toString(i));
		Arrays.sort(i);//数组排序
		System.out.println(Arrays.toString(i));
	}
}

###2.数组的赋值，缩容，扩容

package cn.tedu.array;

import java.util.Arrays;

/**本类用于数组的赋值，缩容，扩容*/
public class TestCopyOf {
	public static void main(String[] args) {
		//1.创建数组
		int[] from = {1,2,3,4,5};
		
		//2.1数组的普通复制
		/**copyOf()用于完成数组的复制，两个参数：
		 * 参数1：要复制哪个数组
		 * 参数2：新数组的长度
		 * 如果新数组的长度=原数组的长度->普通复制*/
		int[] to = Arrays.copyOf(from, 5);
		System.out.println(Arrays.toString(to));
		
		//2.2数组的扩容
		/**扩容：扩充数组的容量：新数组的长度>原数组的长度
		 * 扩容思路：先创建对应新长度的新数组，每个位置上都有默认值
		 * 然后从原数组中将对应的元素复制到新数组，没有被覆盖的位置还是默认值
		 * 
		 */
		int[] to2 = Arrays.copyOf(from, 10);
		System.out.println(Arrays.toString(to2));
		Arrays.sort(to2);
		System.out.println(Arrays.toString(to2));
		to2[3] = 6;
		System.out.println(to2[3]);
		System.out.println(Arrays.toString(to2));
		
		//2.3数组的缩容
		/**
		 * 缩容：缩小数组的容量：新数组的长度<原数组的长度
		 * 缩容思路：先创建对应长度的新数组，每个位置上都有默认值
		 * 然后从原数组中复制指定个数的元素到新数组中，类似于截取
		 * 
		 */
		int[] to3 = Arrays.copyOf(from, 3);
		System.out.println(Arrays.toString(to3));
	}
}

###3.数组的遍历

package cn.tedu.array;

import java.util.Arrays;
import java.util.Random;

/**
 * 本类用于练习数组的遍历
 */
//需求：输出一年中每个月的天数，比如1月有31天
public class ArraysExecl {
	public static void main(String[] args) {
		//getMonthDay();//调用自定义方法
		//createArray1();//调用自定义创建数组的方法，存入数据1-10
		createArray2();//调用自定义创建数组的方法，存入随机数
	}

	private static void createArray2() {
		//1.动态穿件一个长度为6的数组
		int[] a = new int[6];
		//2.遍历数组，依次给数组的每个位置赋值
		for(int i=0;i<a.length;i++) {
			//给数组中每个位置上的元素赋值：随机数的范围[0，100)
			//这个100是自定义的数字
			a[i] = new Random().nextInt(100);
		}
		//3.for循环结束使用数组工具类查看数组中的元素值
		System.out.println(Arrays.toString(a));
	}

	private static void createArray1() {
		//1.创建数组--动态创建
		int[] a = new int[10];
		//2.遍历数组，依次给数组的每个位置赋值
		//从哪开始  到哪结束 如何变化
		for(int i =0;i<a.length;i++) {
			a[i] = i+1;
		}
		System.out.println(Arrays.toString(a));
	}

	private static void getMonthDay() {//创建自定义方法
		//1.创建一个数组，用来保存12个月的天数
		int[] a = {31,28,31,30,31,30,31,31,30,31,30,31};
		//2.输出每个月的天数到控制台
		//从哪开始a[0] 到哪结束a[a.length-1] 如何变化
		/*此处的循环变量i代表的是数组的下标：0~a.length-1
		 * 
		 */
		for(int i=0;i<a.length;i++) {
			System.out.println("下标"+i);
			System.out.println((i+1)+"月有"+a[i]+"天");
			
		}
		
//		int[][] a1 = {{31,28,31},{30,31,30},{30,31,31},{31,30,31}};
	}
}

###4、数组的冒泡排序

package cn.tedu.array;

import java.util.Arrays;

/**本类用于实现冒泡排序*/
public class BubbleSort {
	public static void main(String[] args) {
		//1.创建一个无序的数组
		int[] a = {65,81,35,95,15};
		//Arrays.sort(a);
		//System.out.println(Arrays.toString(a));
		//2.创建自定义排序方法
		sortArray(a);
		
	}

	private static void sortArray(int[] a) {
		//1.外层循环：控制的是比较的轮数，假设有n个数，最多比较n-1轮
		//外层循环的循环变量i代表的是轮数
		//比如5个数，最多比较4轮，<=a.length-1,最多取到1234共4个值
		for(int i=1;i<=a.length-1;i++) {
			//2.内层循环：相邻比较
			//内层循环的循环变量j代表的是数组的下标
			for(int j =0;j<a.length-i;j++) {
				//相邻比较，a[j]代表数组中前一个元素，a[j+1]代表数组中后一个元素
				if(a[j]>a[j+1]) {
					int t = a[j];
					a[j] = a[j+1];
					a[j+1] = t;
				}
			}
			System.out.println("第"+i+"轮排序的效果："+Arrays.toString(a));
		}
		System.out.println("最终效果："+Arrays.toString(a));
	}
}