Java数组

翻斗花园熊爷爷

于 2023-10-31 21:01:53 发布

阅读量35

点赞数

分类专栏： Java学习文章标签： java 算法 python

本文链接：https://blog.csdn.net/qq_42005321/article/details/134149196

版权

Java学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

Java数组：针对数组（Array）的各种操作

Java一维数组的定义、赋值和初始化

创建一维数组：

type[] arrayName; // 数据类型[] 数组名;（一般使用这种，可读性比较好）

或者

type arrayName[]; // 数据类型数组名[];

举个例子：

int [] socre;

String [] name;

double [] price;

特别注意，在声明数组时不需要规定长度：

int score[10]; // 这是错误的

声明数组只是得到了一个存放数组的变量，并没有为数组分配内存空间，所以不能使用，因此为数组分配空间，这样才能进行使用！

int [] socre;

score = new int[10];

为socre分配十个空间

或者直接使用:

int[] a=new int[10];

注意：一旦声明了数组的大小，就不能再修改。这里的数组长度也是必需的，不能少。

初始化一维数组

1.使用new指定数组大小进行初始化

type[] arrayName = new int[size];

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

2.使用new指定数组元素的值

type[] arrayName = new type[]{值 1,值 2,值 3,值 4,• • •,值 n};

int[] number = new int[]{1, 2, 3, 5, 8};

3.直接指定元素的值

type[] arrayName = {值 1,值 2,值 3,…,值 n};

int[] number = {1,2,3,5,8};

获取数组的值，number[index]

Java二维数组详解

在 Java 中二维数组被看作数组的数组，即二维数组为一个特殊的一维数组，其每个元素又是一个一维数组。Java 并不直接支持二维数组，但是允许定义数组元素是一维数组的一维数组，以达到同样的效果。声明二维数组的语法如下：


type arrayName[][];    // 数据类型 数组名[][];

type[][] arrayName;    // 数据类型[][] 数组名;



int [][] age;

char [][] sex;

初始化二维数组

二维数组可以初始化，和一维数组一样，可以通过 3 种方式来指定元素的初始值。这 3 种方式的语法如下：

type[][] arrayName = new type[][]{值 1,值 2,值 3,…,值 n}; // 在定义时初始化

type[][] arrayName = new type[size1][size2]; // 给定空间，在赋值

type[][] arrayName = new type[size][]; // 数组第二维长度为空，可变化

double [][] s={{ 100, 99, 99 }, { 100, 98, 97 }, { 100, 100, 99.5 }, { 99.5, 99, 98.5 }};
for (int i=0;i<s.length;i++){
    for(int j=0;j<s[i].length;j++){

        System.out.println("class_score[" + i + "][" + j + "]=" + s[i][j]);
    }

}

Java不规则数组

首先初始化有两种

1.int intArray[][] = {{1,2}, {11}, {21,22,23}, {31,32,33}};

int intArray[][] = new int[4][]; //先初始化高维数组为4
// 逐一初始化低维数组
intArray[0] = new int[2];
intArray[1] = new int[1];
intArray[2] = new int[3];
intArray[3] = new int[3];

Java Arrays工具类

1）int binarySearch(type[] a, type key)

使用二分法查询 key 元素值在 a 数组中出现的索引，如果 a 数组不包含 key 元素值，则返回负数。调用该方法时要求数组中元素己经按升序排列，这样才能得到正确结果。

2）int binarySearch(type[] a, int fromIndex, int toIndex, type key)

这个方法与前一个方法类似，但它只搜索 a 数组中 fromIndex 到 toIndex 索引的元素。调用该方法时要求数组中元素己经按升序排列，这样才能得到正确结果。

3）type[] copyOf(type[] original, int length)

这个方法将会把 original 数组复制成一个新数组，其中 length 是新数组的长度。如果 length 小于 original 数组的长度，则新数组就是原数组的前面 length 个元素，如果 length 大于 original 数组的长度，则新数组的前面元索就是原数组的所有元素，后面补充 0（数值类型）、false（布尔类型）或者 null（引用类型）。

4）type[] copyOfRange(type[] original, int from, int to)

这个方法与前面方法相似，但这个方法只复制 original 数组的 from 索引到 to 索引的元素。

5）boolean equals(type[] a, type[] a2)

