乐趣区

关于java:Java-从入坑到放弃No-6-数组操作的奇技淫巧

前言

前边曾经讲过了 Java 中的 8 大根本数据类型,这篇文章次要就来讲讲援用类型中的数组。次要内容安顿如下:

  • 数组简介
  • 遍历
  • 排序
  • 罕用办法

数组简介

所谓数组,其实就是多个雷同数据类型的元素按肯定顺序排列而成的汇合。行将无限个类型雷同的变量放到一个容器中,而后依照编号去拜访各个元素,而容器的名字就叫做数组名,各个元素的编号就叫做索引地位。而其中索引地位是从 0 开始计数,而不是咱们日常所习惯的 1

要定义一个数组类型的遍历,其语法为 数据类型 [],比方 int[],而且在初始化时必须指定数组大小,如 int[] arr = new int[10],示意 arr 数组能够包容 10int 类型的元素。

数组的特点:

  • 数组中的元素初始化时都是有默认值的,整型对应 0,浮点型对应 0.0,而布尔型对应 false
  • 数组一经创立,其大小就不可再变;
  • 要拜访数组中的某一元素,须要用到索引,索引从 0 开始;
  • 如果要批改数组中的某一元素,间接对对应索引地位的元素应用赋值语句即可;

一维数组

初始化

  1. 动态初始化

所谓动态初始化,就是在定义数组的同时将其初始化;

int[] arr1 = {1, 3, 5, 8, 10};
int[] arr2 = new int[] {1, 3, 5, 8, 10};
  1. 动静初始化

动静初始化,就是先申明数组定义之后,再对其进行赋值;

int[] arr = new int[5];
arr[0] = 1;
arr[1] = 3;
arr[2] = 5;
arr[3] = 8;
arr[4] = 10;

PS:留神数组的索引地位不能超过数组的长度,如下面例子中的数组长度为 5,所以咱们数组的索引地位最大只能为 4,否则就会报数组越界谬误。

求数组长度

求数组的长度,利用数组的 length 属性即可;

int[] arr = new int[10];
int size = arr.length; // 10
System.out.println("size =" + size);

二维数组

初始化

  1. 动态初始化
int[][] arr1 = {{1, 2, 4}, {5, 7, 9}, {19, 12, 18}};
  1. 动静初始化

二位数组动静申明时,一种是把行和列的长度都指定,而另一种是只须要指定行的长度,不必指定列的长度,列的长度会在初始化时主动确认。

int[][] arr1= new int[3][3];
arr1 = new int[][]{{1, 2, 4}, {5, 7, 9}, {19, 12, 18}};

int[][] arr2= new int[3][];
arr2 = new int[][]{{1, 2, 4}, {5, 7, 9}, {19, 12, 18}};

求数组长度

不同于一维数组,因为二维数组有行和列,所需要长度时须要别离求。

int[][] arr = new int[10][20];

// 求行的长度
int row = arr.lenght;
// 求列的长度,此时求任意一行所在的列的长度即可
int col = arr[0].length;

数组遍历

既然咱们曾经学会了数组的申明及初始化,接下来就是对数组进行操作,而最常见的则是遍历数组。

假如咱们有一个数组如下:

String[] arr = new String[5];
arr = new String[]{"村雨遥", "海贼王", "进击的伟人", "鬼灭之刃", "斗罗大陆"};

规范 for 循环

首先,咱们来应用规范的 for 循环来遍历该数组,只须要通过数组的索引地位来拜访即可。

/**
 * @author : cunyu
 * @version : 1.0
 * @className : TraverseTest
 * @date : 2021/4/25 11:52
 * @description : 遍历
 */

public class TraverseTest {public static void main(String[] args) {String[] arr = new String[5];
        arr = new String[]{"村雨遥", "海贼王", "进击的伟人", "鬼灭之刃", "斗罗大陆"};

//        数组长度
        int size = arr.length;
        for (int i = 0; i < size; i++) {System.out.println("第" + (i + 1) + "个元素:" + arr[i]);
        }
    }
}

加强 for 循环

/**
 * @author : cunyu
 * @version : 1.0
 * @className : EnforceTraverseTest
 * @date : 2021/4/26 9:14
 * @description : 加强 for 循环
 */

public class EnforceTraverseTest {public static void main(String[] args) {String[] arr = new String[5];
        arr = new String[]{"村雨遥", "海贼王", "进击的伟人", "鬼灭之刃", "斗罗大陆"};
        int index = 0;
        for (String name : arr) {System.out.println("第" + (index + 1) + "个元素:" + name);
            index++;
        }
    }
}

