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];       }}