数组Arrays入门

最新推荐文章于 2024-06-02 20:02:05 发布

m0_74352735

最新推荐文章于 2024-06-02 20:02:05 发布

阅读量558

点赞数 1

文章标签： java 开发语言 jvm

本文链接：https://blog.csdn.net/m0_74352735/article/details/130207214

版权

一、数组Arrays的声明、赋值、长度、历遍、输出：

1、一维数组：

a、静态：数组存储的数据类型[] 数组名 = new 数组存储的数据类型[]{元素1,元素2,……};

或数组存储的数据类型[] 数组名 = {元素1,元素2,……};

b、动态：数组存储的数据类型[] 数组名 = new 数组存储的数据类型[长度];

示例：

import java.util.Arrays;//Arrays.toString()
import java.util.Scanner;
public class Example4 {
    public static void main(String[] args){
        System.out.println("动态");
        int[] arr = new int[10];//动态
        Scanner in = new Scanner(System.in);
        for(int i = 0;i < arr.length;i++){//arr.length 数组的长度
            arr[i] = in.nextInt();//元素赋值(输入)
        }
        System.out.println("逐个输出数组arr的元素");
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + " ");//输出
        }
        System.out.println();
        System.out.println("整个输出数组arr的所有人元素");
        System.out.println(Arrays.toString(arr));//输出
        System.out.println("静态");
        int[] arr1 = new int[]{1,2,3,4,5};//静态
        arr1[2] = 6;//元素赋值
        System.out.println("逐个输出数组arr1的元素");
        for(int is : arr){//foreach循环输出数组
            System.out.print(is + " ");
        }
        System.out.println();
        System.out.println("输出数组arr1中地址为3的元素");
        System.out.println(arr1[3]);//访问数组元素
        System.out.println("输出数组arr1的长度");
        System.out.println(arr1.length);//数组长度
    }
}

运行结果：

注意：

a、如果使用静态方法创建数组，那么系统会根据元素个数自动计算数组的长度。

b、静态方式创建数组，右边的中括号里面不能写长度。

c、静态方式的省略格式创建数组不能先声明后赋值，只能声明的同时直接赋值。

2、二维数组：

a、静态：数据类型[][] 数组名 = {{元素1,元素2……},{元素1,元素2,……},……};

b、动态：数据类型数组名[][] = new 数据类型[m][n];

数据类型[][] 数组名 = new 数据类型[m][n];

数据类型[] 数组名[] = new 数据类型[m][n];

示例：

