import java.util.Arrays;

public class test13 {
    public static void main(String[] args) {
        int[] arr=new int[]{1,3,5};
        String ret= Arrays.toString(arr);
        System.out.println(ret);
    }
}

二、数组的拷贝

1、拷贝方法

2、拷贝代码的实现

（1）for循环手动拷贝（此时新数组的长度=原数组的长度，即为全部拷贝）


import java.util.Arrays;

public class test13 {
    public static void main(String[] args) {
        int[] arr=new int[]{1,3,5};
        int[] arr1=copy(arr);
        System.out.println(Arrays.toString(arr1));
    }
    public static int[] copy(int[] arr){
        int[] newarr=new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            newarr[i]=arr[i];

        }return newarr;
    }
}

（2）方法拷贝（此时新数组的长度<原数组的长度，从原数组的第一个开始赋值值，直到元素个数达到新数组的长度）

import java.util.Arrays;

public class test13 {
    public static void main(String[] args) {
        int[] arr=new int[]{1,3,5,7,9,11};
        int[] newarr=Arrays.copyOf(arr,3);
        System.out.println("newarr:"+Arrays.toString(newarr));
    }

}

（3）方法拷贝（此时新数组长度>原数组长度，全拷贝，剩余的元素用新数组数据类型的默认值补齐）

import java.util.Arrays;

public class test13 {
    public static void main(String[] args) {
        int[] arr=new int[]{1,3,5,7,9,11};
        int[] newarr=Arrays.copyOf(arr,10);
        System.out.println("newarr:"+Arrays.toString(newarr));
    }

}

三、找到数组的最大元素

1、最大元素思路

我们在寻找最大值时，需要从数组的第一个数开始遍历，直到走到数组的最后一个元素，找到最大值。

2、最大元素代码实现

public class test13 {
    public static void main(String[] args) {
        int[] arr=new int[]{1,9,4,6,15,17,10};
       int max= maxNum(arr);
        System.out.println(max);
    }
     public static int maxNum(int[] arr){
        int max=arr[0];
         for (int i = 0; i < arr.length; i++) {
             if (arr[i]>max){
                 max=arr[i];
             }
         }return max;
     }
}

四、求一个数组的平均值

1、平均值思路

数组的所有元素加和在除以数组长度

2、平均值代码实现

public class test13 {
    public static void main(String[] args) {
        int[] arr=new int[]{1,3,5,7};
        double avg=average(arr);
        System.out.println(avg);
    }
         public static double average(int[] arr){
        int sum=0;
         for (int i = 0; i < arr.length; i++) {
             sum+=arr[i];
         }return sum/ (double)arr.length;
     }
}

五、查找一个数组中是否包含指定元素，若存在，返回第一个存在该元素的索引，若不存在，返回-1

1、指定元素思路

遍历数组，找到了返回索引，没找到返回-1

2、指定元素代码实现

public class test13 {
    public static void main(String[] args) {
        int[] arr=new int[]{1,3,5,7,14,35,68};
        System.out.println(find(arr,14));
        System.out.println(find(arr,100));
    }
         public static int find(int[] arr, int toFind){
             for (int i = 0; i < arr.length; i++) {
                 if (arr[i] == toFind){
                     return i;
                 }
             }
             return -1;
         }
}

六、二分查找，在有序数组中查找元素

1、二分查找思路

在一个有序区间里，我们不断比较待查找元素和区间中间位置元素的大小关系：

（1）若toFind<arr[mid],说明这个元素一定处于左半边区间，则right=mid-1继续判断

（2）若toFind=arr[mid],说明这个元素恰好等于区间中间的元素

（3）若toFind>arr[mid],说明这个元素一定处于右半边区间，则left=mid+1继续判断

（4）循环的终止条件是left>right,此时区间里面的所有元素都已经查找完毕

2、二分查找代码实现

public class test13 {

    public static void main(String[] args) {
        int[] arr = new int[]{1, 3, 5, 7, 9, 11, 13, 15};
        System.out.println(binarySearch(arr, 11));
        System.out.println(binarySearch(arr, 30));
    }

    public static int binarySearch(int[] arr, int toFind) {
        int left = 0;             //在[left,right]区间中寻找toFind元素的索引
        int right = arr.length - 1;    //终止条件是当left>right,此时区间里面的所有元素检查完毕
        while (left <= right) {
            int mid = (left + right) / 2;
            if (toFind < arr[mid]) {
                right = mid - 1;
            } else if (toFind > arr[mid]) {
                left = mid + 1;
            } else {
                return mid;
            }
        }return -1;
    }
}

七、判断一个数组是否有序，默认为升序

1、判断有序思路

