JAVASE语法零基础——数组的练习、二分查找、冒泡排序

Java系列文章目录

---

Write once,Runanywhere.

学完上一篇文章关于Java中数组的相关知识后，这篇文章来做一些数组相关的练习。

如果你觉得我的文章有帮助到你，还请【关注➕点赞➕收藏】，得到你们支持就是我最大的动力!!!

⚡版权声明：本文由【马上回来了】原创、在CSDN首发、需要转载请联系博主。
版权声明：本文为CSDN博主「马上回来了」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

新的知识开始喽

---

---

1.数组转字符串

将定义的数组以字符串的形式来打印。
代码示例1：使用Arrays工具包来打印

//数组转字符串
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        String ret = Arrays.toString(arr);
        System.out.println(ret);
    }

运行结果：

示例2：使用循环模拟实现

//循环实现将数组转化成字符串
    public static String print(int[] arr){
        if(arr == null){//如果引用不指向任何对象，则直接返回null
            return "null";
        }
        String ret = "[";//定义一个字符串：[
        for (int i = 0; i < arr.length; i++) {
            ret+=arr[i];//用+将字符串ret与arr[i]拼接
            if(i != arr.length-1){//当数组的下标为i == arr.length时，打印结果：[1,2,3,4,5，]
                ret+=",";
            }
        }
        ret+="]";
        return ret;
    }
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        String ret = print(arr);//传递引用
        System.out.println(ret);
    }

运行结果：

2.数组拷贝

示例1：使用循环遍历的方式来拷贝

 //数组拷贝
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};//静态初始化创建一个数组，数组内容{1,2,3,4,5}
        int[] copy = new int[arr.length];//动态初始化创建一个数组，数组的长度和arr相同,数组内容为0
        System.out.println("arr[]"+Arrays.toString(arr));//打印
        System.out.println("copy[]"+Arrays.toString(copy));;
        System.out.println("=========拷贝前========");
        for (int i = 0; i < arr.length; i++) {//将arr[i]的值赋给copy[i]
         copy[i]=arr[i];
        }
        System.out.println("=========拷贝后========");
        System.out.println("arr[]"+Arrays.toString(arr));//打印
        System.out.println("copy[]"+Arrays.toString(copy));;
    }

运行结果：

示例2：使用Arrays里的copyOf方法来拷贝
copyOf方法在进行数组拷贝时，创建了一个新的数组 ，arr和copy引用的不是同一个数组

代码：

 //使用Arrays中copyOf方法完成拷贝
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int[] copy = Arrays.copyOf(arr,arr.length);
        System.out.println("=========拷贝后========");
        System.out.println("arr[]"+Arrays.toString(arr));//打印
        System.out.println("copy[]"+Arrays.toString(copy));;
    }

运行结果：

示例3：使用System.arraycopy方法完成拷贝

 //使用System.arraycopy方法完成拷贝
    int[] arr = {1,2,3,4,5};
    int[] copy = new int[arr.length];
    /**你要拷贝哪个数组
     * 你要从该数数组的哪个下标开始拷贝
     * 你要拷贝到哪个数组
     * 你要从拷贝到的目的数组的哪个下标开始拷贝
     * 你要拷贝多长
     */
    System.arraycopy(arr,0,copy,0,arr.length);//[0,arr.length)
    System.out.println("=========拷贝后========");
    System.out.println("arr[]"+Arrays.toString(arr));//打印
    System.out.println("copy[]"+Arrays.toString(copy));;
}

运行结果：

示例4：使用clone直接克隆一个副本

 //使用clone直接克隆一个副本
        int[] arr = {1,2,3,4,5};
        int[] copy = arr.clone();//源数组.clone()
        System.out.println("=========拷贝后========");
        System.out.println("arr[]"+Arrays.toString(arr));//打印
        System.out.println("copy[]"+Arrays.toString(copy));;

运行结果：

注意这个代码不是数组复制：

public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int[] tmp = arr;//引用变量tmp引用了堆上的数组对象
        System.out.println(Arrays.toString(tmp));
    }

深拷贝与浅拷贝
深拷贝：修改拷贝之后的数组不影响原来的数组。
浅拷贝：修改拷贝之后的数组影响原来的数组。
深拷贝代码实现：

//深拷贝
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int[] copy = Arrays.copyOf(arr,arr.length);//使用Arrays.copyOf来实现拷贝
        System.out.println("=======拷贝后=======");
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(copy));
        System.out.println("=======修改后=======");
        copy[0]=100;//修改拷贝后的值
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(copy));
    }

浅拷贝：

3.求数组中元素的平均值

代码示例：给定一个整型数组, 求平均值

//求数组的平均值
    public static double avg (int[] arr){
        double sum = 0;//平均值可能为小数，所以使用double类型
        for (int x:arr) {//这里不用用到下标所以用for each求和
            sum+=x;
        }
        return(sum/arr.length);
        
    }
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        System.out.println(avg(arr));//链式访问，avg的返回值作为sout的参数
    }

4.查找数组中的指定元素

示例1：顺序查找

 //顺序查找
    public static int findkey(int[] arr, int key){
        for (int i = 0; i < arr.length; i++) {//循环遍历
            if(arr[i] == key){//找到了 返回下标
                return i;
            }
        }
        return -1;//没找到返回-1
    }
    public static void main(String[] args) {
        int[] arr = {1,2,3,15,4,5};//创建一个数组
        int k = 15;//要查找的关键字k
        int ret = findkey(arr,k);//传参 数组名、待查找的元素
        System.out.println(ret);
    }

