数组的一些练习和运用以及二维数组进行解析

:movie_camera:数组练习

数组转化为字符串

使用这个我们以后打印数组就会更加方便一点。

Java中提供了java.util.Arrays包，其中包含了一些操作数组的常用方法。

这里给大家列举几个常用的方法

1、:christmas_tree:二叉搜索算法

使用二叉搜索算法搜索指定值的指定数组的范围。在进行此呼叫之前，范围必须按照sort(int[], int, int)方法进行排序。如果没有排序，结果是未定义的。如果范围包含具有指定值的多个元素，则不能保证将找到哪个元素。

2、:tanabata_tree:复制数组内容（下面我还会再提到）

复制指定的数组，用零截取或填充（如有必要），以便复制具有指定的长度。对于原始数组和副本都有效的所有索引，两个数组将包含相同的值。对于在副本中而不是原件有效的任何索引，副本将包含0 。当且仅当指定长度大于原始数组的长度时，这些索引才会存在。

3、:bamboo:数组深度比较

返回指定数组的内容的字符串表示形式。如果数组包含其它数组作为元件，它们被转换为字符串Object.toString()从Object继承的方法，其描述了他们的身份，而不是其内容。
返回指定数组的“深度内容”的字符串表示形式。

//如果数组包含其他数组作为元素，则字符串表示包含其内容等等。
//此方法用于将多维数组转换为字符串。
//字符串表示由数组元素的列表组成，括在方括号（ "[]" ）中。 
//相邻的元素由字符", " （逗号后跟一个空格）分隔开。 
//元件由String.valueOf(Object)转换为字符串，除非它们本身阵列。 
//如果一个元素e是一个基本类型的阵列，它通过调用的Arrays.toString(e)适当重载转换为字符串作为。 
//如果元素e是引用类型的数组，则通过递归调用此方法将其转换为字符串。 
//为了避免无限递归，如果指定的数组包含自身作为元素，或者通过一个或多个数组级别包含对其自身的间接引用，则将自引用转换为字符串"[...]" 。
//例如，仅包含对其自身的引用的数组将被呈现为"[[...]]" 。
 //如果指定数组是null此方法返回"null"。 
复制代码

4、 ?按照数组顺序排序

按照数字顺序排列数组的指定范围。要排序的范围从索引fromIndex （包括）扩展到索引toIndex 。如果fromIndex == toIndex ，要排序的范围是空的。

a - 要排序的数组

fromIndex - 要排序的第一个元素的索引（包括）

toIndex - 最后一个要排序的元素的索引

4、equals比较和fill填充

这里用代码来解释

public static void main_ArrayEqualsAndFill(String[] args) {
        int[] array1 = {1,2,3,4,5};
        int[] array2 = {1,2,3,4,5};
        boolean equal = Arrays.equals(array1,array2);
        System.out.println(equal);
        System.out.println("==============");
        int[] array = new int[10];
        System.out.println("填充之前的数组"+Arrays.toString(array));
//        结果都是0
        Arrays.fill(array,1);
        System.out.println("填充之后的数组"+Arrays.toString(array));
//        结果都是1
        Arrays.fill(array,4,10,29);
//        从[4,10)填充29

    }
复制代码

其他的我就不多做介绍了，小伙伴们可以自己去了解一下~

这里我们其实就可以发现了，重载函数真的很常见！

:railway_car:数组的拷贝

这里我们用代码来进行讲解

运行结果:point_down:

这里newArr和arr引用的是同一个数组，因此newArr修改空间中内容之后，arr也可以看到修改的结果

运行结果:point_down:

使用Arrays中copyOf方法完成对数组的拷贝：

copyOf方法在进行数组拷贝时，创建了一个新的数组

arr和newArr引用的不是同一个数组

因为arr修改其引用数组中内容时，对newArr没有任何影响

运行结果:point_down:

newArr2:[3,4]

这里有一点要注意的是，从2下标拷贝到4下标，都是左闭右开的，不要搞错[2,4)

这个copyOfRange方法看起来很方便呀！让我们瞧瞧得用CTRL+左键来管中窥豹一下源码吧

