【Java.SE】数组的练习

怼烎@ 2024-05-23 14:06 59阅读 0赞

> **作者简介：** 辭七七，目前大一，正在学习C/C++，Java，Python等  
> **作者主页：** [七七的个人主页][Link 1]  
> **文章收录专栏**：[Java.SE][]，本专栏主要讲解运算符，程序逻辑控制，方法的使用，数组的使用，类和对象，继承和多态，抽象类和接口等内容  
> 欢迎大家点赞 ? 收藏 ⭐ 加关注哦！??

![在这里插入图片描述][fd9619e68b9c4fe6bee9a5de074ecad3.gif_pic_center]

--------------------

#### 数组的练习 ####

*  1. 数组转字符串
 *   *  1.1 自己实现一个tostring函数
 *  2. 数组拷贝
 *  3. 求数组中元素的平均值
 *  4. 查找数组中指定元素(顺序查找)
 *  5. 查找数组中指定元素（二分查找）
 *  6. 数组排序(冒泡排序)
 *  7. 数组逆序
 *  8. 二维数组

## 1. 数组转字符串 ##

数组转字符串我们需要借助**工具类**

代码示例

import java.util.Arrays  //Java中的包 
    
    
    public class TestDemo {
        
        public static int[] func() {
        
            return new int[]{
        1,2,3,4,5,6};
        }
        public static void main(String[] args) {
        
            int[] ret = func();
    
            //这个方法主要将参数的数组转化为字符串输出
           String s = Arrays.toString(ret);
            //Ctrl+鼠标点击，可以跳转到这个方法的原码
            
            System.out.println(s);
        }
    }
    
    
    //执行结果
    [1, 2, 3, 4, 5, 6]

使用这个方法后续打印数组就更方便一些.  
Java 中提供了 `java.util.Arrays` 包，其中包含了一些操作数组的常用方法。

我们可以在jdk里搜索一下Arrays的用法，如图所示：  
![在这里插入图片描述][588ad9ee04974d69af72a7cb0804284c.png]

### 1.1 自己实现一个tostring函数 ###

定义一个`myToString`的方法，利用for循环和if判断来解决问题  
代码示例：

public class TestDemo {
        
    
        public static String myToString(int[] array){
        
            String ret = "[";
            for (int i = 0; i < array.length; i++) {
        
                ret += array[i];
               if (i != array.length -1){
        
                   ret += ",";
               }
            }
            ret += "]";
            return ret;
        }
        public static void main(String[] args) {
        
            int[] array = {
        1,2,3,4,5};
            String ret = myToString(array);
            System.out.println(ret);
        }
    }

打印结果：  
![在这里插入图片描述][2d2dabaab4a241d0aa5215d5fef4f6c8.png]

## 2. 数组拷贝 ##

先来看一个简单的数组拷贝：  
使用`for循环`来完成的拷贝

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

打印结果：  
![在这里插入图片描述][8387db6c82284157b67cb5f997e5482a.png]  
以下代码是不是拷贝  
![在这里插入图片描述][1302ec4da2d5472590fed6e7eb1ef098.png]

> 答案：不是

在上述代码中我们可以通过修改形参的值来改变实参

// array3和array2引用的是同一个数组
      // 因此array3修改空间中内容之后，array2也可以看到修改的结果
      int[] array2 = {
        1,2,3,4,5};
      int[] array3 = array2;
      array3[0] = 10;
      System.out.println("newArr: " + Arrays.toString(array2));

我们可以不用for循环来拷贝数组，直接用Arrays中的copyof方法来完成

import java.util.Arrays
    
    
    public class TestDemo {
        
        public static void main(String[] args) {
        
            int[] array = {
        1,2,3,4,5};
            int[] copy = Arrays.copyOf(array,array.length);
            System.out.println(Arrays.toString(copy));
            
        }
    }

> //使用Arrays中copyOf方法完成数组的拷贝：  
> // copyOf方法在进行数组拷贝时，创建了一个新的数组  
> // array和copy引用的不是同一个数组

数组的扩容：`array.length`后 \***2** 就是扩大两倍  
代码示例：

import java.util.Arrays
    
    
    public class TestDemo {
        
        public static void main(String[] args) {
        
            int[] array = {
        1,2,3,4,5};
            int[] copy = Arrays.copyOf(array,array.length*2);
            System.out.println(Arrays.toString(copy));
    
        }
    }

