Java数组操作与算法实践-优快云博客

本文链接：https://blog.youkuaiyun.com/weiyeyeye/article/details/125878519

1.数组

1.1数组的概念

数组：一组连续的空间，存放的是一组相同数据类型的数据。

//静态初始化(用的多)
int[] array1 = {1,2,3,4,5};
//动态初始化
int[] array2 = new int[10];//大小为10   默认存储的就是0
int[] array3 = new int[]{1,2};

1.2数组的使用

1.数组基本用法

 public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        System.out.println(array.length);//获取数组长度
        System.out.println(array[0]);//访问数组中的元素
        array[2] = 100;//修改数据
        System.out.println(array[2]);
    }

注：使用数组要谨防下标越界 array[6]

2.遍历数组

  public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + "");//第一种打印方式  for循环
        }
        System.out.println("----增强for循环--------"); //第二种打印方式  增强for循环 也叫for each循环
        for (int val :array){
            System.out.print(val+"");
        }
        System.out.println("----使用操作数组的工具类Arrays-----"); //第三种 使用操作数组的工具类Arrays
        String ret = Arrays.toString(array);
        System.out.println(ret);
    }

结果：
在这里插入图片描述
注：

1.3数组作为方法的参数

引用变量：当前变量存储的是一个地址
调用函数函数名（）；

  public static void func1(int[] array){
        array = new int[5];
    }
    public static void func2(int[] array){
        array[2] = 9;
    }

    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        func1(array);
        System.out.println( Arrays.toString(array));
        func2(array);
        System.out.println(Arrays.toString(array));
    }

结果：
在这里插入图片描述
注：

所以改变形参不会影响实参

int[ ] array = null; //代表array这个引用不指向任何对象
System.out.println(array[3]);会显示异常，无法访问

1.4数组练习

1.4.1. 求平均数

 public static double avg(int[] array) {
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        return sum * 1.0 / array.length; //要乘以1.0才能保存小数
    }

    public static void main(String[] args) {
        int[] array = {1,3,5,-1,-3};
         double ret =  avg(array);//接受array的返回值
        System.out.println(ret); //打印返回值
    }

1.4.2. 求数组最大值

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

    public static void main4(String[] args) {
        int[] array = {1,2,3,4,5};
        int ret = max(array);
        System.out.println(ret);
    }

1.4.3. 查找数组中指定的元素的位置【顺序查找，二分查找】

方法1：【顺序查找】

 public static int  findVal(int[] array,int key) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == key) {
                return array[i];
            }
        }
        return -1;//下标为-1，代表没有找到指定的元素
    }

    public static void main(String[] args) {
        int[] array = {1,3,6,7,9};
        System.out.println(findVal(array,8));//在array数组里找8，这种写法就不用定义了，对比题2
    }

结果：-1 //没有找到

方法2：【二分、折半查找】
前提：数组必须是有序的
思路：以升序数组为例，先取中间位置的元素，看要找的值比中间元素大还是小，如果小，就去左边找；否则，就去右边找

 public static int binarySearch(int[] array,int key) {
        int i = 0;
        int j = array.length-1;
       while(i <= j){
           int mid = (i+j)/2;  //因为mid随着i和j变化，所以定义在里面
           if (array[mid] < key) {
               i = mid + 1;
           }else if (array[mid] > key) {
               j = mid - 1;
           }else{
               return mid;
           }
       }
            return -1;
        }

    public static void main(String[] args) {
        int[] array = {1,3,6,7,9};
        System.out.println(binarySearch(array,6));
    }

结果：2

1.4.4. 检查数组的有序性

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

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

1.4.5. 冒泡排序

   public static void bubbleSort(int[] array){
        if (array == null) return;
        for (int i = 0; i < array.length-1; i++) {  //几趟
            boolean flg = false; //每次重置为false,判断有没有进行交换
            for (int j = 0; j < array.length-1-i; j++) {  //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;
            }
        }
    }
    public static void main(String[] args) {
        int[] array = {1,34,37,5,6};
         bubbleSort(array);
         System.out.println(Arrays.toString(array));
    }

结果：
在这里插入图片描述

1.4.6.数组逆序

 public static void reverse(int[] array){
        int i = 0;//第一位
        int j = array.length-1; //最后一位
        while (i < j) {
            int tmp = array[i];
            array[i] = array[j];
            array[j] = tmp;
            i++;
            j--;
        }
    }
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        reverse(array);
        System.out.println(Arrays.toString(array));
    }

1.4.7.数组数字排列

给定一个整型数组，将所有的偶数放在前半部分，将所有的奇数放在后半部分

public static void func2(int[] array){
        int i = 0;
        int j = array.length-1;
        while (i < j) {
            //判断偶数
            while (i < j && array[i]%2 == 0) {  //若不加i<j，则i可能一直++
                i++;
            }
            //判断奇数
            while (i < j && array[j]%2 == 1) {  //若不加i<j，则j可能一直--
                j--;
            }
            int tmp = array[i];//当i遇上奇数，j遇上偶数则互换
            array[i] =array[j];
            array[j] = tmp;
        }
    }

    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        func2(array);
        System.out.println(Arrays.toString(array));
    }

1.4.8 数组拷贝

方法1：

 public static int[] copy(int[] array){
        int[] copy = new int[array.length];//定义一个新数组存放拷贝后的元素
        for (int i = 0; i < array.length; i++) {
            copy[i] = array[i];
        }
        return copy;
    }

    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        //int[] ret = copy(array);
        System.out.println(Arrays.toString(copy(array)));
    }

方法2：利用操作数组的工具类

 public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] ret = Arrays.copyOf(array,array.length);//（需要拷贝的数组，拷贝的新的长度）
        System.out.println(Arrays.toString(ret));
    }

方法3：克隆

public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] ret =array.clone(); //克隆-->array指向的对象的副本
        System.out.println(Arrays.toString(ret));
    }