黑马Java学习笔记之-----数组

---------------------- android培训java培训期待与您交流! ----------------------

 

概念:同一种数据类型的集合。

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

定义一个新的数组:

int[] arr=new int[4]  或者   int[] arr={2,3,4,5};

一、使用for循环对数组遍历,并打印其元素,需要用到数组的属性.length

 

 1 class ArrayDemo
 2 
 3 {
 4 
 5      public static void main(String[] args)
 6 
 7     {
 8 
 9           int arr[]={1,2,4,5}
10 
11           printArray(arr);
12 
13     }
14 
15     public static void printArray(int[] arr)
16 
17     {
18 
19         for(int x=0;x<arr.length;x++)
20 
21         {
22 
23              if(x!=arr.length-1)
24 
25                  System.out.println(arr[x]+",");
26 
27          }
28 
29          else
30 
31              System.out.print(arr[x]);
32 
33      }
34 
35 }

二、获取数组的最大值。

    以数组arr第一个元素arr[0]为最大值max的初始值,一旦遍历到大于或等于max的元素,就将元素的数值赋值于max,for循环遍历,找到最大值

   

 1 public static void getMax(int arr)
 2 
 3    {
 4 
 5        int max=arr[0];
 6 
 7        for(int x=0;x<arr.length-1;x++)
 8 
 9        {
10 
11           if(arr[x]>max)
12 
13              max=arr[x];
14 
15         }
16 
17         return (max);
18 
19    }

 

 

 

排序:

第一种:选择排序

使用第一个元素为基础,使用它和后面的元素比较,只要后面的元素比它小,就进行交换,这样,第一个元素在和后面元素比较并选择性交换的过程中,慢慢变小,最后,本质上,第一个元素已经成为整个数组最小的那个元素。上面的例子,也是获取最值,但是没有变化数组元素,而这个例子则是变化数组元素的顺序。然后再让第二个,第三个,第四个...元素成为剩下元素中最小的,最后形成一个从小到大的有序数组

 1 public static void selectSort(int[] arr)
 2 {
 3        for (int x=0;x<arr.length-1; x++ )
 4        {
 5              for (int y=x+1;y<arr.length ;y++ )
 6               {
 7                   if(arr[x]>arr[y])
 8                    {
 9                         int temp=arr[x];
10                         arr[x]=arr[y];
11                          arr[y]=temp;
12                    }
13               }
14        }
15 }

 

第二种:冒泡排序

将最大元素往数列尾部驱赶的过程,最后将最大元素驱赶到最后一个元素,先将第一个和第二个比较,如果第一个大于第二个就交换(向后驱赶),然后第二个和第三个比较。。。上面的例子却是通过选择性交换,将最小元素最终找到,并放在第一个位置。然后再将驱赶,将次大的元素驱赶到倒数第二个位置,然后是第三大的...

 1 public static void bubbleSort (int[] arr)
 2 {
 3          for (int x=0;x<arr.length-1 ;x++ )
 4           {
 5                 for (int y=0;y<arr.length-x-1;y++ )
 6                 {
 7                       if(arr[y]>arr[y+1])
 8                        {
 9                               int temp=arr[y];
10                               arr[y]=arr[y+1];
11                                arr[y+1]=temp;
12                           }
13                 }
14           }
15 }

 

折半查找,有序数组,需要理解原理,注意两个条件

1当x=arr[mid]时候,就可以做出判断

2当min>max时,数值不属于本数组

 1 public static int halfSearch1 (int[] arr,int x)
 2 {
 3           int min=0,max=arr.length-1,mid=(min+max)/2;
 4           while(min<=max)
 5           {
 6                  if(x>arr[mid])
 7                        min=mid+1;
 8                  else if(x<arr[mid])
 9                        max=mid-1; 
10                   else
11                          return mid;
12                          mid=(min+max)/2;
13 
14 
15             }
16              return -1 ;
17 }

 

进制转换

十进制转16进制,使用了以前的方法,就是右移4位!并使用新函数StringBuffer将数值装入,并反转打印

 1 public static void toHex1(int num)
 2 {
 3        StringBuffer sb=new StringBuffer();
 4 
 5        for (int x=0;x<8 ;x++ )//x保证循环8次
 6        { 
 7              int temp=num&15;
 8              if (temp>10) 
 9                   sb.append((char)('A'+temp-10));
10             else
11                   sb.append(temp);
12             num=num>>>4
13        }
14        System.out.println(sb.reverse());
15 
16 }

 

使用列表法,先定义临时容器,来存储数值,然后再反向打印,如下

 1 public static void toHex3(int num)
 2 {
 3      char[] chs={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
 4      char[] arr= new char[8];
 5      int pos=0;
 6      while(num!=0)
 7      {
 8 
 9           int temp=num&15;
10           arr[pos]=chs[temp];
11           num=num>>>4;
12            pos++;
13     }
14     for (int x=arr.length-1;x>=0 ;x-- )
15    {
16          if (arr[x]!=0) 
17               System.out.print(arr[x]+" ");
18    }
19 
20 }

 

形成一个通用函数,简化进制转换过程

 1 class TransAll
 2 {
 3       public static void main(String[] args) 
 4       {
 5              toBin(60);
 6              toBa(60);
 7              toHex(60);
 8        }
 9      //2进制
10       public static void toBin(int num)
11       {
12              trans(num,1,1);
13       }
14      //8进制
15      public static void toBa(int num)
16      {
17             trans(num,7,3);
18        }
19      //16进制
20        public static void toHex(int num)
21       {
22            trans(num,15,4);
23       }
24    //通用格式
25       public static void trans(int num,int base,int offset)
26      {
27           if(num==0)//如果数值为零,转换进制也为零
28 
29           {
30                  System.out.println(0);
31                         return;
32            }
33             char[] chs={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};//定义一个数组,也就是列表
34 
35            char[] arr= new char[32];//定义一个可以存储数值的容器,因为二进制最多32位,所以定义32个元素的数组
36            int pos=arr.length;//定义接受数值的arr数组的角标初始值为数组元素数,比最大角标还大1
37            while(num!=0)
38 
39           {
40                 int temp=num&base;
41 
42                 arr[--pos]=chs[temp];//通过--pos将接受数值的arr数组的第一个角标变为最末元素角标。然后循环递减
43                 num=num>>>offset;
44          }
45 
46          for (int x=pos;x<arr.length ;x++ )//接受数值之后,数值已经成为正向,只需正向打印
47         {
48 
49                System.out.print(arr[x]);
50         }
51         System.out.println();
52 
53 }
54 }

 


---------------------- android培训java培训期待与您交流! ----------------------

 

posted @ 2013-04-29 02:02  Mercy_K  阅读(127)  评论(0编辑  收藏  举报