啊，就这么短短几行！而且一眼看过去就可以清楚每行代码的用途，简单干练。

果然还是那句话，最好的代码不是生涩难懂的，而是大家都能看得明白的！

这里我简单画个图来帮大家理解一下

我们在这里要注意的是：数组当中存储的是基本类型数据的时候，不论怎么拷贝基本都不会出现什么问题，但如果存储的是引用数据类型，拷贝的时候就需要考虑深浅拷贝的问题，Arrays中也有相关deepCopyOf等方法，这里待我将数据结构学习透彻再为大家讲解

除了用Java提供的方法，我们当然也可以运用自己写的拷贝数组的方法

运行结果:point_down:

求数组中元素的平均值

//    求平均值
public static double avg(int[] array) {
    int sum = 0;
    for (int i = 0;i<array.length;i++){
        sum = sum +array[i];
    }
    return sum*1.0/array.length;
    //        不能 return sum/array.length
    }
复制代码

:railway_car:查找数组中指定元素（顺序查找）

public static int search(int[] array,int key){
        for(int i=0;i<array.length;i++){
            if(array[i]==key){
                return i;
            }
        }
//        如果代码走到这里，说明推出了for循环
        return  -1;//因为数组没有负数下标
    }
    public static void main_search(String[] args) {
        int[] array = {1,2,3,4,5};
        int index = search(array,4);
        if(index == -1){
            System.out.println("没有你要找的关键字！");
        }else {
            System.out.println("找到了你要的关键字，下标是："+ index);
        }
    }
复制代码

:cake:查找数组中指定元素（二分查找）

针对 有序数组 我们可以进行更加快速的二分查找，一定要注意，是有序！也就是说二分查找的前提是数组是排好序的，千万不要因为这个小细节犯错哦。

而有序数组分为升序和降序，1234为升序，4321为降序

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

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

//    二分查找，前提是查找的数组有序
    public static int binarySearch(int[] array,int key){
        int left = 0;
        int right = array.length-1;
        while (left<=right){
            int mid = (left + right) /2;
            if (array[mid]<key){
                left = mid + 1;
            }else if(array[mid]==key){
                return mid;
            }else {
                right = mid -1;
            }
        }
//        代码走到这里说明left已经大于right了，所以返回-1
        return -1;//数组没有-1
    }
复制代码

可以看到,针对一个很多元素的数组查找,二分查找的效率极其高,随着数组元素个数越多,那么二分的优势就越大

Arrays中的sort排序方法

(字好丑小伙伴们谅解一下~:persevere:)

我们用代码来演示一下

这里的sort会自动为我们排序,但它是默认升序的,那么我们再来见识一下源码

!这又是一个方法,哼哼我再点进去看看

.... 好家伙,4162行代码,见识不过来了,等有空我再为大家去庖丁解牛(鸽王发言)

数组排序(冒泡排序)

假设我们需要对数组进行升序排序

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

public static void bubbleSort(int[] array) {
        //[0----len-1)i代表趟数
        for (int i = 0;i<array.length-1;i++){
            boolean flg = false;
            //j<4在这里可以不减i    减i说明是进行了优化
            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) {
//                这里是判断上一次有没有进行交换，flg有没有变成true
                break;
            }
        }
//        这里还可以进一步优化，我们可以进一步添加检查，
//        检查是否发生了简化，如果没有，说明有序了，就不需要进行第三趟，第四趟...
    }

复制代码

冒泡排序相对Arrays提供的sort性能还是欠佳,所以还是多多利用Arrays提供的方法咯

:koala:数组逆序

我们给定一个数组,然后将里面的元素逆序排列

思路如下: 设定两个下标,分别指向第一个和最后一个元素,减缓两个位置的元素然后让前一个下标自增,后一个下标自减,循环继续即可