运行结果：  
![在这里插入图片描述][4c53e5c2d9224081a7f40cfbd1be617e.png]  
拷贝某个范围  
**代码示例**

public class TestDemo {
        
        public static void main(String[] args) {
        
            int[] array = {
        1,2,3,4,5};
            //取下标为1到3的数字
            int[] copy = Arrays.copyOfRange(array,1,3);
            System.out.println(Arrays.toString(copy));
        }
    }

运行结果：  
![在这里插入图片描述][740d4be6abf14427b8446e21e2aebd2e.png]

> 如果下标范围过大，则能拷贝多少拷贝多少，其余位置用0补全

**画图对比看一下拷贝和指向的区别**

![在这里插入图片描述][c683ffbcf7c14f1ea89f92a4df30325b.png]  
![在这里插入图片描述][848aa38f60f04b1bb0b9938b704d733b.png]

**注意：** 数组当中存储的是基本类型数据时，不论怎么拷贝基本都不会出现什么问题，但如果存储的是引用数据类型，拷贝时需要考虑深浅拷贝的问题，关于深浅拷贝在后续详细给大家介绍。

crtl+鼠标左键，单击`copyOfRange`来查看他的原码看一下他是怎么运行的  
![在这里插入图片描述][8f762af62482427ab74d55051c28963f.png]  
在这里crtl+鼠标左键，单击`arraycopy`，来看一下他是怎么实现的  
可以看到他的参数如下图所示：  
![在这里插入图片描述][d0fa5200024048be9e084b06ce7c5372.png]  
按照以上参数用自己代码实现如下：

public class TestDemo {
        
        public static void main(String[] args) {
        
            int[] array = {
        1,2,3,4,5};
            int[] copy = new int[array.length];
            System.arraycopy(array,0,copy,0,array.length);
            System.out.println(Arrays.toString(copy));
        }
    }

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

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

public static void main(String[] args) {
        
       int[] arr = {
        1,2,3,4,5,6};
       System.out.println(avg(arr));
    }
    
    public static double avg(int[] arr) {
        
       int sum = 0;
       for (int x : arr) {
        
         sum += x;
       }
       return (double)sum / (double)arr.length;
       //需要强转成double型
    }
    
      // 执行结果
      3.5

## 4. 查找数组中指定元素(顺序查找) ##

给定一个数组, 再给定一个元素, 找出该元素在数组中的位置.  
代码示例：

public static void main(String[] args) {
        
       int[] arr = {
        1,2,3,10,5,6};
       System.out.println(find(arr, 10));
    }
    public static int find(int[] arr, int data) {
        
       for (int i = 0; i < arr.length; i++) {
        
         if (arr[i] == data) {
        
           return i;//找到返回下标
         }
       }
       return -1; // 表示没有找到
    }
    // 执行结果
    3

## 5. 查找数组中指定元素（二分查找） ##

针对有序数，可以使用更高效的二分查找。

> 什么叫有序数组？  
> 有序分为 “升序” 和 “降序”  
> 如 1 2 3 4 ，依次递增即为升序。  
> 如 4 3 2 1 ，依次递减即为降序。

如果数组为无序数组，可以用 `Arrays.sort(array)`这个方法对其进行排序  
代码所示：

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

打印结果：  
![在这里插入图片描述][8a62f71892de45e8bbae98f33d22a0b0.png]

以升序数组为例，二分查找的思路是先取中间位置的元素，然后使用待查找元素与数组中间元素进行比较：

*  如果相等，即找到了返回该元素在数组中的下标
 *  如果小于，以类似方式到数组左半侧查找
 *  如果大于，以类似方式到数组右半侧查找

画图理解  
当我们想找的是4时  
![在这里插入图片描述][51a1cfaa4c8749f2b3f229a38db8160d.png]

代码示例：

public static void main(String[] args) {
        
       int[] arr = {
        1,2,3,4,5,6};
       System.out.println(binarySearch(arr, 6));
    }
    public static int binarySearch(int[] arr, int toFind) {
        
       int left = 0;
       int right = arr.length - 1;
       while (left <= right) {
        
         int mid = (left + right) / 2;
         if (toFind < arr[mid]) {
        
           // 去左侧区间找
           right = mid - 1;
         } else if (toFind > arr[mid]) {
        
           // 去右侧区间找
    l      eft = mid + 1;
         } else {
        
           // 相等, 说明找到了
           return mid;
         }
       }
       // 循环结束, 说明没找到
       return -1;
    }
    // 执行结果
    5

