【JAVA】数组练习

- 日理万妓 2024-04-23 20:27 4阅读 0赞

> ⭐ 作者：小胡\_不糊涂  
> 🌱 作者主页：[小胡\_不糊涂的个人主页][Link 1]  
> 📀 收录专栏：[浅谈Java][Java]  
> 💖 持续更文，关注博主少走弯路，谢谢大家支持 💖

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

*  1. 数组转字符串
 *  2. 数组拷贝
 *  3. 求数组中的元素的平均值
 *  4. 顺序查找数组中指定元素
 *  5. 二分查找数组中指定元素
 *  6. 数组排序(冒泡排序)
 *  7. 数组逆序

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

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

`toString()` ：可以将Array 对象转换为字符串。

//语法格式：
    arraylist.toString()

**实例1：**

import java.util.Arrays;//调用Arrays类，包含了常用的数组操作
    public class test {
        
        public static void main(String[] args) {
        
            int[] arr = {
        1,2,3,4,5,6};
            String newArr = Arrays.toString(arr);
            System.out.println(newArr);
        }
    }

🍤 *运行结果：*

![在这里插入图片描述][924af81e18a7489b9a2788a261b82140.png]

**实例2：**

import java.util.ArrayList;
    public class test {
        
        public static void main(String[] args) {
        
              // 创建一个动态数组
               ArrayList<String> sites = new ArrayList<>();
                sites.add("Runoob");
                sites.add("Google");
                sites.add("Wiki");
                sites.add("Taobao");
                System.out.println("网站列表: " + sites);
                 // 将ArrayList转换为String类型
                 String list = sites.toString();
                 System.out.println("String: " + list);
                }

🍤 *运行结果：*

![在这里插入图片描述][e23857a54aa6490592a7d6c0c251947b.png]

## 2. 数组拷贝 ##

**实例1：**

import java.util.Arrays;
    public class test {
        
        public static void func(){
        
            // newArr和arr引用的是同一个数组
            // 因此newArr修改空间中内容之后，arr也可以看到修改的结果
            int[] arr = {
        1,2,3,4,5,6};
            int[] newArr = arr;
            newArr[0] = 10;
            System.out.println("newArr: " + Arrays.toString(arr));
    }
    public static void main(String[] args) {
        
            func();
        }

🍤 *图解：*

![在这里插入图片描述][c9476659ceee4a31ba8d1ed0814cb204.png]

🍤 *运行结果：*

![在这里插入图片描述][b9b20e09893d4f1c81d1fad7bee4486e.png]  
**实例2：使用Arrays中copyOf方法完成数组的拷贝**

import java.util.Arrays;
    public class test {
        
        public static void func(){
        
            int[] arr = {
        1,2,3,4,5,6};
            int[] newArr = arr;
            // copyOf方法在进行数组拷贝时，创建了一个新的数组
            // arr和newArr引用的不是同一个数组
            arr[0] = 1;
            newArr = Arrays.copyOf(arr, arr.length);
            System.out.println("newArr: " + Arrays.toString(newArr));
    		}
    	public static void main(String[] args) {
        
            func();
        }
     }

🍤 *图解：*

![在这里插入图片描述][10654646b57b4ea29b8bdf7f778e05b1.png]

🍤 *运行结果：*

![8e8e98f417b247ec82f1cb25cc176bcd.png][]  
**实例3：拷贝某个范围**

import java.util.Arrays;
    public class test {
        
        public static void func(){
        
            int[] arr = {
        1,2,3,4,5,6};
            int[] newArr = arr;
            int[] newArr2 = Arrays.copyOfRange(arr, 2, 4);
            System.out.println("newArr2: " + Arrays.toString(newArr2));
         }
         public static void main(String[] args) {
        
            func();
        }
    }

注： 数组当中存储的是基本类型数据时，不论怎么拷贝基本都不会出现什么问题，但如果存储的是引用数据类型，拷贝时需要考虑深浅拷贝的问题

模拟拷贝数组：

import java.util.Arrays;
    public class test {
        
    	//copyOf方法拷贝数组
        public static int[] copyOf(int[] arr) {
        
            int[] ret = new int[arr.length];
            for (int i = 0; i < arr.length; i++) {
        
                ret[i] = arr[i];
            }
            return ret;
        }
    
        public static void main(String[] args) {
        
            int[] a={
        1,4,5,6,9};
            int[] Array=copyOf(a);
            for(int i=0;i<Array.length;i++) {
        
                System.out.println(Array[i]);
            }
    
        }

🍤 *运行结果：*

![在这里插入图片描述][aa8f893253cd493aab6e6f35799f5ca1.png]

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

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

public class test {
        
        public static void main(String[] args) {
        
            int[] arr = {
        1,2,3,4,5};
            System.out.println(avg(arr));//输出：3.0
        }
        public static double avg(int[] arr) {
        
            int sum = 0;
            for (int x : arr) {
        //遍历数组
                sum += x;
            }
            return (double)sum / (double)arr.length;
        }
    }

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

> 给定一个数组，再给定一个元素，找出该元素在数组中的位置。

import java.util.Scanner;
    public class test {
        
        public static void main(String[] args) {
        
             int[] arr = {
        1,2,3,10,5,6};
            Scanner scanner=new Scanner(System.in);//创建一个Scanner对象
            int num=scanner.nextInt();//读取用户输入
            System.out.println(find(arr, num));
        }
        
        public static int find(int[] arr, int data) {
        
            for (int i = 0; i < arr.length; i++) {
        
                if (arr[i] == data) {
        
                    return i;//返回下标
                }
            }
            return -1; // 表示没有找到
        }
    }

🍤 *运行结果：*

![在这里插入图片描述][434d95722eec45e9828a8caf15fa3697.png]

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

二分查找仅适用于有序查找

> **什么是有序数组?**  
> 有序分为 “升序” 和 “降序”  
> 如 1 2 3 4 , 依次递增即为升序.  
> 如 4 3 2 1 , 依次递减即为降序

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

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

**代码示例：**

import java.util.Scanner;
    public class test {
        
        public static void main(String[] args) {
        
            int[] arr = {
        1,2,3,4,5,6};
            System.out.print("请输入你要查找的数字：");
            Scanner scanner=new Scanner(System.in);//创建一个Scanner对象
            int num=scanner.nextInt();
            System.out.println(binarySearch(arr, num));
        }
        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]) {
        
                // 去右侧区间找
                    left = mid + 1;
                } else {
        
                // 相等, 说明找到了
                    return mid;
                }
            }
                // 循环结束, 说明没找到
            return -1;
        }
    }

