/**

• 数组的定义
• 概念：同一种数据类型的集合，其实数组就是一个容器
• 数组的好处：可以自动给数组的元素从0开始编号，方便操作这些元素
• 格式一、
• 元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
• 示列： int [] arr = new int [5];
• 格式二、
• 元素类型[] 数组名 = new 元素类型[]{元素,元素,元素。。。。。};
• 示例：int[] arr = new int[3,4,5,6,7];
• int[] arr = {3,5,1,7};
• 内存结构：
• JAVA在运行时，需要在内存中分配空间。为了提高运算效率，有对空间进行了
• 不同区域的划分，因为每一篇区域都有特定的处理数据方式和内存管理方式
• 1.栈内存：用于存储局部变量，当数据使用完，所占的空间会自动释放
• 2.堆内存：

•  	数组和对象，通过new建立的实列都存放在堆内存中
  

•  	每一个实体都有默认初始化值
  

•  	实体不再被使用，会在不确定时间内被垃圾回收器回收
  

• 3.方法区，本地方法区，寄存器
• 4.new出来的都是实体，都存放在堆里面产生了空间，这个空间就是数组
• 5.数组一旦被定义，数组都有默认初始化值 int型 默认 0 float默认 0.0

•  							double型默认 0.00  boolend  false
  

• 6.数组的赋值 x[角标] = 值;
• 7. x =null;当一个实体在堆内存中没有任何引用所使用它的话，java虚拟机就视为它为垃圾
• 这个垃圾不会立刻被清理掉，而是在不定时的时间内启动一个垃圾回收机制，将这个数组实体在
• 堆内存中清除。
• 堆内存的三个特点

•  		1.内存地址值
  

•  		2.默认初始化值
  

•  		3.垃圾回收机制
  

• 数组中在操作时常见的问题
  *1、数组角标越界异常(arrayIndexOutofBounddsException):操作数组时访问到了数组中不存在的角标就会发生异常.
  *2、空指针异常(NULL pointerException),arr中不具备任何实体，当引用没有任何指向值为null的情况，

•  该引用还在用于操作实体
  

*2.8.5 数组中的数组(二维数组)

•  	格式一：int[][] arr = new int[3][2];
  

•  			定义了名称为arr的二维数组
  

•  			二维数组中有3个一维数组
  

•  			每一个一维数组中有两个元素
  

•  			一维数组的名称分别是arr[0],arr[1],arr[2]
  

•  			给第一个一维数组1角标位赋值为 78 的写法是 arr[0][1] = 78;
  

•  	格式二：int[][] arr = new int[a][];
  

•  			二维数组中有三个一维数组
  

•  			每个一维数组都是默认初始化值NULL
  

•  			可以对这三个一维数组分别进行初始化
  

•  			arr[0] = new int[3];
  

•  			arr[1] = new int[1];
  

•  			arr[2] = new int[2];
  

•  	二维数组中的长度arr.length
  

*定义格式

•  一维数组: int[] x; int x[];
  

•  二维数组：int[][] y; int y[][]; int[] y[]; 
  

*中括号放哪都行
*练习：int[] x,y[]; //x一维，y二维
*int[] x;
*int[] y[];
*下面那个答案是对的？
*
*a. x[0] = y; //error ： 把二维数组赋值给一维数组中的元素
*b. y[0] = x; //yea 把一个一维数组赋值给二维数组
*c. y[0][0] = x; //error 把一个一维数组赋值给二维数组中的一个元素
*d. x[0][0] = y; //error x根本不是二维数组
*e. y[0][0] = x[0]; // 元素赋值给元素
*f. x = y; //error

• */

package 黑马程序员;
import java.util.*;
public class day_04 {