public static void reverse(int[] arr) {
        int left = 0;
        int right = arr.length-1;
        int tmp = 0;
        while (left<right){
            tmp = arr[left];
            arr[right] = tmp;
            left++;
            right--;
        }

复制代码

很简单,就不细说啦

二维数组

基本语法

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

介绍几种初始化方式

import java.util.ArrayList;

public class TestDemo{
public static void main(String args[]) {
	int[][]a1= {{1,2},{3,4},{5,6,7}};
	for(int i=0;i<a1.length;i++) {
		System.out.print(a1[i].length+" ");
		for(int j=0;j<a1[i].length;j++)
			System.out.print(a1[i][j]+" ");
		System.out.println();
	}
	
	System.out.println();
	int[][]a2=new int[2][3];
	for(int i=0;i<a2.length;i++) {
		System.out.print(a2[i].length+" ");
		for(int j=0;j<a2[i].length;j++)
			System.out.print(a2[i][j]+" ");
		System.out.println();
	}
	
	System.out.println();
	int[][]a3=new int[2][];
	for(int i=0;i<a3.length;i++) {
		a3[i]=new int[3];
		System.out.print(a3[i].length+" ");
		for(int j=0;j<a3[i].length;j++)
			System.out.print(a3[i][j]+" ");
		System.out.println();
	}
	
	System.out.println();
	ArrayList<Integer> a4[]=new ArrayList[3];
	for(int i=0;i<a4.length;i++) {
		a4[i]=new ArrayList();
		a4[i].add(1);
		for(int j:a4[i])
			System.out.print(j+" ");
		System.out.println();
	}
}
}

复制代码

输出:point_down:

二维数组的用法和一维数组并没有明显的差别,所以不在赘述,除了要注意的是不规则数组的情况,

这里我给出一段代码,来帮助大家理解

public static void main_3(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        String newArr = Arrays.toString(arr);
        System.out.println(newArr);
    }

    public static void main_2(String[] args) {
//        int[][] array = {{1,2},{4,5,6}};是可以这样定义的
        int[][] array2=new int[2][];//这里编译器只知道这里有两行，还没给出列
        array2[0] = new int[2];
        array2[1] = new int[4];
//        这叫不规则数组
        for (int i = 0;i<array2.length;i++){//代表我们的行
            for (int j =0;j<array2[i].length;j++){//代表我们的列
                System.out.println(array2[i][j]);
            }
        }
//        这里没有array2[0] = new int[2];
//               array2[1] = new int[4];
//               会显示空指针异常，
//        PS:这里区别于C语言，不能再使用array+1来表示数组地址了
    }

    public static void main_1(String[] args){
//      二维数组不能这么写  int[][] array = {1,2,3,4,5,6};
        int[][] array = {{1,2,3},{4,5,6}};
        int[][] array2 = new int [][]{{1,2,3},{4,5,6}};

        for (int i = 0;i<2;i++){//代表我们的行
            for (int j =0;j<3;j++){//代表我们的列
                System.out.println(array[i][j]);
            }
        }
//        优化一下
        for (int i = 0;i<array.length;i++){//代表我们的行
            for (int j =0;j<array[i].length;j++){//代表我们的列
                System.out.println(array[i][j]);
            }
        }
        System.out.println("使用for-each来进行打印");
        for (int[] tmp:array){
            for(int x:tmp){
                System.out.println(x+" ");
            }
        }

        System.out.println("使用toString进行打印");
        System.out.println(Arrays.deepToString(array));
//
    }

复制代码

以下是我在学习数组中用到的代码,如果有需要的小伙伴自取~

import java.util.Arrays;
public class TestDemo {


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


    public static void main_average(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        System.out.println(average(arr));
    }
    public static double average(int[] arr) {
        int sum = 0;
        for (int x: arr){
            sum += x;
        }
        return (double) sum/(double) arr.length;
    }//执行结果为3.5



    public static void main_4(String[] args) {
        int[] array = {1,2,3,4,5,6};
        int[] array2= new int[6];
        System.out.println("未拷贝前：" + Arrays.toString(array2));
        array2 = copyOf(array);
        System.out.println("拷贝了之后："+Arrays.toString(array2));
    }
    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 copyOf2(int[] arr){

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

        arr[0] = 1;
        newArr = Arrays.copyOf(arr,arr.length);
        System.out.println("newArr:" + Arrays.toString(newArr));


//          使用Arrays中copyOf方法完成对数组的拷贝：
        //copyOf方法在进行数组拷贝时，创建了一个新的数组
        //arr和newArr引用的不是同一个数组
        //因为arr修改其引用数组中内容时，对newArr没有任何影响
        arr[0] = 10;
        System.out.println("arr:" + Arrays.toString(arr));
        System.out.println("newArr: "+Arrays.toString(newArr));

        //拷贝某个范围
        int[] newArr2 = Arrays.copyOfRange(arr,2,4);
        System.out.println("newArr2: "+ Arrays.toString(newArr2));
    }


    public static void main_3(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        String newArr = Arrays.toString(arr);
        System.out.println(newArr);
    }

    public static void main_2(String[] args) {
//        int[][] array = {{1,2},{4,5,6}};是可以这样定义的
        int[][] array2=new int[2][];//这里编译器只知道这里有两行，还没给出列
        array2[0] = new int[2];
        array2[1] = new int[4];
//        这叫不规则数组
        for (int i = 0;i<array2.length;i++){//代表我们的行
            for (int j =0;j<array2[i].length;j++){//代表我们的列
                System.out.println(array2[i][j]);
            }
        }
//        这里没有array2[0] = new int[2];
//               array2[1] = new int[4];
//               会显示空指针异常，
//        PS:这里区别于C语言，不能再使用array+1来表示数组地址了
    }

    public static void main_1(String[] args){
//      二维数组不能这么写  int[][] array = {1,2,3,4,5,6};
        int[][] array = {{1,2,3},{4,5,6}};
        int[][] array2 = new int [][]{{1,2,3},{4,5,6}};

        for (int i = 0;i<2;i++){//代表我们的行
            for (int j =0;j<3;j++){//代表我们的列
                System.out.println(array[i][j]);
            }
        }
//        优化一下
        for (int i = 0;i<array.length;i++){//代表我们的行
            for (int j =0;j<array[i].length;j++){//代表我们的列
                System.out.println(array[i][j]);
            }
        }
        System.out.println("使用for-each来进行打印");
        for (int[] tmp:array){
            for(int x:tmp){
                System.out.println(x+" ");
            }
        }

        System.out.println("使用toString进行打印");
        System.out.println(Arrays.deepToString(array));
//
    }

    public static void reverse(int[] arr) {
        int left = 0;
        int right = arr.length-1;
        int tmp = 0;
        while (left<right){
            tmp = arr[left];
            arr[right] = tmp;
            left++;
            right--;
        }

    }
    public static void bubbleSort(int[] array) {
        //[0----len-1)i代表趟数
        for (int i = 0;i<array.length-1;i++){
            boolean flg = false;
            //j<4在这里可以不减i    减i说明是进行了优化
            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) {
//                这里是判断上一次有没有进行交换，flg有没有变成true
                break;
            }
        }
//        这里还可以进一步优化，我们可以进一步添加检查，
//        检查是否发生了简化，如果没有，说明有序了，就不需要进行第三趟，第四趟...
    }


    public static void main_ArrayEqualsAndFill(String[] args) {
        int[] array1 = {1,2,3,4,5};
        int[] array2 = {1,2,3,4,5};
        boolean equal = Arrays.equals(array1,array2);
        System.out.println(equal);
        System.out.println("==============");
        int[] array = new int[10];
        System.out.println("填充之前的数组"+Arrays.toString(array));
//        结果都是0
        Arrays.fill(array,1);
        System.out.println("填充之后的数组"+Arrays.toString(array));
//        结果都是1
        Arrays.fill(array,4,10,29);
//        从[4,10)填充29

    }

    public static void main_Array(String[] args) {
        int[] array = {1,2,3,14,5};
        System.out.println("排序之前的数组："+Arrays.toString(array));
        Arrays.sort(array);//默认升序
        System.out.println("排完序之后的数组"+Arrays.toString(array));

//index:下标，索引
        int index = Arrays.binarySearch(array,14);
        if (index == -1){
            System.out.println("没有");
        }else {
            System.out.println("下标为"+index);
        }
    }

//    二分查找，前提是查找的数组有序
    public static int binarySearch(int[] array,int key){
        int left = 0;
        int right = array.length-1;
        while (left<=right){
            int mid = (left + right) /2;
            if (array[mid]<key){
                left = mid + 1;
            }else if(array[mid]==key){
                return mid;
            }else {
                right = mid -1;
            }
        }
//        代码走到这里说明left已经大于right了，所以返回-1
        return -1;//数组没有-1
    }

    public static int search(int[] array,int key){
        for(int i=0;i<array.length;i++){
            if(array[i]==key){
                return i;
            }
        }
//        如果代码走到这里，说明推出了for循环
        return  -1;//因为数组没有负数下标
    }
    public static void main_search(String[] args) {
        int[] array = {1,2,3,4,5};
        int index = search(array,4);
        if(index == -1){
            System.out.println("没有你要找的关键字！");
        }else {
            System.out.println("找到了你要的关键字，下标是："+ index);
        }
    }


//    求平均值
    public static double avg(int[] array) {
        int sum = 0;
        for (int i = 0;i<array.length;i++){
            sum = sum +array[i];
        }
        return sum*1.0/array.length;
//        不能 return sum/array.length
    }


    public static void main1(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] ret = {1,2,3};
        ret =Arrays.copyOfRange(array,1,3);
        System.out.println(Arrays.toString(ret));
//        这里输出为[2,3]
//        因为从1下标拷贝到3下标，这里都是左闭右开的[1,3)
    }
}

