精华内容
下载资源
问答
  • 新手小白学JAVA 数组 数组工具类 二维数组

    万次阅读 多人点赞 2021-04-02 08:28:55
    1 数组 1.1 概念 数组Array,标志是[ ] ,用于储存多个相同类型数据的集合 想要获取数组中的元素值,可以通过脚标(下标)来获取 数组下标是从0开始的,下标的最大值是数组的长度减1 1.2 创建数组 数组的创建方式一般...

    1 数组

    1.1 概念

    数组Array,标志是[ ] ,用于储存多个相同类型数据的集合
    想要获取数组中的元素值,可以通过脚标(下标)来获取
    数组下标是从0开始的,下标的最大值是数组的长度减1
    数组结构

    1.2 创建数组

    数组的创建方式一般分为动态初始化和静态初始化

    1. 动态初始化
      int[] a = new int[5];
    2. 静态初始化
      int[] b = new int[]{1,2,3,4,5};
      int[] c = {1,2,3,4,5};

    1.3 创建数组过程分析

    程序创建数组 int[] a = new int[5]; 时发生了什么?

    1. 在内存中开辟连续的空间,用来存放数据,长度是5
    2. 给数组完成初始化过程,给每个元素赋予默认值,int类型默认值是0
    3. 数组完成初始化会分配一个唯一的地址值
    4. 把唯一的地址值交给引用类型的变量a去保存

    数组名是个引用类型的变量,它保存着的是数组的地址,不是数组中的数据

    1.4 数组的长度

    数组的长度用 length属性来表示,数组一旦创建,长度不可改变
    数组的长度允许为0

    1.5 练习:向数组中存入数据hello

    数组中存入hello示例
    创建包: cn.tedu.array
    创建类: TestCreateArray.java

    package cn.tedu.array;
    
    import java.util.Arrays;
    
    /**本类用于练习数组的创建*/
    public class TestCreateArray {
    	public static void main(String[] args) {
    		//1.创建数组
    		//1.1静态创建--创建的时候已经知道了每一个元素的值
    		char[] c1 = {'h','e','l','l','o'};
    		char[] c2 = new char[] {'h','e','l','l','o'};
    		
    		//1.2动态创建--知道了数组的长度,后面再具体赋值
    		char[] c3 = new char[5];//在内存中开辟一块连续的内存空间,用来存放5个字符
    		//1.2.2给c3数组动态的赋值
    		/**我们通过数组的下标来操作数组中的每一个元素,注意数组下标从0开始*/
    		c3[0] = 'h';//给数组中的第1个元素赋值
    		c3[1] = 'e';//给数组中的第2个元素赋值
    		c3[2] = 'l';//给数组中的第3个元素赋值
    		c3[3] = 'l';//给数组中的第4个元素赋值
    		c3[4] = 'o';//给数组中的第5个元素赋值
    		
    		//2.打印查看刚刚创建好的数组
    		System.out.println(c1);
    		System.out.println(c2);
    		System.out.println(c3);
    		
    		//3.创建String类型的数组,存放数据"a","b","c"
    		String[] s1 = {"a","b","c"};
    		String[] s2 = new String[] {"a","b","c"};
    		String[] s3 = new String[3];
    		s3[0] = "a";//给s3数组的第1个元素赋值为"a"
    		s3[1] = "b";//给s3数组的第2个元素赋值为"b"
    		s3[2] = "c";//给s3数组的第3个元素赋值为"c"
    		
    		/**char类型的数组底层中做了处理,可以直接打印数组中的具体元素
    		 * 除了char类型以外的数组想要查看数组中的具体元素,需要使用数组的工具类Arrays
    		 * 具体方式:Arrays.toString(数组名);
    		 * 注意Arrays使用时需要导包*/
    		//4.打印创建好的数组
    		System.out.println(s1);//打印出来的是数组的地址值
    		System.out.println(Arrays.toString(s2));
    		
    		//5.查看数组的长度--数组中存放的元素的个数
    		/**数组一旦创建,长度不可改变,如果想要增加/删除数组中的元素
    		 * 只能先创建一个新长度的数组,再将原来的数据复制过去*/
    		System.out.println(c1.length);
    		System.out.println(s1.length);
    		
    	}
    	
    }
    

    1.6 数组的遍历

    遍历:从头到尾,依次访问数组每一个位置,获取每一个位置的元素.形式如下:
    我们通过数组的下标操作数组,所以for循环变量操作的也是数组下标

    开始:开始下标0 结束:结束下标length-1 如何变化:++
    for(从下标为0的位置开始 ; 下标的取值 <= 数组的长度-1 ; 下标++){
    循环体;
    }`

    1.7 练习-1:输出每个月的天数

    创建类: TestArrayExec.java

    package cn.tedu.array;
    /**本类用于练习数组的遍历
     * 需求:输出一年中每个月份的天数
     * */
    public class TestArrayExec {
    	public static void main(String[] args) {
    		m ();//本方法用于输出每个月的天数,快速修复快捷键Ctrl+1
    	}
    	//打印需求:例如 1月有31天
    	public static void m () {
    		//1.创建数组用来存12个月的天数
    		int[] a = {31,28,31,30,31,30,30,31,30,31,30,31};
    		
    		//2.输出每个月的天数打印到控制台
    		//数组的遍历--通过循环的方式--操作的是数组的下标
    		//循环开始:a[0]--数组中的第一个元素
    		//循环结束:a[a.length-1]--数组中的最后一个元素
    		//如何变化:++
    		//for(int i = 0 ; i <=a.length-1 ; i++) {
    		for(int i = 0 ; i <a.length ; i++) {
    			//a[i]--根据下标i来获取数组a中对应位置上元素的值
    			System.out.println((i+1)+"月有:"+a[i]+"天");
    		}
    	}
    }
    

    1.8 练习-2:遍历数组,存入1到10

    //需求:遍历数组,存入1-10
    	public static void m2() {
    		//1.创建数组--动态创建
    		int[] a = new int[10];
    		
    		//2.遍历数组,依次给每个位置赋值
    		//循环开始:a[0]--数组中的第一个元素
    		//循环结束:a[a.length-1]--数组中的最后一个元素
    		//如何变化:++
    		for(int i = 0 ; i <= a.length-1 ; i++) {
    			//a[i]--根据下标i来获取数组a中对应位置上元素的值
    			a[i] = i+1;
    		}//for循环结束
    		//3.在存入10个数据之后,打印a数组
    		System.out.println(a);//[I@15db9742
    		//除了char类型的数组,其他类型的数组想要查看具体内容需要借助工具类Arrays
    		//Arrays.toString(要打印的数组的名字)来查看数组中的具体内容
    		System.out.println(Arrays.toString(a));//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    		
    	}
    

    1.9 练习-3:创建随机数组

    需求:创建数组,数组中的内容是100以内的随机数

    public static void m3() {
    	//1.创建数组--动态
    	int[] a = new int[10];
    	//2.遍历数组,给数组中的每个元素赋值
    	for(int i = 0 ; i <a.length ; i++) {
    		//100是自定义的数据,表示生成的随机整数的范围是[0,100)
    		a[i] = new Random().nextInt(100);
    		//a[i] = new Random().nextInt(100)+1;//取值范围前后都+1-->[1,101)
    	}
    	//3.使用数组的工具类查看数组中的元素
    	System.out.println(Arrays.toString(a));
    }
    

    2 数组工具类Arrays

    2.1 Arrays.toString(数组)

    把数组里的数据,用逗号连接成一个字符串[值1,值2]
    

    2.2 Arrays.sort(数组)

    对数组进行排序,对于基本类型的数组使用的是优化后的快速排序算法,效率高
    对引用类型数组,使用的是优化后的合并排序算法
    

    2.3 练习:练习Arrays.sort(数组)

    创建类: TestArraysSort.java

    package cn.tedu.array;
    
    import java.util.Arrays;
    
    /**本类用于测试数组的工具类Arrays*/
    public class TestArraysSort {
    	public static void main(String[] args) {
    		//1.创建无序数组
    		int[] a = {21,96,75,23,25};
    		
    		//底层使用的排序算法是进行优化后的快速排序算法
    		Arrays.sort(a);//对无序数组进行直接排序
    		System.out.println(Arrays.toString(a));
    	}
    }
    

    2.4 Arrays.copyOf(数组,新的长度)

    把数组赋值成一个指定长度的新数组
    新数组的长度 大于 原数组, 相当于复制,并增加位置
    新数组的长度 小于 原数组, 相当于截取一部分数据

    2.5 练习:练习Arrays. copyOf(数组,新的长度)

    创建类: TestArraysCopyOf.java

    package cn.tedu.array;
    
    import java.util.Arrays;
    
    /**本类用于练习数组的缩容与扩容*/
    public class TestArraysCopyOf {
    	public static void main(String[] args) {
    		//1.创建数组
    		int[] from = {1,2,3,4,5};//数组一旦创建,长度不可改变
    		
    		//2.1 数组的普通复制
    		/**copyOf()用于完成数组的复制,两个参数:
    		 * 参数1:要复制哪个数组
    		 * 参数2:新数组的长度*/
    		int[] to = Arrays.copyOf(from, 5);
    		System.out.println(Arrays.toString(to));
    		
    		//2.2数组的扩容
    		/**扩容:给数组扩大容量,新数组的长度>原数组的长度
    		 * 扩容思路:先创建对应长度的新数组,每个位置上都是默认值0
    		 * 然后从原数组中将元素复制到新数组,没有被覆盖的元素还是默认值0*/
    		int[] to2 = Arrays.copyOf(from, 10);
    		System.out.println(Arrays.toString(to2));
    		
    		//2.3数组的缩容
    		/**缩容:缩小数组的容量,新数组的长度<原数组的长度
    		 * 缩容思路:先创建对应长度的新数组,每个位置上都是默认值0
    		 * 然后从原数组中复制指定个数的元素到新数组中,类似于截取*/
    		int[] to3 = Arrays.copyOf(from, 3);
    		System.out.println(Arrays.toString(to3));
    		
    		//2.4指定首尾截取原数组中的元素
    		/**copyOfRange()用于完成数组的截取,3个参数:
    		 * 参数1:要截取哪个数组【原数组】
    		 * 参数2:从原数组的哪个下标开始
    		 * 参数3:到原数组的哪个下标结束
    		 * 注意:截取的元素包含开始下标处的元素,不包含结束下标处的元素*/
    		int[] to4 = Arrays.copyOfRange(from, 2, 4);
    		System.out.println(Arrays.toString(to4));
    	}
    }
    

    3 拓展之二维数组

    3.1 概念

    存放数组的数组,也就是说数组里存的还是数组的数据形式
    二维数组图示

    3.2 创建二维数组

    int[][] a = {{3,5},{7,9},{1,2}};
    –创建外部数组,长度是3
    –给每个外部数组的位置创建内部数组,每个内部数组的长度是2
    –给每个内部数组进行数据初始化
    –二维数组生成唯一的地址值
    –把地址值交给引用类型变量a来保存

    3.3 遍历二维数组

    for (int i = 0; i < a.length; i++) {//遍历外部数组
    for (int j = 0; j < a[i].length; j++) {//遍历内部数组
    System.out.println(a[i][j]);//依次打印二维数组中每个元素的值
    }
    }

    3.4 打印二维数组中的数据

    package cn.tedu.array;
    
    import java.util.Arrays;
    
    /**本类用于打印二维数组中的数据*/
    public class TestArrays2 {
    	public static void main(String[] args) {
    		//1.创建二维数组
    		//    3      5    
    		//a[0][0] a[0][1]
    		//    7       9
    		//[1][0] a[1][1] 
    		//    1       2      3
    		//a[2][0] a[2][1] a[2][2]
    		int[][] a = {{3,5},{7,9},{1,2,3}};
    		
    		//2.遍历二维数组
    		for (int i = 0; i < a.length; i++) {
    //			System.out.println(Arrays.toString(a[i]));
    			for (int j = 0; j < a[i].length; j++) {
    				//a[i][j]--根据外部数组的下标和内部数组的下标定位具体的元素
    				System.out.print(a[i][j]);
    			}
    			System.out.println();
    		}
    	}
    }
    
    展开全文
  • Java数组

    千次阅读 2016-07-21 18:49:56
    java数组 java二位数组

    数组的作用:是用于存储大量相同类型的数据。

    一、语法

    1.是一个数据类型。

    2.在现有数据类型的后面,加上[]就变成了数组类型。

    数据类型->数组类型

    int -> int[]

    byte -> byte[]

    char ->char[]

    int[] -> int[][]

    int[][] -> int[][][]

     

    1.1初始化数组

    1.1.1动态初始化数组

    指定数组的长度,不指定数组里面每个元素的实际内容。实际内容全部自动填充默认值,如果是整数则为0,浮点则是0.0,引用类型的则是nullboolean类型则是false

    数据类型[] 变量名 = new 数据类型[长度];

    eg.

         // 声明一个类型为double[]的变量,名为wages

    // 使用new关键字创建一个double类型的数组,长度为30(连续30double

    // new以后,需要连续分配30double类型的内存空间

    // 30double的值,全部都是默认值

    double[] wages = newdouble[30];

     

     

    1.1.2静态初始化数组

    指定内容,不指定长度。长度系统自动计算。在{}里面直接指定每个元素,元素之间用逗号隔开

    数据类型[] 变量名 = new 数据类型[]{};

    // 声明一个类型为double[]的变量,名为wages

    // 内容在内存里面按照代码的顺序依次排列

    double[] wages = newdouble[]{1.0, 3, 5, 6.4};

     

    1.2使用数组

    1.2.1获取数组的长度

    变量名.length:返回int类型

    1.2.2获取数组里面的某个值(元素)

    利用偏移量来进行获取,这个偏移量不需要程序员计算字节,只需要计算偏移多少个元素即可。

    偏移量从0开始,0是第一个正整数,也表示第一个元素不需要偏移即可获取。

    数组变量[索引]

    1.2.3给数组里面的某个元素赋予值

    把数组里面的元素,当做是一个变量来使用即可!

    数组变量[索引] = ;

    eg.

    ar1[7] = 41;

     

    1.2.4使用循环输出数组里面所有的元素的值

    数组长度有多少,就循环输出多少次,并且第一个元素从0开始

    eg.

    for( int i=0; i<arg1.length; i++ ){

        System.out.println( arg1[i] );

    }

     

    1.2.5数组的排序

    把无序的数据,整理变成有序的数据。

     

    冒泡排序

    循环一次数组,找到数组里面最大的元素,并且把此元素的移动到数组的最后面。

    步骤

    1.循环数组,只需要循环长度减一次

    2.在循环里面,如果发现左边的数比右边的数大,交换两个数的位置

    3.在前面这个循环的外面,嵌套一层循环,循环数组长度减一次

    4.修改内层循环的比较次数,减去外层循环的计数器

     

    Arrays.sort 使用JDK自带的排序算法

     

    Arrays.parallelSort Java 8新增的并行排序算法

     

    二、数组存储方式

    数组是一种引用数据类型,所有的引用数据类型,必须要new才能得到实际的值。除了char类型的数组外,其他的所有类型的数组都是输出内存地址,而char数组输出的是实际内容。

    输出流System.outPrintStream对象,PrintStream有多个重载的println方法,其中一个就是public void println(char[] x),直接打印字符数组的话,不像int[]等其他数组,它会直接调用这个方法来打印,因而可以打印出数组内容,而不是地址。

    // 1.声明一个int[]类型的变量,名为ar1

    // 2.创建10个连续的int,放到一个数组里面,并且返回内存地址[I@***,其中[I@表示int数组;[BByte数组

        //除了char类型的数组外,其他的所有类型的数组都是输出内存地址,而char数组输出的是实际内容

    // 3.把返回的内存地址给ar1作为值

    // 每个int都是为0

    int[] ar1 = newint[10];

     

    System.out.println(ar1);

     

    系统把内存分为栈、堆两个区域,所有的变量的值,都是存储在栈里面。

    基本类型的值,就是变量的值;引用类型的值,只是一个内存地址。

    引用类型利用这个内存地址,到堆里面去获取实际的数据。

     

    引用数据类型的值,也被称之为"指针"。

    但是Java里面不能直接操作"指针",都系统自动控制的。

    指针其实就是一个数字!但是不能被直接当做数字使用。

     

    三、Java数组的特点:

    长度不可变,在new的时候,数组的长度是多少,那么会一直是那么长。

    3.1变相进行数组扩容

    既然Java的数组长度是不能变的,那么就创建一个新的数组,并且把旧的数组里面的内容,复制到新数组里面。

    最后把新数组作为使用的数组。

    int[] ar = newint[]{10,20,30,40,50};

     

    //1/2/3步骤全部使用多行注释给注释掉,那么就会出现"数组索引超出边界异常"

    // java.lang.ArrayIndexOutOfBoundsException

     

    //把容量改为10

    //1.创建一个长度为10的新数组

    int[] t = newint[10];

    //2.ar里面的每个元素,复制到新数组里面

    for( inti = 0; i < ar.length; i++ )

    {

    // ar数组里面i位置的值,赋予给t数组里面的i位置

    // i0~4

    t[i] = ar[i];

    }

    //3.把新数组赋予给ar变量

    ar = t;

     

    //在索引为56的位置,分别是(666,777

    ar[5] = 666;

    ar[6] = 777;

     

     

    System.out.println( ar.length );// 10

     

    for( inti = 0; i < ar.length; i++ )

    {

    // 10 20 30 40 50 666 777

    System.out.println( ar[i] );

    }

     

    3.2在数组的中间部分插入、删除元素

    如果要在中间插入元素:

    1.要把现有的位置的元素移动在后面一位,在移动之前,需要先检查空间是否足够。

    2.把新的元素,插入到原有的位置

     

    如果把中间的某个元素删除

    把后面一位的元素,往前移动一位

     

    3.3简化的for循环

    自从Java 5以后,jdk提供了简化的for循环用于输出数组的内容

    for( <数据的数据类型> <变量名> : <数组变量名> )

    {

    //

    }

    eg.

    int[] ar = new ...

    for( int i = 0; i < ar.length; i++ )

    {

    int v = ar[i];

    }

    上面内容可以简化为:

    //简化的for循环只适合读取,不能给数组里面写数据

    //好处是不需要声明一个循环计数器

    //数组有多少个元素,就循环多少次,每次循环的时候把元素取出下一个放到变量v里面

    for( int v : ar )

    {

    }

     

    四、二维数组

    本质上不存在二维数组!全部都是一维数组。

    所谓"二维数组",其实是"数组数据类型"的数组。

    int -> int[]

    int[] 就是int的数组类型

    int[][] 就是int数组的数组

    理解二维数组的时候,最典型的实体就是电子表格。

     

    4.1动态初始化

    //53

    int[][] ar = new int[5][3];

     

    //5行,列的数量未知

    //每行都没有内容,为null

    int[][] ar = new int[5][];

     

    4.2二维数组的使用

    // ar1int[]类型的数组,那么里面装的是int[]类型的数据

    int[][] ar1 = newint[5][3];

     

    //获取ar1索引为0的元素,赋予给x变量

    //因为ar1里面装的是int[],所以x的类型必须是int[]

    //取出第0

    //x的使用方法和其他int数组没有任何差别

    int[] x = ar1[0];

     

    //5行,列未知

    //每行都没有内容,为null

    int[][] ar2 = newint[5][];

     

     

    // ar1的长宽已知,[I@表示内存地址

    System.out.println( ar1[1] );

    // null 表示空,就是未赋予实际的内容

    System.out.println( ar2[1] );// null

     

    //ar2变量里面的第 4 行,赋予一个具体的int[]

    ar2[4] = newint[]{3,4,5,6,7,8,9};

    System.out.println( ar2[1] );// null

    System.out.println( ar2[4] );// [I@内存地址

     

     

    五、Arrays

    专门用来操作数组的一个工具。使用此类的时候,必须先导入 java.util.Arrays 类。

    常用方法

    toString : 用于把数组转换为String,通常输出的时候使用。

    binarySearch : 使用二分查找法,在数组里面查询指定的元素的位置。使用的时候必须确保数据是有序的。

    copyOf : 复制数组用的,性能非常高,因为直接使用系统底层的API,复制堆内存。

    copyOfRange : 复制原始数组中的一部分,产生一个新的数组。

    parallelSort : 并行排序。在Java 8之前,排序之类的动作只能由一个CPU内核来完成。

    并行排序能够同时利用多个CPU内核进行排序,并且排序后把结果汇总一起。

    sort: 以前的使用单个CPU核进行排序的方法。

    eg.将数组转化为string输出;扩容

    import java.util.Arrays;

     

    publicclassTestArrays

    {

    publicstaticvoid main(String[] args)

    {

    int[] ar = newint[]{13,4,6,8,9};

     

    //把数组里面所有的内容全部输出

    // Arrays.toString(ar)是把ar里面的内容转换为String类型,直接输出

    System.out.println( Arrays.toString(ar) );

     

     

    //相当于是扩容

    int[] ar1 = Arrays.copyOf(ar, ar.length + 5);

    System.out.println(ar.length);

    System.out.println(ar1.length);

    }

    }

     

     

    六、获取java的命令行参数

    开始运行之前传递进来

    main方法后面的圆括号里面,每次总有一个 String[] args 是固定的,main方法必须有此参数。

    这是String[]类型的参数,用于装多个String

    String[] args相当于就是一个变量,这个变量用来装从命令行在启动java命令的时候,传入的命令行参数。

    在命令行里输入java <类名> [多个参数,使用空格隔开],空格的数量不限,但是都只认非空格,每组空格间的非空格都是一个参数。

    publicclassTestArguments

    {

    publicstaticvoid main(String[] args)

    {

    //数组的长度就是参数的个数

    System.out.println("参数的个数: " + args.length);

     

    //输出所有的参数

    for( String s : args )

    {

    System.out.println( s );

    }

    }

    }

    在命令行里输入

    java TestArguments

    运行结果

    参数的个数:0

    在命令行里输入

    java TestArguments a b cc d

    运行结果

    参数的个数:4

    a

    b

    cc

    d

     

    运行中传递进来

    使用System.in可以获得键盘输入。键盘输入也被称之为"标准输入流"。 System.in

    屏幕(cmd)也被称之为"标准输出流"。 System.out

    同时屏幕(cmd)也有另外一个作用,叫做"标准错误输出流",专门输出错误信息的。System.err

     

    System.in使用的时候比较麻烦,因为是通过字节( byte[] )的方式来处理数据的。

    所以通常接收键盘的输入,会使用Scanner,创建Scanner的时候,需要一个标准的字符输入流。

    eg.

    //导入

    import java.util.Scanner;

    //创建实例

    //创建一个Scanner,用于读取标准输入流里面的字符串内容

    Scanner s = new Scanner( System.in );

     

    import java.util.Scanner;

     

    publicclassTestScanner

    {

    publicstaticvoid main(String[] args)

    {

    //创建实例

    Scanner s = new Scanner( System.in );

     

     

    //调用next开头的方法,会等待键盘的输入,输入内容以后,遇到回车就会结束next

    //获得键盘输入的字符串

    String c = s.next();

     

    System.out.println( "输入的字符串: " + c );

     

     

    //等待输入数字。如果输入的字符串无法转换为int,报错

    inti = s.nextInt();

    System.out.println( "整数: "+ i );

    }

    }

     

    七、重点

    普通的一维数组

    动态初始化、静态初始化

    获取数组长度

    获取数组的元素

    给数组里面的元素赋予值

    循环输出数组里面所有的内容

    普通的for循环

    简化的for循环

     

    八、练习

    练习1

    使用循环给一个长度为20的数组里面的每个元素,填入随机的值。

     

    要使用随机,需要使用 java.util.Random 类的实例

    1.java源代码的第一行写上

    import java.util.Random;

    2.声明Random类变量,并且创建Random类的实例

    Random r = new Random();

    3.调用Random实例的nextInt方法产生随机数

    int t = r.nextInt();

     

    实现步骤:

    1.import

    2.main方法里面new一个Random

    3.new一个int数组,长度为20

    4.使用for循环给数组里面的每个元素赋予一个随机数

    5.使用另外一个循环,计算需要的结果变量(四个)

     

    练习2

    把练习1里面的数组里面的值,计算以下几个结果:

    1.总和

    2.最大值

    3.最小值

    4.平均值

     

    练习3

    计算1~100的阶乘,只需要一个循环即可

     

    练习4

    找出1~1000以内的所有完全数

     

    完全数

    当一个数的所有真约数(所有的约数里面,除本身之外的约数)的和等于数本身,那么这个数就是完全数。

    eg.

    6的约数:1/2/3/6

    publicclass Wanquanshu

    {

    publicstaticvoid main(String[] args)

    {

        intsum = 0;

        for( inti=1; i<=1000; i++ ){

            for( intj=1; j<i; j++ ){

                if( i%j==0 ){

                    sum += j;

                }

            }

            if( sum==i )

                System.out.println(sum);

            sum = 0;

        }

         

    }

    }

     

    练习5

    把一个数组的内容对调

    eg.

    int[] ar = new int[]{1,2,3,4,5};

    //对调后的结果是 5,4,3,2,1

    publicclass duidiao

    {

    publicstaticvoid main(String[] args)

    {

        int[] ar = newint[]{1,2,3,4,5};

        intar_length = ar.length;

        int[] ar2 = newint[ar_length];

        for( inti=0; i<ar_length; i++ ){

            ar2[ar_length-i-1] = ar[i];

        }     

    }

    }

     

    练习6

    随机生成数字,检查此数字是否在数组里面已经存在

    Random r = new Random();

    //生成1~10之间的数字

    int t = r.nextInt(10) + 1;

     

    //检查t是否已经在ar里面,如果在则输出已经存在;否则输出不存在。

    //如果检查到已经存在则不再继续检查。

    int[] ar = new int[]{1,2,4,5,6,8,10};

     

    练习7

    生成随机字符

    字符的本质就是数字,生成0~25之间的随机数,然后加上小写字母a,那么就变成az的字符。

    int t = r.nextInt(26);

    char c = (char) (t + 'a');

     

    练习8

    生成包括AZaz0~9之间的6位字符。

    aBc61h

    8Acl0o

    在随机字符的基础上,结合重复检查,实现不重复的随机字符。

    package shuzu;

     

    //1.导入Random

    import java.util.Random;

    //生成6位随机字符

    publicclassRandomChar2

    {

    publicstaticvoid main(String[] args)

    {

    //2.

    Random r = new Random();

     

    //3.放一个共享的数组,里面包含了所有需要的字符

    char[] cs = newchar[62];

    //3.1.循环给cs变量里面的每个元素赋予一个字符

    for(inti = 0; i < 26; i++)

    {

    //i = 0 ~ 25

    // 0~25的位置,放小写字母

    cs[i] = (char)(i + 'a');

     

    // i + 26 表示 26 ~ 51的范围,放大写字母

    cs[i + 26] = (char)(i + 'A');

     

    // 判断i小于10的时候,正好有10个数字,放到最后

    // 52 + i

    if ( i < 10 )

    {

    cs[i + 52] = (char)(i + '0');

    }

    }

     

    //cschar类型的数组,直接使用System输出,会输出内容

    System.out.println( cs );

     

    //4.循环6次,每次循环生成一个数字,这个数字的范围是0~数组长度减一

    // 这个数字其实就是数组的索引

    for( inti = 0; i < 6; i++ )

    {

    //随机生成cs索引范围的数字,利用这个数字到cs里面获取字符

    intindex = r.nextInt( cs.length );

     

    //5.利用生成的随机索引,从数组里面取字符

    charc = cs[index];

    System.out.print( c );

    }

    System.out.println( );

    }

    }

     

    练习9

    魔术矩阵

    在一个二维数组里面,实现每行、每列、对角线的值的和相等。

     

    规则就是不断的往右上角填数

    步骤

    1.把第一个数放在第一行的最中间

    2.x加一,y减一

    如果y小于0,那么就把y的值设置为行数减一

    如果x大于长度,那么就把x的值设置为0

    3.如果当前填的数是行数的整数倍,那么不要进行第二步。

    直接y加一

    ar[y][x] =

     

    展开全文
  • Java 数组

    千次阅读 2018-05-24 14:55:06
    Java 数组数组对于每一门编程语言来说都是重要的数据结构之一,当然不同语言对数组的实现及处理也不尽相同。Java 语言中提供的数组是用来存储固定大小的同类型元素。你可以声明一个数组变量,如 numbers[100] 来代替...

    Java 数组

    数组对于每一门编程语言来说都是重要的数据结构之一,当然不同语言对数组的实现及处理也不尽相同。

    Java 语言中提供的数组是用来存储固定大小的同类型元素。

    你可以声明一个数组变量,如 numbers[100] 来代替直接声明 100 个独立变量 number0,number1,....,number99。

    本教程将为大家介绍 Java 数组的声明、创建和初始化,并给出其对应的代码。


    声明数组变量

    首先必须声明数组变量,才能在程序中使用数组。下面是声明数组变量的语法:

    dataType [ ] arrayRefVar ; // 首选的方法
    dataType arrayRefVar [ ] ; // 效果相同,但不是首选方法
    dataType arrayRefVar1[],arrayRefVar2[]; //  同时声明多个数组

    注意: 建议使用 dataType[] arrayRefVar 的声明风格声明数组变量。 

    dataType arrayRefVar[] 风格是来自 C/C++ 语言 ,在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。

    注意:与C/C++不同,Java不允许在声明数组中的方括号内指定数组元素的个数。

    若声明int a[12]; 或 int [12] a; 将导致语法错误

    实例

    下面是这两种语法的代码示例:

    double [ ] myList ; // 首选的方法
    double myList [ ] ; // 效果相同,但不是首选方法

    创建数组

    Java语言使用new操作符来创建数组,语法如下:

    arrayRefVar = new dataType[arraySize];

    上面的语法语句做了两件事:

    • 一、使用 dataType[arraySize] 创建了一个数组。
    • 二、把新创建的数组的引用赋值给变量 arrayRefVar。

    数组变量的声明,和创建数组可以用一条语句完成,如下所示:

    dataType[] arrayRefVar = new dataType[arraySize];

    另外,你还可以使用如下的方式创建数组。

    dataType[] arrayRefVar = {value0, value1, ..., valuek};

    数组的元素是通过索引访问的。数组索引从 0 开始,所以索引值从 0 到 arrayRefVar.length-1。

    实例

    下面的语句首先声明了一个数组变量 myList,接着创建了一个包含 10 个 double 类型元素的数组,并且把它的引用赋值给 myList 变量。

    TestArray.java 文件代码:

    public class TestArray {
        public static void main ( String [ ] args ) {
            // 数组大小
            int size = 10 ;
            // 定义数组
            double [ ] myList = new double [ size ] ;
            myList [ 0 ] = 5 .6 ;
            myList [ 1 ] = 4 .5 ;
            myList [ 2 ] = 3 .3 ;
            myList [ 3 ] = 13 .2 ;
            myList [ 4 ] = 4 .0 ;
            myList [ 5 ] = 34 .33 ;
            myList [ 6 ] = 34 .0 ;
            myList [ 7 ] = 45 .45 ;
            myList [ 8 ] = 99 .993 ;
            myList [ 9 ] = 11123 ;
            // 计算所有元素的总和
            double total = 0 ;
            for ( int i = 0 ; i < size ; i ++ ) {
                total += myList [ i ] ;
            }
            System . out . println ( " 总和为: " + total ) ;
        }
    }

    以上实例输出结果为:

    总和为: 11367.373

    注意:与C不同,Java允许使用int型变量的值指定数组元素的个数:

    int size = 30;

    double number[] = new double[size];

    数组一经分配空间,其中的每个元素都被按照成员变量同样的方式被隐式初始化。(数值类型是0或0.0,引用类型是null)

    int []a = new int[5];//a[3]则是0

    下标值超出范围(0到长度-1)时,能通过编译但访问时会抛出异常:ArrayIndexOutOfBoundsException


    下面的图片描绘了数组 myList。这里 myList 数组里有 10 个 double 元素,它的下标从 0 到 9。

    java数组结构说明


    处理数组

    数组的元素类型和数组的大小都是确定的,所以当处理数组元素时候,我们通常使用基本循环或者 foreach 循环。

    示例

    该实例完整地展示了如何创建、初始化和操纵数组:

    TestArray.java 文件代码:

    public class TestArray {
        public static void main ( String [ ] args ) {
            double [ ] myList = { 1 .9 , 2 .9 , 3 .4 , 3 .5 } ;
            // 打印所有数组元素
            for ( int i = 0 ; i < myList . length ; i ++ ) {
                System . out . println ( myList [ i ] + " " ) ;
            }
             // 计算所有元素的总和
            double total = 0 ;
            for ( int i = 0 ; i < myList . length ; i ++ ) {
                total += myList [ i ] ;
            }
            System . out . println ( " Total is " + total ) ;
            // 查找最大元素
            double max = myList [ 0 ] ;
            for ( int i = 1 ; i < myList . length ; i ++ ) {
                if ( myList [ i ] > max ) max = myList [ i ] ;
            }
        System . out . println ( " Max is " + max ) ;
        }
    }

    以上实例编译运行结果如下:

    1.9
    2.9
    3.4
    3.5
    Total is 11.7
    Max is 3.5

    length实例变量

    Java中的数组是一种对象,它会有自己的实例变量。事实上,数组只有一个公共实例变量,也就是length变量,这个变量值得是数组的长度。
    int[] array1 = new int[10];
    array1的length的值为10,使用for循环的时候就可以不用事先知道数组的大小:for(int i = 0;i < array1.length; i++)

    foreach 循环

    JDK 1.5 引进了一种新的循环类型,被称为 foreach 循环或者加强型循环,它能在不使用下标的情况下遍历数组。

    示例

    该实例用来显示数组myList中的所有元素:

    TestArray.java 文件代码:

    public class TestArray {
        public static void main ( String [ ] args ) {
            double [ ] myList = { 1 .9 , 2 .9 , 3 .4 , 3 .5 } ;
            // 打印所有数组元素
            for ( double element : myList ) {
                System . out . println ( element ) ;
            }
        }
    }

    以上实例编译运行结果如下:

    1.9
    2.9
    3.4
    3.5

    数组作为函数的参数

    数组可以作为参数传递给方法。

    例如,下面的例子就是一个打印 int 数组中元素的方法:

    public static void printArray ( int [ ] array ) {
        for ( int i = 0 ; i < array . length ; i ++ ) {
            System . out . print ( array [ i ] + " " ) ;
        }
    }

    下面例子调用 printArray 方法打印出 3,1,2,6,4 和 2:

    printArray ( new int [ ] { 3 , 1 , 2 , 6 , 4 , 2 } ) ;

    数组作为函数的返回值

    public static int [ ] reverse ( int [ ] list ) {
        int [ ] result = new int [ list . length ] ;
        for ( int i = 0 , j = result . length - 1 ; i < list . length ; i ++, j -- ) {
            result [ j ] = list [ i ] ;
        }
        return result ;
    }

    以上实例中 result 数组作为函数的返回值。


    命令行参数

    命令行参数就是用户在执行程序时提供的一些参数,以供程序运行时使用,而不是每次都修改源程序中的数据或者通过标准输入输出读取用户输入的参数。(现在比较流行使用Scanner类)。
    在所有的Java程序中都有一个main方法,而这个方法带有一个参数String args[],这个参数就是main方法接受的用户输入的参数列表,即命令行参数。
    public class ArgsDemo
    {
       public static void main(String args[])
     {
        System.out.println("共接受到" + args.length + "个参数");
           for(int i = 0;i < args.length;i++)
      System.out.println("第" + i +"个参数" +args[i]);
      }
    }

    多维数组

    多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组,例如:

    String str [ ] [ ] = new String [ 3 ] [ 4 ] ;

    多维数组的动态初始化(以二维数组为例)

    1. 直接为每一维分配空间,格式如下:

    type arrayName = new type [ arraylenght1 ] [ arraylenght2 ] ;

    type 可以为基本数据类型和复合数据类型,arraylenght1 和 arraylenght2 必须为正整数,arraylenght1 为行数,arraylenght2 为列数。

    例如:

    int a [ ] [ ] = new int [ 2 ] [ 3 ] ;

    解析:

    二维数组 a 可以看成一个两行三列的数组。

    2. 从最高维开始,分别为每一维分配空间,例如:

    String s [ ] [ ] = new String [ 2 ] [ ] ;
    s [ 0 ] = new String [ 2 ] ;
    s [ 1 ] = new String [ 3 ] ;
    s [ 0 ] [ 0 ] = new String ( " Good " ) ;
    s [ 0 ] [ 1 ] = new String ( " Luck " ) ;
    s [ 1 ] [ 0 ] = new String ( " to " ) ;
    s [ 1 ] [ 1 ] = new String ( " you " ) ;
    s [ 1 ] [ 2 ] = new String ( " ! " ) ;

    解析:

    s[0]=new String[2] 和 s[1]=new String[3] 是为最高维分配引用空间,也就是为最高维限制其能保存数据的最长的长度,然后再为其每个数组元素单独分配空间 s0=new String("Good") 等操作。

    多维数组的引用(以二维数组为例)

    对二维数组中的每个元素,引用方式为 arrayName[index1][index2],例如:

    num [ 1 ] [ 0 ] ;

    数组拷贝

    数组拷贝可以直接把一个数组变量拷贝给另一个,这时候,数组都指向同一个数组。
    假如有两个数组array1和array2,执行array1 = array2;这时候两个数组类型变量都指向同一个数组,及原来的array2所指向的数组。
    执行数组拷贝后,改变array2中的值,array1的值也会改变。
    这样的方法有点“粗暴”,如果只想把一个数组的值拷贝给另一个数组,要使用System类中的arraycopy方法。
    System.arraycpy(fromArray,fromIndex,toArray,toIndex,length); // length表示复制length个元素
    注意,目标数组必须有足够的空间来存放复制的数据,如果空间不择的话,会抛出异常,并且不会修改该数组。
    int[] array1 = {1,2,3,4,5,6,7,8,9};
    int[] array2 = {10,20,30,40,50,60,70,80,90};
    System.arraycopy(array1,0,array2,2,5);
    结果:10 20 1 2 3 4 5 80 90

    数组排序


    1.选择排序

    思路:对一个长度为n的数组进行n趟遍历,第一趟遍历选出最大(或最小)的元素,将之与数组的第一个元素交换, 然后进行第二趟遍历,再从剩余的元素中选取最大(或者最小)的元素,将之与数组的第二个元素交换。 这样遍历n次之后,得到的就为降序(或者升序)数组。
    在数组的排序中需要对数组的两个元素进行交换,这时候可以使用赋值语句来实现,需要一个临时变量来存放数组。
    int temp;
    temp = a[i];
    a[i] = a[j];
    a[j] = a[i];
    这种在排序过程中需要对数组元素进行交换的排序算法,称为“交换排序算法”。选择排序就是一种典型的交换排序算法。
    选择排序效率比较低,但是实现是简单的。
    2.冒泡排序
    把数组中较小的进行上浮操作,从底部开始反复地对数组进行上浮操作n次,最后得到有序数组
      System.out.println();
      for(int i = 0;i < intArray.length;i++)
      {
           index = i;
           keyValue = intArray[i];
          for(int j = i;j < intArray.length;j++)
                if(intArray[i]<keyValue)
    冒泡排序过程简洁。

    3.快速排序

    快速排序是最有名的排序算法,它的效率很高,这也是它名字的由来,实现起来比较复杂。

      System.out.println();
      for(int i = 0;i < intArray.length;i++){
           index = i;
           keyValue = intArray[i];
     for(int j = i;j < intArray.length;j++)

         if(intArray[i]<keyValue)

    多维数组

    int [][] twoD = new int[5][5];//声明了一个5行5列的二维数组 二维数组的初始化有以下两种方法,一种是直接赋值的方法。 twoD={ 
    {1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15},{16,17,18,19,20},{21,22,23,24,25},
    };
    第二种即使用循环访问数组的每个元素进行赋值。
    int [][] twoD2 = new int[5][5];
    int k = 1;
    for(int i = 0;i < twoD2.length;i++)
     for(int j = 0;j < twoD2[i].length;j++)
      twoD2[i][j] = k++;
    twoD2.length表示数组的行数,twoD2[i].length表示数组的列数。
    数组的行数在数组声明时必须确定,列数可以再确定。
    int[][] twoD = new int[4][];
    twoD[0] = new int[1];
    twoD[1] = new int[2];
    twoD[2] = new int[3];
    twoD[3] = new int[4];
    经过上面的声明,在二维数组twoD中,第一行有一个元素,第二行有两个元素,第三个有三个元素,第四行有四个元素。这个数组是一个不规则的数组。

    Arrays 类

    java.util.Arrays 类能方便地操作数组,它提供的所有方法都是静态的。

    具有以下功能:

    • 给数组赋值:通过 fill 方法。
    • 对数组排序:通过 sort 方法,按升序。
    • 比较数组:通过 equals 方法比较数组中元素值是否相等。
    • 查找数组元素:通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

    具体说明请查看下表:

    序号方法和说明
    1public static int binarySearch(Object[] a, Object key)
    用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中,则返回搜索键的索引;否则返回 (-(插入点) - 1)。
    2public static boolean equals(long[] a, long[] a2)
    如果两个指定的 long 型数组彼此相等,则返回 true。如果两个数组包含相同数量的元素,并且两个数组中的所有相应元素对都是相等的,则认为这两个数组是相等的。换句话说,如果两个数组以相同顺序包含相同的元素,则两个数组是相等的。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
    3public static void fill(int[] a, int val)
    将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
    4public static void sort(Object[] a)
    对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。


    展开全文
  • Java 数组 异常处理

    千次阅读 2017-11-04 14:55:19
    从命令行输入5个整数,放入一整型数组,然后打印输出。要求: 如果输入数据不为整数,要捕获输入不匹配异常,显示“请输入整数”;如果输入数据多余5个,捕获数组越界异常,显示“请输入5个整数”。 无论是否发生...

    题目:

    从命令行输入5个整数,放入一整型数组,然后打印输出。要求:

    如果输入数据不为整数,要捕获输入不匹配异常,显示“请输入整数”;如果输入数据多余5个,捕获数组越界异常,显示“请输入5个整数”。

    无论是否发生异常,都输出“感谢使用本程序!”


    代码:

    import java.util.InputMismatchException;
    import java.util.Scanner;
    
    public class TestArrayException {
    
    	public static void main(String[] args) {
    		
    		int a[] = new int[5];
    		System.out.println("请输入5个数,结束后输入0打印数组:");
    		Scanner in = new Scanner(System.in);
    		try{
    			int i=0;
    			if(in.hasNextInt()){  
    				for(i=0;i<a.length;i++)
    					a[i] = in.nextInt();
    				int b=in.nextInt();
    				if(b==0){
    					System.out.println("数组为:");
    					for(int j=0;j<a.length;j++)
    						System.out.println(a[j]);
    				}
    				else
    					throw new ArrayIndexOutOfBoundsException();
    			}
    			else
    				throw new InputMismatchException();
    		}catch(InputMismatchException e1){
    			System.err.println("请输入整数!");
    			e1.printStackTrace();
    		}catch(ArrayIndexOutOfBoundsException e2){
    			System.err.println("请输入5个数!");
    			e2.printStackTrace();
    		}finally{
    			System.out.print("感谢使用本程序!");
    		}
    	}
    
    }
    
    运行图:



    展开全文
  • java数组删除数组元素When we create an array in Java, we specify its data type and size. This is used by JVM to allocates the necessary memory for array elements. There are no specific methods to ...
  • Java数组详解

    千次阅读 多人点赞 2021-03-05 14:07:27
    Java数组详解 一. 什么是数组 二. 数组的声明和创建 1. 数组的声明 2. 数组的创建 三. 三种初始化和内存分析 1. 三种初始化 2. 内存分析 四. 数组的特点 1. 四个基本特点 2. 数组边界 五. 数组的使用 1. for-Each ...
  • jni 操作 java 数组

    千次阅读 2018-06-12 10:52:49
    jni操作java数组 在 jni 函数中对 java 数组的操作主要包含以下几类: GetArrayLength(jarray array) 用于返回 java 数组的数据长度 jstring stringFromJNI(JNIEnv *env, jobject thiz, jintArray intArray){ ...
  • 【Java】探究Java数组的本质

    千次阅读 2020-01-25 14:18:46
    深入地剖析一下Java数组的本质
  • #1.修改数组长度到指定长度并把数组加入...//复制数组进入新数组,arr=复制的数组,0=复制数组的起始元素位置,newarr=复制进的目标数组,2=写入目标数组的位置,5=写入目标数组的元素个数 输出:[null,null,1,2,3...
  • 理解java数组

    千次阅读 2013-09-17 11:08:38
    理解java数组 参考资料: 1.《java jdk5.0 学习笔记》良葛格 第五章数组 2.如何理解数组的length? http://blog.csdn.net/treeroot/archive/2005/01/22/264001.aspx 3.关于java数组的深度思考 ...
  • java8处理数组 If a program needs to work with a number of values of the same data type, you could declare a variable for each number. For example, a program that displays lottery numbers: 如果程序...
  • JVM处理java数组的方法

    2017-05-15 21:20:31
    后来我又明白 数组是一个特殊的对象,在《java编程思想》中说 “数组是一种效率最高的存储和随机访问对象引用序列的方式。数组就是一个简单的线性序列,这使得元素访问非常快速。但是这种速度所付出的代价是数组...
  • java数组 初始化_用Java初始化数组

    千次阅读 2020-07-14 21:45:19
    java数组 初始化 具有使用C或FORTRAN等语言进行编程的经验的人熟悉数组的概念。 它们基本上是一个连续的内存块,每个位置都是某种类型:整数,浮点数或您所拥有的。 Java中的情况与此类似,但有一些额外的折痕。 ...
  • JAVA数组常见问题

    2020-06-09 01:15:55
    JAVA数组 数组对于每一门编程语言来说都是重要的数据结构之一,当然不同语言对于数组的实现和处理不尽相同 java语言中提供的 数组是用来存储固定大小的同类型元素的 数组变量的声明 double[] myList; //首选方法 ...
  • Java数组例子讲解

    2018-12-05 15:11:45
    Java数组 数组对于每一门编程语言来说都是重要的数据结构之一,当然不同语言对数组的实现及处理也不尽相同。 Java 语言中提供的数组是用来存储固定大小的同类型元素。 你可以声明一个数组变量,如 numbers[100] ...
  • java数组理解

    2018-09-10 23:39:26
    1.数组中的元素是同一种类型,数组的长度在创建的时候确定,并且在创建后不变,在Java数组是作为类处理的,在Java中类类型申明并不创建该类的对象,而是一个引用!!! 2.数组元素所需内存空间是通过new运算符...
  • 一、数组初始化Java 中的数组变量是引用类型的变量。Java 是静态语言,因此 Java 数组是静态的,即当数组初始化之后,该数组所占的内存空间、数组长度都是不变的。1、Java数组初始化的两种方式: 静态初始化:...
  • JAVA数组详解

    千次阅读 2013-03-06 19:08:58
    最近看了一些关于java数组的资料,在此总结一下: 一、数组的定义和类型:  数组就是类型相同的数据对象元素集合。简单的说:就是类型相同的数据存储在一个容器里面【注意:Java中的数组是引用类型,即使一个数组中...
  • 内容索引:Java源码,初学实例,数组 与数组相关的Java例子代码,比如测试数组、划分成绩等级、从方法中返回数组、二分查找法、求二维数组的长度、锯齿数组处理二维数组等,对学习Java基础知识有很大帮助。
  • java数组遍历 删除remove。需要的朋友可以过来参考下,希望对大家有所帮助
  • JVM处理Java数组方法的思考

    千次阅读 2014-09-21 16:18:44
    在Java中,获取数组的长度和String的长度是两种不同的方法,这引起了本文作者的一番思考。本文从JVM的角度,探讨了Java数组在JVM中是什么对象,有哪些成员,以及声明方法。
  • java数组程序

    2015-01-26 15:02:15
    6. 编写一个方法search(int a[],int x): 若数组a中存在值为x 的元素,则返回该元素的下标值;否则返回-1。 7. 编写一个方法print_MaxMin(int a[]): ... 处理后为:(an,an-1,…,a3,a2,a1)。
  • java中打印数组的方法An array is a data structure used to store data of the same type. Arrays store their elements in contiguous memory locations. 数组是用于存储相同类型数据的数据结构。 数组将其元素...
  • Java数组基本操作

    千次阅读 多人点赞 2018-02-21 13:47:32
    数组声明 数组初始化 遍历数组 Arraysfill填充数组 ...java打印数组 定位元素位置 数组声明 数组声明有如下两种形式(方括号的位置不同): int arr[]; int[] arr2; 数组初始化 数...
  • Java 数组综述

    千次阅读 2016-12-05 21:44:59
    本文主要阐述了 Java 中与数组的知识,主要从 数组与容器、数组的创建与初始化、数组与泛型、数组与可变参数列表、Arrays 工具类的实用功能 五个方面来对数组进行详细说明和总结。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 587,233
精华内容 234,893
关键字:

java数组处理

java 订阅