java基础知识-(数组)

Java数组

一.  概述

  1.     定义:数组是一种数据结构,用来存储同一类型值的集合。

  2.     数组是存在下标索引的,通过下标可以获取指定位置的元素,数组小标是从0开始的,也就是说下标0对应的就是数组中第1个元素,可以很方便的对数组中的元素进行存取操作。

  3.     数组存在一维数组和多维数组。

二.  一维数组 

  1.     声明方式一

    A.     数据类型   数组名   =   new 数据类型[个数]     

           String s[] = new String[10];

    定义了一个长度为10的String类型的一维数组。

    B.     数据类型[]   数组名  =   new 数据类型[个数]

           String[] s = new String[10];

    定义了一个长度为10的String类型的一维数组。

    数组属于引用数据类型,它指向的是内存中的一个对象的地址。只要使用new对象产生一个对象或数组都会在堆内存中创建一块内存空间,然后将这块空间的内存地址赋给引用变量,

    以上只是声明创建一个大小为10的数组,但是没有给每一个元素赋值,所以体现出来的都是这个数据类型的默认值,即String类型的默认值为null。 

  2.     声明格式二

   A.     数据类型  数组名[]  = {元素1,元素2,元素3,……数值n};

                           int  a[] = {1,3,6,0,2,8,10};
   声明一个为数组长度为7的int类型数组,并静态的为数组每一个小标对应的元素赋值。

     B.     数据类型[]  数组名  =  {元素1,元素2,元素3,……数值n};
        int[] a = {1,3,6,0,2,8,10};

   声明一个为数组长度为7的int类型数组,并静态的为数组每一个小标对应的元素赋值。

  3.     创建一个匿名数组

      new int[]{1,3,6,0,2,8,10};

  4.     数组与数组之间的赋值关系

      String s[] = new String[10];

     String t[] = s;

   

  5.     一维数组长度:数组名.length

  6.     一维数组的有效最大角标:数组名.length-1

三.  二维数组

  1.     定义:

    二维数组实际上是指数组元素为一维数组的一维数组,简单说也就是数组中的数组。

  2.     声明格式一  

    数据类型  数组名[][] =  new  数据类型[个数][个数];

    数据类型[][]   数组名= new    数据类型[个数][个数];

    int arry[] [] = new int[5][6];

  上述语句声明了一个二维数组,其中[5]表示该数组有(0~4)5行,每行有(0~5)6个元素,因此该数组有30个元素,其中[5]也可说是有5个一维数组,

  [6]可以说是每一个一维数组中有6个int型号的元素。

  数组new出来后,就在堆内存中开辟的内存空间,并将所在内存空间地址返回给arry数组变量,因为以上语句只是声明了一个数组并未没一个元素赋值,

  所以都是类型默认值,为0。

  array[0][0]=3;即给第一个一维数组中的第一个元素赋值.

  

  依此方式还可以和其他元素赋值。

  3.     声明格式二   

    int[][] arr = new int[3][];

    此二维数组中含有3个一维数组,每个一维数组的默认初始化值都为null,每个一维数组中的元素值都为0;可对每个一维数组赋值,如:
      arr[0] = new int[3];

      arr[1] = new int[2];

       arr[2] = new int[1];

    对每个一维数组中某个元素赋值:如:

               arr[0][2]=90;

               arr[1][1]=89;

               arr[2][2]=78;

  

  4.     声明格式三  

    显式初始化二维数组:int[][] arr = {{1,5,7},{4,8},{3,9,20,12}}

      A.     以上数组定义了一个长度为3的数组,arr.length=3

      B.     数组中第一维数组的长度:arr[0].length=3

 

