黑马程序员_day05_数组的操作及应用

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

数组应用中常见的错误提示：Array Index Out of Bounds Exception ：当访问到数组中不存在角标时，就会在运行时发生该角标越界异常。

Null Point Exception：空指针异常。当引用型变量没有任何实体指向时，还再该变量操作具体的实体时，就会发生该异常。

这些错误都是在运行时期发生的。编译时不会，因为没有语法错误，编译时不会在内存中创建实体。

数组的另一定义方式。

在数组定义时，既明确了数组的长度、类型，还明确了元素的内容。

格式：元素类型[ ] 数组名=new 元素类型[ ]{元素，元素，---}

int[ ] arr = new int [ ] {2,6,9};还可以写成int [ ] arr = {2,6,9};直接大括号。

通过数组实体具备的一个属性--length，直接获取数组的长度。

操作数组的核心思想：角标。 通过角标就可以对数组中的元素进行访问（设置和获取）

通过数组操作的最基本动作：遍历。通过循环操作数组。

从前向后遍历：for(int x=0 ,x<arr.length;x++)

从后向前遍历：for(int x= arr.length-1;x>=0;x++)

数组常见的操作

一、获取数组中的最大值、最小值。

思路：1、互相比较。2、两个元素相比，获取较大的那个和下一个继续比，以此类推，最终出现最大值。

步骤：1、每次比完，哪个是较大的元素不确定，需要定义一个变量进行记录。该变量需要初始化，初始化为数组中的任一元素。

2、每一个元素都要和该位置记录的元素进行依次比较。需要取出数组中的每一个元素。需要变量，for循环。

3、遍历过程中，需要判断，将较大值存储到变量中。

4、循环结束，最大值出现在该变量中。

需要定义一个功能来进行最大值的获取

1、明确结果。既然数组是int类型，那么结果为int类型

2、明确未知内容。数组是未知，所以参数列表是数组类型。

public static int getMax(int [] arr )

{

int max=arr[0]

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

{

if(arr[x]>max])

max=arr[x];

}return max;

}

另一种方式：

public static int getMax_2(int[]arr)

{

int maxIndex=0;

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

{

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

{

maxIndex=x;

}

}return arr[maxIndex];

}

二、排序

选择排序

public static void selectsort(int[]arr)

{

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-1-x;y++)

{

if (arr[y]>arr[y+1])//(从小到大排)

{

int temp=arr[y];

arr[y]=arr[y+1];

arr[y+1]=temp;

}

}

}

}若不涉及性能优化，这种思想方式易记忆。

For表达式部分也可写成for(int x=arr.length-1;x>0;x--)

{

for(int y=0;y<x;y++)

----------

}

数组中元素的置换

public static void swap(int []arr,int a,int b)

{

int temp=arr[a];

arr[a]=arr[b];

arr[b]=temp;

}

三、二分查找（折半查找）

1、查找一个元素在数组中的位置

思路：直接对数组遍历，遍历过程中需要对要找元素进行判断。如果遍历的元素和要找的元素相等，说明存在，返回该元素角标即可。

如果没有找到，可以用-1来表示没有找到的情况。

步骤：1、定义一个功能

明确结果：角标 int

明确未知内容：数组、要找的元素

2、函数的具体实现

通过循环遍历数组，在循环中进行判断

public static int getIndex(int[]arr,int key)

{

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

{

if (arr[x]==key)

return x;

}return -1;（若没有这一句，编译不会通过，因为函数会缺少返回值）

}

二分查找：前提：对有序数组进行查找

public static int binarySearch(int[]arr,int key)

{

//需要定义三个变量，用于记录角标的变化。

int min,max,mid;

min=0;//头角标

max=arr.length-1;//尾角标

//只要min<=max就有继续折半的可能。

while (min<=max)

{

//mid是变化，是随着循环而变化的，定义在循环内。

mid=(min+max)>>>1;//获取中间角标值

//获取到的中间角标元素和key进行比较，来确定min和max的新值

if (key>arr[mid])

min=mid+1;

else if (key<arr[mid])

max=mid-1;

else

return mid;

}return -1;

}

二分查找的另一种写法

public static int binarySearch(int[]arr,int key)

{

int min,max,mid;

min=0;

max=arr.length-1;

mid=(min+max)>>>1;

while (arr[mid]!=key)

{

if (key>arr[mid])

{

min=mid+1;

}

else if (key<arr[mid])

{

max=mid-1;

}

if (min>max)

return -1;

mid=(min+max)>>>1;

}return mid;

}

二分练习

有一个有序数组，要求在该数组中添加一个元素，还能继续保持这个数组有序，元素位置如何获取。

思路：1、数组有序，还要获取位置，即查找，可用二分查找

2、如果插入元素在数组中存在，只要找到元素在数组中的位置即可。

3、如果元素在数组中不存在，位置在头角标即可，只是将return-1改为return min即可。

给定的数组中的元素进行反转

思路：1、反转其实就是头尾角标的元素进行位置置换

2、然后让头角标自增，尾角标自减，再继续位置置换

3、以此类推，直至头角标>=尾角标结束

public static void reverseArry(int[]arr)

{

for (int start=0,end=arr.length-1;start<end ;start++,end-- )

{

int temp=arr[start];

arr[start]=arr[end];

arr[end]=temp;

}

}

四、数组应用之进制转换

查表法：我们发现，十六进制中一共有十六个元素，而且没通过&15获取的数值都在15内，都有对应的十六进制元素。而元素对应的数字恰好有规律，既符合数组这种容器的特点角标。

那么可将十六进制的元素都存储到数组中，将每次&15的结果作为角标来查找这个数组，就可获取对应的十六进制元素。

查表法的使用：元素很多时，而且这些元素与数字有对应关系，而且这些数字都有角标的规律，这时优先考虑查表法。

进制转换

public static void trans(int num,int base,int offset)

{

if (num==0)

{

System.out.println(0);

return;

}

//数组建表思想：元素和角标是否有规律

char[]arr={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

//数组存储思想：定义数组存储用指针来操作数组元素。

char[]chs=new char[32];

int pos =chs.length;

while (num!=0)

{

int temp=num&base;

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

num>>>=offset;

}

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

{

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

}System.out.println();

}

public static void toBin(int num)

{

     trans(num,1,1);

}

public static void toOctal(int num)

{

trans(num,7,3);

}

public static void toHex(int num)

{

    trans(num,15,4);

}

开发时使用的数组排序：class前加上import java .util.*;

Main函数中Arrays.sort(arr);（java提供的数组排序方式。）

开发时使用的进制转换 

System.out.println(Integer.toBinaryString(6));对6进行2进制的转换

System.out.println(Integer.toOctalString(6));对6 进行 8进制的转换

System.out.println(Integer.toHexString(6));  对6 进行 16进制的转换

----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------------------