如果 a 数组和 a2 数组的长度相等，而且 a 数组和 a2 数组的数组元素也一一相同，该方法将返回 true。

6）void fill(type[] a, type val)

该方法将会把 a 数组的所有元素都赋值为 val。

7）void fill(type[] a, int fromIndex, int toIndex, type val)

该方法与前一个方法的作用相同，区别只是该方法仅仅将 a 数组的 fromIndex 到 toIndex 索引的数组元素赋值为 val。

8）void sort(type[] a)

该方法对 a 数组的数组元素进行排序。

9）void sort(type[] a, int fromIndex, int toIndex)

该方法与前一个方法相似，区别是该方法仅仅对 fromIndex 到 toIndex 索引的元素进行排序。

10）String toString(type[] a)

该方法将一个数组转换成一个字符串。该方法按顺序把多个数组元素连缀在一起，多个数组元素使用英文逗号,和空格隔开。

Java中数组和字符串的相互转换

这里只介绍两种方法

1.char[]转String直接使用定义

String str=new String(char[]);

2.String转char[],使用String.toCharArray()

String str=new String("123abc");
    char[] arr=str.toCharArray();
    for(int i=0;i<arr.length;i++){
        System.out.println(arr[i]);
    }
    String str1=new String(arr);
    System.out.println(str1);

Java比较两个数组是否相等（equals()）

Arrays.equals(array A,array B);

double[] s1=new double[]{1,2,3,56.7};
    double[] s2=new double[5];
    for(int i=0;i<s2.length;i++)
    {
    s2[i]=i;

    }
    double[] s3={99, 96.5, 98.5, 100, 72};
    System.out.println(Arrays.equals(s1,s3));

Java数组填充（fill()）

Arrays.fill(array,value);这个是固定的填充数值是依次进行的。

 int[] number=new int[5];
        for (int i = 0; i < number.length; i++){
            Arrays.fill(number,i);
            System.out.println(number[i]);
        }

Java数组使用binarySearch()方法查找指定元素

查找数组是指从数组中查询指定位置的元素，或者查询某元素在指定数组中的位置。使用 Arrays 类的 binarySearch() 方法可以实现数组的查找，该方法可使用二分搜索法来搜索指定数组，以获得指定对象，该方法返回要搜索元素的索引值。

第一种形式：

binarySearch(Object[] a,Object key);

如果找到就返回搜索值的索引，否则返回-1或者负的插入值。

在进行数组查询之前，必须对数组进行排序（可以使用 sort() 方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法确认找到的是哪一个。

        int[] arr=new int[]{1,3,5,4,7};
        int key=2;
        int value=4;
        Arrays.sort(arr);//排序
        System.out.println(Arrays.binarySearch(arr,value));
        System.out.println(Arrays.binarySearch(arr,key));

除了上述形式外，binarySearch() 还有另一种常用的形式，这种形式用于在指定的范围内查找某一元素。语法如下：

binarySearch(Object[] a,int fromIndex,int toIndex,Object key);

这个也需要提前进行排序

    int []arr=new int[]{2,5,8,9,6,3};
    Arrays.sort(arr);
    int key=6;
    int fromindex=2;
    int endindex=5;
    System.out.println(Arrays.binarySearch(arr,fromindex,endindex,key));

Java复制（拷贝）数组的4种方法：arraycopy()方法、clone() 方法、copyOf()和copyOfRan

java中的四种拷贝方式：

1.Arrays类中的copyOf()方法；

2.Arrays类中的copyOfRange()方法；

3.System类的arraycopy方法

4.Object类的clone方法

1. 使用 copyOf() 方法对数组进行复制

Arrays.copyOf(dataType[] srcArray,int length);

其中，srcArray 表示要进行复制的数组，length 表示复制后的新数组的长度。

使用这种方法复制数组时，默认从原数组的第一个元素（索引值为 0）开始复制，目标数组的长度将为 length。如果 length 大于 srcArray.length，则目标数组中采用默认值填充；如果 length 小于 srcArray.length，则复制到第 length 个元素（索引值为 length-1）即止。

注意：目标数组如果已经存在，将会被重构。

int []arr=new int[]{57,81,68,75,91};
int []arrcopy=(int[])Arrays.copyOf(arr,8);
for(int i=0;i<arrcopy.length;i++){
    System.out.print(arrcopy[i]+"\t");
}
//57    81    68    75    91    0    0    0

