Java基础系列之IDEA使用及数组的初始化

idea ： 非常高级的 开发工具
notepad 记事本
notepad++ 高级记事本。
idea 高级开发工具 （今后开发就用他了。）

	idea版本：
		2017版  最多支持到 jdk10
		2018版  最多支持到 jdk11，     jdk12不支持。
		2019版  支持jdk12 jdk13 不支持jdk14
		2020版  都支持。

	管理java文件的目录结构：
		 总目录，  以后 所有的idea产生的 所有的文件 基本上都会在这里面。  D:\develop\ideaProjects 
		 	
			项目目录
				模块目录
					包目录
						java文件
			
	资料：
		ideaIU-2019.3.3.exe
		jetbrains-agent.jar  破解包
		激活教程视频
	
	idea的快捷键：
		psvm + 回车 快速生成main方法
		sout + 回车 快速生成输出语句
		Alt + 1 打开 \ 隐藏工程目录结构
		Alt + 4 打开 \ 隐藏控制台

		Ctrl + D 向下复制一行
		Ctrl + X 剪切当前行
		Ctrl + alt + L 格式化代码
		Alt+ enter 代码修正提示
		Ctrl + / 批量加入单行注释，再按一次就是取消
		Ctrl + shift + / 批量加入多行注释，再按一次就是取消
		Alt + shift + ↑ 上移当前行
		Alt + shift + ↓ 下移当前行

		true.if
		5.fori
		某某.var
	
	模块的操作：
		新建
		删除
		导入
	
	项目的关闭和打开：
		关闭  close project
		打开
		新建
	
