萌新卷妹带你从头复习JavaSE-数组2

举报
京与旧铺 发表于 2022/10/31 17:26:20 2022/10/31
【摘要】 萌新卷妹带你从头复习JavaSE-数组2✨欢迎关注🖱点赞🎀收藏⭐留言✒🔮本文由京与旧铺原创，csdn首发！😘系列专栏：java学习💻首发时间：🎞2022年10月14日🎠🎨你做三四月的事，八九月就会有答案，一起加油吧🀄如果觉得博主的文章还不错的话，请三连支持一下博主哦🎧最后的话，作者是一个新人，在很多方面还做的不好，欢迎大佬指正，一起学习哦，冲冲冲💬推荐一款模拟面试、刷题...

萌新卷妹带你从头复习JavaSE-数组2

✨欢迎关注🖱点赞🎀收藏⭐留言✒

🔮本文由京与旧铺原创，csdn首发！

😘系列专栏：java学习

💻首发时间：🎞2022年10月14日🎠

🎨你做三四月的事，八九月就会有答案，一起加油吧

🀄如果觉得博主的文章还不错的话，请三连支持一下博主哦

🎧最后的话，作者是一个新人，在很多方面还做的不好，欢迎大佬指正，一起学习哦，冲冲冲

💬推荐一款模拟面试、刷题神器👉[点击进入网站

🎨3.Java数组应用

🎳3.1利用数组求平均值与交换两个数

public class AvgSwap {
    public static void swap(int[] data) {
        int tmp = data[0];
        data[0] = data[1];
        data[1] = tmp;
    }
    public static double avg(int[] data) {
        int sum = 0;
        for (int i = 0; i < data.length; i++) {
            sum += data[i];
        }
        return 1.0 * sum / data.length;
    }
​
    public static void main(String[] args) {
        int[] swap = {22, 33};
        int[] avg = {1,2,3,4,5,6,7,8,9,0};
        System.out.println("数据交换前：a = " + swap[0] + ", b = " + swap[1]);
        swap(swap);
        System.out.println("数据交换后：a = " + swap[0] + ", b = " + swap[1]);
        System.out.println("数组平均值为：" + avg(avg));
    }
}

7

🎳3.2拷贝数组

import java.util.Arrays;
​
public class Copy {
    public static int[] copy(int[] arr) {
        if (arr == null) {
            return null;
        }
        int[] copy = new int[arr.length];//新建一个数组
        for (int i = 0; i < arr.length; i++) {
            copy[i] = arr[i];//遍历拷贝
        }
        return copy;
    }
    public static void main(String[] args) {
        int[] arr1 = {1,2,3,4,5,6,7,8,9};
        System.out.println("数组1：");
        System.out.println(Arrays.toString(arr1));
        int[] arr2 = copy(arr1);
        System.out.println("数组2：");
        System.out.println(Arrays.toString(arr2));
    }
}

2

当然Java中的Arrays类有内置的拷贝方法： $static\ 数据类型[]\ copyOf(数据类型[]\ original,\ int\ newLength) $ 复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。

$static\ 数据类型[]\ copyOfRange(数据类型[]\ original,\ int\ from,\ int\ to) $ 将指定数组的指定范围[from, to)复制到新数组中。 $static\ void\ arraycopy(Object\ src,\ int\ srcPos,\ Object\ dest,\ int\ destPos,\ int\ length) $ Object src表示源数组，srcPos表示从源数组开始拷贝的下标位置，Object dest表示目标数组，destPos表示表示从目标数组开始拷贝的下标位置，length表示拷贝数组元素个数。 如果细心去查看该方法源代码，会发现该方法被native修饰，这个表示这个方法是使用C/C++实现的。 将指定源数组中的数组从指定位置复制到目标数组的指定位置。 $数组名.clone()$

最后一种就是利用数组名.clone创建并返回此对象的副本。 “复制”的精确含义可能取决于对象的类。因为数组实例化后就是一个对象，该方法会返回值为对应类型的数组，所以使用该方法进行拷贝。

import java.util.Arrays;
​
public class Copy {
​
    public static void main(String[] args) {
        int[] arr1 = {1,2,3,4,5,6,7,8,9};
        System.out.println("arr1:" + Arrays.toString(arr1));
        int[] arr2 = Arrays.copyOf(arr1, arr1.length);
        System.out.println("arr2:" + Arrays.toString(arr2));
        int[] arr3 = Arrays.copyOf(arr1, arr1.length * 2);
        System.out.println("arr3:" + Arrays.toString(arr3));
        int[] arr4 = Arrays.copyOfRange(arr1, 1, 5);
        System.out.println("arr4:" + Arrays.toString(arr4));
        int[] arr5 = new int[arr1.length];
        System.arraycopy(arr1, 0, arr5, 0, arr1.length);
        System.out.println("arr5:" + Arrays.toString(arr5));
        int[] arr6 = arr1.clone();
        System.out.println("arr6:" + Arrays.toString(arr6));
    }
}

5 另外，一般来说数组的拷贝是浅拷贝，因为Java中万物皆对象，对对象的拷贝就是浅拷贝，而数组也是一种对象，除非人为因素使实现深拷贝，如果数组中的为简单的数据类型一般都是深拷贝，如果数组中为引用类型一般都是浅拷贝。

🎳3.3数组转换字符串

再上述代码展示中我相信大家已经看到了Arrays.toString方法的使用，它能将一个数组转换成带中括号字符串！现在我们来模拟一下这个方法：

public class StringArray {
    public static String myToString(int[] arr) {
        if (arr == null) {
            return "[]";//空引用返回[]
        }
        String str = "[";//初始化字符串为[
        for (int i = 0; i < arr.length - 1; i++) {
            str += arr[i] + ",";//注意最后一个数组元素后无逗号
        }
        str += arr[arr.length - 1] + "]";//查漏补缺，补上最后一个元素和]
        return str;
    }
    public static void main(String[] args) {
    int[] arr = {1,2,3,4,5,6,7,8,9};
        System.out.println(myToString(arr));
    }
}

6

🎳3.4数组查找

⛳️3.4.1顺序查找

顺序查找是最简单的查找方法，直接遍历一遍数组就可以了。

public class Search {
    public static void main(String[] args) {
        //顺序查找元素，找到其下标，未找到则输出未找到
        int[] arr = {1,2,3,4,5,6,7,8,9};
        int k = 7;
        int flag = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == k) {
                System.out.println("找到了！下标为：" + i);
                flag = 1;
                break;
            }
        }
        if (flag == 0) {
            System.out.println("未找到！");
        }
    }
}

