精华内容
下载资源
问答
  • package text4; public class demo { public static void main(String[] args) { int[] arr = new int[4]; arr[0] = 5;...静态初始化 :定义数组的同时就为 ...动态初始化:只指定数组的长度,有系统为数组赋初始值

    package text4;

    public class demo {

    public static void main(String[] args) {
    	int[] arr = new int[4];
    	arr[0] = 5;
    	arr[1] = 3;
    	arr[2] = 8;
    	arr[3] = 9;
    	int max = arr[0];
    	int n = 0;
    	for (int i = 1; i < arr.length; i++) {
    		if (arr[i] > max) {
    			max = arr[i];
    			n = i;
    		}
    	}
    	System.out.println("最大值為:" + max + "下標為:" + n);
    }
    

    }

    静态初始化 :定义数组的同时就为 数组赋值
    动态初始化:只指定数组的长度,有系统为数组赋初始值

    展开全文
  • 1.动态初始化 1.1 二维数组格式1 数据类型[][] 变量名 = new 数据类型[m][n]; m表示这个二维数组有多少个一维数组 必须写上 n表示每一个一维数组的元素个数 可选 举例: int[][] arr = new int[3][2]; 定义了一个二维...

    一、二维数组

    (一)二维数组概述

    二维数组其实就是每一个元素为一维数组的数组。

    (二)二维数组初始化格式

    1.动态初始化

    1.1 二维数组格式1

    数据类型[][] 变量名 = new 数据类型[m][n];
    m表示这个二维数组有多少个一维数组 必须写上
    n表示每一个一维数组的元素个数 可选

    举例:
    int[][] arr = new int[3][2];
    定义了一个二维数组arr
    这个二维数组有3个一维数组,名称是arr[0],arr[1],arr[2]
    每个一维数组有2个元素,可以通过arr[m][n]来获取
    表示获取第m+1个一维数组的第n+1个元素

    注意事项
    (1)以下格式也可以表示二维数组

    • 数据类型 数组名[][] = new 数据类型[m][n];
    • 数据类型[] 数组名[] = new 数据类型[m][n];
      这两种格式不推荐使用

    (2)注意下面定义的区别

    int x,y;
    int[] x,y[];

    区别是:
    int[] x,y[];
    定义了两个数组 一个是一维数组x 一个是二维数组y

    案例演示

    public class ArrayDemo {
        public static void main(String[] args) {
            //二维数组:数组中的元素是一维数组,数组嵌套数组
            //动态初始化
    
            //3 表示这个二维数组里面,放了3个一维数组
            //2 表示二维数组中的一维数组的长度
            int[][] arr=new int[3][2];
            arr[0]=new int[]{10,20};//为第一个一维数组赋值
            System.out.println(arr[0]);//二维数组里第一个一维数组的地址
            System.out.println(arr[1]);//二维数组里第二个一维数组的地址
            System.out.println(arr[0][0]);//输出第一个一维数组的第一个元素值
            System.out.println(arr[0][1]);//输出第一个一维数组的第二个元素值
            System.out.println(arr.length); //二维数组的长度
            System.out.println(arr[0].length);//二维数组中的第一个一维数组的长度
        }
    }
    

    在这里插入图片描述
    内存解析
    在这里插入图片描述
      首先,程序编译好后生成了字节码文件(.class文件),JVM将字节码文件加载进内存的方法区,而main方法是程序的入口,需要被执行,于是调用main方法进栈执行。接着,执行第一句代码,创建了一个长度为3的int型二维数组,其每个元素为长度为2的一维数组。于是堆内存为该二维数组开辟空间,并将3个元素都初始化为null,内存空间地址为0x12345678(此处随意写的一个地址),然后再初始化3个长度为2的一维数组,开辟完空间以后将每个一维数组的引用覆盖掉二维数组的初始值null,于是这个二维数组的每个元素都指向对应的一维数组。再将0x12345678赋给二维数组的引用arr,则名为arr的这个数组便指向了地址为0x12345678的空间。main方法执行完毕后,main方法弹栈,此时就没有引用指向堆内存中地址为0x12345678的空间了,于是最后垃圾回收器回收了该空间,释放内存。

    1.2 二维数组格式2

    数据类型[][] 变量名 = new 数据类型[m][];
    m表示这个二维数组有多少个一维数组
    这种格式没有直接给出一维数组的元素个数,可以动态的给出。

    举例:

    int[][] arr = new int[3][];
    arr[0] = new int[2];//二维数组里的第一个一维数组长度为2
    arr[1] = new int[3];//二维数组里的第二个一维数组长度为3
    arr[2] = new int[1];//二维数组里的第三个一维数组长度为1
    

    案例演示

    public class ArrayDemo2 {
        public static void main(String[] args) {
            int[][] arr=new int[3][];
            System.out.println(arr);//二维数组地址
            System.out.println(arr[0]);//二维数组中第一个元素的值(初值null)
            System.out.println(arr[1]);
            System.out.println(arr[2]);
            arr[0]=new int[3];
            arr[1]=new int[5];
            arr[2]=new int[4];
            System.out.println(arr[0]);//动态赋值后第一个一维数组地址
            System.out.println(arr[1]);
            System.out.println(arr[2]);
        }
    }
    

    在这里插入图片描述
    内存解析:
    在这里插入图片描述
    这种格式,没有直接给出一维数组的元素个数,因此在创建二维数组时只会为二维数组开辟空间并初始化,不会为一维数组开辟空间和初始化。

    注意事项:数组的长度不宜过长,否则会报堆内存不足的错误

    public class Demo1 {
        public static void main(String[] args) {
            int[][] arr=new int[999999999][];
        }
    }
    

    在这里插入图片描述

    2.静态初始化

    2.1 二维数组格式3

    数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}...};

    简化版:
    数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
    这个格式属于静态初始化:由我们指定具体的元素值,由系统给分配长度

    举例:
    int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
    int[][] arr = {{1,2,3},{5,6},{7}};

    案例演示

    public class ArrayDemo {
        public static void main(String[] args) {
            //二维数组静态初始化
            int[][] arr=new int[][]{{2,4},{10,30},{10,30,40},{10,1}};
            System.out.println(arr.length);
            System.out.println(arr[3][1]);
            //简写方式
            int[][] arr2 ={{2, 4}, {10, 30}, {10, 30, 40}, {10, 1},{2,5}};
            System.out.println(arr2.length);
            System.out.println(arr2[2][2]);
        }
    }
    

    在这里插入图片描述

    (三)二维数组的遍历

    案例演示
    1.

    public class ArrayDemo {
        public static void main(String[] args) {
            int[][] arr = {{2, 4}, {10, 30}, {10, 30, 40}, {10, 1}};
            //二维数组的遍历
            //外循环控制的是二维数组的长度,其实就是一维数组的个数。
    		//内循环控制的是一维数组的长度。
            for (int i = 0; i < arr.length; i++) {
                for (int j = 0; j < arr[i].length; j++) {
                    System.out.println(arr[i][j]);
                }
            }
        }
    }
    

    在这里插入图片描述
    2.公司年销售额求和
    某公司按照季度和月份统计的数据如下:单位(万元)
    第一季度:22,66,44
    第二季度:77,33,88
    第三季度:25,45,65
    第四季度:11,66,99

    public class ArrayDemo {
        public static void main(String[] args) {
            int[][] arr={{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
            int sum=0;
            for (int i = 0; i < arr.length; i++) {
                for (int j = 0; j < arr[i].length; j++) {
                    sum+=arr[i][j];
                }
            }
            System.out.println("公司年销售额为:"+sum);
        }
    }
    

    在这里插入图片描述

    3.需求:打印杨辉三角形(行数可以键盘录入)
    1
    1 1
    1 2 1
    1 3 3 1
    1 4 6 4 1
    1 5 10 10 5 1

    import java.util.Scanner;
    
    public class Demo {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个数字");
            int x = sc.nextInt();
            int[][] a=new int[x][x];
            for(int i=0;i<a.length;i++){//任何一行的第一列和最后一列都是1
                a[i][0]=1;
                a[i][i]=1;
            }
            //从第三行开始,每一个数据是它上一行的前一列和它上一行的本列之和。
            for(int i=2;i<a.length;i++){
                for(int j=1;j<i;j++){//第一列和最后一列已赋值
                    a[i][j]=a[i-1][j-1]+a[i-1][j];
                }
            }
            //遍历二维数组 输出结果  
            for (int i = 0; i < a.length; i++) {
                for(int j=0;j<=i;j++){
                    System.out.print(a[i][j]+" ");
                }
                System.out.println();
            }
        }
    }
    

    在这里插入图片描述

    (四)思考题

    看程序写结果,并画内存图解释

    public static void main(String[] args) {
    		int a = 10;
    		int b = 20;
    		System.out.println("a: " + a + ",b: " + b);
    		change(a,b);
    		System.out.println("a: " + a + ",b: " + b);
    		int[] arr = {1,2,3,4,5};
    		change(arr);
    		System.out.println(arr[1]);
    }
    public static void change(int a,int b)  {
    		System.out.println("a: " + a + ",b: " + b);
    		a = b;
    		b = a + b;
    		System.out.println("a: " + a + ",b: " + b);
    }
    public static void change(int[] arr){
    		for(int x = 0 ; x < arr.length ; x++){
    			if(arr[x]%2 == 0){
    				arr[x] *= 2;
    			}
    		}
    }
    

    答案
    在这里插入图片描述
    内存解析
    在这里插入图片描述
    首先main方法被调用进栈,然后定义了两个变量a和b并赋了值。当main方法调用change(int a,int b)方法时,此方法进栈,并执行其中代码,修改了两个变量的值,执行完以后便出栈了。返回主方法中继续执行代码,此时输出a和b的值时只能找到主方法中的a和b,因此a和b的值仍然不变。接着创建一个int型数组并赋值,在堆内存中开辟了空间并赋上各元素值,并将该空间的地址赋给数组的引用arr,于是arr便指向该空间的数组。当调用change(int[] arr)时,此方法进栈,并执行其中代码,修改了数组中两个元素的值,执行完以后方法弹栈,但堆内存中数据的改动仍然保留,返回主方法继续执行代码,找到arr指向地址的数组,找到索引为1的元素,输出。
    基本数据类型,作为参数传递,形参的改变,不影响实参
    引用数据类型,作为参数传递,形参的改变,会影响实参

    二、递归

    (一)递归概述

    方法定义中调用该方法本身的现象

    递归注意事项:

    • 要有出口,否则就是死递归,会造成栈内存溢出
    • 递归次数不能太多,否则也会造成栈内存溢出

    死递归:

    public class Demo1 {
        public static void main(String[] args) {
            test();
        }
        public static void test(){
            System.out.println("这是一个死递归");
            test();
        }
    }
    

    在这里插入图片描述

    递归在生活中的举例:
    从前有座山,山里有座庙,庙里有个老和尚,老和尚给小和尚在讲故事:从前有座山,山里有座庙…

    (二)递归解决问题的思想

    递归解决问题的思想即“拆分合并
    也就是将一个大问题拆分成一个个小问题,解决完小问题后再合并,便解决了大问题。

    案例演示

    1.求5的阶乘

    方法1:利用循环

    public class MyTest {
        public static void main(String[] args) {
            //问题求 5的阶乘  5!=5*4*3*2*1;
            //循环做
            int r=1;
            for (int i = 1; i <= 5; i++) {
                r*=i;
            }
            System.out.println("结果是"+r);
        }
    }
    

    在这里插入图片描述
    方法2:利用递归
    在这里插入图片描述

    public class MyTest {
        public static void main(String[] args) {
            //求 5的阶乘
            //用递归来做
           int r= jieCheng(5);
            System.out.println("结果是"+r);
    
        }
        public static int jieCheng(int i) {
            if(i==1){
                return 1;
            }else{
                return i*jieCheng(i-1);
            }
        }
    }
    

    在这里插入图片描述
    在这里插入图片描述
    递归和循环的区别和联系

    递归算法:
    优点:代码简洁、清晰,并且容易验证正确性。
    缺点:它的运行需要较多次数的方法调用,如果调用层数比较深,会对执行效率有一定影响。并且调用次数过多会出现栈内存溢出的现象。

    循环算法:
    优点:速度快,结构简单。
    缺点:并不能解决所有的问题。

    用循环能实现的,递归一般可以实现,但是能用递归实现的,循环不一定能。

    2.兔子问题(斐波那契数列)
    题目:有一对兔子,从出生后第3个月起每个月都生一对兔子,小兔子长到第三个月后每个月又生一对兔子,假如兔子都不死,问第二十个月的兔子对数为多少?

    分析:由此可见兔子对象每个月的对数分别是:1 , 1 , 2 , 3 , 5 , 8, 13 …
    从中找到规律:前两个数都是1,从第三个数开始,这个数等于前两个数之和 (斐波那契数列)

    方法1:

    public class MyTest {
        public static void main(String[] args) {
    		//采用数组方法来做,到第20个月有多少对兔子
            int[] arr=new int[20];
            arr[0]=1;
            arr[1]=1;
            for (int i =2; i < arr.length; i++) {
                arr[i]=arr[i-1]+arr[i-2];
            }
            System.out.println("兔子的对数"+arr[19]);
        }
    }
    

    在这里插入图片描述

    方法2:递归

    public class MyTest2 {
        public static void main(String[] args) {
            //递归来做
            int sum = sumRabbit(20);
            System.out.println("兔子的对数" + sum);
        }
        public static int sumRabbit(int i) {
            if (i == 1 || i == 2) {
                return 1;
            } else {
                return sumRabbit(i - 1) + sumRabbit(i - 2);
            }
        }
    }
    

    在这里插入图片描述

    展开全文
  • 一维数组初始化

    2019-08-03 20:51:26
    数组初始化分为动态初始化和静态初始化。 动态初始化: 在定义数组的时候就对该数组进行初始化。 int[] array = new int[]{23,34,45,56}; 黑体部分可以省略,注意别忘记大括号后面的分号。 静态初始化: 将数组...

    数组初始化分类

    数组初始化分为动态初始化和静态初始化。

    静态初始化:

    在定义数组的时候就对该数组进行初始化。

    int[] array = new int[]{23,34,45,56};

    分步写:

    int[] array;
    第一步还可以写为:int array[];两种方式都可以

    array = new int[]{23,34,45,56};
    第二步黑体部分可以省略,注意别忘记大括号后面的分号。

    动态初始化:

    将数组的定义和数组的初始化分开来进行。

    // 等号后面的[ ]内必须写上数组的长度
    int[] array1 = new int[3];
    array1[0] = 1;
    array1[2] = 2;
    array1[3] = 3;
    

    注意:
    ①.所谓初始化就是为数据对象或变量赋初值的做法,但引用数据类型有初值,如null,0等,数组的初值为0。
    ②.

    	 array1 = new int[]{2,3,4,2};
         System.out.println(array1[4]);
    

    这个错误不会报告错误,但运行时会出错。
    ③.
    int[] numbers = new int[3] {};
    在提供数组初始化器时不能定义维度表达式,不能同时写[3]里的数字{},两者只能选其一写。

    展开全文
  • 一维数组初始化: 动态初始化:(声明并开辟数组) 数据类型[ ] 数组名称=new 数据类型[长度] int[ ] data=new int [5] :声明并开辟一个长度为5的数组 数组通过下标索引来获取元素,下标默认从0开始。数组下标...

    数组属于引用数据类型,在使用前必须初始化,否则会报NullPointerException(空指针异常:运行时异常)
    一维数组初始化:
    动态初始化:(声明并开辟数组)
    数据类型[ ] 数组名称=new 数据类型[长度]

    int[ ] data=new int [5] :声明并开辟一个长度为5的数组

    数组通过下标索引来获取元素,下标默认从0开始。数组下标超出数组长度,数组越界异常(运行时异常)

    数组中每个元素都有默认值,默认值是该数据类型默认值

    数组长度:数组名称.length

    数组遍历推荐使用JDK1.5 提供for-each循环(仅限于数组内容读取),要修改数组内容,还是使用常规for循环

        for(int x : data)
    

    {
    System.out.println(x+" ");
    }
    引用传递:多个栈内存指向同一块堆内存

    int[ ] tmp=data; //引用传递 注意是地址的传递
    tmp[3]=10; ----> x[3]=10;

    数组静态初始化
    简化格式:
    数据类型[ ] 数组名称 ={值,值…}
    完整格式: (推荐使用)
    数据类型[ ] 数组名称 =new 数据类型[ ]{值,值…}
    int[ ] data =new int[ ] {1,2,3} ;

    长度 :数组名称.length ,静态初始化长度固定,根据值的个数确定长度,并且长度不可修改

    匿名数组:没有任何栈内存指向,在使用一次后会变成垃圾,只会使用一次

    二维数组
    动态初始化:数据类型[ ][ ] 数据名称 =new 数据类型[ 行个数] [列个数]

    int[ ] [ ]data =new int [3][4];开辟行数为3,列数为4的整型数组

    静态初始化:
    数据类型[ ][ ] 数组名称 =new 数据类型[ ][ ]{ {第一行的值},{第二行的值}…}

    int[ ][ ] data={{1,2,3},{4,5,6},{7}};

    x<data.length

    y<data[x].length

    对象数组初始化:

    首先看对象数组动态初始化:

    对象数组动态初始化
    public class ArrayDemo
    {
        public static void main(String[] args)
        {
            String[] str=new String[3];  //数组动态初始化,每个元素都是其对应数据类型的默认值
            for(String num :str)
            {
                System.out.print(num+"、"); //null、null、null、
            }
            str[0]=new String("pick");
            str[1]=new String("happy");
            str[2]=new String("day");
           for(String num :str)
           {
               System.out.print(num+"、"); //pick、happy、day、
           }
        }
    }
    

    对象数组静态初始化:

    public class ArrayDemo
    {
        public static void main(String[] args)
        {
            String[] str=new String[]{"pick","happy","day"};  //数组静态初始化,pick、happy、day、
           for(String num :str)
           {
               System.out.print(num+"、"); //pick、happy、day、
           }
        }
    }
    
    展开全文
  • 动态初始化: String books = new String[3]; books[0] = "活着"; books[1] = "追风筝的人"; books[2] = "茶花女"; 2. 二维数组的初始化: 二维数组实际上就是一个一维数组,他的每个元素都是一个一维数组。 可以画...
  • 、问题描述 有n 个物品,它们有各自的重量和价值,现有给定容量的背包, 如何让背包里装入的物品具有最大的价值总和? 二、动态规划原理 动态规划是将大问题分解成许多小问题,通过寻找大问题与小问 题之间的...
  • java一维数组和二维数组初始化方式

    千次阅读 2018-03-22 15:06:26
    java一维数组的初始化方式和二维数组的初始化方式都包括动态初始化和静态初始化,四种(两种动态初始化方式和两种静态初始化方式)。 一维数组初始化: 动态初始化:数据类型[] 变量名 = new 数据类型[数组长度];...
  • 动态初始化数组的初始化和数组元素的赋值操作分开进行 int[] idArray;//声明 //静态初始化 idArray = new int[]{101, 102, 103, 104}; //动态初始化 String[] nameArray = new String[5]; ...
  • Java数组的初始化主要分为两种:静态初始化和动态初始化。在了解这两种初始化方式之前,先看一下Java提供的数组默认初始化。 Java为了保证安全性,防止内存缺失,为已创建的数组提供了默认初始化机制。在创建成功...
  • 维数组的初始化与位数组初始化类似,同样可以使用静态初始化或动态初始化。 1)静态初始化 静态初始化的格式如下: 数组名字 = new 数组元素的类型[][]{new 数组元素的类型[]{元素1,元素2,...},new 数组元素...
  • 给定个二网格和个单词,找出该单词是否存在于网格中。 单词必须按照字母顺序,通过相邻的单元格内的字母构成,其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同个单元格内的字母不允许被重复使用 ...
  • package com.sxt.arraytest1; import java.util.Arrays; ... * 一维数组 */ public class ArrayTest2 { public static void main(String[] args) { //动态初始化 int[] arr1 = new in...
  • 一维维数组初始化

    2020-09-02 14:03:04
    1.一维数组 静态 int array[100]; 定义了数组array,并未对数组进行初始化 静态int array[100] = {1,2}; 定义并初始化了数组array 动态int* array = new int[100]; delete []array; 分配了长度为100的数组...
  • 1.动态初始化 2.静态初始化 public class Demo01 { public static void main(String[] args) { // TODO Auto-generated method stub //动态初始化 /** * 第一个中括号:由几行组成,表示由几个一维数组组...
  • Java中二维数组动态初始化

    千次阅读 2020-07-11 17:50:27
    java中二维数组动态初始化: 使用new关键字实例化,不是直接等于{{“hello”, “world”}, {“I”, “am”, “coming”}} 注意:维度 和 初始化不能同时出现。 public class ArrayTest07 { public static void ...
  • 今天通过本文给大家分享Java中的数组,包括一维数组和二维数组的静态初始化和动态初始化问题,感兴趣的朋友一起看看吧
  • 在编程过程中,很多情况下(涉及到坐标、层级操作)我们都会用到二维数组,下面介绍介绍几种二维数组初始化的方法: 方法、直接定义并且初始化,这种情况适用于数量和值已知的数组: var arr=[["0-1","0-2"],[...
  •  1.2动态初始化数组的初始化和数组元素的赋值操作分开进行    数组一旦初始化完成,其长度就确定了。 示范代码: int num;//声明 num = 10;//初始化 int id = 1001;//声明 +初始化 int[] ids;//声明 //1.1...
  • Java从入门到放弃05(下)—二维数组的...动态初始化:自定义二维数组长度,即自定义二维数组中一维数组的个数。 动态初始化格式:数据类型[ ] [ ] 数组名=new 数据类型[m ] [n ]; a.m表示这个二维数组有多少个...
  • 在一个二维数组中(每个一维数组的长度相同),每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。 class ...
  • 维数组的初始化 1.静态初始化 int intArray[ ][ ]={{1,2},{2,3},{3,4,5}}; Java语言中,由于把二...2.动态初始化 1) 直接为每一维分配空间,格式如下: arrayName = new type[arrayLength1][arrayLength2];
  • 维数组初始化

    2021-02-03 11:18:48
    静态初始化 方式: int[][] arr1 = {{1,2,3}, {23,10}, {9,10,12,20,30}};...动态初始化 int[][] arr3 = new int[3][]; arr3[0] = new int[]{11,22}; arr3[1] = new int[]{10,9,8}; arr3[2] = new int
  • /* 动态初始化一维数组 1.动态初始化一维数组,会在堆内存中分配这个数组 并且数组中每一个元素都采用默认值 byte short int long 0 float double 0.0 boolean false ...
  • 1.一维数组初始化 (1)动态初始化(声明并开辟数组) 数据类型[] 数组名称 = new 数据类型[长度]; 如:声明并开辟一个长度为5的整型数组:int[] data = new data[5]; 注: 数组通过下标索引...
  • C++中二维数组初始化

    万次阅读 2017-08-18 17:54:16
    种是静态声明及初始化,如下: int array2[3][2]={{4,2},{5},{6}};第二种是,有时我们不知道二维数组需要多少行和多少列,这时是动态数组。 int **array; 后来我们通过输入来获取数组的行n和列m,则对数组进行...
  • 一维数组、二维数组声明与初始化

    千次阅读 2018-12-11 08:17:25
    一维数组 声明 type var [ ]; 或 type [ ] var; //例 int age [ ]; 或 int [ ] age; 注意:java中声明时不能指定其长度 对象创建 数组名 = new 数组元素的类型[数组元素的个数] //例 int age [ ]; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,461
精华内容 584
关键字:

一维数组动态初始化