Java中数组定义与使用（找出数组中的最大元素；求数组中的平均值；顺序查找数组中的指定元素；二分查找数组中的指定元素；判断数组的有序性；数组冒泡排序）

Java中数组的定义与使用

数组的定义

数组本质上就是让我们能 “批量” 创建相同类型的变量. 在 Java 中, 数组中包含的变量必须是 相同类型

创建数组

// 动态初始化
数据类型[] 数组名称 = new 数据类型 [] { 初始化数据 };
// 静态初始化
数据类型[] 数组名称 = { 初始化数据 };
代码示例：
int[] arr = new int[]{1, 2, 3};
int[] arr = {1, 2, 3};

数组的使用

使用for-each遍历数组

int[] arr = {1, 2, 3};
for (int x : arr) {
System.out.println(x);
}
// 执行结果
1
2
3

找数组中的最大元素

给定一个整型数组, 找到其中的最大元素

public class maxarray {
    public static void main(String[] args) {
        int [] array={1,2,3,4,5};
        int ret=max(array);
        System.out.println(ret);
    }
    public static int max(int[] array){
        int max=array[0];
        for(int i=1;i<array.length;i++){
            if(max<array[i]){
                max=array[i];
            }
        }
        return max;
    }
}
//执行结果
5

求数组的平均值

给定一个整型数组, 求平均值

public class maxarray {
    public static void main(String[] args) {
        int [] array={1,-2,3,4,-5};
        int ret=max(array);
        System.out.println(ret);
    }
    public static int max(int[] array){
        int max=array[0];
        for(int i=1;i<array.length;i++){
            if(max<array[i]){
                max=array[i];
            }
        }
        return max;
    }
}
//执行结果
0.2

顺序查找数组中的指定元素

给定一个数组, 再给定一个元素, 找出该元素在数组中的位置.

public class findVal {
    public static void main(String[] args) {
        int[] array={1,-2,3,4,-5};
        System.out.println(findVal(array,4));
    }
    public static int findVal(int[] array,int key){
        for (int i=0;i<array.length;i++){
            if(array[i]==key){
                return i;
            }
        }
        return -1;
    }
}
//执行结果
3

二分查找数组中的指定元素

条件：针对有序数组, 可以使用更高效的二分查找
以升序数组为例, 二分查找的思路是先取中间位置的元素, 看要找的值比中间元素大还是小. 如果小, 就去左边找; 否
则就去右边找

public class binarySearch {
    public static void main(String[] args) {
        int[] array={1,2,3,4,5};
        System.out.println(binarySearch(array,3));
    }
    public static int binarySearch(int[] array,int key){
        int i=0;
        int j=array.length-1;
        while(i<=j){
            int mid=(i+j)/2;
            if(array[mid]<key){
                i=mid+1;
            }else if(array[mid]>key){
                j=mid-1;
            }else{
                return mid;
            }
        }
        return -1;
    }
}
//执行结果
2

判断数组的有序性

给定一个整型数组, 判断是否该数组是有序的(升序)

public class isUp {
    public static void main(String[] args) {
        int[] array = {1, 2, 31, 4, 5};
        System.out.println(isUp(array));
    }

    public static boolean isUp(int[] array){
        for(int i=0;i<array.length-1;i++){
            if(array[i] > array[i+1]){
                return false;
            }
        }
        return true;
    }
}
//执行结果
false

数组排序（冒泡排序）

给定一个数组, 让数组升序 (降序) 排序.
算法思路：每次尝试找到当前待排序区间中最小(或最大)的元素, 放到数组最前面(或最后面).

public class bubbleSort {
    public static void main(String[] args) {
        int[] array ={1,12,31,4,5};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
    public static void bubbleSort(int[] array){
        for(int i=0;i<=array.length-1;i++){
            boolean flg=false;
            for(int j=0;j<array.length-1-i;j++){
                if(array[j]>array[j+1]){
                    int tmp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=tmp;
                    flg=true;
                }
            }
            if(flg==false){
                break;
            }
        }
    }
}