精华内容
下载资源
问答
  • Java多维数组声明格式

    千次阅读 2019-04-20 22:49:42
    关于多维数组声明的形式你知道哪几种呢? 首先先上一个错误的例子: 这里arr9 - arr11在等式右边都错误的在中括号中加了数组大小,导致报错; 而arr11、arr12则是等式右边二维数组初始化时没有赋予初始大小导致报错...

    刷题目再次遇到了声明这种最基本形式的考题,以此记录,共勉。

    关于多维数组声明的形式你知道哪几种呢?

    首先先上一个错误的例子:
    2

    这里arr9 - arr11在等式右边都错误的在中括号中加了数组大小,导致报错;
    而arr11、arr12则是等式右边二维数组初始化时没有赋予初始大小导致报错。

    正确的声明形式如下:
    1
    本质上arr0、arr4和arr3、arr8是一样的;

    而arr1-2和arr5-6则是以一种俏皮的方式进行了声明,虽然也是可以通过编译运行的,但是我的IDE上的阿里代码规约还是建议使用arr0、arr4 或者 arr3、arr8这种形式。
    3
    大家只要知道可以这样子声明即可,实际工作中为了方便他人查看代码,还是遵守一些规约吧!


    这里献上代码以供大家到IDE中测试:

        int[][] arr0 = new int[2][2];
        int arr1[][] = new int[2][2];
        int []arr2[] = new int[2][2];
        int [][]arr3 = new int[2][2];
    
        int[][][] arr4 = new int[2][2][2];
        int arr5[][][] = new int[2][2][2];
        int []arr6[][] = new int[2][2][2];
        int [][]arr7[] = new int[2][2][2];
        int [][][]arr8 = new int[2][2][2];
    

    最近在找实习,压力有点大,写点博客减减压。

    展开全文
  • java多维数组详解

    2020-11-12 18:52:41
    java中其实没有多维数组的概念,只不过是依据数组的概念以及特点技术上的延伸 本质上就是存储数组的数组 多维的数组的使用 ①声明 // ### ①声明 // 1)数据类型 [][] 数组名; // 创建一个存储整数类型数组 ...

    多维数组

    在java中其实没有多维数组的概念,只不过是依据数组的概念以及特点技术上的延伸

    本质上就是存储数组的数组

    多维的数组的使用

    在这里插入图片描述

    ①声明

    		// ### ①声明
    		// 1)数据类型 [][] 数组名;
    		// 创建一个存储整数类型数组 的 数组 名为arr1
    		int[][] arr1;
    		// 2)数据类型 数组名[][]
    		// 创建一个存储整数类型数据的 名为arr2 的数组中存储数组
    		int arr2[][];
    

    ②创建

    		// ### ②创建
    		// 1)动态创建
    		// 多维数组创建与普通数组不同的是,普通数组创建时必须指定长度
    		// 多维数组也是必须指定长度,但是可以先不指定里层数组长度
    		// 多维数组就是将原来存储数据的块改为存储数组
    		// 前面的长度必填,代表当前数组存储数据的个数
    		// 后面的长度可以先不填,但是在使用时必须创建相应长度数组存储,代表存储的数组可以存储数据的个数
    		arr1 = new int[3][4];
    		// {0,0,0,0}
    		// {0,0,0,0}
    		// {0,0,0,0}
    
    		// 2)静态创建
    		int arr3[][] = { { 1, 2, 3, 4 }, { 4, 5, 6, 7 }, { 7, 8, 9, 10 } };
    		// 不论是静态创建还是动态创建每块保存数组的长度可以不同
    		int arr4[][] = { { 1 }, { 4, 5 }, { 7, 8, 9 } };
    

    ③赋值

    // ### ③赋值
    		// 数组赋值只有一种通过数组名[下标]的形式进行赋值
    		arr3[0] = new int[1];// 注意现在存储的数据为数组那么赋值的数据也应该为数组
    		// 对于多维数组通常使用两个索引进行数据的定位数组名[行][列]
    		arr3[1][2] = 2;
    		System.out.println(arr3[1][2]);
    

    ④使用

    		// ### ④使用
    		// 与赋值相同
    		// 本质上使用与一维数组一样,但是由于其存储数据的形式与一维数组不同所以语法上也存在不同
    		// 数组名[取出数据所在数组索引索引][取出数据在其数组索引]
    
    		int [] a=new int[2];
    		int [][] b=new int[2][2];
    

    冒泡排序算法

    算法:

    算法可以理解为完成某一需求的过程(最简洁)

    完成需求的思路

    冒泡排序算法

    将指定的数据通过交换依次向后输送

    	// 冒泡排序
    	public static void main(String[] args) {
    		int[] arr = { 3, 7, 6, 2, 4, 1, 8, 9, 5 };
    		// 将数据两两比较(当前位与后一位比较)
    		// 如果后一位较大则交换依次进行
    
    		// arr[0]=>arr[1];
    		// arr[1]=>arr[2];
    		// arr[2]=>arr[3];
    		// arr[i]=>arr[i+1];
    		// 当比较到最后一位时i+1会越界 所以i的范围应为0~最大索引-1
    		for (int i = 0; i < arr.length - 1 - 1; i++) {
    			if (arr[i] > arr[i + 1]) {
    				int tmp = arr[i];
    				arr[i] = arr[i + 1];
    				arr[i + 1] = tmp;
    			}
    		}
    		// 执行一轮只能确定一位最值 根据长度需要执行length-1次
    		for (int j = 0; j < arr.length - 1; j++) {
    			for (int i = 0; i < arr.length - 1 - 1; i++) {
    				if (arr[i] > arr[i + 1]) {
    					int tmp = arr[i];
    					arr[i] = arr[i + 1];
    					arr[i + 1] = tmp;
    				}
    			}
    		}
    		// 在内存进行判断时每次都会判断到最后但每次执行最后已经判断过的最值不应该继续判断
    		// 每次判断时应将内层条件 随着外层修改而修改 修改范围应为arr.length - 1 - 1-j(外层循环次数)
    		// 外层每每循环一次就会确定一个最值 那么在内层判断时就可以少判断一个
    		for (int j = 0; j < arr.length - 1; j++) {
    			for (int i = 0; i < arr.length - 1 - 1 - j; i++) {
    				if (arr[i] > arr[i + 1]) {
    					int tmp = arr[i];
    					arr[i] = arr[i + 1];
    					arr[i + 1] = tmp;
    				}
    			}
    		}
    
    		// for (int j = 0; j < arr.length - 1; j++) {
    		// for (int i = 0; i < arr.length - 1 - j; i++) {
    		// if (arr[i] > arr[i + 1]) {
    		// int tmp = arr[i];
    		// arr[i] = arr[i + 1];
    		// arr[i + 1] = tmp;
    		// }
    		// }
    		// }
    
    		for (int i = 0; i < arr.length; i++) {
    			System.out.print(arr[i] + " ");
    		}
    	}
    

    java面向对象——封装

    封装的概念可以理解为打包,将程序进行一定程度的封装既能提高程序维护的效率也能提高程序的安全性

    java中的封装

    方法:

    将执行的多条语句以一个代码块进行封装并指定名称与运行时需要的数据,在需要使用时进行调用,隐藏了执行的过程,调用方只需要知道方法名以及传入指定参数就可以获取结果,并可以重复调用,既提高了系统的安全性也提高了系统开发维护的方便

    类:

    将一群具有相同特征相同行为对象相同进行抽取封装为类。可以用类来表示这些拥有共同属性的任意对象。

    属性:

    在类的定义过程中使用访问权限修饰符修饰属性,将属性权限设置为只对指定位置可见以提高系统的安全性。

    访问权限修饰符

    java中的封装只的就是使用访问权限修饰符对类、方法、属性进行修饰以达到安全性的体现

    在这里插入图片描述

    public:所有的类都能有public访问说明符。你能从任何Java程序的任何对象里使用公有类、成员数据(属性)和方法。
    private:只有本类的类对象才能访问的私有变量或方法,类内部成员之间可以访问;
    protected:在类中被声明为保护的变量,方法能被其子类访问。
    默认:(default)假如没有规定访问说明符,那就是friendly的。拥有友元访问符的类、变量或方法对包里的所有类来说都是可访问的。

    说明:在方法中的变量不能有访问说明符,因为该变量只能在该方法中使用,外界无法访问。

    使用限制

    访问权限修饰符可以用来修饰类、方法、属性但有一定的限制

    修饰类

    使用访问权限修饰类时只能使用public与默认修饰符

    package com.yunhe.day1016;
    //修饰类只能使用public或默认
    public class ASD {
    }
    
    package com.yunhe.day1016;
    //同包下其他类可以直接使用无需导包
    public class Test {
    	public static void main(String[] args) {
    		ASD asd=new ASD();
    	}
    }
    
    package com.yunhe.day1015;
    import com.yunhe.day1016.ASD;
    //不同包下需要导包才可以使用
    public class T1 {
    public static void main(String[] args) {
    	ASD asd=new ASD();
    }
    }
    

    默认访问权限修饰符修饰的类只有同包下可以使用其他包下不能访问

    修饰方法

    可以使用全部修饰符(常用public、private)

    修饰属性

    可以使用全部修饰符(常用private)

    私有属性赋值方法

    1)构造方法初始化赋值

    2)创建公开的方法进行修改

    由于方法的特性以及类的特性封装使用不是很多,所以现在一般封装指的就是属性的封装

    封装,就是隐藏实现细节
    将属性私有化,提供公有方法访问私有属性
    通过这些公有方法访问私有属性

    封装的实现

    1、修改属性的可见性来限制对属性的访问
    2、为每个属性创建一对赋值(setter)方法和取值(getter) 方法,用于对这些属性的访问
    3、在setter和getter方法中,加入对属性的存取限制

    学习完封装之后类的书写规范

    //类的属性规范
    //类修饰符根据实际使用决定使用public还是默认
    public class Teacher {
    	// 属性
    	// 所有属性使用private修饰
    	private String name;// 名字
    
    	// 为所有属性提供公开的getter与setter方法
    	// getter方法书写规范
    	// 修饰符必须为public 返回值类型与属性类型一致 方法名为get+属性名(遵循驼峰命名法)
    	public String getName() {
    		return name;
    	}
    
    	// setter方法书写规范
    	// 修饰符必须为public 返回值为void 方法名为set+属性名(遵循驼峰命名法)
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	// 构造方法
    	// 1无参构造方法
    	public Teacher() {
    	}
    
    	// 2全参构造方法
    	public T
    		this.name = name;
    	}
    }
    
    展开全文
  • Java多维数组

    千次阅读 2017-03-22 09:14:19
    数组声明的每个维度的一对括号[]来声明多维数组。 例如,如下所示定义int类型的二维数组: int[][] table; Java 这里,table是一个引用变量,可以保存对int类型的二维数组的引用。下面创建具有三行和两列的...

    可以在二维数组中存储表格数据。在数组声明的每个维度的一对括号[]来声明多维数组。
    例如,如下所示定义int类型的二维数组:

    int[][] table;
    
      
    Java

    这里,table是一个引用变量,可以保存对int类型的二维数组的引用。下面创建具有三行和两列的int类型二维数组,如下所示:

    table = new int[3][2];
    
      
    Java

    多维数组中每个维度的索引都是从零开始的。可使用table[rownumber] [columnNumber]访问table数组的每个元素。行号(rownumber)和列号(columnNumber)始终从0开始。

    例如,以下代码将一个值 32 分配给表数组中的第一行和第二列,如图所示:

    table[0][1] = 32;
    
      
    Java

    可以将值1分配给第三行和第一列,如下所示:

    table[2][0] = 1;
    
      
    Java

    必须在创建多维数组时指定至少第一级数组的维度。例如,

    table = new int[3][];
    
      
    Java

    此语句仅创建第一级数组。此时仅存在table[0]table[1]table[2],它们都是引用 null 值。 table.length的值为3table[0]table[1]table[2]int类型的数组,也可以将它们赋值为 -

    table[0] = new int[2]; // Create two  columns  for row 1 
    table[1] = new int[2]; // Create two  columns  for row 2 
    table[2] = new int[2]; // Create two  columns  for row 3
    
      
    Java

    Java可以为每行创建一个具有不同列数的二维数组。这样的数组称为粗糙数组。

    public class Main {
      public static void main(String[] args) {
        // Create a two-dimensional array of 3 rows
        int[][] raggedArray = new int[3][];
    
        // Add 2 columns to the first row
        raggedArray[0] = new int[2];
    
        // Add 1 column to the second row
        raggedArray[1] = new int[1];
    
        // Add 3 columns to the third row
        raggedArray[2] = new int[3];
    
        // Assign values to all elements of raggedArr
        raggedArray[0][0] = 1;
        raggedArray[0][1] = 2;
        raggedArray[1][0] = 3;
        raggedArray[2][0] = 4;
        raggedArray[2][1] = 5;
        raggedArray[2][2] = 6;
    
        // Print all elements. One row at one line
        System.out.println(raggedArray[0][0] + "\t" + raggedArray[0][1]);
        System.out.println(raggedArray[1][0]);
        System.out.println(raggedArray[2][0] + "\t" + raggedArray[2][1] + "\t"
            + raggedArray[2][2]);
      }
    }
    
      
    Java

    上面的代码生成以下结果。

    1    2
    3
    4    5    6
    
      
    Java

    访问多维数组的元素

    通常,使用嵌套for循环来填充多维数组。用于处理多维数组的for循环次数等于数组中的维数。

    以下代码显示了如何访问多维数组的元素

    public class Main {
      public static void main(String[] args) {
        int[][] myArray = new int[3][];
        myArray[0] = new int[2];
        myArray[1] = new int[1];
        myArray[2] = new int[3];
    
        // Populate the ragged array using for loops
        for (int i = 0; i < myArray.length; i++) {
          for (int j = 0; j < myArray[i].length; j++) {
            myArray[i][j] = i + j;
          }
        }
    
        // Print the array using for loops
        for (int i = 0; i < myArray.length; i++) {
          for (int j = 0; j < myArray[i].length; j++) {
            System.out.print(myArray[i][j] + "\t");
          }
    
          // Add a new line after each row is printed
          System.out.println();
        }
      }
    }
    
      
    Java

    上面的代码生成以下结果。

    0    1    
    1    
    2    3    4
    
      
    Java

    初始化多维数组

    可以在声明时或在创建时提供值列表来初始化多维数组中的每个元素。

    每个维度的初始值数量将决定数组中每个维度的长度。级别的值列表用大括号括起来。对于二维数组,每行的值列表都包含在一对大括号中,如下所示:

    int[][] arr = {{10, 20, 30},   
                   {1, 2},   
                   {2, 3, 4, 5}};
    
      
    Java

    在上面的语句中创建一个具有三行的二维数组。以下代码显示如何初始化一个二维String类型的数组:

    String[][] acronymlist = {{"A", "a"},
                              {"B", "b"},
                              {"C", "c"}};
    
      
    Java

    可以在创建多维数组时初始化多维数组的元素。如下代码所示 -

    int[][] arr = new int[][]{{1, 2},   {3,4,5}};
    展开全文
  • Java多维数组初始化的问题

    千次阅读 2019-01-11 09:31:47
    昨天遇到了三维数组初始化的问题,代码如下, int[][][] arr = new int[2][][]; arr[1] = new int[][]{{1,...这里只是找到了一个可以编译的写法,盲人摸象,想要高屋建瓴的理解还是去了解Java编译器和虚拟机。 i...

    昨天遇到了三维数组初始化的问题,代码如下,

    int[][][] arr = new int[2][][];
    arr[1] = new int[][]{{1,2}, {3,4}, {5,6}};//这里出问题了

    研究了一下后有所收获,思考过程都在代码注释中,主要是快速初始化和匿名数组的问题。这里只是找到了一个可以编译的写法,盲人摸象,想要高屋建瓴的理解还是去了解Java编译器和虚拟机。

    import java.util.Arrays;
    public class Test
    {
        public static void main(String[] args)
        {
            //声明了一个数组变量,但是这个变量还没有初始化,
            // 也就是说没有指向任何内存,甚至连null都不是,此时还不能使用
            int[] a;
    
            a = null;//数组也是对象,将a初始化为null
            System.out.println(Arrays.toString(a));
    
            a = new int[5];//将a初始化为一个长度为5的整型数组,数组中的元素默认初始化为0
            System.out.println(Arrays.toString(a));
    
            a = new int[]{1, 2, 3, 4, 5};//创建了一个匿名数组,并将a指向这个匿名数组
            System.out.println(Arrays.toString(a));
    
            //这是创建数组对象并同时赋值的简化书写形式,不需要调用new,也不能调用new
            int[] smallPrimes = {2, 3, 5, 7, 11};
            System.out.println(Arrays.toString(smallPrimes));
    
            /*
             * java中没有多维数组,也就是说arr表示引用一个数组,这个数组中存放的应该是int[][]型的引用
             * 但是这个时候arr没有初始化,它甚至连null都不是
             * */
    
            int[][][] arr = new int[2][][];
             /* new int[2][][]将在堆中开辟内存,内存的大小为两个int[][]型引用的长度
             * 默认初始化为null,也就是说arr[0]和arr[1]都是null
             * 如果要给arr[0]赋值,需要赋一个int[][]型的引用值,
             * 像下面这样*/
            arr[0] = new int[3][3];
            /*
             * 下面是创建一维数组对象并同时赋值的简化书写形式,
             * 不需要调用new,也不能调用new
             *int[] smallPrimes = {2, 3, 5, 7, 11};
             * 如果想要像这样给arr[1]赋值,应该已经没有机会了
             *
             * 下面是通过创建匿名数组初始化一维数组a
             * a = new int[]{1, 2, 3, 4, 5};//创建了一个匿名数组,并将a指向这个匿名数组
             * 如果是想要像这样给arr[1]赋值,考虑如何创建二维匿名数组
             *首先明确,二维数组中存放的是一维数组的引用,仿照一维数组的形式,
             * 在大括号中创建匿名一维数组就可以了*/
            arr[1] = new int[][]{new int[]{1, 2}, new int[]{3, 4}, new int[3], {}};
            System.out.println(Arrays.deepToString(arr));//查看arr的内容,是不规则数组
        }
    }

     

    展开全文
  • 有一个二维数组,我想按照第一,第二,第三列进行降序排列。 注意: 1、如果第一列数值相同,那么就按照第二列降序排列。 2、同理,如果第二列数值相同,那么就按照第三列降序排列。 代码如下: import ...
  • java中的多维数组

    2017-08-23 16:53:02
    多维数组声明 数据类型[][] 数组名称; 数据类型[] 数组名称[]; 数据类型数组名称[][]; 以上三种语法在声明二维数组时的功能是等价的。同理,声明三维数组时需要三对中括号,中括号的位置可以在数据类型的后面,...
  • Java 中没有多维数组的概念,从数组底层的运行机制上来看 Java 没有多维数组,但是 Java 提供了支持多维数组的语法,可以实现多维数组的功能。 Java 语言里的数组类型是引用类型,因此数组变量其实是一个引用,这个...
  • 数组 概念: 数组是存储同一种数据类型多个元素的集合,也可以看成是一个容器。 数组既可以存储基本数据类型,也可以存储引用数据类型(后面讲解)。 一维数组 定义格式: //格式1:数据类型[] 数组名; int...
  • 在学习了一维数组之后,便开始学习多维数组。 【动因】 目前,你已经使用过一维数组来对线性的元素集合进行建模。你可以使用二维数组来表示矩阵或表格。例如:使用二维数组可以存储下面这个描述城市之间距离的表格。...
  • ##多维数组实现逆时针螺旋输出,如下 1 2 3 4 12 13 14 5 11 16 15 6 10 9 8 7 首先我们要实现1 2 3 4的输出很简单 接下来实现从5到7的输出,需要保持j不变,i++ ...
  • Java多维数组

    2021-03-11 15:51:18
    Java语言里提供了支持多维数组的语法,但如果从数组底层的运行机制上来看声明多维数组的实质便是一次性声明多个一维数组。 二维数组使用示例 二维数组的三种声明使用方式 第一种 //多个[]的使用即为多维数组 有几...
  • 多维数组声明关键词:数组长度,数组高位数组低位、外数组内数组。
  • java多维数组

    2020-03-02 23:04:00
    二维数组数组数组 int[][] arr = {{66,77},{789,921,520},{8,963,9}};
  • Java多维数组 声明、创建二维数组 声明还是那两种方法: 数据类型[][] 数组名; int [][] matrix; 数据类型 数组名[][]; int matrix [][]; (不推荐这种方法) 创建也是如此(基本跟一维数组没有什么区别): ...
  • 数组前言1、数组的创建1.1 、动态初始化创建数组1.2 、静态初始化创建数组2、数组的遍历2.1、数组的遍历(1)2.2、数组的遍历(2)3、数组的练习4、存储引用变量5、多维数组 前言 数组的定义:在内存中一段连续的...
  • java中数组和多维数组

    2019-11-23 14:48:38
    数组 1、通常我们用的最多的是一维数组,一维数组有两种赋值方式 例一: public static void main(String[] args) { int[] arr2 = { 1, 2, 4, 6 }; for (int i = 0; i < arr2.length; i++) { System....
  • Java 没有多维数组

    2016-07-06 16:38:16
    JAVA语言里提供了支持多维数组的语法. 但如果从数组的底层运行机制上来看,是没有多维数组的. JAVA语言里的数组类型是引用类型. 因此, 数组变量其实是一个引用, 这个引用指向真实的数组内存. 数组元素的...
  • 1、数组概述 数组,是多个相同类型数据按一定顺序排列的集合,并使用一个名字命名,并通过编号的方式对这些数据进行统一管理。 1.1、数组的相关概念 (1)数组名 (2)数组元素 //数组元素就是多个相同类型数据...
  • C++多维数组

    2020-02-07 15:22:23
    二维数组 #include<iostream> using namespace std;... //二维数组声明, 数据类型 数组名 [整型常量表达式] [整型常量表达式] .....; int array_2[3][4] = { {1, 2, 3, 4},{ 5, 6, 7, 8},{ 9, ...
  • 文章目录Java数组1、数组声明创建与初始化2、内存分析3、多维数组4、Arrays类5、冒泡排序 面试常遇见6、稀疏数组 重点 压缩数组7、二分查找法(折半查找法) 面试常见 Java数组 数组是相同类型数据的有序集合。每个...
  • Java中没有真正意义的多维数组多维数组是通过一维数组进行组装产生的, 定义的方式和一维数组类似 1、定义二维数组的四步方式 int[][] a;// 定义变量,声明二维数组 a = new int[5][5];// 分配空间...
  • java基础 多维数组简单的使用 1.使用二维数组打印一个 10 行杨辉三角。 1.1题目提示 1.2代码 //使用二维数组打印一个10行杨辉三角 public class YangHuiTest { public static void main(String[] args) { //1....
  • 最近在java学习中学习了数组列表和多维数组列表的一些知识及有关方法,颇有收获,所以打算写一篇博客将它们记录下来,如果其中有不恰当的地方或者错误希望各位能够斧正,谢谢大家。 Array list(数组列表) 数组列表在...
  • 多维数组 多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组。 二维数组: int a[][]=new int[2][5]; 多维数组的使用: public class ArrayDemo05 { public ...
  • Java数组的输入输出

    万次阅读 多人点赞 2019-08-15 15:28:59
    首先声明一个int型数组 int[] a 或者 int a[] 给数组分配空间 a=new int[10]; 和声明连起来就是int[] a=new int[10]; 或者是 int a[]=new int[10]; 给数组赋值 a[0]=1;//0代表的是数组的第1个元素 ,元素下标...
  • 数组 数组----是用来存储一组相同数据类型的数据的容器 数组本身是一个引用数据类型[] ...数组的定义/声明 数组的初始化 静态初始化—有长度 有元素 动态初始化—有长度 没有元素(默认值) 数组元素的访问通过
  • 多维数组的使用

    2020-08-09 16:41:41
    Java 语言里提供了支持多维数组的语法。 如果说可以把一维数组当成几何中的线性图形,那么二维数组就相当于是一个表格。 对于二维数组的理解,我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,609
精华内容 5,843
关键字:

java多维数组声明

java 订阅