6

⛳️3.4.2二分查找

然后就是我们已经非常熟悉的二分查找：

public class BinSearch {
    public static int binSearch(int[] arr, int k) {
        if (arr == null) {
            return -1;
        }
        int left = 0;
        int right = arr.length - 1;
        int mid = left + (right - left) / 2;
        while (left <= right) {
            mid = left + (right - left) / 2;
            if (k > arr[mid]) {
                left = mid + 1;
            }
            else if (k < arr[mid]) {
                right = mid - 1;
            }
            else {
                return mid;
            }
        }
        return -1;
    }
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9};
        int k = 7;
        System.out.println(binSearch(arr, k));
    }
}

7

🎳3.5数组的排列

⛳️3.5.1判断数组是否有序

使用两个计数棋进行计数（从1开始计数），遍历数组分别对数组前一项不小于后一项，数组后一项不小于前一项独立计数，如果计数结果有刚好等于数组长度的结果则数组有序。

public class ArraryOrder {
    public static boolean arrOrder(int[] arr) {
        if (arr == null) {
            return false;
        }
        int cnt1 = 1;
        int cnt2 = 1;
        for (int i = 0; i < arr.length - 1; i++) {
            if (arr[i] <= arr[i+1]) {
                cnt1++;
            }
            if (arr[i] >= arr[i+1]) {
                cnt2++;
            }
        }
        if (cnt1 == arr.length || cnt2 == arr.length) {
            return true;
        }
        else {
            return false;
        }
    }
    public static void main(String[] args) {
        int[] arr1 = {1,2,3,4,5,6,7,8,9};
        int[] arr2 = {9,8,7,6,5,4,3,2,1};
        int[] arr3 = {2,1,4,7,5,9,8,3,6};
        System.out.println(arrOrder(arr1));
        System.out.println(arrOrder(arr2));
        System.out.println(arrOrder(arr3));
    }
}

8

⛳️3.5.2数组逆序

双指针，依次将左边元素与右边元素互换。

import java.util.Arrays;
​
public class ReverseArr {
    public static void rever(int[] arr) {
        if (arr == null) {
            return;
        }
        int l = 0;
        int r = arr.length - 1;
        while (l < r) {
            int tmp = arr[l];
            arr[l] = arr[r];
            arr[r] = tmp;
            l++;
            r--;
        }
    }
​
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9};
        System.out.println("逆序前：");
        System.out.println(Arrays.toString(arr));
        System.out.println("逆序后：");
        rever(arr);
        System.out.println(Arrays.toString(arr));
    }
}

8

⛳️3.5.3冒泡排序（升序）

从数组首位元素开始将数组的相邻两个元素进行比较，如果前面的元素比后面大，则进行交换否则不交换，每进行一趟排序就能将一个最大的数放在最后，如果需要把所有元素都排好序，需要进行数组元素个数减一趟排序。因为每一趟排序都会排出一个最大的数放在后面，也就是说每排序一趟就有一个数排序完成，所以每完成一趟排序，排序比较次数就减一，假设数组元素个数为size，则一共要进行size-1趟排序，第1趟排序比较次数为size-1，随着趟数比较次数逐次递减，如果此时为第i趟排序，则需要比较的次数为size - 1 - i。比如10个元素进行冒泡排序，一共要进行9趟排序，第一趟需排序比较9次，第二趟8次，第三趟7次，以此类推。

import java.util.Arrays;
​
public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        if (arr == null) {
            return;
        }
        for (int i = 0; i < arr.length - 1; i++) {
            int flag = 0;
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j+1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                    flag  = 1;
                }
            }
            if (flag == 0) {
                break;
            }
        }
    }
    public static void main(String[] args) {
        int[] arr = {2,1,8,5,9,4,6,7,3};
        System.out.println("排序前：");
        System.out.println(Arrays.toString(arr));
        bubbleSort(arr);
        System.out.println("排序后：");
        System.out.println(Arrays.toString(arr));
    }
}

9

🎨4.二维数组

二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组. 22

前面我们知道了，我们是使用引用来指向一个数组的，那么二维数组其实一个类型为引用的数组，数组中的每个元素都是一个引用变量，引用变量中指向另一个一维数组。 33

二维数组定义：

$$数据类型\ 数组名称\ =\ new\ 数据类型\ 行数\ { 初始化数据 }$$

数组名称.length;//表示行数
数组名称[行数].length;//表示某一行的列数
public class TestBolg {
    public static void main(String[] args) {
        int[][] arr = new int[3][3];
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = 8 + i +j;
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(Arrays.toString(arr[i]));
        }
    }
}

222

同理, 还存在 "三维数组", "四维数组" 等更复杂的数组。

【版权声明】本文为华为云社区用户原创内容，转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息， 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
Java 数据结构
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入