四.  数组的应用代码

  1. 获取一个数组中的最大值和最小值  

 1 public class ArrayMaxMinValue  {  
 2     public static void main(String[] args)  {  
 3         int[] array = {7,9,6,3,9,8,0,10,2,1};  
 4         System.out.println("最大值: "+getMaxValue(array));  
 5         System.out.println("最小值: "+getMinValue(array));  
 6     }  
 7     public static int getMaxValue(int 8         int max = a[0];//一开始假设最大值为a[0]  
 9         for(int i = 1 ; i < a.length ;i++)  {  
10               if(a[i] > max)  {  
11                      max = a[i];//每一次比较将大值赋值给max变量存储  
12                }  
13          }  
14        return max;  
15     }  
16      public static int getMinValue(int a[]) {  
17            int min = 0;//一开始假设最小值为角标为0的元素  
18            for(int i = 1 ; i < a.length ;i++)  {  
19                 if(a[i] < a[min])  {  
20                     min = i;//每一次比较将最小值的角标赋值给min变量存储  
21                  }  
22             }  
23            return a[min];  
24      }  
25 }   

  2.对数组进行排序

 1 public class ArraySortTool  {  
 2        public static void main(String[] args)  {  
 3             int[] array = {7,9,6,3,9,8,0,10,2,1};  
 4             System.out.println("排序前:");  
 5             printArray(array);  
 6             bubblSort(array);  
 7             System.out.println("排序后:");  
 8             printArray(array);  
 9       }  
10        //选择排序  
11         public static void SelectSort(int[] a)  {  
12            //外层循环写成i < a.length-1,是因为选择排序,  
13           //当到最后一个元素的时候,就不需要进行选择排序的,因为数序已     经确定了  
14           for(int i = 0 ; i < a.length-1 ; i++)  {  
15              //内层循环写成i < a.length,是因为每一个选择用来比较的元素都要比较到最后//一个元素,  
16             //int j = i+1是因为没一个元素都不需要和自身比较  
17                for(int j = i+1 ; j < a.length ; j++)  {  
18                      if(a[i] > a[j])  {  
19                             //交换两个值  
20                         int temp = a[j];  
21                          a[j] = a[i];  
22                         a[i] = temp;  
23                      }  
24                }  
25           }  
26      }  
27       //冒泡排序  
28       public static void bubblSort(int a[])  {  
29          //a.length-1冒泡排序是每一次相邻两个元素进行比较,总共要比较a.length-1次  
30            //int i=0 是因为比较是从角标0开始的  
31           for(int i = 0 ; i < a.length-1; i++)  {  
32            //a.length-1-i,第一轮全部计较,每轮比较都产生一个最值,  
33               //下一轮这个最值就不用参与比较了  
34             //int j = i+1因为是相邻比较,所以要改成int j = i+1  
35                 for(int j = 0 ; j < a.length-1-i ; j++)  {  
36                    //因为是两两比较所以要写成a[j] > a[j+1]  
37                       if(a[j] > a[j+1])  {  
38                                int temp = a[j+1];  
39                               a[j+1] = a[j];  
40                               a[j] = temp;  
41                         }  
42                   }  
43             }  
44         }   
45         //用来打印数组  
46         public static void printArray(int a[] )  {   
47               System.out.print("[");  
48              for(int i = 0 ; i < a.length ; i++)  {  
49                   if(i == a.length-1)  {  
50                        System.out.println(a[i]+"]");  
51                   }  
52                   else  {  
53                        System.out.print(a[i]+",");  
54                    }   
55              }  
56         }  
57 }  

  3.查找数组中指定值的索引位置

  

 1 public class ArraySearchTool  {  
 2          public static void main(String[] args)  {  
 3               int[] array = {1,5,9,11,20,21,25,30};  
 4               System.out.println(halfSearch2(array , 25));  
 5               // System.out.println(oneByoneSearch(array , 10));  
 6          }  
 7           //遍历判断查找  
 8           public static int oneByoneSearch(int[] a , int value)  {  
 9                     for(int i = 0 ; i < a.length ; i++)  {  
10                           if(a[i] == value)  {  
11                                     return i;  
12                           }  
13                      }  
14                      return -1;  
15            }  
16           //二分查找1  
17            public static int halfSearch(int[] a , int value)  {  
18                   int left = 0;  
19                   int right = a.length-1;  
20                   int mid = (left+right) >> 1;  
21                   while( a[mid] != value)  {   
22                           if(a[mid] > value)  {  
23                                   right = mid-1;  
24                            }  
25                          else  {  
26                                 left = mid+1;  
27                           }  
28                          if(left > right)  {  
29                                return -1;  
30                           }  
31                           mid = (left+right)>>1;  
32                   }  
33                  return mid;  
34           }  
35            //二分查找2  
36           public static int halfSearch2(int[] a, int value)  {  
37                   int left = 0;  
38                   int right = a.length-1;  
39                   int mid;  
40                   while( left <= right)  {  
41                           mid = (left+right) >> 1;  
42                          if(a[mid] == value)  {  
43                                 return mid;  
44                           }  
45                         else if(a[mid] > value)  {  
46                                 right = mid -1;  
47                         }  else  {  
48                                left = mid+1;  
49                         }  
50                   }  
51                return -1;  
52          }  
53 }      

五:  编写一个类,类中提供方法可以将任何int类型的数值做八进制、二进制、十六进制转换

  

 1 public class toBintoHextoOctalDemo  {  
 2     
 3       public static void main(String[] args)  {  
 4 
 5             System.out.println(toBintoHextoOcta( 500 , 15 , 4 ));  
 6    
 7        }  
 8   
 9         public static String toBintoHextoOcta( int n , int a , int m ) {  
10              char[] c = { '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F' };  
11              char[] ch = new char[32];  
12             StringBuilder sb = new StringBuilder();  
13             int pos = ch.length;  
14             while( n != 0)  {  
15                   ch[--pos] = c[ n & a ];  
16                   n = n >>> m ;  
17             }  
18             for(int i = pos ; i < ch.length ; i++)  {  
19                    sb.append(ch[i]);  
20              }  
21              return sb.toString();  
22         }   
23 }      

 

六    扩展应用

  int[] x ,y[];  àx一维数组,y二维数组。

  拆解步骤:

    int[] x;

    int[] y[];

    A.     x[0] = y;错误

    B.     y[0] = x;正确

    C.     y[0][0]=X;错误

    D.    x[0][0] =y;错误

    E.     y[0][0] =x[0]正确

posted @ 2017-09-23 13:30  huster-stl  阅读(369)  评论(0编辑  收藏  举报