	public static void main(String[] args)
	{
		//格式一、
		//元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
		
		//定义一个可以存储三个整数二点容器
		int[] x = new int[3];  //x为数组类型  
		int[] y = {0,1,2,3,2};
		
		x[2] = 2;
		//打印数组中角标为0的元素的值
		System.out.println(x[2]);
		
		//实验两个引用指向了同一个对象或者同一个数组：判断有没有垃圾
		//解答：没有垃圾 
			int [] z = new int [3];
			int [] h = z;
			h[1] = 89;
			System.out.println(z[1]); // 89
			z = null;
			
		//格式二、静态初始化方式
		int[] arr = new int[]{3,1,6,5,4};
		
		//数组的操作
		//获取数组中的元素。通常会用到遍历
		int[] brr = {3,4,5,6,7,8,9,10,-1,2,3,1,156};
		
		brrMAXMIN(brr);//求brr数组的最值
		
		//数组中有一个属性可以直接获取到数组元素个数，length.
		//使用方式：数组名称.length = 数组
		System.out.print(brr.length);
		
		for(int i = 0; i < brr.length; i++) {
			System.out.print(brr[i]);
		}	
		//printArray(arr);//遍历
		
		int[] crr = {1,3,-1,5,7,8,10,7,6};
		 //selectSort(crr);  //数组的排序
		// printArray(crr); //遍历
		 selectsort1(crr);
		// printArray(crr); 
		 //System.out.println(crr.length);
		 //Arrays.sort(crr);
		 printArray(crr);  //java自带的排序方法真实开发其实就是用Arrys.sort(数组名)，前面必须声明：imoprt java.util.*;
		//StringBuffer se = new StringBuffer();//声明容器
		System.out.println();
		//toHex(60); //二进制转换成十六进制
		 //求一个十进制的二进制形式
		 //toBin(16);	//十进制转换二进制
		//sze(-6);		//十进制转二进制
		//toHex1(-60);	//负数的十进制转十六进制
		//		toEr(15);  //优化后
		//		toBa(15);	//优化后
		//		toShiLiu(15);	//优化后
		
		//System.out.print(Integer.toBinaryString(60));  //转换成二进制的
		
		
		//二维数组
		ArrSum();
		
	}
	//数组遍历类
		public static void printArray(int[] arr) {
			System.out.print("[ ");
			
			for(int e = 0; e<arr.length ; e++) {
				if(e != arr.length-1)
					System.out.print(arr[e] + ", ");
				else
					System.out.println(arr[e] + " ]");
			}
		}
		
		//求数组最值
		public static void brrMAXMIN(int[] brr) {
			int max,min,t;
			max = min = brr[0];
			
			for(int i = 0 ; i<brr.length ; i++) {
						if(brr[i] > max)
							max = brr[i];
						if(brr[i] < min)
							min = brr[i];
			}
			System.out.println("max " + max);
			System.out.println("min" + min);
		}
		
		//对给定数组进行排序(选择排序)
		//选择排序特点：内循环结束一次，最值出现头角标位置上
		public static void selectSort(int[] crr) {
			int min;
			for(int i = 0; i<crr.length - 1 ; i++) {   //几个数比较第一次比较n-1次
				for(int j = i+1 ; j<crr.length ; j++) {
					if(crr[i]>crr[j]) {
						min = crr[i];
						crr[i] = crr[j];
						crr[j] = min;
					}
				}
			}
		}
		
		//对给定数组进行排序(冒泡排序)
		//相邻的两个元素进行比较符合条件就换位
		public static void selectsort1(int[] err) {
			int max;
			for(int i = 0; i < err.length-1 ; i++) {
				for(int j = 0 ; j < err.length - i -1;j++) {  //err.length - i - 1是为了防止数组越界问题
						if(err[j] > err[j+1]) {
//							max = err[j];
//							err[j] = err[j+1];
//							err[j+1] = max;
							swap(err,j,j+1);		//把数组的两个数互换封装成一个类
						}
				}
			}
		}
		//发现无论什么排序。都需要对满足条件的元素进行位子置换
		//所以可以把这部分相同的代码提取出来，单独封装成一个函数;
		//数组互换函数
		public static void swap(int[] arr,int a,int b) {
			int temp = arr[a];
			arr[a] = arr[b];
			arr[b] = temp;
		}
		
