精华内容
下载资源
问答
  • 高分悬赏!Java语言数组如何将数组中相同数字合并,并且输出重复数量最多的5个数字 思路我会,就是代码写出来
  • Java打印数组中不重复的元素和个数

    千次阅读 2017-10-07 22:39:07
    /*这个方法看起来繁琐,但是可以大大减少程序的工作量。... //设置一个flag数组,重复的元素都做一下标记; boolean[] flagArr = new boolean[arr.length]; for (int i = 0; i ; i++) { if (!flagArr[i])
            /*这个方法看起来繁琐,但是可以大大减少程序的工作量。
            */ 
            //设置一个flag数组,重复的元素都做一下标记;
            boolean[] flagArr = new boolean[arr.length];
            for (int i = 0; i < arr.length; i++) {
    
                if (!flagArr[i]) {
                    for (int j = i + 1; j < arr.length; j++) {
                        if (arr[i] == arr[j] && i != j) {
                            flagArr[j] = true;
                            flagArr[i] = true;
                        }
                    }
                }
            }
            for (boolean b : flagArr) {
                System.out.println(b);
            }
            int count = 0;
            for (int i = 0; i < arr.length; i++) {
    
                if (!flagArr[i]) {
                    System.out.println(arr[i]);
                    count++;
                }
            }
            System.out.println(count);
    
    
    展开全文
  • 新手小白学JAVA 数组 数组工具类 二维数组

    万次阅读 多人点赞 2021-04-02 08:28:55
    想要获取数组中的元素值,可以通过脚标(下标)来获取 数组下标是从0开始的,下标的最大值是数组的长度减1 1.2 创建数组 数组的创建方式一般分为动态初始化和静态初始化 动态初始化 int[] a = new int[5]; 静态初始...

    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个字符
    		//通过数组下标,操作数组中的每个元素,给数组元素赋值
    		//数组下标从0开始,数组的最大下标就是数组的长度-1
    		//快速向下复制:Ctrl+Alt+向下键
    		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类型的数组s,存"a","b","c"
    		/**
    		 * char类型底层做了处理,可以直接打印数组中的内容
    		 * 除了char类型以外的所有数组想要查看数组中的具体元素
    		 * 需要使用数组的工具类Arrays的toString(数组名)方法
    		 * 注意:Arrays使用时需要导包
    		 * */
    		String[] s = {"a","b","c"};
    		System.out.println(Arrays.toString(s));
    		
    		//4.查看数组的长度--数组中存放元素的个数
    		System.out.println(c2.length);
    		System.out.println(s.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;
    
    /**本类用于测试数组的工具类Arrays*/
    public class TestArraysCopyOf {
    	public static void main(String[] args) {
    		//1.创建无序数组
    		int[] from = {1,2,3,4,5};//数组一旦创建,长度不可改变
    		
    		//2.1数组的普通复制
    		int[] to = Arrays.copyOf(from, 5);//需要复制哪个数组,复制的长度
    		System.out.println(Arrays.toString(to));
    		
    		//2.2 数组的扩容
    		//先创建对应长度的新数组,然后复制原数组的数据,不足的即为默认值,此处int[]的默认值是0
    		int[] to2 = Arrays.copyOf(from, 10);//需要复制哪个数组,复制的长度
    		
    		System.out.println(Arrays.toString(to2));
    		
    		//2.3 数组的缩容
    		//先创建对应长度的新数组,然后按照参数个数复制原数组中的数据,类似截取
    		int[] to3 = Arrays.copyOf(from, 3);//需要复制哪个数组,复制的长度
    		System.out.println(Arrays.toString(to3));
    		
    		//2.4指定首尾截取数组中的元素
    		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-05-12 22:40:34
    数组,就是相同数据类型元素按一定顺序排列的集合。 数组也是编程最常见的一种数据结构,...①Java数组要求所有的数组元素都具有相同的数据类型。因此,在一个数组中数组元素的类型是唯一的,即一个数组里只能存

    数组,就是相同数据类型元素按一定顺序排列的集合。
    数组也是编程中最常见的一种数据结构,可用于存储多个数据,每个数组元素存放一个数据,通常我们可以通过数组元素的索引来访问数组元素。包括为数组元素赋值和取出数组元素的值。

    Java语言数组有其特有的特征。

    一、理解数组:数组也是一种类型
    ①Java的数组要求所有的数组元素都具有相同的数据类型。因此,在一个数组中,数组元素的类型是唯一的,即一个数组里只能存储一种类型的数据。

    ②数组一旦初始化完成,数组在内存所占用的空间将被固定下来,因此数组的长度不可变。

    ③Java的数组既可以存储基本类型的数据,也可以存储引用类型的数据,只要同一个数组里存储的是相同类型的数据类型的元素。

    ④int[]也是一种数据类型。它本身是一种引用类型。

    二、定义数组
    Java语言支持两种格式定义数组。

    type[] arrayName;
    type arrayName[];

    对于这两种语法格式而言,推荐使用第一种形式。因为第一个形式不仅有很好的语义,而且有很好的可读性。
    type[] arrayName;
    很容易理解这是定义一个变量,这个变量名是arrayName,而变量类型是type[]。

    数组是一种引用类型的变量,因此使用它定义一个变量时,仅仅表示定义了一个引用变量(也就是定义了一个指针),这个引用变量还未指向任何有效的内存,因此定义数组时不能指定数组的长度。而且由于只是定义了一个引用变量,并未指向任何有效的内存空间,所以还没有内存空间来存储数组元素,因此这个数组也不能使用,必须初始化后才能使用。

    三、数组的初始化
    Java语言中数组必须先初始化(C语言中定义直接使用),然后才可以使用。
    初始化,就是为数组的数组元素分配内存空间,并为每个数组元素赋初值。

    初始化的两种方式:
    1.静态初始化:初始化时显示指定每个元素的初始值,由系统决定数组长度
    2.动态初始化:初始化时候程序员只指定数组长度,由系统元素分配初始值。

    ①静态初始化
    语法:

    arrayName = new type[]{element1,element2,element3,...};

    type是数据元素的数据类型。
    例如

    int[] intArr = new int[]{5,6,7,8};
    String[] strArr = new String[]{"today","tomorrow"};

    ②动态初始化
    语法:

    arrayName = new type[length];

    例如

    int[] prices = new int[5];
    String[] books = new String[5]; 

    动态初始化时,系统会自动为这些数组赋值。
    例如int型为0,String修改为null,boolean型为false,float型为0.0。

    但是注意不要同时使用静态初始化和动态初始化。

    四、使用数组
    数组最常用的用法就是访问数组元素,包括对数组元素进行赋值和取出数组元素的值。访问数组一般通过在数组引用变量后跟一个方括号([ ]),方括号里是数组的索引值。
    例如:

    String[] strArr = new String[] {"today" , "tomorrow"};
    
    //给第一个元素赋值
    strArr[0] = "name";
    //输出第二个元素
    System.out.println(strArr[1]);

    所有的数组都提供了length属性,这个属性可以访问到数组的长度,可以通过循环来遍历该数组的每个数组元素。
    例如:

    int[] prices = new int[10];
    
    //使用循环输出prices数组的每个元素的值
    for(int i = 0;i < prices.length ;i++)
    {
        System.out.println(prices[i]);
    }

    上面将会输出5个0,因为prices执行的是默认初始化,数组元素是int型的数组元素赋值为0。

    String[] books = new String[2];
    //对动态初始化后的数组元素进行赋值
    books[0] = "C Primer Plus";
    books[1] = "数据结构";
    //使用循环输出books数组的每个数组元素的值
    for(int i = 0;i < books.length;i++)
    {
        System.out.println(books[i]);
    }
    展开全文
  • Java数组

    2016-05-22 23:15:20
    数组  Java语言的数组变量是引用类型的变量。是多个类型相同变量的集合。 Java数组是静态数组。必须经过初始化方可使用。...(为数组对象的元素分配内存...1 静态初始化:初始化时由程序员显示指定每个数组元素
    一 数组 

    Java语言的数组变量是引用类型的变量。是多个类型相同变量的集合。
    Java的数组是静态数组。必须经过初始化方可使用。
    (为数组对象的元素分配内存空间,为每个数组元素指定初始值 也就是通过new建立实例)。

    二 数组初始化

     数组初始化有两种初始化方式:

    1 静态初始化:初始化时由程序员显示指定每个数组元素的初始值,由系统决定数组长度。

    2 动态初始化:初始化时程序员只指定数组的长度,由系统元素为数组分配初始值。

    数组一旦初始化完成,数组元素的内存空间分配也就结束,程序只能改变数组元素的值,不能改变数组的长度。
    不能同时对数组进行静态和动态初始化,也就是说既指定了长度,也为每个元素分配初始值。
    Java的数组变量是一种引用类型的变量,数组变量并不是数组本身,它只是指向堆内存中的数组对象。

    三 数组不一定要进行初始化
    Java数组变量是引用类型变量,并不是数组本身,只需把引用变量本身指向有效的的数组对象,程序中即可使用该数组变量。
    如果数组变量未指向有效的内存,未指向任何数组对象,程序不能使用此数组变量。
    数组变量是一个引用变量,通常放在栈内存中(也可以放在堆内存中);而数组对象就是保存在堆内存中的连续内存空间。对数组执行初始化,其实并不是对数组变量进行初始化,而是对数组对象进行初始化,为该数组对象分配一块连续的内存空间,这块连续的内存空间的长度就是数组的长度。

    四 基本类型数组的初始化
    基本类型数组而言,数组元素的值直接存储在对应的数组元素中,因此基本类型数组的初始化比较简单:程序直接为数组分配内存空间,再将数组元素的值对应内存里。
    所有局部变量都是放在栈内存里保存的,不管其是基本类型的变量,还是引用类型的变量,都是存储在各自的方法栈区中;但引用类型变量所引用的对象(包括数组、普通的Java对象)则总是存储在堆内存中。
    堆内存中的对象通常是不予访问,想访问堆内存中的对象,要通过引用变量。
    引用变量本质上只是一个指针,只要程序引用变量访问的属性,或者通过调用引用变量来调用方法,该引用变量将会由它所引用的对象代替。

    五 引用类型数组初始化
    引用类型数组的数组元素依然是引用类型的,数组元素存储的还是引用,它指向另一块内存,这块内存里存储了该引用变量所引用的对象(包括数组和Java对象)

    六 使用数组
    当数组引用变量指向一个有效的数组对象之后,程序就可通过该数组引用变量来访问数组对象。

    七 数组元素就是变量
       
    当程序需要多个类型相同的变量来保存程序状态时,可以考虑使用数组来保存这些变量。当一个数组初始化完成后,就相当于定义了多个类型相同的变量。

    用索引来使用数组元素时,将数组元素当成普通变量使用即可,包括访问数组元素的值,为数组元素赋值等。

    八 没有多维数组

    对于int[][][]类型的数组,其数组元素就相当于int[][]类型的变量;对于int[][]类型的数组,其数组元素就相当于int[]类型的变量;对于int[]类型的数组,其数组元素就相当于int类型的变量。

    所谓多维数组,其实只是数组元素依然是数组的1维数组:2微数组是数组元素是1维数组的数组,3维数组是数组元素是2维数组的数组,4维数组是数组元素是3维数组的数组。。。。N维数组是数组元素是(N-1)维数组的数组。

    Java允许将多维数组当成1维数组处理。初始化多维数组时可以先只初始化最左边的维数,此时该数组的每个元素都相当于一个数组引用变量,这些数组元素还需要进一步初始化。

    数组的length属性返回系统为该数组所分配的连续内存空间的长度。

    如果定义一个object[]类型的数组,此时每个数组元素都相当于一个object类型的引用变量,可以指向任何对象(包括数组对象和普通Java对象)。
    在使用多维数组时,应该多从内存控制的角度来把握程序,而不是仅仅停留在代码表面。



    展开全文
  • java中数组遍历的三种方式

    千次阅读 2020-11-08 02:36:36
    1.for循环遍历 通常遍历数组都是使用for循环来...java5之后,Java提供了一种更简洁的循环:foreach循环,这种循环遍历数组和集合更加简洁。使用foreach循环遍历数组时,无须获得数组和集合长度,无须根据索引来访问数组
  • java数组

    2015-03-20 21:43:20
    数组在编程语言是一种常见的数据结构或者说数据类型,数组中可以存储多个数据,这些数据叫做... 数组初始化以后,他所占用的内存就固定下来了,也就是长度将可变,即使数组中的数据全部清空,他所占的内存依旧
  • 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: 如果程序...
  • Java数组

    2016-03-01 09:54:53
    数组对于每一门编程语言来说都是重要的数据结构之一,当然不同语言对数组的实现及处理也不尽相同。 Java语言提供的数组是用来...本教程将为大家介绍Java数组的声明、创建和初始化,并给出其对应的代码。 声明
  • java多维数组

    2017-02-10 19:48:53
    数组Java中的一种容器对象,它拥有多个单一类型的值。当数组被创建的时候数组长度就已经确定了。在创建之后,其长度是固定的。下面是一个长度为10的数组:public class ArrayDemo { private int arraySize=10; ...
  • Java 数组

    2016-11-16 08:06:28
    Java 语言提供的数组是用来存储固定大小的同类型元素。 你可以声明一个数组变量,如 numbers[100] 来代替直接声明 100 个独立变量 number0,number1,....,number99。 本教程将为大家介绍 Java 数组的声明、...
  • Java中数组的存储与内存分配

    千次阅读 2015-02-26 20:13:36
    Java数组及其内存分配 [日期:2013-03-28] 来源:Linux社区 作者:xiaoxuetu [字体:大  小] 几乎所有的程序设计语言都支持数组。Java也例外。当我们需要多个类型相同的变量...
  • java数据结构的练习一:如何用Java来实现数组; 说起来数据结构大家肯定会想到,数组,队列,堆栈,链表,图,树等其他的,接下来会每天逐一对其进行学习和使用,以及个人所理解的情况给展示出来 什么是数组呢? ...
  • 如果定义两个数组 int[] a = {1,1,2,3,4,4,5,7,7}; int[] b = {2,5,4,4,4,7,7,7,7}; 它们的相同元素应该是2,4,4,5,7,7, 怎么用代码求出相同元素并放到另外一个数组中
  • Java中数组的操作(一)

    千次阅读 2014-09-18 18:20:56
    Java中数组的操作(一)  一、说明  1.数组是最常见的一种数据结构,可以用于存储多个数据,每个数组元素存放一个数据,可以通过索引检索数组元素。通过数组名加数组下标,来使用数组中的数据。下标从 0 开始...
  • Java 多维数组遍历

    千次阅读 2016-07-18 23:22:43
    数组Java中的一种容器对象,它拥有多个单一类型的值。当数组被创建的时候数组长度就已经确定了。在创建之后,其长度是固定的。下面是一个长度为10的数组: 1 2 3 4 public ...
  • java中数组

    2015-10-22 10:41:30
    java中数组既可以存储基本类型数据,也可以存储对象,如:整型数组(基本类型数据的数组),字符串数组(对象数组java中字符串为对象类型)。 1、数组的创建和初始化 使用数组这种结构时,需要先声明、定义一个...
  • 一、前言 ...2、遍历数组或字符串,对其中元素分情况讨论: (1)map的key无此元素,此时将此元素的个数置为1; (2)map的key有此元素,首先需将该元素的个数取出,更新加一后再放入map; (3)
  • Java中数组的介绍与使用

    万次阅读 多人点赞 2016-08-06 08:59:31
    数组中的元素可以是任意类型(包括基本类型和引用类型),但同一个数组里只能存放类型相同的元素。 创建数组大致包括如下步骤: . 声明一个数组类型的引用变量,简称为数组变量; . 用new语句构造数组的实例。new...
  • JAVA数组

    2015-08-15 20:51:14
    所谓数组,就是相同数据类型的元素按一定顺序排列的集合,就是有限个类型相同的变量用一个名字命名,然后用编号区分他们的变量的集合,这个名字成为数组名,编号成为下标。 1.数组的定义 概念:同一种类型数据的...
  • 数组是用来存储相同数据类型的一组数据 声明一个变量就是在内存划出一块空间 声明一个数组就是在内存划出一串连续的空间 数组的四要素: 数组名称:用来区分不同的数组 数组元素:向数组中存放的数据 元素...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 140,687
精华内容 56,274
关键字:

java把数组中相同的不显示

java 订阅