2. 使用 CopyOfRange() 方法对数组进行复制

Arrays 类的 CopyOfRange() 方法是另一种复制数组的方法，其语法形式如下：

Arrays.copyOfRange(dataType[] srcArray,int startIndex,int endIndex)

srcArray 表示原数组。
startIndex 表示开始复制的起始索引，目标数组中将包含起始索引对应的元素，另外，startIndex 必须在 0 到 srcArray.length 之间。
endIndex 表示终止索引，目标数组中将不包含终止索引对应的元素，endIndex 必须大于等于 startIndex，可以大于 srcArray.length，如果大于 srcArray.length，则目标数组中使用默认值填充.

int []arraycopyOfRange=(int[])Arrays.copyOfRange(arr,0,3);

        for(int i=0;i<arraycopyOfRange.length;i++){
            System.out.print(arraycopyOfRange[i]+"\t");
        }//57    81    68

3.使用 arraycopy() 方法

arraycopy() 方法位于 java.lang.System 类中，其语法形式如下：

System.arraycopy(dataType[] srcArray,int srcIndex,int destArray,int destIndex,int length)

其中，srcArray 表示原数组；srcIndex 表示原数组中的起始索引；destArray 表示目标数组；destIndex 表示目标数组中的起始索引；length 表示要复制的数组长度。

        int[] arr=new int[]{ 100, 81, 68, 75, 91, 66, 75, 100 };
        int newScores[] = new int[] { 80, 82, 71, 92, 68, 71, 87, 88, 81, 79, 90, 77 };
        int sindex=0;
        int tindex=2;
        for (int k = 0; k < newScores.length; k++) {
            System.out.print(newScores[k] + "\t");
        }
        System.out.println();
        System.arraycopy(arr,sindex,newScores,tindex,8);

        for (int k = 0; k < newScores.length; k++) {
            System.out.print(newScores[k] + "\t");
        }
//80    82    71    92    68    71    87    88    81    79    90    77    
//80    82    100    81    68    75    91    66    75    100    90    77

4.使用clone的方法

clone() 方法也可以实现复制数组。该方法是类 Object 中的方法，可以创建一个有单独内存空间的对象。因为数组也是一个 Object 类，因此也可以使用数组对象的 clone() 方法来复制数组。

clone() 方法的返回值是 Object 类型，要使用强制类型转换为适当的类型。其语法形式比较简单：

array_name.clone()

//int[] targetArray=(int[])sourceArray.clone();

        int []s=new int[]{1,3,5,7,9};
        int []a=(int[]) s.clone();
        System.out.println(Arrays.equals(a,s));\\True

Java sort()数组排序（升序和降序）

使用 java.util.Arrays 类中的 sort() 方法对数组进行升序分为以下两步：

导入 java.util.Arrays 包。
使用 Arrays.sort(数组名) 语法对数组进行排序，排序规则是从小到大，即升序。

Arrays.sort(s);

降序

1）利用 Collections.reverseOrder() 方法（Collections 是一个包装类。大家可以学习《Java Collections类》一节详细了解）：

这里必须使用类进行排序

        Integer[] t={9,6,2,5,1};
        Arrays.sort(t,Collections.reverseOrder());

2）实现 Comparator 接口的复写 compare() 方法，代码如下:

有错误！！！

Java冒泡排序法（非常重要）

冒泡排序的基本思想是：对比相邻的元素值，如果满足条件就交换元素值，把较小的元素值移动到数组前面，把大的元素值移动到数组后面（也就是交换两个元素的位置），这样数组元素就像气泡一样从底部上升到顶部。

        Scanner sc=new Scanner(System.in);
        double[] socre=new double[5];
        for(int i=0;i<socre.length;i++){
            System.out.print("请输入第 " + (i + 1) + " 个成绩：");
            socre[i]=sc.nextDouble();
        }
        System.out.println("排序前的元素值：");
        for(double var:socre){
            System.out.print(var+"\t");
        }
        System.out.println();
        System.out.println("通过冒泡排序方法对数组进行排序：");
        for(int i=0;i<socre.length-1;i++){
            for(int k=0;k<socre.length-1-i;k++){
                if(socre[k]>socre[k+1]){
                double tmp=socre[k+1];
                socre[k+1]=socre[k];
                socre[k]=tmp;
                }
            }

        }
        System.out.println("排序后的元素值：");
        for(double var:socre){
            System.out.print(var+"\t");
        }
        
        \\\
        