两者的区别 :规范 for 循环是通过计数器来进行遍历,咱们可能很清晰的得悉每个元素所对应的索引地位,而加强 for each 循环则是间接拜访数组中的元素值,而不关怀每个元素对应的索引地位。

规范库遍历

通过调用规范库 Arrays 中的 toString() 办法,咱们能够将任意类型的数组转换为一个字符串示意模式,从而打印进去。

import java.util.Arrays;

/**
 * @author : cunyu
 * @version : 1.0
 * @className : StandardLibraryTest
 * @date : 2021/4/26 9:22
 * @description : 规范库遍历
 */

public class StandardLibraryTest {public static void main(String[] args) {String[] arr = new String[5];
        arr = new String[]{"村雨遥", "海贼王", "进击的伟人", "鬼灭之刃", "斗罗大陆"};
        System.out.println(Arrays.toString(arr));
    }
}

以上的遍历次要是针对一维数组,而针对二维数组,当咱们要拜访其中的一个元素时,能够应用 array[row][col] 来进行拜访,而对于二维及更多维的数组,能够应用 Arrays.deepToString()

数组排序

应用排序算法

排序算法多样,最罕用的则有 冒泡排序、插入排序、疾速排序等 ,进行排序时会批改数组自身;

冒泡排序:通过一轮循环,将最大的数置换到开端,而后进入下一轮循环,每轮均比上一轮的完结地位靠前一位;

import java.util.Arrays;

/**
 * @author : cunyu
 * @version : 1.0
 * @className : BubbleSort
 * @date : 2021/4/26 10:16
 * @description : 冒泡排序
 */

public class BubbleSort {public static void main(String[] args) {char[] chArray = {'c', 'u', 'n', 'y', 'u'};
        // 排序前
        System.out.println(Arrays.toString(chArray));

        for (int i = 0; i < chArray.length - 1; i++) {for (int j = 0; j < chArray.length - 1 - i; j++) {
                // 从大到小
                if (chArray[j] < chArray[j + 1]) {
                    // 替换
                    char temp = chArray[j];
                    chArray[j] = chArray[j + 1];
                    chArray[j + 1] = temp;
                }
            }
        }
        // 冒泡排序后
        System.out.println(Arrays.toString(chArray));
    }
}

规范库排序

import java.util.Arrays;

/**
 * @author : cunyu
 * @version : 1.0
 * @className : StandardLibrarySortTest
 * @date : 2021/4/26 10:22
 * @description : 规范库排序
 */

public class StandardLibrarySortTest {public static void main(String[] args) {String[] arr = new String[]{"村雨遥", "海贼王", "进击的伟人", "鬼灭之刃", "斗罗大陆"};

//        排序前
        System.out.println(Arrays.toString(arr));
//        规范库排序
        Arrays.sort(arr);
//        排序后
        System.out.println(Arrays.toString(arr));
    }
}

罕用办法

对于数组而言,Java 规范库中曾经内置了许多办法,罕用的有如下一些办法:

返回值 办法 形容
static String toString(Object[] a) 输入数组的字符串模式
static <T> List<T> asList(T…… a) 数组转 List
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @author : cunyu
 * @version : 1.0
 * @className : CommonMethodsTest
 * @date : 2021/4/26 10:37
 * @description : 罕用办法
 */

public class CommonMethodsTest {public static void main(String[] args) {String[] arr = new String[]{"村雨遥", "海贼王", "进击的伟人", "鬼灭之刃", "斗罗大陆"};
//        输入数组的字符串模式
        System.out.println("打印数组");
        System.out.println(Arrays.toString(arr));
//        数组转列表
        System.out.println("数组转列表");
        List<String> list = new ArrayList<String>(Arrays.asList(arr));
        System.out.println(list);

        System.out.println("列表转数组");
        list.add("镇魂街");
        String[] newArr = new String[list.size()];
        list.toArray(newArr);
        System.out.println(Arrays.toString(newArr));

        System.out.println("数组是否蕴含某一元素");
        System.out.println(Arrays.asList(newArr).contains("进击的伟人"));
        System.out.println(Arrays.asList(newArr).contains("网球王子"));
    }
}

总结

数组相干的内容就到此结束了,次要从 4 个方面简略介绍了数组的一些相干用法,如果你有更多想要理解的内容,欢送评论区留言交换。最初,都看到这儿了,不给个赞和关注再走么 🤔.

退出移动版