精华内容
下载资源
问答
  • 主要介绍了Java数组的定义、初始化、及二维数组用法,结合具体实例形式分析了java数组概念、功能、数组定义、静态数组、动态数组、二维数组等相关使用技巧,需要的朋友可以参考下
  • 前言:最近这两天在csdn论坛经常看到有人因为自定义的数据的实例化而导致报NullPointerException异常,原因只是因为没有把数组实例化,因为它是“自定义”的,那么必须得初始化才能调用属性和方法。下面简单动手实例...

     前言:最近这两天在csdn论坛经常看到有人因为自定义的数据的实例化而导致报NullPointerException异常,原因只是因为没有把数组实例化,因为它是“自定义”的,那么必须得初始化才能调用属性和方法。下面简单动手实例自定义数组。

    1、自定义一维数组:(可能比较常见的就是在Swing中应用的,就举Swing的例子)

    import java.awt.*;
    import javax.swing.*;
    public class OA extends JFrame{
    	JPanel jp=(JPanel)this.getContentPane();
        private JTable[] jt;//定义全局一维数组
        public OA()
        {
        	jp.setLayout(null);
        	jt=new JTable[256]; //初始化数组
    		for(int i=0;i<jt.length;i++)
    		{
    			jt[i]=new JTable(); //实例化数组
    		}
    		int k=0,j=0; 
    		for(int i=0;i<jt.length;i++,j++)
    		{
    			final int g=i;
    			if(j%16==0)
    			{
    				k++;
    			}
    			int x=Math.abs(j%16);
    			int marginwidth=x*5+20*x;
    			int marginheight=(k-1)*5+20*(k-1);
    			jt[i].setBounds(new Rectangle(marginwidth,marginheight, 20, 20)); 
    			jp.add(jt[i]);  
    		}
        }
    	public static void main(String[] args) { 
    		 OA frame=new OA();
    		 frame.setSize(800,600);
    		 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		 frame.setVisible(true);
    	}
    }


     

    2、二维数组“动态”实例化:

      Student team[][];//定义二维数组
      team=new Student[3][]; //初始化二维数组
      for(int i=0;i<team.length;i++)
      { 
       team[i]=new Student[i+1]; //这里很重要,不可缺少.分配空间
       team[i][0]=new Student();//实例化自定义二维数组
      }
    展开全文
  • 主要介绍了Java编程中二维数组初始化和基本操作实例,是Java入门学习中的基础知识,需要的朋友可以参考下
  • 本篇文章小编给大家分享一下java二维数组指定不同长度代码实例,文章代码介绍的很详细,小编觉得挺不错的,现在分享给大家供大家参考,有需要的小伙伴们可以来看看。1、二维数组的每个元素都是一个一维数组,这些...

    本篇文章小编给大家分享一下java二维数组指定不同长度代码实例,文章代码介绍的很详细,小编觉得挺不错的,现在分享给大家供大家参考,有需要的小伙伴们可以来看看。

    1、二维数组的每个元素都是一个一维数组,这些数组不一定都是等长的。声明二维数组的时候可以只指定第一维大小,空缺出第二维大小,之后再指定不同长度的数组。但是注意,第一维大小不能空缺(不能只指定列数不指定行数)。

    public class ArrayTest4

    {

    public static void main(String[] args)

    {

    //二维变长数组

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

    a[0] = new int[2];

    a[1] = new int[3];

    a[2] = new int[1];

    //Error: 不能空缺第一维大小

    //int[][] b = new int[][3];

    }

    }

    2、二维数组也可以在定义的时候初始化,使用花括号的嵌套完成,这时候不指定两个维数的大小,并且根据初始化值的个数不同,可以生成不同长度的数组元素。

    public class ArrayTest5

    {

    public static void main(String[] args)

    {

    int[][] c = new int[][]{{1, 2, 3},{4},{5, 6, 7, 8}};

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

    {

    for(int j = 0; j < c[i].length; ++j)

    {

    System.out.print(c[i][j]+" ");

    }

    System.out.println();

    }

    }

    }

    实例扩展:

    Java不指定长度的二维数组实例

    import java.util.*;

    public class Tek

    {

    public static void main(String[] args)

    {

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

    a[0]=new int[3];//相当于int[] a=new int[3]

    for(int i=0;i

    展开全文
  • 1、数组的基本概念 数组指的是组相关变量的集合。Java中,数组属于引用数据类型,所以必然牵扯到内存的关系。对于数组的定义格式包括: ...以上可以看出定义格式 和 实例化对象的思路基本一致,eg: int...

    目录

    1、数组的基本概念

    2、数组的引用分析

    3、数组的静态初始化

    4、二维数组

    5、数组相关操作方法

    6、对象数组


    1、数组的基本概念

    数组指的是一组相关变量的集合。Java中,数组属于引用数据类型,所以必然牵扯到内存的关系。对于数组的定义格式包括:

    • 声明并开辟数组: 数据类型 数组名称[] = new 数据类型 [长度];
    • 分布完成:
      • 数据类型 数组名称[] = null;
      • 数组名称 = new 数据类型 [长度];

    以上可以看出定义格式 和 实例化对象的思路基本一致,eg:

    int data[] = new int[3];
    data[0] = 10;
    data[1] = 20;
    data[2] = 30;

    以上操作属于数组的动态初始化,其特点是数组开辟空间后,每个数组元素 的内容为对应数据类型的默认值。

    通过数组[索引]方式进行数组的访问,索引的范围:0~长度-1;若超过此范围,程序允许时会出现ArrayIndexOutofBoundsException(数组索引超出绑定异常,数组越界)

    【数组输出】:使用for循环即可,关键是用数组名.length获取数组的长度,不再代码举例赘述。

    2、数组的引用分析

    引用数据类型分析基本一致,与对象的流程一样的,唯一的区别就是普通类的对象是保存属性,利用属性名称操作,而数组保存的是内容,利用索引来操作。

    【举例】:数组的引用操作

            int data[] = new int[3];
            data[0] = 10;
            data[1] = 20;
            data[2] = 30;
            int temp[] = data;
            temp[0]=100;
            for(int i=0;i<data.length;i++){
                System.out.print(data[i]+"、");//输出100、20、30
            }

    3、数组的静态初始化

    以上数组的动态初始化,其特点是,先开辟数组内容空间,再进行内容的赋值,若想数组开辟后直接存在明确内容,可以使用数组的静态初始化:

    • 简化型    数组类型 数组名称 [] = {值,值,,,,};  (一般不推荐使用)
    • 完全型    数组类型 数组名称 [] = new 数据类型[] {值,值,,,,};

    【举例】:数组的静态初始化

    int data[] = new int[] {10,20,30};

    【举例】:判断某个数字是否存在于数组中

            int data[] = new int[] {10,20,30};
            int x =10;
            boolean flag = false;
            for(int i=0;i<data.length;i++){
                if(data[i]==x){
                    flag=true;
                    break;
                }
            }
            if(flag){
                System.out.println("数组中存在该数字");
            }else{
                System.out.println("数组中不存在该数字");
    
            }

    但是以上的做法性能不好,它需要将数组中每一个元素遍历判断,直到找到为止。这里涉及到算法的问题,有个查找算法叫二分查找法,但是使用的前提是数组中的数据必须是有序的,二分查找法原理不再赘述了。

    4、二维数组

    之前使用的数组只有一个索引下标,二维数组有行和列,要想确认一个数据得有行索引 和 列索引。对于二维数组的定义方式:

    • 动态初始化: 数据类型 数组名称 [][] = new 数据类型[行个数][列个数];
    • 静态初始化:数据类型 数组名称 [][] = new 数据类型[][]{

                                                                                          {数据,,,},{数据,,,},...

                                                                                          };

    【举例】:观察二维数组使用

            int data[][] = new int[][] {{10,20,30},{11,321,31}};
            for(int x=0;x<data.length;x++){
                for(int y=0;y<data[x].length;y++){
                    System.out.print(data[x][y]+"、");
                }
                System.out.println();
            }

    【举例】:实现二维数组转置

                int data[][] = new int[][] {{1,2,3},{4,5,6},{7,8,9}};
                for(int x=0;x<data.length;x++){
                for(int y=0;y<=x;y++){
                    if(x!=y){
                        int temp = data[x][y];
                        data[x][y] = data[y][x];
                        data[y][x] = temp;
                    }
                }
                }

    以上实际开发中帮助不大,仅训练逻辑思维用。

    5、数组相关操作方法

    • 数组拷贝:System.arraycopy(原始数组,起始位号,目标数组,起始位号,copy个数);

    • 数组排序:Arrays.sort(数组);

    具体应用不再赘述了。

    6、对象数组

    对象数组就是某一个数组中保存的都是对象,对象数组的定义格式:

    • 动态初始化: 类名称 对象数组名称 [] = new 类名称[长度];
    • 静态初始化:    类名称 对象数组名称 [] = new 类名称[] {实例化对象、实例化对象,....};

    【举例】:动态初始化定义数组

            Person per[] =new Person[3];
            per[0] =new Person("张三",10);
            per[1] =new Person("李四",20);
            per[2] =new Person("王五",30);

    【举例】:静态初始化定义数组

            Person per1 =new Person("张三",10);
            Person per2 =new Person("李四",20);
            Person per3 =new Person("王五",30);
            Person per[] =new Person[]{per1,per2,per3};

    或者

            Person per[] =new Person[]{
                    new Person("张三",10),
                    new Person("李四",20),
                    new Person("王五",30)};

     

    作于202003281600,已归档

    ———————————————————————————————————

    本文为博主原创文章,转载请注明出处!

    若本文对您有帮助,轻抬您发财的小手,关注/评论/点赞/收藏,就是对我最大的支持!

    祝君升职加薪,鹏程万里!

    展开全文
  • java二维数组三种初始化方法(实例)

    万次阅读 2018-05-10 12:17:25
    2、给定二维数组的大小 3、数组第二维的长度可变化,未改变 代码举例如下: public class NewArray { public static void main(String[] args) { //第种: //int[][] arr1 = new int[][]...

    初始化方法:

    1、使用大括号直接赋值,适合已经确定知道数组元素的情况

    2、给定二维数组的大小

    3、数组第二维的长度可变化,未改变

    代码举例如下:

    public class NewArray {
        public static void main(String[] args) {
    
            //第一种:
            //int[][] arr1 = new int[][]{{1,2}, {2, 3}, {4, 5}};
            int[][] arr1 = {{1,2}, {2, 3}, {4, 5}};
            System.out.println("arr1的数值:");
            for(int i=0; i<3; ++i) {
                for(int j=0; j<2; ++j)
                    System.out.print(arr1[i][j]);
                System.out.print("\n");//显示成数组的表现形式
            }
    
            //第二种
            int[][] arr2 = new int[4][3];
            System.out.println("arr2的数值:");
            for(int i=0; i < arr2.length; ++i)
                for(int j=0; j<arr2[i].length; ++j)
                    arr2[i][j] = i*j;
            for(int i=0; i<arr2.length; ++i) {
                for(int j=0; j<arr2[i].length; ++j)
                    System.out.print(arr2[i][j]);
                System.out.print("\n");
            }
    
            //第三种
            int[][] arr3 = new int[4][];//五行的长度
            System.out.println("arr3的数值:");
            for(int i=0; i<arr3.length; ++i) {
                arr3[i] = new int[i + 1];
                //列的长度每次都变化。每次都要重新申请空间(长度)
                for (int j = 0; j < arr3[i].length; ++j)
                    arr3[i][j] = i + j;
            }
            for(int i=0; i<arr3.length; ++i) {
                for(int j=0; j<arr3[i].length; ++j)
                    System.out.print(arr3[i][j]);
                System.out.print("\n");
            }
    
    
        }
    }
    

    程序运行结果:

    arr1的数值:
    12
    23
    45
    arr2的数值:
    000
    012
    024
    036
    arr3的数值:
    0
    12
    234
    3456

     

    展开全文
  • Java中的数组是类类型(引用类型),Java的同一个数组中,只能存放相同类型的数据元素。 一维数组维数组的定义方式 一维数组有以下两种定义方式,推荐使用第一种定义方式 &amp;amp;amp;amp;amp;amp;lt;...
  • 今天小编就为大家分享Java不指定长度的二维数组实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • String s = "0,1;3,6,4;7,1"; //创建一个新的数组 String[] a = s.split(";"); //以;为分隔符返回一个数组 ... //创建一个只有名字的二维数组 d = new double[a.length][]; /...
  • Java中二维数组的动态初始化

    千次阅读 2020-07-11 17:50:27
    java中二维数组的动态初始化: 使用new关键字实例化,不是直接等于{{“hello”, “world”}, {“I”, “am”, “coming”}} 注意:维度 和 初始化不能同时出现。... //静态初始化一个二维数组 String[][] strArray = {
  • 其中,每一个数据称作一个元素,每个元素可以通过一个索引(下标) 来访问它们。数组的四个基本特点: 1.长度是确定的。数组一旦被创建,它的大小就是不可以改变的。2. 其元素的类型必须是相同类型,不允许出现混合...
  • Java二维数组的声明和初始化

    万次阅读 2013-09-01 15:29:41
    1.二维数组可以看成以数组为元素的数组;  2.Java中二维数组的声明和初始化应按照从高维到低维的顺序进行.  实例:  静态初始化:  Array2.java:  程序代码  public class Array2 { public static void...
  • JAVA一维数组二维数组

    2019-10-07 20:41:26
    数组概念 ...在JAVA数组必须初始化才能使用, 就是为数组中的数组元素分配内存空间,并为每个数组元素赋值! 动态初始化: 只指定长度,由系统给出初始化值 静态初始化: 给出初始化值,由系统决定...
  • 1.概述 ①Java语言中的数组是一种引用数据类型。不属于墓本数据类型。数组的父类是 object ②数组实际上是一个容器,可以同时容纳多个元素。(数组是一个数据的集合。...⑦数组的分类:一维数组、二维数组、三
  • Java 数组、多维数组,动态、静态初始化数组JVM内存模型分析什么是数组所谓数组,是具有相同数据类型的若干变量或者数据按照一定排序规则组合起来的种数据存储格式。数组中的数据称为数组元素,我们使用索引来...
  • Java 二维数组

    2020-12-18 10:35:37
    次我们讲了java维数组,今天我们来讲java二维数组。 正文: 二维数组的声明: 格式:数组元素类型 数组名[][]; int arr[][]; 格式二:数组元素类型[][] 数组名; int[][] arr; 注:元素类型可以是...
  • 二维数组初始化

    2014-02-19 09:35:12
    public class A{  public static void main (String [] args)  {  //实例一、  String str1[][];  str1=new String[3][];  str1[0]=new String[3];
  • 点击进入_更多_Java千百问1、二维数组如何定义Java语言中,多维数组被...2、二维数组如何初始化二维数组初始化和维数组一样,分为静态初始化和动态初始化静态初始化 Java语言中,由于把二维数组看作是数组的数组,
  • 68_初识Java_二维数组初始化方式_学习1、静态初始化2、动态初始化3、默认初始化 1、静态初始化 除了用new关键字来产生数组,还可以直接在定义数组的同时就为数组元素分配空间并赋值 int[][] arr={{1,2},{3,4,5},...
  • 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 = ...
  • Java教程当数组中每个元素都只带有一个下标时,这种数组就是“一维数组”。一维数组(one-dimensional array)实质上是一组相同类型数据的线性集合,是数组中最简单的一种数组。 数组是引用数据类型,引用数据类型在...
  • 1.二维数组可以看成以数组为元素的数组; 2.Java中二维数组的声明和初始化应按照从高维到低维的顺序进行. 实例: 静态初始化: Array2.java: 程序代码 public class Array2 { public static void main...
  • JAVA之旅(三)——数组,堆栈内存结构,静态初始化,遍历,最值,选择/冒泡排序,二维数组,面向对象思想 我们继续JAVA之旅 一.数组1.概念 数组就是同一种类型数据的集合,就是一个容器数组的好处:可以自动给...
  • 文章目录输入输出流输入输出程序示例数组创建一维数组二维数组创建二维数组声明数组的同时初始化数组相关链接 输入输出流 输入 java的输入,我们用到Scanner类,可以用它创建一个对象: Scanner reader=new Scanner...
  • 数组初始化方式总共有三种:静态初始化、动态初始化、默认初始化。 静态初始化 除了用new关键字来产生数组以外,还可以直接在定义数组的同时就为数组元素分配空间并赋值。 eg: int[][] arr = {{1,2},{4,5,6},{4,5,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,047
精华内容 8,418
关键字:

初始化一个二维数组java实例

java 订阅