Java笔记(八)……数组

数组的概念

同一种类型数据的集合。其实数组就是一个容器。

数组的好处

可以自动给数组中的元素从0开始编号，方便操作这些元素。

数组的格式

元素类型[] 数组名 = new 元素类型[个数];

int[] arr = new int[5];

元素类型[] 数组名 = new 元素类型[]{元素1,元素2,……};

int[] arr = new int[]{1,3,5,7};

元素类型[] 数组名 = {元素1,元素2,……};

int[] arr = {1,3,5,7};

内存结构

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，又对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈内存：

用于存储局部变量，当数据使用完，所占空间会自动释放。

堆内存：

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

每一个实体都有内存地址值

实体中的变量都有默认初始化值

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

数组的内存结构

二维数组

格式

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

格式二：int[][] arr = new int[2][];

格式三：int[][] arr = {{2,3,4}{5,6,7}};

特殊格式：int[] x,y[];:此处，x为一维数组，y为二维数组

数组的常见操作

冒泡排序

   1: class Sort

   2: {

   3:     private Sort(){}

   4:  

   5:     //exchange

   6:     private static void exchange(int[] arr,int x,int y)

   7:     {

   8:         arr[x] = arr[x]^arr[y];

   9:         arr[y] = arr[x]^arr[y];

  10:         arr[x] = arr[x]^arr[y];

  11:     }

  12:  

  13:     //bubble sort

  14:     public static void bubbleSort(int[] arr)

  15:     {

  16:         for(int x = 0 ; x < arr.length-1 ; x ++)

  17:         {

  18:             for(int y = 0 ; y < arr.length-x-1 ; y ++)

  19:             {

  20:                 if(arr[y] > arr[y+1])

  21:                 {

  22:                     exchange(arr,y,y+1);

  23:                 }

  24:             }

  25:         }

  26:     }

  27:  

  28:     //print arr

  29:     public static void printArr(int[] arr)

  30:     {

  31:         for(int x = 0 ; x < arr.length ; x ++)

  32:         {

  33:             if(x != arr.length-1)

  34:                 System.out.print(arr[x]+",");

  35:             else

  36:                 System.out.println(arr[x]);

  37:         }

  38:     }        

  39: }

  40: class SortDemo 

  41: {

  42:     public static void main(String[] args) 

  43:     {

  44:         int[] arr = {8,7,6,5,4,3,1,2};

  45:  

  46:         Sort.printArr(arr);

  47:  

  48:         Sort.bubbleSort(arr);

  49:  

  50:         Sort.printArr(arr);

  51:     }

  52: }

折半查找

   1: class Search

   2: {

   3:     private Search(){};

   4:  

   5:     //half search

   6:     public static int halfSearch(int[] arr,int key)

   7:     {

   8:         int min,mid,max;

   9:         

  10:         min = 0;

  11:         max = arr.length-1;

  12:         

  13:  

  14:         while(max >= min)

  15:         {

  16:             mid = (min+max)/2;

  17:  

  18:             if(key < arr[mid])

  19:                 max = mid - 1;

  20:             if(key > arr[mid])

  21:                 min = mid + 1;

  22:             if(key == arr[mid])

  23:                 return mid;

  24:         }

  25:         return -1;

  26:     }

  27:  

  28: }

  29: class SearchDemo 

  30: {

  31:     public static void main(String[] args) 

  32:     {

  33:         int[] arr = {1,2,3,4,5,6,7,8,9};

  34:  

  35:         int index = Search.halfSearch(arr,10);

  36:  

  37:         if(index == -1)

  38:             System.out.println("No key in this arr!");

  39:         else

  40:             System.out.println("index = "+index);

  41:     }

  42: }

幸运儿问题

   1: /*

   2: 10个小孩围成一圈，从第一个小孩算起，数到3，

   3: 则第三个小孩出列，接着向下数，数到3，

   4: 则该小孩出列，求最后留下的小孩是哪个

   5: */

   6:  

   7: class LuckyNumber 

   8: {

   9:     public static void main(String[] args) 

  10:     {

  11:         findLuck(10);

  12:     }

  13:  

  14:     public static void findLuck(int num)

  15:     {

  16:         int[] arr = new int[num];

  17:         

  18:         for(int i = 0 ; i < arr.length ; i ++)

  19:         {

  20:             arr[i] = 1;

  21:         }

  22:         //用于实际计数

  23:         int pos = 0;

  24:         //最终需要出圈的人数

  25:         int size = num;

  26:         

  27:         while(true)

  28:         {

  29:             for(int i = 0 ; i < arr.length ; i ++)

  30:             {

  31:                 pos++;

  32:                 if(arr[i] == 0)

  33:                     pos--;

  34:                 else if(pos%3 == 0)

  35:                 {

  36:                     arr[i] = 0;

  37:                     size--;

  38:                     //当所有人都出去之时，最后一个即为结果

  39:                     if(size == 0)

  40:                     {

  41:                         System.out.println("index = "+i);

  42:                         return;

  43:                     }

  44:                 }    

  45:             }

  46:         }

  47:     }

  48: }