🍤 *运行结果：*

![在这里插入图片描述][adce3a7d54c04a93b805fa797a18fe98.png]

`🍩随着数组元素个数越多, 二分的优势就越大`

[二分查找–图文详解][Link 2] \- 这篇文章是用C语言介绍的二分查找，虽然语言不同，但思想都是一样的，而且是以图的形式详细描述二分查找的过程，大家可以去看看~

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

> 给定一个数组，让数组升序 (降序) 排序

算法思路： 假设排升序

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

import java.util.Arrays;
    
    public class test {
        
    public static void main(String[] args) {
        
            int[] arr = {
        9,5,7,8,6,6,7};;
            bubbleSort(arr);//调用方法
            System.out.println(Arrays.toString(arr));
            }
    
        public static void bubbleSort(int[] arr) {
        
            for (int i = 0; i < arr.length; i++) {
        
                for (int j = 1; j < arr.length-i; j++) {
        
                    //前一个与后一个比较，可能的话需要交换位置
                    if (arr[j-1] > arr[j]) {
        
                        int tmp = arr[j - 1];
                        arr[j - 1] = arr[j];
                        arr[j] = tmp;
                    }
                }
            } 
        }
    }

🍤 *运行结果：*

![在这里插入图片描述][6d2864524df64b14980e664014efb021.png]

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

import java.util.Arrays;
    
    public class test {
        
        public static void main(String[] args) {
        
            int[] arr = {
        9,5,7,8,6,6,7};
            Arrays.sort(arr);//升序排序
            System.out.println(Arrays.toString(arr));
        }

## 7. 数组逆序 ##

> 给定一个数组，将里面的元素逆序排列

算法思路：  
设定两个下标，分别指向第一个元素和最后一个元素，交换两个位置的元素，然后让前一个下标自增，后一个下标自减，循环继续即可。

import java.util.Arrays;
    
    public class test {
        
        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--;
            }
        }
    }

🍤 *运行结果：*

![在这里插入图片描述][33845891d8e14b8aaee82309ff6dd4ab.png]

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

![在这里插入图片描述][c2b56e1103304ca7ad4ab7ce0c7ef0ba.png]

[Link 1]: https://blog.csdn.net/iLoyo_
[Java]: http://t.csdn.cn/P9HTz
[e5ff543b74f342e9b33b2191d1006ced.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/e925eefab15141159497c5d068c67b1c.gif
[924af81e18a7489b9a2788a261b82140.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/e885459f4bc44116a64946cfe85e9e75.png
[e23857a54aa6490592a7d6c0c251947b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/0f649fe6bbe54611b5025e92a102da44.png
[c9476659ceee4a31ba8d1ed0814cb204.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/dbe2f2735b504935914d1c1230d71509.png
[b9b20e09893d4f1c81d1fad7bee4486e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/0fecd24971fb4af481cdb7b4eed57fc0.png
[10654646b57b4ea29b8bdf7f778e05b1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/bb59fd25d19d4e36ab9fcfcb32ceccf1.png
[8e8e98f417b247ec82f1cb25cc176bcd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/b4a0486f5caf4812a879222f5d7eaf63.png
[aa8f893253cd493aab6e6f35799f5ca1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/de876d690ca8495486c2c239096fc088.png
[434d95722eec45e9828a8caf15fa3697.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/55b77e2add5f4e92a9726a8bc2bc451d.png
[adce3a7d54c04a93b805fa797a18fe98.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/7b6b985e05c34d499943e4d1046c9abc.png
[Link 2]: http://t.csdn.cn/TPL63
[de5225940c9046b1856cbad5ae1cae83.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/f26199ef5c384a26a1e25a9a5223e6b7.png
[6d2864524df64b14980e664014efb021.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/0f95557a36f043b98bc014a333a4f835.png
[33845891d8e14b8aaee82309ff6dd4ab.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/9c60229c7bc64569b20353081bd04077.png
[c2b56e1103304ca7ad4ab7ce0c7ef0ba.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/33b01e9f492f4164a228f36426b0afc8.png