可以看到，针对一个长度为 10000 个元素的数组查找，二分查找只需要循环 14 次就能完成查找。随着数组元素个数越多，二分的优势就越大。

我们也可以直接调用Java中的`binarySearch`方法来直接找下标  
代码演示：

public class TestDemo {
        
        public static void main(String[] args) {
        
            int[] array = {
        1,3,2,6,4,5};
            Arrays.sort(array);
            System.out.println(Arrays.binarySearch(array,5));
        }
    }

运行结果：  
![在这里插入图片描述][d709982063674b1d89182acb2854ae73.png]  
**扩展：Java中的Attays方法**  
![在这里插入图片描述][a9a6d850d28747b0b5068670585c08ba.png]  
例如：比较两个数组两个对应位置数字的大小是否相等用`Arrays.equals()`的方法  
代码演示：

public static void main(String[] args) {
        
            int[] array1 = {
        1,2,3,4,5};
            int[] array2 = {
        1,2,3,4,5};
            boolean flg = Arrays.equals(array1,array2);
            System.out.println(flg);
        }

结果为  
![在这里插入图片描述][b8a7e440803344eea606c2c2da16694a.png]  
填充一个数组时用`Arrays.fill()`的方法  
代码演示：

public static void main(String[] args) {
        
            int[] array3 = new int[10];
            Arrays.fill(array3,-1);
            System.out.println(Arrays.toString(array3));
        }

打印结果为：  
![在这里插入图片描述][c62307d0d5e54de08f986807d7701bff.png]  
也可选择填充位置 `Arrays.fill(array3,1,4,-1);`，把括号里边改成1~4下标的数字，填充为-1

## 6. 数组排序(冒泡排序) ##

给定一个数组, 让数组升序 (降序) 排序。  
假设排升序：

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

我们来看一下4，8，9，3，6的排序图  
![在这里插入图片描述][746ba640a1b04a25ae3459f44ab56f0a.png]

代码示例：

public class TestDemo {
        
        public static void bubbleSort(int[] array) {
        
            //i代表的是趟数！！
            for (int i = 0; i < array.length-1; i++) {
        
                //j代表每一趟比较的次数
                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;//说明有序了！！！
                }
            }
        }
        public static void main(String[] args) {
        
            int[] arr = {
        9, 5, 2, 7};
            bubbleSort(arr);
            System.out.println(Arrays.toString(arr));
        }
    }
    
    //运行结果
    [2, 5, 7, 9]

冒泡排序性能较低。Java 中内置了更高效的排序算法

public static void main(String[] args) {
        
       int[] arr = {
        9, 5, 2, 7};
       Arrays.sort(array);
       System.out.println(Arrays.toString(array));
    }

关于 Arrays.sort 的具体实现算法, 我们在后面的排序算法课上再详细介绍. 到时候我们会介绍很多种常见排序算法.

## 7. 数组逆序 ##

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

public static void main(String[] args) {
        
       int[] arr = {
        1, 2, 3, 4};
       reverse(arr);
       System.out.println(Arrays.toString(arr));
    }
    public static void reverse(int[] arr) {
        
       int left = 0;
       int right = arr.length - 1;
       while (left < right) {
        
         int tmp = arr[left];
         arr[left] = arr[right];
         arr[right] = tmp;
         left++;
         right--;
       }
    }

运行结果：  
![在这里插入图片描述][6829b84572184b62a1af6affcd5b7065.png]

库里边没有方法可以直接数组逆序

## 8. 二维数组 ##

二维数组本质上也就是一维数组，只不过每个元素又是一个一维数组。  
**基本语法**

`数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };`  
初始化示例：

int[][] arr = {
        {
        1, 2, 3, 4},{
        5, 6, 7, 8},{
        9, 10, 11, 12}};
    int[][] arr1 = new int[][]{
        {
        1, 2, 3, 4},{
        5, 6, 7, 8},{
        9, 10, 11, 12}};
    int[][] arr2 = new int[2][3]

通过`array[行][列]`的坐标来访问某一个值  
图解:  
![在这里插入图片描述][5073445b47a14a4180446bc71a5869d4.png]

代码示例：