请输入第 1 个成绩：5
请输入第 2 个成绩：3
请输入第 3 个成绩：7
请输入第 4 个成绩：1
请输入第 5 个成绩：4
排序前的元素值：
5.0	3.0	7.0	1.0	4.0	
通过冒泡排序方法对数组进行排序：
排序后的元素值：
1.0	3.0	4.0	5.0	7.0	
        
        \\\

Java快速排序法（Quicksort）

快速排序的基本思想是：通过一趟排序，将要排序的数据分隔成独立的两部分，其中一部分的所有数据比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此使整个数据变成有序序列。

具体做法是：假设要对某个数组进行排序，首先需要任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它的前面，所有比它大的数都放到它的后面。这个过程称为一趟快速排序；递归调用此过程，即可实现数据的快速排序。

 int[] number={13,15,24,99,14,11,1,2,3};
    System.out.print("排序前：");
    for(int var:number){
        System.out.print(var+"\t");
    }
    quick(number);
    System.out.println("\n排序后：");
    for(int val:number) {
    System.out.print(val +" ");
    }

    }

    public static int getMiddle(int []list,int low,int high){
        int tmp=list[low];
        while(low<high){
            while(low<high&&list[high]>tmp){high--;}
            list[low]=list[high];
            while (low<high&&list[low]<tmp){low++;}
            list[high]=list[low];
        }
        list[low]=tmp;
        return low;
    }

    public static void unckSort(int[] list,int low,int high){
        if(low<high){
            int middle =getMiddle(list, low, high);
            unckSort(list,low,middle);
            unckSort(list,middle+1,high);
        }
    }
    public static void quick(int[] str){

        if(str.length>0){
            unckSort(str,0,str.length-1);
        }
    }

Java选择排序法

使用选择排序法也可以对上述数组中的元素进行排序，但是它与冒泡排序不同。选择排序是指每一趟从待排序的数据元素中选出最大（或最小）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。例如，使用选择排序法重新对 number 数组中的元素进行排序，那么第一趟排序后的结果如下：

        int[] number = {13,15,24,99,4,1};
        System.out.println("排序前：");
        for(int var:number){System.out.print(var+"\t");}
        String end="\n";
        int index;
        for(int i=1;i<number.length;i++){
            index=0;
            for(int j=1;j<=number.length-i;j++){
                if(number[j]>number[index]){index=j;}
            }
            int tmp=number[number.length-i];
            number[number.length-i]=number[index];
            number[index]=tmp;



        }
        System.out.println();
        System.out.println("排序后：");
        for(int var:number){System.out.print(var+"\t");}

Java直接插入排序法

直接插入排序的基本思想是：将 n 个有序数存放在数组 a 中，要插入的数为 x，首先确定 x 插在数组中的位置 p，然后将 p 之后的元素都向后移一个位置，空出 a§，将 x 放入 a§，这样可实现插入 x 后仍然有序。

int[] number = { 13, 15, 24, 99, 4, 1 };
        System.out.println("排序前：");
        for (int val : number) { // 遍历数组元素
            System.out.print(val + " "); // 输出数组元素
        }
        int temp,j;
        for (int i=1;i<number.length;i++){
            temp=number[i];
            for(j=i-1;j>=0&&number[j]>temp;j--)
            {number[j+1]=number[j];}
            number[j+1]=temp;

        }
        System.out.println("排序hou：");
        for (int val : number) { // 遍历数组元素
            System.out.print(val + " "); // 输出数组元素
        }

翻斗花园熊爷爷

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java数组

创建一维数组：type[] arrayName; // 数据类型[] 数组名;（一般使用这种，可读性比较好）或者type arrayName[]; // 数据类型数组名[];举个例子：int [] socre;String [] name;double [] price;特别注意，在声明数组时不需要规定长度：int score[10]; // 这是错误的声明数组只是得到了一个存放数组的变量，并没有为数组分配内存空间，所以不能使用，因此为数组分配空间，这样才能进行使用！int [] socre;
复制链接

扫一扫