复制代码

Java:数组入门级教学(定义、使用+练习)

:movie_camera:数组练习

数组转化为字符串

:railway_car:数组的拷贝

求数组中元素的平均值

:railway_car:查找数组中指定元素（顺序查找）

:cake:查找数组中指定元素（二分查找）

Arrays中的sort排序方法

数组排序(冒泡排序)

:koala:数组逆序

二维数组

基本语法

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

介绍几种初始化方式

相关推荐

取消回复欢迎你发表评论:

Google 黑客常用搜索语句一览原力计划

npx简介（npxvip是哪国的）

在 Android 模拟器上运行 ARM 应用（android模拟器原理）

GB28181,B接口协议之SIPRTSPRTPRTMP协议从入门到精通

手机实时提取SIM卡打电话的信令和声音-辅助外设与商用通话方案

安装使用Hoppscotch构建API请求访问与测试

轻松转换!AppleNumbers到Excel的快捷教程

Python自动化办公——后台截图（python 自动截图）

电脑端腾讯文档如何导出excel

网络流媒体经典开源软件宝典webRTC, FFMpeg, SIP_流媒体开发教程

Java:数组入门级教学(定义、使用+练习)

:movie_camera:数组练习

数组转化为字符串

:railway_car:数组的拷贝

求数组中元素的平均值

:railway_car:查找数组中指定元素（顺序查找）

:cake:查找数组中指定元素（二分查找）

Arrays中的sort排序方法

数组排序(冒泡排序)

:koala:数组逆序

二维数组

基本语法

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

介绍几种初始化方式

相关推荐

取消回复欢迎 你 发表评论:

Google 黑客常用搜索语句一览 原力计划

npx简介（npxvip是哪国的）

在 Android 模拟器上运行 ARM 应用（android模拟器原理）

GB28181,B接口协议之SIPRTSPRTPRTMP协议从入门到精通

手机实时提取SIM卡打电话的信令和声音-辅助外设与商用通话方案

安装使用Hoppscotch构建API请求访问与测试

轻松转换!AppleNumbers到Excel的快捷教程

Python自动化办公——后台截图（python 自动截图）

电脑端腾讯文档如何导出excel

网络流媒体经典开源软件宝典webRTC, FFMpeg, SIP_流媒体开发教程

取消回复欢迎你发表评论:

Google 黑客常用搜索语句一览原力计划