		//十进制转换成二进制
		public static void toBin(int num) {
			StringBuffer sb = new StringBuffer(); //对象：存数据的
			while(num>0) {
				//System.out.print(num%2);
				sb.append(num%2);
				num = num / 2;
			}
			System.out.println(sb.reverse());
		}
		
		//十进制转换成16进制
		public static void toHex(int num) {
			StringBuffer se = new StringBuffer();
			for(int x = 0 ; x<8 ; x++) {
				int temp = num & 15;
				if(temp > 9) {
					//System.out.println((char)(temp - 10 + 'A'));
					se.append((char)(temp - 10 + 'A'));
				}
				else {
					//System.out.println(temp);
					se.append(temp);
				}
			
				num = num>>>4;
			}
			System.out.println(se.reverse());
		}
		
		//十进制转换成16进制(查表法)
		//查表法：将所有的元素临时存储起来，建立对应关系，每一次&15后的值作为索引去查
		//建立好的表，可以找对应的元素
		//下面出结果了 但是是反着的 想要正过来可以通过StringBuffer reverse功能来完成也可以通过数组来完成
		//下面就是通过数组来完成反转
		//字符数组在内存中一被定义它的默认初始化值是\u0000空位 
		/*
		 * 0  1  2  3  4  5  6  7  8  9   A   B   C   D   E  F  == 十六进制中的元素
		 * 0  1  2  3  4  5  6  7  8  9  10  11  12  13  14 15	
		 * */
		public static void toHex1(int num)
		{
			char[] arr = new char[8];
			char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
			//int pos = 0;
			int pos = arr.length-1;
			while(num!=0){
				int temp = num & 15;
				//arr[pos++] = chs[temp];
				arr[--pos] = chs[temp];
				//System.out.println(chs[temp]);
				num = num >>> 4;
			}
//			for(int x = pos-1; x >= 0 ; x--) {  //pos - 1 指针存完3以后自增了一 回
//				System.out.print(arr[x]);
//			}
			//倒着打印
			for(int x = pos;x<arr.length;x++ ) {  //从pos开始遍历
				System.out.print(arr[x]);
			}
		}
		
		//十进制转换成二进制(查表法)
		public static void sze(int num) {
			//定义二进制的表
			char[] chs = {'0','1'};
			
			//定义一个临时存储容器
			char[] arr = new char[32]; //int类型32位二进制
			
			//定义一个操作数组的指针
			int pos = arr.length;
			
			while(num!=0) {
				int temp = num & 1;
				
				arr[--pos] = chs[temp];
				
				num = num >>> 1;
			}
			for(int x = pos; x<arr.length ; x++) {
				System.out.print(arr[x]);
			}
		}
		
		/*
		 * 十进制 --》 二进制
		 */
		public static void toEr(int num) {
			trans(num,1,1);
		}
		
		/*
		 *十进制 --》 八进制 
		 */
		public static void toBa(int num) {
			trans(num,7,3);
		}
		/*
		 *十进制 --》 十六进制 
		 */
		public static void toShiLiu(int num) {
			trans(num,15,4);
		}
		//优化
		public static void trans(int num,int base,int offset) {
			if(num == 0) {
				System.out.println(0);  //如果为0直接返回0并退出这个类
				return ; 
			}
			char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
			char[] arr = new char[32];
			
			int pos = arr.length;
			
			while(num !=0) {
				int temp = num & base;
				arr[--pos] = chs[temp];
				num = num >>> offset;
			}
			
			for(int x = pos; x < arr.length ; x++) {
						System.out.print(arr[x] + " ");
			}
		}
		
		//二维数组的练习：求公司中的各组的销售和
		public static void ArrSum() {
			int[][] arr = {
   {3,5,1,7},{2,3,5,8},{6,1,8,2}};
			
			int sum = 0;
			for(int i = 0 ; i<arr.length ; i++) {
				for(int j =0 ; j<arr[i].length ; j++) {
					sum = sum + arr[i][j];
				}
				System.out.println("销售额 " + sum);
			}
			System.out.println("总销售： " + sum);
		}
}