就是去找反例，在升序数组中，前一个元素<=后一个元素，遍历数组，如果发现一个某个元素比后面的元素大，就找到了一个反例，就可以证明这个数组不是升序数组。

2、判断有序代码实现

public class test13 {

    public static void main(String[] args) {
        int[] arr = new int[]{1,5,9,2,4};
        int[] arr1=new int[]{1,2,3,4,5,6,7};
        System.out.println(jude(arr));
        System.out.println(jude(arr1));
    }
      public static boolean jude(int[] arr){
        //当i取到arr.length-1时，已将处于左后一个元素，后面没有元素可以比较了
          for (int i = 0; i < arr.length-1; i++) {  
              if (arr[i]>arr[i+1]){
                  return false;
              }
          }    return true;

      }
}

八、冒泡排序

1、冒泡思路

对要进行排序的数据中【相邻的数据进行两两比较，将较大的数放在后面】依次对所有数据进行操作，直至所有数据按要求完成排序。

2、冒泡排序代码实现

public class test13 {

    public static void main(String[] args) {
        int[] arr = new int[]{7,6,5,4,3};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));

    }
     public static void bubbleSort(int[] arr){
        //最外层的循环表示遍历的次数，每遍历一次数组，就会有一个最大值放在了数组的最后面
         //当待排序的数组只剩下左后一个元素时，此时整个数组已将时有序的，就不需要在遍历了，所以i<arr.length-1
         for (int i = 0; i < arr.length-1; i++) {
             //最内层的循环表示元素的大小关系，如果前一个元素大于后面的元素，就交换他们两个的位置
             //初始时：待排序数组为[0,i-1]已排序数组为[]
             for (int j = 0; j < arr.length-1; j++) {
                 if (arr[j]>arr[j+1]){
                     int temp=arr[j];
                     arr[j]=arr[j+1];
                     arr[j+1]=temp;
                 }
             }
         }
     }
}

3、冒泡排序的优化

（1）优化思路

如果存在一部分元素[1,2,3,4],此时内层循环根本就没有进行元素交换，此时这个数组就是有序的，此时排序过程结束

（2）代码实现

   public static void main(String[] args) {
        int[] arr = new int[]{7,6,5,4,3};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));

    }
     public static void bubbleSort(int[] arr){
        //最外层的循环表示遍历的次数，每遍历一次数组，就会有一个最大值放在了数组的最后面
         //当待排序的数组只剩下左后一个元素时，此时整个数组已将时有序的，就不需要在遍历了，所以i<arr.length-1
         for (int i = 0; i < arr.length-1; i++) {
             boolean exchange=false;
             //最内层的循环表示元素的大小关系，如果前一个元素大于后面的元素，就交换他们两个的位置
             //初始时：待排序数组为[0,i-1]已排序数组为[]
             for (int j = 0; j < arr.length-1; j++) {
                 if (arr[j]>arr[j+1]){
                     exchange=true;
                     int temp=arr[j];
                     arr[j]=arr[j+1];
                     arr[j+1]=temp;
                 }
             }if (!exchange){
                 //此时内层循环已经没有元素交换，数组已将有序，则结束程序
                 break;
             }
         }
     }
}

九、数组逆序

1、逆序思路

对于数组[1,2,3,4,5]来说，只需要把第一个和最后一个交换，第二个和倒数第二个交换，以此类推就可，当（i>=j）时（此时i指的是前面的元素，j指的是后面的元素）,就没有元素可以交换了，结束程序。

2、逆序代码实现

import java.util.Arrays;

public class test13 {

    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5,6};
        reverse(arr);
        System.out.println(Arrays.toString(arr));
    }
   public static void reverse(int[] arr){
        int i=0;
        int j= arr.length-1;
        while (i<j){
            int temp=arr[i];
            arr[i]=arr[j];
            arr[j]=temp;
            i++;
            j--;
        }
   }
}

十、数组的数字排列（偶数放到前面，奇数放在后面）

1、排列思路

这是一个双引用问题，从前向后找奇数，找到后放前面，从后往前找偶数，找到之后放后面

2、排列代码实现

 public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5,6,7,8,9};
        transform(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void transform(int[] arr) {
        int i = 0;
        int j = arr.length - 1;
        while (i < j) {
            // i从前向后找到第一个奇数停止
            // 若数组全是偶数，根本就找不到奇数
            while (i < j && arr[i] % 2 == 0) {
                i++;
            }
            // 此时i一定是落在了从前向后第一个奇数的位置
            // j从后向前找到第一个偶数停止
            // 若数组全是奇数，根本就找不到偶数
            while (i < j && arr[j] % 2 != 0) {
                j--;
            }
            // 此时j一定是落在了从后向前第一个偶数的位置
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i ++;
            j --;
        }
    }
}