黑马程序员 基础总结（三）

------- android培训、java培训、期待与您交流！ ----------

数组的定义:

       概念：同一种类型数据的集合，其实数组就是一个容器。

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

       格式1： 元素类型【】 数组名 = new 元素类型【元素个数或数组长度】

                      示例：int【】 arr = new int 【5】；

格式2：元素类型【】 数组名 = new 元素类型【】{元素，元素，元素。。。。。}

                     int [] arr = new int[] {1,2,,4,5};

                     int [] arr = {1,2,,4,5};

内存结构

        java程序在运行时，需要在内存中分配空间，为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

        栈内存：

               用于存储局部变量，当数据使用完，所占空间会自动释放。

         堆内存：

                数组和对象，通过new建立的实例都放在堆内存中。

                每一个实体都有内存地址值。

                实体中的变量都有默认初始化值。

                实体不再被使用，会在不确定时间被垃圾回收期回收。

        方法区：

        本地方法区：

        寄存器：

数组（静态初始化）

        ArrayIndexOutOfBoundsException

                  操作数组时，访问到了数组中不存在的角标。

         NullPointerException

                  空指针异常，当引用没有任何指向值为null的情况，该引用还在用于操作实体。

数组（常见操作-遍历）

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

      } 
}

数组（获取最值）

        

     获取数组中的最大值。
            思路：
            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;
                 }

                获取最大值的另一种方式。

             

          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];
            }

数组（排序--选择排序）

        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])
                         {
                         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])
                           {
                                 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;
       }

/*
数组的查找操作。

练习：有一个有序的数组，想要将一个元素插入到该数组中，
还要保证该数组是有序的。如何获取该元素在数组中的位置。
 
int x = Arrays.binarySearch();//java提供好的一个进行折半查找的功能。开发时使用这个。

 

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