黑马程序员-Java基础知识-day04

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

数组的常见操作

1.遍历

class ArrayDemo{      public static void main(String[] args)      {             //数组的操作：获取数组中的元素，通常会用到遍历             //int[]arr = new int[3];             int[]arr = {3,6,4,1,9,6,0};             //数组中有一个属性可以直接获取到数组元素个数：length。             //使用方式：数组名称.length             /*             for(int x=0; x<arr.length; x++)             {                    System.out.println("arr["+x+"]="+arr[x]+";");             }             */             printArray(arr);      }

//定义一个打印数组的方法(函数)

public static void printArray(int[] arr)      {             System.out.print("[");//为了输出的结果好看，这里直接输出一个正括号             for(int x=0; x<arr.length; x++)             {                    if(x!=arr.length-1)//只要x不等于数组的最后一个元素，就输出一个数组元素和一个逗号                           System.out.print(arr[x]+",");                    else                           System.out.println(arr[x]+"]");             }      }}

小结：length:可以直接获取数组元素的个数或者长度。

2、获取最值

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

1.获取数组中的最大值，以及最小值。

获取数组中的最大值。

思路：

1.获取最值需要进行比较，每一次比较都会有一个较大的值，因为该值不确定，通过一个变量进行临存。

2.让数组中的每一个元素都和这个变量中的值进行比较，如果大于了变量中的值，就用该变量记录较大值。

3.当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。

步骤：

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

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

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

需要定义一个功能来完成，以便提高函数复用性。

1.明确结果，数组中的最大值

2.未知内容，一个数组，int[]

*/

class ArrayTest{      public static int getMax(int[] arr)      {             int max = arr[0];             for(int x=1; x<arr.length; x++)//之所以将x定义为1，是为了少比较一次             {                    if(arr[x]>max)                           max= arr[x];             }             return max;      }       //获取最值的另一种方法      //可不可以将临时变量初始化为0呢？可以，这种方式，其实是在初始化为数组中任意一个角标。      public static int getMax_2(int[] arr)//将需要操作的数组传递进来int[]arr      {             intmax = 0;             for(int x=1; x<arr.length; x++)             {                    if(arr[x]>arr[max])                           max= x;             }             return arr[max];      }      public static void main(String[] args)      {             int[]arr = {5,1,6,4,2,8,9};             int max = getMax(arr);             System.out.println("max="+max);      }}

小结：程序中定义的max,其实是可以定义两种方法的，第一种就是直接赋值为数组中的一个元素，即arr[0]，这样返回值就直接得到的是一个元素；第二种方法就是可以将其定义为数组元素中的一个角标，也就是arr[max],这样获取的值在经过arr数组封装后也能得到相应结果。通俗的说就是可以将max定义为数组中的元素或者角标。

 

3、常见排序方法

3.1选择排序法

对给定数组进行排序：{5,1,6,4,2,8,9}

class ArrayTest2{      //定义一个排序方法：选择排序法      //选择排序：内循环结束一次，最值出现在头角标的位置上。      public static void selectSort(int[] arr)      {//由于不需要比较到最后一个元素，因此这里可以将其长度-1，减少一次比较,提高效率             for(int x=0; x<arr.length-1; x++)             {                     for(int y=x+1; y<arr.length; y++)                {                           if(arr[x]>arr[y])                           {                                  int temp = arr[x];                                  arr[x]=arr[y];                                  arr[y]= temp;                           }                    }             }      }       //冒泡排序      public static void bubbleSort(int[] arr)      {             for(int x=0;x<arr.length-1; x++)             {                    for(int y=0;y<arr.length-x-1; y++)//-x：让每一次比较的元素逐渐减少，-1：避免角标越界                    {                           if(arr[y]>arr[y+1])                           {                                  /*                                  int temp = arr[y];                                  arr[y]= arr[y+1];                                  arr[y+1]= temp;                                  */                                  swap(arr,y,y+1);                           }                    }             }      }       //发现无论什么排序，都需要对满足条件的元素进行位置置换      //所以可以吧这部分相同代码提取出来，单独封装成一个函数      public static void swap(int[] arr,int a,int b)      {             int temp = arr[a];             arr[a]= arr[b];             arr[b]= temp;      }      public static void main(String[] args)      {             int[]arr = {5,1,6,4,2,8,9};             //排序前             printArray(arr);             //排序             //selectSort(arr);             bubbleSort(arr);             //排序后             printArray(arr); //Arrays.sort(arr);//java中已经定义好了一种排序方法，开发时就用这种排序方法      }       //定义一个遍历数组的方法      public static void printArray(int[] arr)      {             System.out.print("[");             for(int x=0; x<arr.length; x++)             {                    if(x!=arr.length-1)                           System.out.print(arr[x]+",");                    else                           System.out.println(arr[x]+"]");             }      }}

小结：

选择排序：头元素与后面的元素一一比较，也就是内循环结束一次，最值出现在头角标位置上；接着头元素自增，循环与后面的元素进行比较，即可得到排序结果。大圈套小圈，尖朝下，改变内循环初始值

冒泡排序：相邻的两个元素进行比较，如果符合条件就换位。大圈套小圈，尖朝上，改变内循环条件

4、数组的查找操作：折半查找

练习：有一个有序的数组，想要将一个元素插入到该数组中，还要保证该数组是有序的，如何获取该元素在数组中的位置？

class ArrayTest4{      //定义功能，获取key第一次出现在数组中的位置，如果返回是-1，那么代表该key在数组中不存在。      public static int getIndex(int[] arr,int key)      {                 int min=0;//定义需要插入未知的初始化角标             for(int x=0; x<arr.length; x++)             {                    if(arr[x]==key)                           return x;             }             return-1;//由于数组中不存在-1这个角标，因此返回-1则说明该数组中没有这个元素，即表示错误      }       //折半查找：提高效率，但是必须要保证数组是有序的数组      public static int halfSearch(int[] arr,int key)      {             int min,max,mid;             min= 0;             max= arr.length-1;             mid= (min+max)/2;             while(arr[mid]!=key)             {                    if(key>arr[mid])                           min= mid+1;                    elseif(key<arr[mid])                           max= mid-1;    if(min>max)           return -1;                    mid= (max+min)/2;//循环确定中间值的大小             }             return mid;      }       //折半的第二种方式      public static int halfSearch_2(int[] arr,int key)      {             int min=0,max = arr.length-1,mid;             while(min<=max)             {                    mid= (min+max)/2;                    if(key>arr[mid])                           min= mid+1;                    elseif(key<arr[mid])                           max= mid-1;                    else                           return mid;             }             return -1;      }      public static void main(String[] args)      {             int[]arr = {3,5,6,7,8,9};             //int index = getIndex(arr,0);             int index = halfSearch_2(arr,6);             System.out.println("index="+index);      }}

面试题：有一个有序的数组，想要将一个元素插入到该数组中，还要保证该数组是有序的，如何获取该元素在数组中的位置？

解答：可以通过折半查找的方法，确定需要插入的数的角标，继而将原本返回为-1的那句改成min即可

public static int halfSearch_2(int[]arr,int key)      {             int min=0,max = arr.length-1,mid;             while(min<=max)             {                    mid= (min+max)/2;                    if(key>arr[mid])                           min= mid+1;                    elseif(key<arr[mid])                           max= mid-1;                    else                           return mid;             }             return min;//返回的这个min就是需要插入的数的角标      }

小结：

需要值得注意几点的是，在折半查找的方法中，首先就是需要确定要折半的数组是有序的，其次，在定义好一个标记key后，与折半的最大、小值相比较，继而突出折半的原理，而在查找的过程中，还需将中间值角标mid=(min+max)/2一次，防止出现死循环。

5、进制转换

class ArrayTest5{      public static void main(String[] args)      {             //toBin(6);             toHex(60);      }     //十进制-->二进制public static void toBin(int num){//定义一个容器，用于存储数据StringBuffer sb = new StringBuffer();while(num>0){sb.append(num%2);//将num%2的值添加到容器中num = num/2;}System.out.println(sb.reverse);//将得到的数据反转}      //十进制-->十六进制      publicstatic void toHex(int num)      {//定义一个容器，用于存储数据             StringBuffer sb = new StringBuffer();              for(int x=0; x<8; x++)//由于取的是最低4位，而在十六进制中有4组八位，因此这里的x<8             {                    inttemp = num & 15;//之所以num&15,是为了得到其最低4位                    if(temp>9)                           //System.out.println((char)(temp-10+'A'));                           sb.append((char)(temp-10+'A'));                    else                           //System.out.println(temp);                           sb.append(temp);                    num= num >>> 4;//无符号往右移4位             }             System.out.println(sb.reverse());      }}

//查表法 

class ArrayTest6{      public static void main(String[] args)      {             toHex(60);      }      /*             01 2 3 4 5 6 7 8 9 A  B  C D  E  F           -->十六进制中的元素             01 2 3 4 5 6 7 8 9 10 11 12 13 14 15              查表法：将所有的元素临时存储起来，建立对应关系。             每一次&15后的值作为索引去查建立好的表，就可以找对应的元素。             这样比-10+‘A’简单得多              这个表该怎么建立呢？可以通过数据的形式来定义。      */       public static void toHex(int num)      {             char[]chs = {'0','1','2','3',                                         '4','5','6','7',                                         '8','9','A','B',                                         'C','D','E','F'};             //定义一个临时容器             char[]arr = new char[8];             int pos = arr.length;             //for(intx=0; x<8; x++)             while(num!=0)             {                    int temp = num & 15;                    //System.out.println(chs[temp]);                    arr[--pos]= chs[temp];                    num= num >>> 4;             }              //存储数据的arr数组遍历             for(int x=pos; x<arr.length; x++)             {                    System.out.print(arr[x]+",");             }      }}

//查表法

class ArrayTest6{      public static void main(String[] args)      {             //toHex(60);             toBin(6);      }       /*      十进制-->二进制      */      public static void toBin(int num)      {             //定义一个二进制表             char[]chs = {'0','1'};              //定义一个临时容器             char[]arr = new char[32];              //定义一个操作数组的指针             int pos = arr.length;             while(num!=0)             {                    int temp = num & 1;                    arr[--pos]= chs[temp];                    num= num >>> 1;             }              for(int x=pos; x<arr.length; x++)             {                    System.out.print(arr[x]);             }      }        /*      十进制-->十六进制             01 2 3 4 5 6 7 8 9 A  B  C D  E  F           -->十六进制中的元素             01 2 3 4 5 6 7 8 9 10 11 12 13 14 15              查表法：将所有的元素临时存储起来，建立对应关系。             每一次&15后的值作为索引去查建立好的表，就可以找对应的元素。             这样比-10+‘A’简单得多              这个表该怎么建立呢？可以通过数据的形式来定义。      */       public static void toHex(int num)      {             char[]chs = {'0','1','2','3',                                         '4','5','6','7',                                         '8','9','A','B',                                         'C','D','E','F'};             //定义一个临时容器             char[]arr = new char[8];             int pos = arr.length;             //for(int x=0; x<8; x++)             while(num!=0)             {                    int temp = num & 15;                    //System.out.println(chs[temp]);                    arr[--pos]= chs[temp];                    num= num >>> 4;             }              //存储数据的arr数组遍历             for(int x=pos; x<arr.length; x++)             {                    System.out.print(arr[x]+",");             }      }}

class ArrayTest7{      public static void main(String[] args)      {             //toBin(6);             //toBa(60);             toHex(60);      }       /*      十进制-->二进制      */      public static void toBin(int num)      {             trans(num,1,1);      }       /*      十进制-->八进制      */      public static void toBa(int num)      {             trans(num,7,3);      }       /*      十进制-->十六进制      */      public static void toHex(int num)      {             trans(num,15,4);      }      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];              intpos = arr.length;              while(num!=0)             {                    int temp = num & base;                    arr[--pos]= chs[temp];                    num= num >>> offset;             }//直接将pos的值赋值给x             for(int x = pos; x<arr.length; x++)             {                    System.out.print(arr[x]);             }      }}

小结：在进制互转的过程中，指针很重要，为了让得到的数据时正着打印，这里可以定义一个pos指针，使其初始化值就为数组arr.length,继而让pos自减，即可得到一个正着打印的数组。

 

6、二维数组[][]

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

解析：

(1)定义了名为arr的二维数组；

(2)二维数组中有3个一维数组

(3)每个一维数组中有2个元素

(4)一维数组的名称分别为arr[0],arr[1],arr[2]

 

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

(1)二维数组中有3个一维数组

(2)每个一维数组都是默认初始化值null

(3)可以对这个三个一维数组分别进行初始化

arr[0] = new int[3];

arr[1] = new int[1];

arr[2] = new int[2];

格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};

(1)定义一个名称为arr的二维数组

(2)二维数组中有三个一维数组

(3)每一个一维数组中具体元素也都已初始化

arr[0] = {3,8,2};

arr[1] = {2,7};

arr[2] = {9,0,1,6};

(4)第三个一维数组的长度表示方式：arr[2].length;

class Array2Demo{      public static void main(String[] args)      {             /*             int[]arr = new int[3];//一维数组              int[][]arr = new int[3][4];//定义了名称为arr的二维数组，二维数组中有                                                //3个一维数组，每一个一维数组中有四个元素。               int[]][]arr = new int[3][];             arr[0]= new int[3];             arr[1]= new int[1];             arr[2]= new int[2];              System.out.println(arr.length);//打印是二维数组的长度：3             System.out.println(arr[0].length);//打印二维数组中第一个一维数组长度             */              int[][]arr = {{1,4,5,6},{2,5,6,3},{77,8,5,4}};             int sum = 0;             for(int x=0;x<arr.length; x++)             {                    for(int y=0;y<arr[x].length; y++)                    {                           sum= sum+arr[x][y];                    }             }             System.out.println("sum="+sum);      }}

一维、二维数组的常见写法：

一维数组：int[] x;          intx[];

二维数组：int[][] y; int y[][]; int[]y[];

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------
详细请查看：http://edu.csdn.net