黑马程序员_数组

---------------------- <ahref="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<ahref="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

黑马程序员_数组

数组是相同类型的元素按顺序组成的一种复合数据类型

数组分一维数组和多维数组（以二维数组为例）

一维数组：

包含两个部分：数组的名字和数组元素的类型

 两种定义形式：dataType[]  arrayName :int [] arr

                               dataType arrayName[] : int arr []

dataTpye：值数据类型

arrayName:数组名称

数组长度：arrayName.length：arr.length

静态初始化：在声明一个数组的同时对该数组中的每个元素直接进行赋值。

int [] arr ={2,3,5};  int [] arr = new int[] {3,1,6,5,4}    “[]”内别写常数。

动态初始化：在声明一个数组类型对象时，只是通过NEW运算符为其分配所需的内容空间，而不对其元素赋值

                            Int [] arr= new int[3]

Int [] arr= new int[3]的角标只到2

编译时一定要注意：数组角标越界异常

默认初始化值为0:

 

二维数组：
即“数组的数组”

定义：int arr[] []

         或int [] [] arr

实例：静态int arr [] [] ={{1,2},{3,4},{5,6}}

          动态 int arr [] [] =new int[3] [2]

 

 则有： arr[0] [1] =2;

                    arr[2] [0]= 5;

        而 arr[3][2] 则越界

 

 

1遍历

获取数据是数组运用中最常见操作

通常会用到“遍历”

遍历：只要用角标挨个出示即可

运用“for”循环（可以释放x）

定义一个功能打印数组中的元素：printArray()

         Public static void printArray(int []arr)

         {

                 for(int x=0;x<arrlength,x++)

                  {

                            If（x!=arr.length-1）

                            System.out.print(arr[x]+”,”);

                   else

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

}

}

 

2获取最值

/*

要求：给定一个数组{5，1,6,4,2,8,9}

获取最大值以及最小值

思路：

         1获取最值需要进行比较。没比较一次就会有一个较大值。通过一个变量进行临时存储

     2让数组中的每一个元素都跟这个变量中的值进行比较

         如果大于变量中的值，就用该值记录较大值

         3当所有的元素都比较完成，呢么该变量中存储的救赎这一数组中的最大值了

步骤：

         1定义变量，初始化为数组中任意一个元素即可

         2通过循环语句对数组进行遍历

         3在遍历过程中定义判断条件，如果遍历到的元素比变量中的元素打，就赋值给该变量。

*/

class Test

{

         public static void main(String[] args)

         {

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

         getMax(arr);

         System.out.println("Max="+getMax(arr));

         System.out.println("----------------");

         getMin(arr);

         System.out.println("Min="+getMin(arr));

         }

         public static int getMax(int[] arr)

         {

                   int max = arr[0];

                   for(intx=0;x<arr.length;x++)

                   {

                            if(arr[x]>max)

                                     max =arr[x];

                  

                   }

                   return max;

         }

         public static int getMin(int[] arr)

         {

                   int min =arr[arr.length-1];//arrlength-1 是因为数组的角标是元素个数减一

                   for(intx=arr.length-1;x>0;x--)

                   {

                            if(arr[x]<min)

                                     min =arr[x];

 

                   }

                   return min;

 

         }

        

}

3排序（选择排序和冒泡排序，位置置换的功能）

排序也是比较：注意相同角标不需再比，还有当循环到最后一个角标时只剩他一个也不需要比了

 

冒泡排序：相邻的两个元素进行比较，如果符合条件换位子

public static voidselectsort(int[] arr)

         {

                  for(int x=0;x<arr.length-1;x++)//最后一个角标不需要比

                   {

                            for(inty=x+1;y<arr.length;y++)//相同角标不需要再比

                            {

                                     if(arr[x]>arr[y])

                                     {

                                     int temp=arr[x];

                                     arr[x]=arr[y];

                                     arr[y]=temp;

                                     }

                            }

                   }       

         }

位置置换的功能：

Public static voidswap(int[] arr,int a,int b )//置换赋予的值，对数组本身并没有关系

//我们要换的是数组中2个角标的值

{

         int temp = arr[a];

         arr[a] = arr[b];

         arr[b]=temp;

}

 

4折半查找

折半查找的前提是该数组必须是有序的

其实就是让该数于数组中间值比较，通过与中间值比较来减少比较次数

 

public static inthalfsearcher(int[] arr, int key)//因为要输出，所以此处要用“int”

         {

                   int min = 0,max =arr.length-1,mid;

                   while(min<=max)

                   {

                            mid =(min+max)>>1;//右移1位相当于除于2

                            if(key>arr[mid])

                                     min = mid +1;

                            elseif(key<arr[mid])

                                     max = mid-1;

                            else

                                     return mid;

 

                   }

                   return -1;//不存在时返还-1，因为数组中元素角标最小为0

 

         }

5.进制转化：

要运用查表法比较方便

 

十进制à二进制

/*

要求：将一个十进制数用二进制表示

 

思路：任何一个数在电脑里都是以二进制的形式存在的

         将所有元素临时存储起来，建立对应关系

         每次&1后的值作为索引去查建立的表。就可以找到对应的元素

         将对应的元素用一个数组存储起来

         倒序

 

*/

class Test3

 

{

         public static void main(String[] args)

 

         {

                   toBin(6);

         }

 

         public static void toBin(int num)

         {

                   char []brr={'0','1'};

                   char []arr= new char[32];//32个二进制位

                   int pos=arr.length;

 

                   while(num!=0)

                            {  int temp =num&1;

                               arr[--pos] =brr[temp];

                            num = num>>1;

                            }

                   for(int x =pos;x<arr.length;x++)

                            System.out.print(arr[x]);

                  

 

 

                           

                  

         }

}

十进制à十六进制

只是把&的值改成15，并且是右移4位，把数组内元素改成（123456789ABCDEF）

十进制à八进制

只是把&的值改成7，并且是右移3位，把数组内元素改成（1234567）

 

注意如何让数组只输出有效位:   for(int x =pos;x<arr.length;x++)//此时Pos是被减过的

                                                                 System.out.print(arr[x]);

 

 

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<ahref="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------