示例2：二分法查找
以升序数组为例, 二分查找的思路是先取中间位置的元素, 然后使用待查找元素与数组中间元素进行比较：
如果相等，即找到了返回该元素在数组中的下标
如果小于，以类似方式到数组左半侧查找
如果大于，以类似方式到数组右半侧查找

//二分查找 有序
    public static int binarySearch(int[] arr,int key){
        int low = 0;//左下标
        int hight = arr.length-1;//右下标，因为数组下标从零开始，所以-1
        while(low<=hight){//因为是有序查找，所以当low<=hight才有可能找到
            int mid =(low + hight)/2;//折半
            if(key == arr[mid]){//arr[mid]==key
                return mid;//返回mid下标
            }else if(arr[mid] < key){//arr[mid]
                low = mid+1;//左边折去
            }else{//arr[mid]>key
                hight = mid-1;//折去右边
            }
        }
        //low>hight 该数组已经查找完毕，无法找到key
        return -1;//返回-1
    }
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7};//创建一个数组
        int k = 5;//要查找的关键字k
        int ret = binarySearch(arr,k);//传参 数组名、待查找的元素
        System.out.println(ret);
    }

示例三：直接使用Arrays.binarySearch包实现快速查找

  public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7};//创建一个数组
        int k = 5;//要查找的关键字k
        int ret = Arrays.binarySearch(arr,k);
        System.out.println(ret);
    }

5.数组排序(冒泡排序)

给定一个数组, 让数组升序 (降序) 排序.
算法思路：
假设排升序：

1. 将数组中相邻元素从前往后依次进行比较，如果前一个元素比后一个元素大，则交换，一趟下来后最大元素就在数组的末尾
2. 依次从上上述过程，直到数组中所有的元素都排列好

  //冒泡排序
    public static void bubblesort(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {//假设有n个元素，由于每排完一趟都会使一个最大的数字在最高位，因此只用排n-1趟，剩下的一个数字自然在最低位了
            boolean flg = false;//定义flg作为标志，来判断是否还要进行下一趟排序，提高效率
            for (int j = 0; j < arr.length-1-i; j++) {//因为每排一趟都会使一个数字到高位置，因此每一趟都会比上一趟少一个数字，所以arr.length-1-i
                if (arr[j] > arr[j+1]){//if条件满足则该趟进行了交换
                    flg =true;//flg=true我们认为该趟发生排序交换
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1]=tmp;
                }
            }
            if(flg == false){//如果flg=false,就说明该趟没有满足if条件，即没有发生排序，所以所有的数字都已经排好了，因此不用再进行下一趟排序了
                return ;
            }
        }
    }
    public static void main(String[] args) {
        int[] arr= {1,5,6,8,7,10,3,2,4,9};
        bubblesort(arr);//void类型，直接传引用
        System.out.println(Arrays.toString(arr));
    }

运行结果：

这个代码三个地方注意：
1.n个元素排的趟数是n-1；
2.每一趟排的个数都比上一趟少1；
3.如果在排完i趟后发现这组数字已经是排好了，就不用再进行下一次排序了。
示例二：直接使用Arrays.实现

   int[] arr= {1,5,6,8,7,10,3,2,4,9};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

关于 Arrays.sort 的具体实现算法，在后面的排序算法上再详细介绍。
运行结果：

6. 数组逆序

给定一个数组, 将里面的元素逆序排列.
思路
设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素.
然后让前一个下标自增, 后一个下标自减, 循环继续即可

public static void reverse(int[] arr){
        int low = 0;//左边
        int hight = arr.length-1;//右边
        while(low<=hight){//能交换必须满足的条件
            int tmp = arr[low];
            arr[low]=arr[hight];
            arr[hight]=tmp;
            low++;
            hight--;
        }
    }
    public static void main(String[] args) {
        int[] arr= {1,2,3,4,5,6,7,8,9};
        reverse(arr);
        System.out.println(Arrays.toString(arr));
    }

7.求两数之和
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/two-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

 public static int[] find(int[] arr,int k){
        int[] ret = {-1,-1};
        for (int i = 0; i < arr.length-1; i++) {//arr.length-1防止arr[j]拿到的下标越界，arr[i]只能拿到[0,arr.length-2]
            for (int j = i+1; j < arr.length ; j++) {//arr[j]只能拿到[1,arr.length-1]
                if(arr[i]+arr[j]==k){
                    ret[0]=i;
                    ret[1]=j;
                   return ret;
                }
            }
        }
        return ret;//如果没有则返回的数组下标都是-1
    }

    public static void main(String[] args) {
        int[] arr = {2, 7, 11, 15};
        int k = 22;
        int[] ret = find(arr, k);
        System.out.println(Arrays.toString(ret));
    }

7.判断一个数组是否为升序

//给定一个整型数组, 判定数组是否有序（递增）
    public static void judgeorder(int[] arr) {
        boolean flg = true;
        for (int i = 0; i < arr.length - 1; i++) {//10个数字，两两之间只用比9次  arr.length-1
            if (arr[i] > arr[i + 1]) {//因为arr.length-1 所以arr下标最大为9 不会越界
                flg = false;
                break;
            }
        }
        if (flg == true) {
            System.out.println("arr是升序");
        } else {
            System.out.println("arr不是升序");
        }
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        judgeorder(arr);
    }

运行结果：

---

今天的你看懂这里又学到了很多东西吧

下次见喽