int[][] arr = {
        
       {
        1, 2, 3, 4},
       {
        5, 6, 7, 8},
       {
        9, 10, 11, 12}
    };
    for (int i = 0; i < arr.length; i++) {
        
       for (int j = 0; j < arr[i].length; j++) {
        
         System.out.printf("%d\t", arr[i][j]);
       }
       System.out.println("");
    }
    // 执行结果
    1 2 3 4
    5 6 7 8
    9 10 11 12

二维数组的用法和一维数组并没有明显差别，因此我们不再赘述。  
同理，还存在 “三维数组”，“四维数组” 等更复杂的数组，只不过出现频率都很低。

我们如果想直接打印二维数组要用什么呢？  
我们知道一维数组的打印用`Arrays.toString()`,但是用它打印二维数组打印的是数组的地址  
所以我们要用`Arrays.deepToString()`的方法直接打印二维数组  
代码演示：

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

![在这里插入图片描述][572d5cf97caa418f939cc97b0225282d.png]  
**不规则的二维数组**  
代码演示：

public static void main(String[] args) {
        
            int[][] array = new int[2][];
            array[0] = new int[]{
        1,2,3};
            array[1] = new int[]{
        4,5,6,7,8,9};
    
            System.out.println(Arrays.deepToString(array));
        }
    //运行结果
    [[1, 2, 3], [4, 5, 6, 7, 8, 9]]

可以指定二维数组的长度，这时可以省略他的列  
画图解释：  
![在这里插入图片描述][bbe1c7dd357e4e03be13fe6364bd919d.png]

> 关于【Java.SE】数组的练习，七七就先分享到这里了，如果你认为这篇文章对你有帮助，请给七七点个赞吧，如果发现什么问题，欢迎评论区留言！！??

[Link 1]: https://blog.csdn.net/2201_75366661?spm=1000.2115.3001.5343
[Java.SE]: https://blog.csdn.net/2201_75366661/category_12297122.html?spm=1001.2014.3001.5482
[fd9619e68b9c4fe6bee9a5de074ecad3.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/0c6618928f7e40079f8fe8da293dc59e.gif
[588ad9ee04974d69af72a7cb0804284c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/b0c389b5dacb469c994911d5428333fa.png
[2d2dabaab4a241d0aa5215d5fef4f6c8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/24b0dfa3744e486a85b2f2fc0a4f30e2.png
[8387db6c82284157b67cb5f997e5482a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/4f088bd0abf44f368e96d228dd6b3b80.png
[1302ec4da2d5472590fed6e7eb1ef098.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/b5a7bda0b7e64a81acea78d892e7ce8b.png
[4c53e5c2d9224081a7f40cfbd1be617e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/e2dcd12cd463480ab853ce34ede57e61.png
[740d4be6abf14427b8446e21e2aebd2e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/8be737ad6c004a8a869d3263e3724aac.png
[c683ffbcf7c14f1ea89f92a4df30325b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/d56afa1754cf417080dedebd6fd01cda.png
[848aa38f60f04b1bb0b9938b704d733b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/388e34273db345fc95a5882d04808f5b.png
[8f762af62482427ab74d55051c28963f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/0664a7c145474c73a8d8dbd78d3e048c.png
[d0fa5200024048be9e084b06ce7c5372.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/569934c666414b99a558ac84993d6ca2.png
[8a62f71892de45e8bbae98f33d22a0b0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/7438d6a4ffc3468297e207dd36aa7f7e.png
[51a1cfaa4c8749f2b3f229a38db8160d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/cfc393e1d1304615a6cd715a7b529a08.png
[d709982063674b1d89182acb2854ae73.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/10e0ff184273486d9d767d257a820f5c.png
[a9a6d850d28747b0b5068670585c08ba.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/437128e189be4bfcbd8294815cc9f98b.png
[b8a7e440803344eea606c2c2da16694a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/6f213989c4c849e1a637cf1d40c5e5ff.png
[c62307d0d5e54de08f986807d7701bff.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/d7343af1088647e785629b0dbef1542b.png
[746ba640a1b04a25ae3459f44ab56f0a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/d99eb52ad52f41cda8ef96dbcf57f332.png
[6829b84572184b62a1af6affcd5b7065.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/38a37d9e40474a94a99ec7d638c858d9.png
[5073445b47a14a4180446bc71a5869d4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/9fc0b0d616e04e338f9557c3d4887232.png
[572d5cf97caa418f939cc97b0225282d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/1ae36fcb88464dd1b26925676181cc26.png
[bbe1c7dd357e4e03be13fe6364bd919d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/23/7599ac063f9244a5b92d031d39e3fbf2.png