精华内容
下载资源
问答
  • JAVA 数组 一维数组二维数组

    千次阅读 2016-05-28 14:43:28
    维数组知识点 // 定义一个a数组 int[] a = new int[]{3, 4 , 5, 6}; // 定义一个a2数组 int[] a2 = new int[]{3, 4 , 5, 6}; // a数组和a2数组的长度相等,每个元素依次相等,将输出true System.out.println("a...

    一维数组知识点


    // 定义一个a数组
    int[] a = new int[]{3, 4 , 5, 6};
    // 定义一个a2数组
    int[] a2 = new int[]{3, 4 , 5, 6};
    // a数组和a2数组的长度相等,每个元素依次相等,将输出true
    System.out.println("a数组和a2数组是否相等:"
    + Arrays.equals(a , a2));
    // 通过复制a数组,生成一个新的b数组
    int[] b = Arrays.copyOf(a, 6);
    System.out.println("a数组和b数组是否相等:"
    + Arrays.equals(a , b));
    // 输出b数组的元素,将输出[3, 4, 5, 6, 0, 0]
    System.out.println("b数组的元素为:"
    + Arrays.toString(b));
    // 将b数组的第3个元素(包括)到第5个元素(不包括)赋为1
    Arrays.fill(b , 2, 4 , 1);
    // 输出b数组的元素,将输出[3, 4, 1, 1, 0, 0]
    System.out.println("b数组的元素为:"
    + Arrays.toString(b));
    // 对b数组进行排序
    Arrays.sort(b);
    // 输出b数组的元素,将输出[0, 0, 1, 1, 3, 4]
    System.out.println("b数组的元素为:"
    + Arrays.toString(b));


    程序代码练习





    二维数组



    数组的简单输出方法:

    System.out.println(Arrays.ToString(a));一维数组输出

    System.out.println(Arrays.deepToString(a));二维数组输出

    foreach循环

    for(int[] ww:a){
    for(int ss:ww){
    System.out.print(ss+"\t");
    }
    System.out.println();

    }


    作者:冲天之峰                20160528

    展开全文
  • Java数组二维数组)

    2021-03-05 16:11:32
    在上一篇文章Java数组(一维数组)中,我们学习了一维数组,那么今天我们来学习Java二维数组。 多维数组 数组元素除了可以是原始数据类型、对象类型之外,还可以是数组,即数组元素是数组,通过声明数组的数组来...

    目录

    前言

    多维数组

    二维数组

    声明二维数组

    创建二维数组

    访问二维数组

    遍历二维数组

    最后


    前言

    在上一篇文章Java数组(一维数组)中,我们学习了一维数组,那么今天我们来学习Java二维数组。

    多维数组

    数组元素除了可以是原始数据类型、对象类型之外,还可以是数组,即数组元素是数组,通过声明数组的数组来实现多维数组。多维数组的使用和二维数组使用相似,我们来介绍二维数组。

    二维数组

    声明二维数组

    声明二维数组语法有两种格式,例如:

    数组类型[] [] 数组名;        //声明一个二维数组,建议使用这种声明
    int [] [] num;
    或者
    数组类型 数组名[] [];        //声明一个二维数组
    int num [] [];

    对于其他多维数组声明也是类似的,例如:

    数组类型 [] [] [] 数组名;          //声明一个三维数组变量
    int [] [] [] threeDimension;
    
    数组类型 [] [] [] [] 数组名;       //声明一个四维数组变量
    int [] [] [] [] fourDimension;

    创建二维数组

    创建二维数组对象有两种格式,例如:

    int [] [] num=new int [3] [4];     //创建一个int类型二维数组,长度为3和4
    或者
    int [] [] num={{3,5,6},{1,2,3,4}}; //创建一个int类型二维数组,长度为3和4,并赋值

    注意:

    • 使用new运算符来创建二维数组对象时,必须指定这个数组的长度;
    • 直接把数组元素放在大括号中,要使用逗号分隔每个花括号,每个花括号中用逗号分开数据。

    访问二维数组

    创建数组变量并赋值后就可以访问二维数组元素了,在该数组的名称后面加两个中括号表示,第一个下标为行索引,第二个下标为列索引,例如:

    public class myfirst {
    	public static void main(String[] args) {
    		int [][]num= {{1,2,3,4,5},{6,7,8,9,10}};    //创建一个二维数组并赋值
    		System.out.print(num[1][3]);                //输出第二行第四个元素
    	}
    }

    运行结果为:9

    注意:在二维数组中,行和列的下标都是从0开始计数的。

    遍历二维数组

    我们可以使用两个for循环遍历打印数组。例如:

    public class myfirst {
    	public static void main(String[] args) {
    		int [][]num= {{1,2,3,4,5},{6,7,8,9,10}};    //创建二维数组并赋值
    		System.out.println("输出a数组:");
    		for(int i=0;i<num.length;i++) {             //for循环遍历输出数组
    			for(int j=0;j<num[i].length;j++) {
    				System.out.print(num[i][j]+" ");
    			}
    		}
    	}
    }

    运行结果为:

    输出a数组:
    1 2 3 4 5 6 7 8 9 10 

    最后

    好了,有关Java数组(二维数组)的知识讲到这里了,谢谢观看!!!

    我们下篇文章再见!!!

    成功不是将来才有的,而是从决定去做的那一刻起,持续累积而成。

    展开全文
  • Java数组 一维数组,二维数组

    千次阅读 2011-03-18 14:41:00
    维数组 1) int[] a; //声明,没有初始化   2) int[] a = new int[5]; //初始化为默认值,int型为0   3) int[] a = {1,2,3,4,5}; //初始化为给定值班   4) int[] a = ...

    一维数组
    1) int[] a; //声明,没有初始化

     

    2) int[] a = new int[5]; //初始化为默认值,int型为0

     

    3) int[] a = {1,2,3,4,5}; //初始化为给定值班

     

    4) int[] a = new int[]{1,2,3,4,5}; // 同3)
        int[] a = new int[5]{1,2,3,4,5}; //错误,如果提供了数组初始化操作,则不能定义维表达式

     

    5) int[] a;
                a = new int[5]; //正确,同2)   
       int[] a;
              a = {1,2,3,4,5}; //错误,数组常量只能在初始化操作中使用,如3)

     

    6) int a[];
           a[0] = 1; //错误,因为数组没有初始化,不能赋值。
           a[1] = 2;


    二维数组
    1)int[][] a; //声明,没有初始化

     

    2)int[][] a = new int[2][3]; //初始化为默认值,int型为0

     

    3)int[][] a = {{1,2},{2,3},{3,4}}; //初始化为给定的值
       int[][] a = {{1,2},{2,3},{3,4,5}}; //没有错,数组空间不是连续分配的,所以不要求每一堆的大小相同。

     

    4)int[][] a = new int[2][];
       int[0] = new int[3]; //a[0]其实就是一个数组
       int[1] = new int[4]; //每一维的大小可以不一样

     

    5)int[][] a = new int[][]{{1,2},{2,3},{3,4,5}}; //同3)
       int[] a = new int[5]{{1,2},{2,3},{3,4,5}}; //错误,如果提供了数组初始化操作,则不能定义维表达式
       int[][] a = new int[2][];
       a[0] = {1,2,3,4,5}; //错误,数组常量只能在初始化操作中使用

     

    6)int[][] a = new int[2][];
       a[0][1] = 1; //错误,第二维没有初始化,不能赋值,NullPointerException异常

     

    总结:
    1、二维数组可以看成以数组为元素的数组;
    2、不管一维还是二维,在使用前(赋值,访问)必须初始化,可以用new默认初始化,也可以用数组常量初始化;
    3、Java中二维数组的声明和初始化应按照从高维到低维的顺序进行。

     

    动态初始化:数组定义与数组分配空间和赋值的操作分开进行;
    静态初始化:在定义数字的同时就为数组元素分配空间并赋值;
    默认初始化:数组是引用类型,它的元素相当于类的成员变量,因此数组分配空间后,每个元素也按照成员变量的规则被隐士初始化。


    实例:

    // ~ 静态初始化 程序代码  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

    public class Array2
    {
        public static void main(String args[]) {
            int a[][] = {{1,2},{3,4,5,6},{7,8,9}} ;
            for(int i=0 ; i <a.length ; i++) {
                for(int j=0 ; j<a[i].length ; j++) {
                    System.out.println("a[" + i + "][" + j + "]=" + a[i][j]) ;
                }
            }
        }
    }

     

    输出结果:

    a[0][0]=1
    a[0][1]=2
    a[1][0]=3
    a[1][1]=4
    a[1][2]=5
    a[1][3]=6
    a[2][0]=7
    a[2][1]=8
    a[2][2]=9

    // ~ 动态初始化 程序代码  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

    public class Array2D
    {
        public static void main(String args[]) {
            int i , j ;
            String s[][] ;
            s = new String[3][] ;
            s[0] = new String[2] ;
            s[1] = new String[3] ;
            s[2] = new String[2] ;
            for(i=0 ; i<s.length ; i++) {
                for(j=0 ; j <s[i].length ; j++) {
                    s[i][j] = new String("我的位置是:" + i + "," + j) ;
                }
            }
            for(i=0 ; i<s.length ; i++) {
                for(j=0 ; j<s[i].length ; j++) {
                    System.out.println(s[i][j]) ;
                }
            }
        }
    }

     

    输出结果:

    我的位置是:0,0
    我的位置是:0,1
    我的位置是:1,0
    我的位置是:1,1
    我的位置是:1,2
    我的位置是:2,0
    我的位置是:2,1

     

    参考资料,感谢
    http://wenku.baidu.com/view/7e02d65e312b3169a451a4d3.html
    http://gonglianying.javaeye.com/blog/655674
     
     

    展开全文
  • 新手小白学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个字符
    		//通过数组下标,操作数组中的每个元素,给数组元素赋值
    		//数组下标从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一维数组二维数组详解API

    千次阅读 2019-03-12 12:24:06
    所谓数组,是有序的元素序列。若将有限个类型相同的变量的集合命名,那么这个名称为数组名。组成数组的各个变量称为数组的分量,也称为数组的元素...数组是用于储存多个相同类型数据的集合,数组有一维数组二维数...
  • Java数组介绍(一维数组和二维数组)1. 概述· 数组是存储多个变量的容器。· 存储的多个变量必须是同一种数据类型。· 数组既可以存储基本数据类型,也可以存储引用数据类型。2. 数组定义的格式· 格式1:数据...
  • Java数组二维数组与多维数组 二维数组 二维数组也是个容器 保存的是 相同数据类型的一维数组 书写公式: 数据类型[][] 数组名 = 初值; 例如: int[][] array = new int[3][4]; 代表的是 这个二维数组中...
  • 二维数组 二维数组是个容器,保存的是相同数据类型的一维数组 书写公式: 数据类型[][] 数组名 = 初值; 定义方式一: // 该二维数组中有3个一维数组,每个一维数组中有4个元素 int[][] array = new int[3][4]; ...
  • Java数组----引用数据类型,必须在使用前先初始化;否则会nullPointerException(运行时异常)。 (引用传递:多个栈内存指向同一块堆内存) 1.一数组初始化 (1)动态初始化(声明并开辟数组) 数据类型[] 数组...
  • Java数组-二维数组

    2016-10-11 23:24:00
    数组的好处:数组可以用作容器,存储很多的元素。 数组可以存储整型、字符型、浮点型、布尔型等。 数组的特殊情况:存储的非以上类型,存储数组。...数组中的元素还是数组,我们称之为数组中的数组二维数组
  • Java-一维数组二维数组的定义和遍历

    千次阅读 2018-10-17 17:07:01
    维数组数组的几种定义方法: public class Array { public static void main(String[] args) { // 定义一维数组 int[] a = new int[4]; // 定义一维数组 int[] b = {1, 2, 3, 4}; // 定义...
  • import java.util.Arrays;public class shuzu { public static void main(String[] args) { int arr[]=new int[]{1,8,5,6,2,3,1}; float are[]=new float[]{1,2,3,12,1.12f}; for (int i : arr) {...
  • http://www.verejava.com/?id=17159392878528import java.util.Scanner;... * 模拟扫雷游戏, 在一个二维数组中, 1:无雷 2:有雷, 键盘输入 行号和列号, 判断是否扫到了雷. */ public static void main(String[...
  • JAVA基础之二维数组三维数组及应用

    千次阅读 2018-01-05 19:17:19
    二维数组 简单说明: 如何描述下面定义的二维数组 定义方式一: int[][] array = new int[3][4]; 描述:该二维数组中有三个一维数组 每一个一维数组中有4个元素 打印二维数组的长度 相当于打印数组中有多少个一...
  • 1.定义数组直接赋值 int a[]= {1,2,3,4,5}; 2.用new在数组中创建元素 int a[]=new int[]{1,2,3}; 注意:后面的[]不要忘...输出结果为[0, 0, 0],Arrays.toString产生一维数组的可打印版本。 4.先声明再赋值 int c
  • Java数组之一数值数组Java数组之一数值数组之成绩统计一数组声明一数值数组变量创建一数值数组一数组初始化一数组元素的使用一数组长度成绩统计 Java数组之一数值数组之成绩统计 一数组 数组...
  • java二维数组字符数组Today we will look into Two-dimensional array in java. An array is like a container that can hold a certain number of values. 今天,我们将研究Java中的二维数组数组就像可以容纳...
  • Java数组1.数组的概述容器的概念2.数组的定义格式方式一方式二方式三3.数组元素的默认值4.什么是数组初始化5....二维数组二维数组概述二维数组定义格式方式一方式二方式三二维数组内存图二维数组...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 108,430
精华内容 43,372
关键字:

java数组二维

java 订阅