9.Java编程基础（二）
数组（概述-内存结构）：
概念：同一种类型数据的集合，其实数组就是一个容器。
好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
格式1：元素类型[] 数组名 = new 元素类型[元素个数或数组长度];或：元素类型 数组名[] = new 元素类型[元素个数或数组长度];
格式2：元素类型[] 数组名 = new 元素类型[]{1,2,3....}
数组是引用数据类型。
内存空间：
栈：数据使用完毕，会自动释放。（主函数在栈中）
凡是new出来的东西都在堆中存放，例如数组：数组名存放在栈中，数组实体存放在堆中，数组名的值只是数组实体在堆中的起始地址。
堆内存中每个实体都有一个内存地址值。数组是通过下标访问其中的每个元素。
数组在堆中有默认的初始值：bute，int，short，long默认0；float默认0.0f，double默认0.0；char默认‘\u0000’；boolean默认false；引用数据类型默认null。
当数组的值等于null时，就是垃圾，java会在适当的时候启动垃圾回收机制给清除。
栈是自动释放，堆是垃圾回收。
引用数据类型不一样的地方：
把一个数组的值赋值给另一个数组时，只是复制地址，是两个引用指向同一数组。
当把其中的一个数组等于null时，只是把栈中的其中一个数组的值设为空，不指向堆中的实体了，但还有一个栈中的数组指向对堆中的实体，所以此时堆中没有垃圾。
数组（静态初始化-常见问题）：
ArrayIndexOutOfBoundsException：操作数组时，访问到了数组中不存在的角标，即数组越界。
NullPointerException：空指针异常。例如：当引用没有任何指向，值为null时，该引用还在用于操作实体。
数组（常见操作-遍历）：
但凡有数组，一般都要用for循环遍历
数组（常见操作-获取最值）：
思路：
（1）.获取最值需要进行比较，每次比较都会有一个较大的值，因为该值不确定，通过一个变量进行临储。
（2）.让数组中的每一个元素都和这个变量的值进行比较，如果大于了变量中的值，就用该变量记录较大值。
（3）.当所有的元素都比较完成，那么该变量中存储的就是数组中最大的值了。
数组（排序-选择排序）：
for(int i=0;i<array.length-1;i++)
{
for(int j=i+1;j<array.length;j++)
{
if(array[i]>array[j])
{
int temp=0;
temp=array[i];
array[i]=array[j];
array[j]=temp;
}
}
}
数组（排序-冒泡排序）：
冒泡排序：相邻两个元素进行比较，如果符合条件就换位。
for(int i=0;i<array.length-1;i++)
{
for(int j=0;j<array.length-i-1;j++)
{
if(array[j]>array[j+1])
{
int temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
真实开发时，排序用的是java.util.*包中的Arrays.sort(arrray);方法。
数组（排序-位置置换功能抽取）：
选择排序和冒泡排序中的换位置功能可以提取出来，单独封装一个函数。
public static void swap(int[] array,int a,int b)
{
int temp=array[a];
array[a]=array[b];
array[b]=temp;
}
数组（折半查找）
查找定义功能，获取key第一次出现在数组中的位置，如果返回是-1，那么代表该key在数组中不存在。
折半查找可以提高效率，但数组必须是有序的。
折半的第一种方式：
int min,max,mid;
min=0;
max=array.length-1;
mid=(min+max)/2;
while(key!=array[mid])
{
if(key>array[mid])
{
min=mid+1;
}
else if(key<array[mid])
{
max=mid-1;
}
if(min>max)
{
return -1;
}
mid=(min+max)/2;
}
return mid;
折半的第二种方式：
int min,max,mid;
min=0;
max=array.length-1;
while(min<=max)
{
mid=(min+max)>>1;
if(key>array[mid])
{
min=mid+1;
}
else if(key<array[mid])
{
max=mid-1;
}
else
{
return mid;
}
}
return -1;
如果要把一个有序数组插入一个值，且插入后仍有序，可以把上一行的return -1；改成return min；
数组（进制转换-十进制-二进制）：
public static void TenToTwo(int num)
{
StringBuffer sb=new StringBuffer();
while(num>0)
{
sb.append(num%2);
num=num/2;
}
System.out.println(sb.reverse());
}
数组（进制转换-十进制-十六进制）：
public static void TenToSixteen(int num)
{
StringBuffer sb=new StringBuffer();
for(int i=0;i<8;i++)
{
int temp=num&15;
if(temp>9)
{
sb.append((char)(temp-10+'A'));
}
else
{
sb.append(temp);
}
num=num>>>4;
}
System.out.println(sb.reverse());
}
数字（查表法-十进制-十六进制）：
除了StringBuffer的reverse可以翻转顺序，还可以用数组来完成存储。
/*
查表法-十进制to十六进制
按顺序存储
*/
public static void TenToSixteen2(int num)
{
char[] table={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char[] array=new char[8];
int pos=0;
while(num!=0)
{
int temp=num&15;
array[pos++]=table[temp];
num=num>>>4;
}
for(int i=pos-1;i>=0;i--)
{
System.out.print(array[i]);
}
}
/*
查表法-十进制to十六进制
按反序存储
*/
public static void TenToSixteen3(int num)
{
char[] table={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char[] array=new char[8];
int pos=array.length;
while(num!=0)
{
int temp=num&15;
array[--pos]=table[temp];
num=num>>>4;
}
for(int i=pos;i<array.length;i++)
{
System.out.print(array[i]);
}
}
数字（查表法-十进制-2进制）：
/*
查表法：十进制-二进制
反序存储
*/
public static void TenToTwo2(int num)
{
char[] table={'0','1'};
char[] array=new char[32];
int pos=array.length;
while(num!=0)
{
int temp=num&1;
array[--pos]=table[temp];
num=num>>>1;
}
for(int i=pos;i<array.length;i++)
{
System.out.print(array[i]);
}
}
数组（进制转换优化）：
public static void trans(int num,int base,int offset)
{
if(num==0)
{
System.out.println(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.println(arr[x]);
}
}
数组（二维数组）：
格式1：int[][] array=new int[3][2];
格式1定义了名称为array的二维数组，二维数组中有三个一维数组，每一个数组中有三个元素。
格式2：
int[][] array=new int[3][];
array[0]=new int[3];array[0]=new int[1];array[0]=new int[2];
格式2就好比C#中的锯齿数组。
二维数组的长度是行数。
二维数组中第一行（第一个数组）的长度array[0].length;
其他格式：
int[][] array={{3,5,1,7},{2,3,5},{6,1,8,2}};
或：
int[] x[];也是二维数组的定义，不建议这种定义方法。
遍历二维数组：(求和)
for(int i=0;i<array.length;i++)
{
for(int j=0;j<array[i].length;j++)
{
sum=sum+array[i][j];
}
}