import java.util.Scanner;
import java.util.Arrays;
public class Example5 {
    public static void main(String[] args){
        System.out.println("动态");
        int[][] arr = new int [3][3];//声明
        Scanner in = new Scanner(System.in);
        for(int i = 0;i < arr.length;i++){//arr.length 行数
            for(int j = 0;j < arr[0].length;j++){//arr[0].length 列数
                arr[i][j] = in.nextInt();//赋值(输入)
            }
        }
        arr[1][1] = 7;//赋值
        System.out.println("双重for循环历遍arr");
        for(int i = 0;i < arr.length;i++){
            for(int j = 0;j < arr[0].length;j++){
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println("静态");
        int[][] arr1 = {{1,2,3},{4,5,6},{7,8,9}};//声明
        arr1[2][1] = 1;//赋值
        System.out.println("增强for循环foreach历遍");
        for(int[] is : arr1){
            for(int i : is){
                System.out.print(i + " ");
            }
            System.out.println();
        }
        System.out.println("输出数组arr1中第2行第2列第数值");
        System.out.println(arr1[1][1]);
    }
}

运行结果：

二、toString和foreach循环在数组的使用：

1、toString:打印数组

示例：

import java.util.Scanner;
import java.util.Arrays;
public class Example6 {
    public static void main(String[] args){
        //一维数组
        int[] arr = new int[10];
        Scanner in = new Scanner(System.in);
        System.out.println("一维数组输入:");
        for(int i = 0;i < arr.length;i++){
            arr[i] = in.nextInt();
        }
        System.out.println("toString输出");
        System.out.println(Arrays.toString(arr));//输出整个数组
        System.out.println("arr.toString()的输出:");
        System.out.println(arr.toString());//输出数组的地址
        System.out.println("arr的输出:");
        System.out.println(arr);//输出数组的地址
        // 二维数组
        int[][] arr1 = new int[3][3];
        System.out.println("二维数组输入");
        for(int i = 0;i < arr1.length;i++){
            for(int j = 0;j < arr1[0].length;j++){
                arr1[i][j] = in.nextInt();
            }
        }
        System.out.println("toString的输出:");
        System.out.println(Arrays.toString(arr1));
        //输出[[I@1b6d3586, [I@4554617c, [I@74a14482]的原因是arr1是一个二维数组。相当于一个长度为3的数组，但是这个数组的元素是数组。当执行Arrays.toString的时候相当于遍历数组，并且输出数组的元素，但是这个数组的元素是数组，所以这里输出的是数组元素是地址。
        System.out.println("arr1.toString的输出:");
        System.out.println(arr1.toString());//输出数组的地址
        System.out.println("arr1的输出");
        System.out.println(arr1);//输出数组的地址
        System.out.println("deepToStriing的输出:");
        System.out.println(Arrays.deepToString(arr1));//输出整个数组
    }
}

运行结果：

2、foreach循环: 增强for循环遍历数组

示例：

//java foreach循环
import java.util.ArrayList;//ArrayList
import java.util.Arrays;//toString
import java.util.List;//List
import java.util.Scanner;
public class Example2{
    public static void main(String[] args){
        //一维数组:
        int[] arr1 = new int[10];
        Scanner in = new Scanner(System.in);
        System.out.println("一维数组输入:");
        for(int i = 0;i < arr1.length;i++){
            arr1[i] = in.nextInt();
        }
        System.out.println("逐个输出一维数组的元素");
        for(int x : arr1){
            System.out.print(x + " ");
        }
        System.out.println();
        //二维数组:
        int[][] arr2 = new int[3][3];
        System.out.println("二维数组输入:");
        for(int i = 0;i < arr2.length;i++){
            for(int j = 0;j < arr2[0].length;j++){
                arr2[i][j] = in.nextInt();
            }
        }
        System.out.println("逐个输出二维数组的元素");
        for(int[] x : arr2){
            for(int y : x){
                //System.out.print(y + " ");
                System.out.printf("%-2d",y);
            }
            System.out.println();   
        }
        //集合:
        List<String> names = new ArrayList<String>();
        names.add("beibei");
        names.add("jingjing");
        for(String name : names){
            name = "huanhuan";
        }
        System.out.println(Arrays.toString(names.toArray()));
        for(int i = 0;i < names.size();i++){
            names.set(i,"huanhuan");
        }
        System.out.println(Arrays.toString(names.toArray()));
     }
}

运行结果:

三、数组操作与数组封装类Arrays：

1、System.arraycopy:数组元素拷贝

方法原型：

public static native void arraycopy(Object src,int srcPos,Object dest,int destPos,int length);

作用是从src数组的srcPos位置往dest数组的destPos位置拷贝length个元素。

示例：

//System.arraycopy
import java.util.Arrays;//toString
public class Example1 {
    public static void main(String[] args){
        int[] a = new int[10];
        int[] b = {5,4,3,2,1};
        System.out.println("copy all elements of b[5] to a[10]:");
        System.arraycopy(b,0,a,0,b.length);
        System.out.println(Arrays.toString(a));
        System.out.println("copy 4 elements of a[10] from index 0 to index 4:");
        System.arraycopy(a,0,a,4,4);
        System.out.println(Arrays.toString(a));
        System.out.println("copy 3 elements of a[10] from index 0 to index 8:");
        System.arraycopy(a,0,a,8,3);
        System.out.println(Arrays.toString(a));
        //Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException at java.lang.System.arraycopy(Native Method)
        //at Example1.main(Example1.java:17)
        //数组越界a.length = 10,copy的总长度不能超过10
        }
    }

运行结果：

注意：

如果数组拷贝位置或长度不当时，可能出现ArrayIndexOutOfBoundsException异常，也就是数组越界；如果类型不匹配时，会出现ArrayStoreException。

2、Arrays.equals:判断数组内容相等

Arrays中针对不同类型的数据提供了equals()方法的多个重组版本，包括各个基本类型的比较：

public static boolean equals(int[] a1,int[] a2);

public static boolean equals(long[] a1,long[] a2);

……

以及对象数组之间的比较：

public static boolean equals(Object[] a1,Object[] a2);

示例：

//Arrays.equals
import java.util.Arrays;//Arrays.equals
public class Example3 {
    public static void main(String[] args){
        int[] a = {1,2,3,4,5};
        int[] b = {1,2,3,4,5};
        System.out.println("int array compare equal?" + Arrays.equals(a,b));
        Integer c[] = {new Integer(1),new Integer(3)};
        Integer d[] = {new Integer(1),new Integer(3)};
        System.out.println("Integer array of autoBoxing and common Integer array:" + Arrays.equals(c,d));
        Integer e[] = {1,3};
        Integer f[] = {new Integer(1),new Integer(3)};
        System.out.println("Integer array of autoBoxing and common Integer array:" + Arrays.equals(e,f));
        // int g[] = {1,3};
        // Integer h[] = {new Integer(1),new Integer(3)};
        // System.out.println(Arrays.equals(g,h));
    }
}

运行结果：

对于最后一个int[]与Integer[]之间的比较，程序会报错：

int g[] = {1,3};

Integer h[] = {new Integer(1),new Integer(3)};

System.out.println(Arrays.equals(g,h));

原因是JDK中不存在不同类型之间比较的equals()方法重组版本，且此处无法自动将int[]转换为封装类型的数组Integer[],因此结果是编译出错。

3、Arrays.fill：数组填充内容

方法原型：

方法一：

public static void fill(Object[] a,Object val);

此方法将val填充至数组a中的每一个位置。需要注意的是，此处是浅拷贝。

方法二：

public static void fill(int[] a,int fromIndex,int toIndex,int value);

此方法将value填充至数组a从fromIndex位置（包含）到toIndex位置（不包含），且仅适用于int类型的数组。

示例：

//Arrays.fill
import java.util.Arrays;
public class Example8 {
    public static void main(String[] args){
        String[] strings = new String[10];
        Arrays.fill(strings,"A");
        System.out.println(Arrays.toString(strings));
        System.out.println();
        int[] number = new int[5];
        for(int i = 0;i < number.length;i++){
            Arrays.fill(number,i);
            System.out.println("number[" + i +"]=" + i);
        }
        System.out.println();
        int[][] a = new int[3][5];
        int[] b = new int[5];
        Arrays.fill(b,3);
        Arrays.fill(a,b);
        for(int i = 0;i < a.length;i++){
            for(int j = 0;j < b.length;j++){
                System.out.print(a[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println();
        int[] c = new int[5];
        Arrays.fill(c,1,4,8);
        Arrays.fill(a,c);
        for(int p[] : a){
            for(int e : p){
                System.out.print(e + " ");
            }
            System.out.println();
        }
    }
}

运行结果：

4、Arrays.asList：将数组转换为List

方法原型：

public static <T> List<T> asList(T…a);

此方法使用泛型作为参数及返回值，因此当方法参数和返回值List参数类型不一致时，编译器会报错。

示例：

//Arrays.asList
import java.util.Arrays;
import java.util.List;
public class Example9 {
    public static void main(String[] args){
        String strings[] = new String[10];
        Arrays.fill(strings,"A");
        List<String> asList = Arrays.asList(strings);
        System.out.println(asList);
        //长度：
        Integer array[] = {1,2,3,4,5};
        List list = Arrays.asList(array);
        System.out.println("长度=" + list.size());
        System.out.println("是否含有元素3=" + list.contains(3));
        //对集合使用增加或删除元素的操作将会报错
        // List list = Arrays.asList("a","b","c");
        // list.add("d");
        // list.remove("a");
        //Exception in thread "main" java.lang.UnsupportedOperationException
        // at java.util.AbstractList.add(AbstractList.java:148)
        // at java.util.AbstractList.add(AbstractList.java:108)
        // at Example9.main(Example9.java:14)

        // int integers[] = {1,2};
        // List<Integer> integers1 = Arrays.asList(integers);//编译出错
    }
}

运行结果：

对于最后List<Integer>会导致编译出错：

5、Arrays.sort：数组排序

方法原型：

方法一：

public static void sort(T[] a);

对整个数组a进行升序排序。

方法二：

public static void sort(T[] a,int fromIndex, int toIndex);

对数组a，从下标fromIndex开始，将toIndex个长度内的元素按升序排序。

方法三：

public static <T> void sort(T[] a,int fromIndex, int toIndex, Comparator<? super T> c)

sort()方法对于不同类型提供了多个重载版本。

示例：

//Arrays.sort
import java.util.Arrays;
public class Example10 {
    public static void main(String[] args){
        int[] arr = {2,3,4,1,6,5};
        //直接用是升序排列
        //第一种Arrays.sort(num)
        Arrays.sort(arr);
        System.out.println("升序排列：");
        System.out.println(Arrays.toString(arr));
        //第二种Arrays.sort(num,起始的下标，想要排序的树的数量)
        int[] arr1 = {0,2,4,1,5,3};
        Arrays.sort(arr1,0,arr.length-2);
        System.out.println("部分升序排列");
        System.out.println(Arrays.toString(arr1));
        //降序排列
        int[] arr2 ={2,5,6,3,1,0,4};
        Arrays.sort(arr2);
        System.out.println("降序排列：");
        for(int i = arr2.length - 1;i >= 0;i--){
            System.out.print(arr2[i] + " ");
        }
        System.out.println();
        //二维数组,sort()不能直接对二维数组排序，下面是对二维数组每一行进行排序
        int[][] arr3 = {{0,2,1},{4,3,5},{7,8,6}};
        for(int i = 0;i < arr3.length;i++){
            Arrays.sort(arr3[i]);
        }
        System.out.println("二维数组升序排列");
        System.out.println(Arrays.deepToString(arr3));
    } 
}

运行结果：

m0_74352735

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
数组Arrays入门

原因是JDK中不存在不同类型之间比较的equals()方法重组版本，且此处无法自动将int[]转换为封装类型的数组Integer[],因此结果是编译出错。a、静态：数组存储的数据类型[] 数组名 = new 数组存储的数据类型[]{元素1,元素2,……},{元素1,元素2,……数据类型[][] 数组名 = new 数据类型[m][n];b、动态：数组存储的数据类型[] 数组名 = new 数组存储的数据类型[长度];b、动态：数据类型数组名[][] = new 数据类型[m][n];
复制链接

扫一扫