数组(☆☆☆☆☆)：
	回顾一下之前提到过数组的地方：
		1：HelloWorld案例
			public class Demo {
				public static void main(String[] args){ //String[] 这是字符串数组
					System.out.println("helloworld");
				}
			}
		
		2：符号
			基本符号
				[] 只有数组用。
		
		3：数据类型
			基本类型
			引用类型
				数组 
				类
					String System Random Scanner

					Random r = new Random();
				接口
		
		综上所述 ：数组是引用类型 数组需要用[]
	数组的作用：
		数组是一个容器 是用来存储数据的。 10 3.14 'a' true "adfad"

		变量其实也是容器，只不过变量只能存储一个数据
			int a = 10;
			a = 20; // a里面的10就没有了 取而代之的是20

	数组的定义：
		变量的定义格式：
			数据类型 变量名 = 值;

			数据类型 变量名;
			变量名 = 值;

			int a = 10;

			int b ;
			b = 10;

			//数据类型 变量名 = 值;
			int[] aa = 值;

			int[] bb;
			bb = 值;
	
	
		动态初始化：
			// 数据类型[] 变量名 = new 数据类型[长度];
			int[] arr = new int[3];
			System.out.println(arr); //地址值 ---[I@ad12432 

			int a = 10;
			System.out.println(a); //10

			/*
				int ： 代表数组里面存储的是int类型的数据
				[] : 代表数组
				arr ： 变量名字  数组名字
				= ： 赋值符号
				new ：引用类型的数据 一般都比较大。所以他们创建的时候 需要去内存中申请开辟空间的。
					这时候 就需要使用new关键字 用来去内存中申请空间。
					Random r = new Random(); // 类 Random
				int ：开辟的这块儿空间里面存储 int类型的数据。
				[3] : 这块儿空间里面只能存3个int数			
			*/

			动态初始化的原理：
				之所以叫做动态初始化，是因为你创建数组的时候，你只给了长度，而没有给数组里面具体的每个位置上的数。那么jvm会根据你的类型自动给。
				为什么jvm会自动给你每个位置上赋值呢？
				因为你去内存中开辟空间。 是必须拿着占位值，去占位的，否则内存不会分配给你空间的。
				所以底层会根据你数组类型，不同的数组类型，会拿着不同的值去占位的。
				
				整数： byte short int long ---0
					byte[] bys = new byte[5]; //0, 0, 0, 0, 0

				小数： float double --- 0.0
					float[] flos = new float[4];// 0.0, 0.0, 0.0, 0.0

				布尔： boolean  ---false
					boolean[] bos = new boolean[2]; // false,false

				字符： char ----'\u0000' 空字符
					char[] chs = new char[2]; // '\u0000' ,'\u0000'
					
					//   \ 转义字符  \可以转换 紧挨着他的后面的那个字符的意思
					// u 本身就是u字母的意思
					//  Unicode 编码意思。
					/*
					 字符 --和数字是一一对应的把。
					 ASCII码表  0-127
					 Unicode 万国码
					 */
					char c1 = '\u8888';
					System.out.println(c1); //袈
				
				引用类型 ： null
		
		静态初始化：
			int[] arr = new int[]{5,4,7,8}; // 自己给值  长度 由系统来定。
			// 长度不能写
		
		静态初始化的简写格式
			int[] arr = {5,6,7,8};  // 自己给值  长度 由系统来定。
			
			简化格式注意事项：
				int[] arr = new int[3];
				int[] arr1;
				arr1 = new int[3];

				int[] arr2 = new int[]{4,5,6};
				int[] arr3;
				arr3 = new int[]{4,5,6};

				int[] arr4 = {6,7,8};
				int[] arr5;
				arr5 = {6,7,8}; //编译报错。

	数组的访问：
		索引：“角标” 数组里面的每个位置 都有一个编号，这个编号 从0开始 一直到 数组的最大长度-1
			int[] arr = new int[3];
			System.out.println(arr); //地址值
			System.out.println(arr[0]); //0
			System.out.println(arr[1]); //0
			System.out.println(arr[2]); //0
			System.out.println(arr[3]); // 出错了  索引越界异常

			arr[0] = 1;
			System.out.println(arr[0]); //1

	
	数组的内存图：
		一个数组的创建过程：
			int[] arr = new int[3];
			System.out.println(arr); // [Iab345
			arr[0] =10;
			System.out.println(arr); // [Iab345
		
		两个数组的内存图：
			// new 每执行一次 就会开辟一个新的空间。
			//--------------------
			int[] arr = new int[3];
			System.out.println(arr[0]); //0
			int[] brr = new int[3];
			brr[0] = 10;
			System.out.println(arr[0]); //0
		
		多个变量指向同一个数组的内存图	
			int[] arr = new int[3];
			System.out.println(arr[0]); //0
			int[] brr = arr;
			brr[0] = 10;
			System.out.println(arr[0]); //10
	
	数组容器出现的异常：
		1：索引越界异常 
			int[] arr = new int[3];
			System.out.println(arr[100]); // ArrayIndexOutofBoundsException
		
		2: 空指针异常  所有引用类型 最常见的异常
			原因： null 调用内容。
			int[] arr = null;
			System.out.println(arr[0]); // NullPointerException
	
	遍历：
		// 数据的遍历：
		//遍历：对容器里面的元素 一个一个的依次展示出来。
		
		//int[] arr = {5,7,9,3,1};

		//遍历方式一： 代码太重复
		/*
		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]);
		*/

		//遍历方式二 ：就解决了重复问题。
		/*
		for (int i = 0; i < 5; i++) {
			System.out.println(arr[i]);
		}
		*/

		int[] arr = {5,7,9,3,1,4,5654,56,67,45,3,342,342,342,354,76,8,897,9,67,54,4,342,324,234,43,54,65,7,87,98,80};

		/*
		int a = arr.length;  // 所有的数组 都可以调用length这个属性， 表示的是 数组的长度。
		System.out.println(a); //32

		int[] brr = {1,2,3,4};
		int b = brr.length;
		System.out.println(b); //4
		*/

		//for (int i = 0; i < 数组的长度; i++) {
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}

	练习题目：
		案例1： 定义一个数组  求数组里面的最大值
			
			int[] arr = {6,7,4,3,9,5,7,8};   // 打印最大值

		
		案例2： 定义一个数组  求数组里面所有元素的和。
			int[] arr = {6,7,4,3,9,5,7,8};  // 打印 和

		
		案例3： 定义一个数组， 打印某个元素在数组中第一次出现的索引。。
			
			int[] arr = {6,7,4,3,9,5,7,8};
			// 打印 9这个数 在数组中第一次出现的索引
			//打印 4
		
		案例4： 键盘录入6个数 存入到数组中。 把数组中的最大值和最小值去除掉之后 求平均值。

			// 键盘录入6个数 存入到数组中。 把数组中的最大值和最小值去除掉之后 求平均值。

	练习答案：
		案例1： 定义一个数组  求数组里面的最大值
			
			int[] arr = {6,7,4,3,9,5,7,8};   // 打印最大值

			int leitai = arr[0];

			for (int i = 1; i < arr.length; i++) {
				if(arr[i] > leitai){
					leitai = arr[i];
				}
			}

			System.out.println(leitai);
		
		案例2： 定义一个数组  求数组里面所有元素的和。
			int[] arr = {6,7,4,3,9,5,7,8};  // 打印 和
			int sum =0;
			for (int i = 0; i < arr.length; i++) {
				sum+=arr[i];
			}
			System.out.println(sum);
		
		案例3： 定义一个数组， 打印某个元素在数组中第一次出现的索引。。
			
			int[] arr = {6,7,4,3,9,5,7,8};
			// 打印 9这个数 在数组中第一次出现的索引
			//打印 4

			Scanner sc = new Scanner(System.in);
			int anInt = sc.nextInt();

			int[] arr = {6,7,4,3,9,5,7,8};
			for (int i = 0; i < arr.length; i++) {
				if(arr[i] == anInt){
					System.out.println(i);
					break;
				}
			}
		
		案例4： 键盘录入6个数 存入到数组中。 把数组中的最大值和最小值去除掉之后 求平均值。

			// 键盘录入6个数 存入到数组中。 把数组中的最大值和最小值去除掉之后 求平均值。

			/*Scanner sc = new Scanner(System.in);
			int anInt0 = sc.nextInt();
			int anInt1 = sc.nextInt();
			int anInt2 = sc.nextInt();
			int anInt3 = sc.nextInt();
			int anInt4 = sc.nextInt();
			int anInt5 = sc.nextInt();

			int[] arr = new int[6];
			arr[0] = anInt0;
			arr[1] = anInt1;
			arr[2] = anInt2;
			arr[3] = anInt3;
			arr[4] = anInt4;
			arr[5] = anInt5;*/

			/*
			Scanner sc = new Scanner(System.in);
			int[] arr = new int[6];
			arr[0] = sc.nextInt();
			arr[1] = sc.nextInt();
			arr[2] = sc.nextInt();
			arr[3] = sc.nextInt();
			arr[4] = sc.nextInt();
			arr[5] = sc.nextInt();
			*/

			Scanner sc = new Scanner(System.in);
			int[] arr = new int[6];
			for (int i = 0; i < arr.length; i++) {
				arr[i] = sc.nextInt();
			}

			// 求平均值 ：  (和 - 最大值 - 最小值 )/(个数-2)
			/*
			//求和
			int sum =0;
			for (int i = 0; i < arr.length; i++) {
				sum+=arr[i];
			}

			//最大值
			int max = arr[0];

			for (int i = 1; i < arr.length; i++) {
				if(arr[i] > max){
					max = arr[i];
				}
			}

			//最小值
			int min = arr[0];

			for (int i = 1; i < arr.length; i++) {
				if(arr[i] < min){
					min = arr[i];
				}
			}
			*/
			/*
			int sum =0;
			int max = arr[0];
			int min = arr[0];
			for (int i = 0; i < arr.length; i++) {
				sum+=arr[i];
				if (arr[i]>max){
					max = arr[i];
				}

				if (arr[i] < min){
					min = arr[i];
				}
			}
			*/
			int sum = arr[0];
			int max = arr[0];
			int min = arr[0];
			for (int i = 1; i < arr.length; i++) {
				sum+=arr[i];
				if (arr[i]>max){
					max = arr[i];
				}
				if (arr[i] < min){
					min = arr[i];
				}
			}

			System.out.println((sum-max-min)/(arr.length-2));