操作数组

(1)获取最值（最大值，最小值）
　通过定义变量记录较大的值的方式实现。

class ArrayDemo{
       public static void main(String[] args) {
             int[] arr= {1,3,6,2,8,11};
             int max = getMax(arr);
             System.out.println("max = " + max);
       }

       public static int getMax(int[] arr){
             int maxElement = arr[0];
             for(int x = 1; x < arr.length; x++){
                   if(arr[x] > maxElement)
                        maxElement = arr[x];
            }
            return maxElement;
      }
}

通过定义变量记录较大的值的索引方式实现。

class ArrayDemo{
       public static void main(String[] args) {
            int[] arr= {1,3,6,2,8,11};
            int max = getMax(arr);
            System.out.println("max = " + max);
      }

       public static int getMax(int[] arr){
             int maxIndex = 0;
             for(int x = 1; x < arr.length; x++){
                   if(arr[x] > arr[maxIndex])
                        maxIndex = x;
            }
            return arr[maxIndex];
      }
}    

(2)排序（选择排序，冒泡排序）
　 选择排序思路：
1、首先拿数组第一个元素依次与除其自身外的其他每个元素顺序比较，如果第一个元素大于剩下的某个元素，就互换内容。
2、经过第一轮比较之后，此时，第一个元素就是数组中最小的元素。然后再拿第二个元素与除第一个元素和其自身的元素进行比较，如果第二个元素大于剩下的某个元素，就互换内容。此时，第二个元素就是数组中倒数第二小的元素。
3、依次类推，直到最后一个元素。

 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 selectSort(int[] arr){
             for(int x = 0; x < arr.length - 1; x++){
                   int num = arr[x];
                   int index = x;
                   for(int y = x + 1; y < arr.length; y++){
                         if(num > arr[y]){
                              num = arr[y];
                              index = y;
                        }
                  }
                  //如果最小的就是自己，就没有必要执行swap操作
                  if(index != x)
                        swap(arr,x,index);
            }
      }

      public static void swap(int[] arr, int a,int b){
            int temp = arr[a];
            arr[a] = arr[b];
            arr[b] = temp;
      }

冒泡排序思路：
思路：
1、首先在第一轮排序中，数组从第一个元素到倒数第二个元素依次与其右边的元素进行比较，如果左边的元素大于右边的元素，那么两个元素就互换。
2、经过第一轮比较，最大的元素就已经存储到数组最右边的结点中了。
3、第二轮排序则是从第一个元素到倒数第三个元素依次与其右边的元素进行比较，如果左边的元素大于右边的元素，那么两个元素就互换。
4、依照此方式，一直到只有第一和第二个元素互相比较而结束。
　

“`

class ArrayDemo{
       public static void main(String[] args) {
        int[] arr= {89,34,-270,17,3,100};
        System.out.print("排序前数组：" );
        printArray(arr);
        bubbleSort(arr);
        System.out.print("排序后数组：" );
        printArray(arr);
  }

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

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

}

（3）折半查找(二分查找)
如果一个数组是无序的，那么可以通过简单遍历查找的方式查找到某个元素所在的角标。但是如果一个数组是有序的，那么就可以通过一种更高效的方式达到相同的目的，也就是二分查找。思路：
1、设置三个变量记录角标：min、max、mid。min初始值为0，max为数组最大角标，mid为（max+min）/2。
2、查看mid角标的元素是否与待查找的值相等，如果相等，则直接返回角标值，程序终止执行。
3、如果待查找的值小于角标为mid的元素值，那么说明待查找的元素的位置可能在min与mid角标之间。设置max = mid - 1，mid = (max + min)/2，重复第1、2步的操作。
4、如果待查找的值大于角标为mid的元素值，那么说明待查找的元素的位置可能在mid与max角标之间。设置min = mid + 1，mid = (max + min)/2，重复第1、2步的操作。
5、如果数组中不存在待查找的元素，那么按照如上流程，最终min角标值会大于max角标值，此时返回-1。

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

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