黑马程序员——JAVA学习日志4

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

1、数组操作常见问题

数组脚标越界异常(ArrayIndexOutOfBoundsException)
int[] arr = new int[2];
System.out.println(arr[3]);
访问到了数组中的不存在的脚标时发生。
空指针异常(NullPointerException)
int[] arr = null;
System.out.println(arr[0]);
arr引用没有指向实体，却在操作实体中的元素时。

2、数组常见操作

获取最值(最大值，最小值)

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

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

*/

class ArrayTest
{

 /*
 获取数组中的最大值。
 思路：
 1，获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定。
 通过一个变量进行临储。
 2，让数组中的每一个元素都和这个变量中的值进行比较。
 如果大于了变量中的值，就用该该变量记录较大值。
 3，当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。

 步骤：
 1，定义变量。初始化为数组中任意一个元素即可。
 2，通过循环语句对数组进行遍历。
 3，在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量；
 
 需要定义一个功能来完成。以便提高复用性。
 1，明确结果，数组中的最大元素 int。、
 2，未知内容：一个数组。int[]
 */
 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;
 }

 /*
 获取最大值的另一种方式。
 可不可以将临时变量初始化为0呢？可以。这种方式，其实是在初始化为数组中任意一个角标。

 */
 public static int getMax_2(int[] arr)
 {
  int max = 0;

  for(int x=1; x<arr.length; x++)
  {
   if(arr[x]>arr[max])
    max = x;
  }
  return arr[max];
 }

 /*
 获取最小值。
 */
 public static int getMin(int[] arr)
 {
  int min = 0;
  for(int x=1; x<arr.length; x++)
  {
   if(arr[x]<arr[min])
    min = x;
  }
  return arr[min];
 }

 //获取double类型数组的最大值。因为功能一致，所以定义相同函数名称。以重载形式存在。
 /*
 public static double getMax(double[] arr)
 {
  
 }
 */
 public static void main(String[] args)
 {
  int[] arr ={5,1,6,4,2,8,9};

  int max = getMax_2(arr);
  int min = getMin(arr);
  System.out.println("max="+max);
  System.out.println("min="+min);

//  boolean[] ar = new boolean[3];
//  System.out.println(ar[1]);
 }

}

排序（选择排序，冒泡排序）

 

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

*/
class ArrayTest2
{

 /*
 选择排序。
 内循环结束一次，最值出现头角标位置上。
 */
 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;
     */
     swap(arr,x,y);
    }
   }
  }
 }
 /*
 冒泡排序
 */

 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);

  //Arrays.sort(arr);//java中已经定义好的一种排序方式。开发中，对数组排序。要使用该句代码。
  //排序后：
  printArray(arr);
   
 }

 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]+"]");

  }  
 }
}

折半查找(二分查找)

/*
数组的查找操作。

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

*/
import java.util.*;
class ArrayTest4
{
 public static void main(String[] args)
 {
//  int[] arr = {3,2,1,5,4,2,9};
//  int index = getIndex(arr,2);
//  System.out.println("index="+index);

  int[] arr = {2,4,5,7,8,19,32,45};//8

  int index = getIndex_2(arr,190);
  System.out.println("index="+index);
  
//  int x = Arrays.binarySearch(arr,190);//java提供好的一个进行折半查找的功能。开发时使用这个。
//  System.out.println("x="+x);
  

 }

 public static int getIndex_2(int[] arr,int key)
 {
  int min = 0,max = arr.length-1,mid;

  while(min<=max)
  {
   mid = (max+min)>>1;

   if(key>arr[mid])
    min = mid + 1;
   else if(key<arr[mid])
    max = mid - 1;
   else
    return mid;
  }
  return min;
 }

 /*
 折半的第二种方式。
 */
 public static int halfSearch_2(int[] arr,int key)
 {
  int min = 0,max = arr.length-1,mid;

  while(min<=max)
  {
   mid = (max+min)>>1;

   if(key>arr[mid])
    min = mid + 1;
   else if(key<arr[mid])
    max = mid - 1;
   else
    return mid;
  }
  return -1;
 }
 /*
 折半查找。提高效率，但是必须要保证该数组是有序的数组。
 */
 public static int halfSearch(int[] arr,int key)
 {
  int min,max,mid;
  min = 0;
  max = arr.length-1;
  mid = (max+min)/2;

  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 = (max+min)/2;
  }
  return mid;
 }

 

 

 //定义功能，获取key第一次出现在数组中的位置。如果返回是-1，那么代表该key在数组中不存在。
 public static int getIndex(int[] arr,int key)
 {
  for(int x=0; x<arr.length; x++)
  {
   if(arr[x]==key)
    return x;
  }
  return -1;
 }
}