精华内容
下载资源
问答
  • 求大神指点java中一维数组和二维数组的区别,为什么一位数组是一行 二维数组可以定义多行
  • 数组一、一维数组1. 一维数组概念及定义格式2. 一维数组的初始化1)动态初始化2)静态初始化3. Java中内存分配及堆栈的区别4. 数组操作常见问题5. 一维数组内存图解6. 一维数组练习二、二维数组1. 二维数组概述及...

    一、一维数组

    1. 一维数组概念及定义格式

    • 为什么要有数组
      数组可以存储同一类型的多个变量,当我们在存储诸如一个单位的工资、一个班级的成绩这种问题时,如果给每一个人都声明一个变量会显得很麻烦,这个时候就可以用数组来存储这些信息
    • 数组的概念
      可以将数组看作是一个容器,数组是存储同一种数据类型的多个元素的集合,存储的元素既可以是基本数据类型,也可以是引用数据类型(二维数组就是)
    • 一维数组定义格式
      • 格式一:数据类型[] 数组名
      • 格式二:数据类型 数组名[]
      • 格式一与格式二都是定义一个一维数组,效果一样,但是常用第一个

    2. 一维数组的初始化

    1)动态初始化

    • 什么是初始化
      刚才我们定义了一个一维数组,需要进行初始化之后才能使用,初始化就是在堆区中为数组开辟一块内存空间,并为数组的每一个元素赋值(可以自己手动赋值,如果没有,系统会赋默认值)
    • 初始化分类
      • 静态初始化
      • 动态初始化
      • 注:两种只能选其一,不能同时使用
    • 动态初始化格式
      • 数据类型[] 数组名 = new 数据类型[数组长度];
      • 举例:int[] array = new int[3];// 定义了一个int型的一维数组array,这个数组的长度是3,可以存放3个int型变量

    2)静态初始化

    • 静态初始化格式
      • 数据类型[] 数组名 = new 数据类型[]{数组元素1,数组元素2,……}
      • 举例:int[] array = new int[]{1,2,3};
        //定义了一个int型的一维数组array,里面存放了1,2,3三个元素
      • 简化格式
        数据类型[] 数组名 = {数组元素1,数组元素2,……}

    3. Java中内存分配及堆栈的区别

    • 栈内存:存放局部变量
      在方法中或方法声明上的变量(参数)都是局部变量
      • 特点:没有初始值,必须赋值才能使用
    • 堆内存:存放所有new(引用)的东西
      • 特点
        • 每一个new出来的东西都会为其分配一个地址值,使用地址值(数组名)来使用
        • 使用完毕就会被垃圾回收器回收
        • 系统会默认给初始值
    类型
    整数型0
    浮点型0.0
    char‘\u0000’
    booleanfalse
    引用类型null
    • 方法区:类的加载
    • 本地方法区:和系统相关
    • 寄存器:cpu使用

    4. 数组操作中常见问题

    • 数组越界:访问了不存在的索引(数组元素的下标,代表该元素在数组中的位置)
    • 空指针异常:数组名已经不指向堆内存了,还用数组名去访问。

    5. 一维数组内存图解

    在这里插入图片描述

    6. 一维数组练习

    • 一维数组遍历

      public static void main(String[] args) {
          int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
          for (int i = 0; i < 9; i++) {
              System.out.println(arr[i]);
          }
      }
      
    • 一维数组最值

      public static void main(String[] args) {
          int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
          int max = arr[0];
          int min = arr[0];
          for (int i = 0; i < 9; i++) {
              max = max > arr[i] ? max : arr[i];
              min = min < arr[i] ? min : arr[i];
          }
          System.out.println("最大值是:" + max + ",最小值是:" + min);
      }
      
    • 一维数组反转

      public static void main(String[] args) {
          int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};//定义数组arr
          for (int i = 0; i < 9 / 2; i++) {//利用for循环对数组首末元素调换,以达到反转
              int mid = arr[i];
              arr[i] = arr[arr.length - i - 1];
              arr[arr.length - i - 1] = mid;//首末元素互换
          }
          for (int i = 0; i < 9; i++) {//对数组遍历输出
              System.out.print(arr[i] + "\t");
          }
      }
      
    • 查表:根据键盘录入索引,查找对应星期

      public static void main(String[] args) {
          int input = input();//调用此方法得到用户输入的索引
          if (input >= 1 && input <= 7) {
              lookUp(input);//当用户输入索引合法时,调用此方法输出对应的星期
          } else
              System.out.println("你输入的索引有误!!");
      }
      
      //此方法用来接收用户键盘输入的一个整数并返回
      private static int input() {
          Scanner in = new Scanner(System.in);
          System.out.println("请输入索引:1-----7");
          int input = in.nextInt();
          return input;
      }
      
      //此方法用来判断传入的索引对应的是星期几
      private static void lookUp(int input) {
          String[] str = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
          for (int i = 0; i < str.length; i++) {
              if ((input - 1) == i) {//当用户输入的索引减一等于i时,输出i所对应数组中的元素
                  System.out.println(str[i]);
                  break;
              }
          }
      }
      

    二、二维数组

    1. 二维数组概述及格式

    • 概述
      对于一个班的单科成绩我们可以用一个一维数组来存放,那对于所有的科目呢,又该如何去存放,为每一个科目新建一个一维数组还是有点麻烦,这里我们引入二维数组进行存放。
    • 思想
      在刚才的一维数组里面我们存放的是一个个具体的数值,比如1,2,3……,也就是说一维数组里存放的是具体的值,那二维数组呢,其实二维数组可以理解为一个特殊的一维数组,这个一维数组里面存放的元素是一个数组而不是具体的值。可以表示为:数据类型[][] 变量名 = {一维数组1,一维数组2,一维数组3……}
    • 格式
      • 数据类型[][] 数组名 = new 数据类型[m][n];
      • m表示这个二维数组里面有几个一维数组(维数),必须写上
      • n表示每一个一维数组有几个元素,可写可不写
    • 举例
      • int[][] arr = new int[2][3];
      • 定义了一个二维数组arr,这个二维数组有两个元素(一维数组)arr[0]、arr[1],每个一维数组有3个元素,比如arr[0]中有arr[0][0]、arr[0][1]、arr[0][2]三个元素
    • 注意:一下格式也可以表示一维数组,但不常用
      • 数据类型 数组名[][] = new 数据类型[m][n];
      • 数据类型[] 数组名[] = new 数据类型[m][n];

    2. 二维数组内存图解

    • 直接定义二维数组的元素长度
      在这里插入图片描述
    • 使用一维数组给二维数组元素赋值
      在这里插入图片描述

    3. 二维数组练习

    • 二维数组求和

        ```
        public static void main(String[] args) {
            int[][] num = {{22, 66, 44}, {77, 33, 88}, {25, 45, 65}, {11, 66, 99}};
            int sum = 0;
            for (int i = 0; i < num.length; i++) {//外层遍历二维数组的每一个元素
                for (int j = 0; j < num[i].length; j++) {//内层遍历一维数组的每一个元素
                    sum += num[i][j];//累加
                }
            }
            System.out.println("数组和是:" + sum);
        }
        
        ```
      
      • 打印杨辉三角,由键盘输入行数
      public static void main(String[] args) {
          int input = input();//得到用户指定的行数
          int[][] triangle = tri(input);//得到指定行数的杨辉三角数,存在二维数组triangle中
          output(triangle);//遍历输出二维数组
      }
      
      //此方法用来得到用户指定行数的杨辉三角数,并存在二维数组中
      private static int[][] tri(int input) {
          int[][] triangle = new int[input][input];//定义用户指定长度的二维数组
          for (int i = 0; i < triangle.length; i++) {//对三角形两边的值赋1
              triangle[i][0] = 1;
              triangle[i][i] = 1;
          }
          for (int i = 2; i < triangle.length; i++) {
              for (int j = 1; j < i; j++) {//对每一行中间值赋值,等于上一行前一列元素与本列元素之和
                  triangle[i][j] = triangle[i - 1][j - 1] + triangle[i - 1][j];
              }
          }
          return triangle;//返回该二维数组
      }
      
      //此方法得到并返回用户从键盘输入的整数
      private static int input() {
          Scanner in = new Scanner(System.in);
          System.out.println("请输入杨辉三角的行数:");
          int input = in.nextInt();
          return input;
      }
      
      //此方法遍历输出二维数组(只输出下三角)
      private static void output(int[][] triangle) {
          for (int i = 0; i < triangle.length; i++) {//遍历二维数组元素
              for (int j = 0; j <= i; j++) {//遍历一维数组元素
                  System.out.print(triangle[i][j] + "\t");
              }
              System.out.println();
          }
      
      }
      
      

    三、递归

    1. 递归概述

    • 递归就是在方法中调用方法本身的现象
    • 注意事项
      • 要有结束的条件,即出口,不然就是死递归
      • 次数不能太多,因为方法要加载进栈,递归次数过多会造成栈溢出

    2. 递归思想图解

    • 斐波那契数列:1,1,2,3,5,8,13,21,34……
    • 可以发现,从第三个数开始,后两个数等于前两个数之和
    • 图解
      在这里插入图片描述

    3.递归练习

    • 打印斐波那契数列第20个数

      public static void main(String[] args) {
          System.out.println(recursive(20));//调用recursive方法求第20个斐波那契数列数
      }
      
      public static int recursive(int n) {
          if (n == 1 || n == 2) {//这个if语句是递归调用终止的条件,当调用到recursive(1)recursive(2)时
              return 1;          //就不再递归调用,给recursive(1)recursive(2)返回一个值1,递归调用结束
          }
          return recursive(n - 1) + recursive(n - 2);//从20往下调用 20=19+18  (19=18+17  18=17+16)
          //一直调用下去,直到调用到1和2为止
      }
      
    • 递归调用时一定要注意程序的出口,不然就会形成死递归

    展开全文
  • 一维数组的语法: 1.java语言的数组一种引用数据类型,不属于基本数据类型。数组的父类是Object。 2.数组实际上是一个容器,存放一组相同类型的数据。 3.数组当中可以存储“基本数据类型”的数据,也可以存储...

    Java中一维数组的语法及初始化:

    1、一维数组的语法:

    (1)java语言中的数组是一种引用数据类型,不属于基本数据类型。数组的父类是Object。

    (2)数组实际上是一个容器,存放一组相同类型的数据

    (3)数组当中可以存储“基本数据类型”的数据,也可以存储“引用数据类型”的数据。

    (4)数组因为是引用类型,所以数组对象是在堆内存当中,数组变量保存了对象的地址。

    (5)数组存储的是引用类型的话,实际上每个元素存储的都是对象的引用地址。

    (6)在java中,数组一旦创建,长度不可变

    (7)数组分为:一维数组,二维数组,多维数组(一维数组使用最多,二维数组使用较少,多维数组几乎不用)。

    (8)所有的数组对象都有length属性(java自带的),用来存储数组中元素的个数。

    (9)一个数组中只能存储相同数据类型,int型数组只能存int数据,Person型数组只能存Person类型数据。

    (10)数组在内存方面存储的时候,数组的元素内存地址是连续的,紧挨着的。数组是一种简单的数据结构。

    (11)所有的数组都是拿第一个元素的内存地址作为整个数组对象的内存地址

    (12)数组中每一个元素都是有下标的,下标从0开始,以1递增,最后一个元素下标是length - 1。

    下标在数组中非常重要,我们就是通过下标的概念来存储和访问数组的元素。下标只能从0到length - 1,一定要注意下标范围,不然会出现数组越界异常。


    2、数组这种数据结构的优点和缺点是什么?(重点)

    优点:
    查询/查找/检索某个下标上的元素效率极高,可以说是查询效率最高的一个数据结构。

    为什么数组检索效率高?

    (1)每一个元素的内存地址在空间存储上是连续的。

    (2)每一个元素类型相同,所以占用空间大小一样。

    (3)知道第一个元素的内存地址,知道每一个元素的内存大小,又知道下标,所以通过一个数学表达式就可以计算出某个下标的元素的内存地址,例如: 假设第一个元素的地址是200,元素大小是6,那么下标1的元素地址就是: 200+1*6,即206。直接通过内存地址定位到元素,所以说数组的检索效率是最高的。

    缺点:
    第一:由于为了保证数组中每个元素的内存地址连续,所以在数组中随机删除或者增加元素的时候,效率较低,因为增删元素会设计后面元素统一向前或者向后移位操作。

    第二:数组不能存储太多数据量,因为很难在内存空间上找到一块特别大的连续内存空间。


    3、怎么声明定义一个一维数组?

    int[] array1;
    boolean[] array2;
    String[] array3;
    Person[] array4;
    Object[] array5;
    

    4、怎么初始化一个一维数组?

    包括两种方式:静态初始化一维数组,动态初始化一维数组。

    (1)静态初始化语法格式:

    int[] array1 = {1, 6, 3, 7, 6};  //array1.length系统自动算出来为5
    String[] array2 = {"hello", "world", "good"};  //array2.length = 3
    

    (2)动态初始化语法格式:

    int[] array3 = new int[5];  //5表示数组元素的个数,每个元素都是int型,默认为0
    String[] array4 = new String[6];  //初始化长度为6的String型数组,默认值为null
    

    不存在这种定义:(静态维度和动态维度不能同时出现)

    int[] a = new int[3]{1, 2, 3};  //报错
    

    5、一维数组的遍历

    测试代码:

    public class ArrayTest01 {
        public static void main(String[] args) {
            //静态初始化数组
            int[] numArray = {2, 6, 5, 8};  //系统算出长度numArray.length = 4
            String[] strArray = {"hello", "world", "I", "am", "coming"};  //length = 5
    
            for (int i = 0; i < numArray.length; i++) {
                System.out.println("下标为" + i + "的数据为" + numArray[i]);
            }
            System.out.println("---------------------------------------------------");
            for (int i = 0; i < strArray.length; i++) {
                System.out.println("下标为" + i + "的数据为" + strArray[i]);
            }
    
            //当你不知道定义的数组该存什么时,你可以使用动态初始化,你只需要预定数组的length即可
            int[] a1 = new int[20];  //给int型数组预定20个元素
            String[] a2 = new String[10];  //给String型数组预定10个元素
            //之后你就可以通过下标给数组赋值
    
            //注意下标范围
            //System.out.println(a1[-1]);  //报错:ArrayIndexOutOfBoundsException
            //System.out.println(a1[a1.length]);
        }
    }
    

    展开全文
  • java中一维数组的声明、初始化和使用 数组可以存储多个相同类型的元素,其中,类型可以是java数据类型的任意一种 1. 一维数组的两种声明方式 方式1:数组元素类型[ ] 数组名; 方式2:数组元素类型 数组名[ ]; //...

    java中一维数组的声明、初始化和使用

    数组可以存储多个相同类型的元素,其中,类型可以是java数据类型的任意一种

    1. 一维数组的两种声明方式

    方式1:数组元素类型[ ] 数组名;
    方式2:数组元素类型 数组名[ ];

    	//声明一个存储分数的数组
    	//方式1
    	int[] scoreArray1;
    	//方式2
    	int scoreArray2[];
    	//也可以声明其他类型的数组
    	char[] sex1;
    	char sex2[];
    	boolean[] isRoll1;
    	boolean isRoll2[];
    	String[] department1;
    	String department2[];
    	byte[] age1;
    	byte age2[];
    		
    

    注意:没有初始化的数组时不能使用的。(可以初始化为null)

    	//未初始化使用数组
    	int[] scoreArray;
    	System.out.println(scoreArray);
    

    在运行时就会报错,如下图:
    报错
    补救措施:给数组初始化即赋值,若不打算赋值可以赋null值。

    	//给数组赋null值
    	int[] scoreArray = null;
    	System.out.println(scoreArray);
    

    在这里插入图片描述
    2. 一维数组的初始化

    数组的初始化可以在声明数组的时候直接初始化,也可以先声明后初始化。

    方式1:数组元素类型 [ ] 数组名 = new 数组元素类型 [数组长度];------------ 默认初始化值:int型为0,double型为0.0,boolean型为false,String型为null,char型为0所对应的字符,float型为0.0。

    方式2:数组元素类型 [ ] 数组名 = new 数组元素类型 []{元素1,元素2,…};------------数组长度根据元素个数确定

    方式3:数组元素类型 [ ] 数组名 = {元素1,元素2,…};------------方式2的简化版本,根据元素个数确定数组的长度

    	//方式1
    	int[] age = new int[50];//默认初始化的值为0
    	//方式2
    	double[] scoreArray = new double[]{98, 87.5};//scoreArray的长度为2
    	//方式3
    	String[] department = {"INFOR", "COMPU", "COMMU", "ENGLISH"};//department的长度为4
    

    注意: 数组初始化时必须要确定数组的长度

    3. 一维数组的使用方法

    <1> 访问和修改一维数组中的数据
    根据数组索引或下标访问数组,缩印的范围是0到数组长度-1,若超出索引范围则在运行时会报错。修改数组中的数据时只需根据索引选定要修改的数据,并赋予新的值即可。

    	//访问scoreArray下标为0的数据
    	double d =  scoreArray[0];
    	System.out.println(d);
    	//修改scoreArray下标为0的数据为88.7
    	scoreArray[0] = 88.7;
    	System.out.println(scoreArray[0]);
    

    修改
    <2>获取一维数组的长度
    所有一维数组的 的长度都可以通过数组名.length获取到。

    	//获取department数组的长度
    	String[] department = {"INFOR", "COMPU", "COMMU", "ENGLISH"};
    	int l = department.length; 
    	System.out.println(l);
    

    长度
    <3>一维数组之间的赋值

    	int[] a = new int[10];
    	int[] b = {3, 5, 6, 2, 45, 28};
    	System.out.println(a[0] + " " + b[0]);
    	a[0] = b[0];//将b[0]的值赋给a[0]
    	System.out.println(a[0] + " " + b[0]);
    	b[4] = a[4];//将a[4]的值赋给b[4]
    	System.out.println(a[4] + " " + b[4]);
    

    相互赋值
    <4>一维数组的填充
    Arrays.fill(数组名, 值); ------------使用指定的值填充指定的数组
    在使用该方法时需要导入java.util.Arrays包。

    	int[] b = new int[3];
    	Arrays.fill(b, 100);
    	System.out.println(b[0]);
    	System.out.println(b[1]);
    	System.out.println(b[2]);
    

    填充
    <5>一维数组的遍历

    	//输出数组中的元素
    	int[] a = new int[]{67, 778, 45, 53, 80};
    	for(int i = 0; i < a.length; i++){
    		System.out.print(a[i] + " ");
    	}
    

    遍历
    <6>一维数组的最值问题

    思路:将数组中第一个元素确定为最大值(最小值),存入一个临时变量中,然后选用for循环,将临时变量与数组中其他元素挨个比较,若数组元素大于(小于)临时变量的值,则更新临时变量的值,直到遍历完整个数组,最后存在临时变量中的值就是最大值(最小值)。

    	//一维数组的最值问题(此处以最大值为例,最小值同理)
    	int[] a = {7, 35, 45, 2, 67, 889} ;
    	int max = a[0];
    	for(int i = 1; i < a.length; i++){
    		if(a[i] > max)
    			max = a[i];
    	}
    	System.out.println(max);
    

    最大值

    一维数组的用处还有很多,在这里就不一一列举了。

    以上都是一维数组相对来说比较基础的知识,需要熟练掌握。

    PS:以上内容若有错误,欢迎指出!!!

    展开全文
  • 1、数组: 相同数据的集合。 1.1、定义数组的方法: 类型[] 变量名 = new 类型[数组元素个数];   int[]a = new int[10]; first index:0;max:length-1;1.2、创建和初始化数组:1.2.1、创建时指定大小: //...

    1、数组:

    相同数据的集合。


    1.1、定义数组的方法:

    类型[] 变量名 = new 类型[数组元素个数];

     

    int[]a = new int[10];


    first index:0;
    max:length-1;
    1.2、创建和初始化数组:
    1.2.1、创建时指定大小:

    //创建时指定大小  int[] arrays = new int[2];  arrays[0] = 1;  arrays[1] = 2;


    1.2.2、创建时赋初值:

    int[] arrays2 = {1,2};


    1.2.3、创建时赋初值(使用new关键字):

    int[] arrays3 = new int[]{1,2};


    1.3、数组的大小:

    数组的大小是一个常量。一旦初始化一个数组之后数组的大小便固定了,不能再修改。

     

    属性:length 数组长度。

     

    public final int length;


    1.4、数组默认值:

    int类型不赋初值则默认赋值为0,引用类型默认为null。


    1.5、数组的equals方法:

    数组的equals方法只是使用了==判断是否同一个对象,所以,如果要判断两个数组包含的数值是否相等,最好使用Arrays类中的静态方法:

     

    static boolean equals(int[] a, int[] a2)  如果两个指定的 int 型数组彼此相等,则返回 true。


    1.6、数组的保存:

    int[] a = new int[10]

     

    a是一个引用,指向了生成的数组对象的首地址。数组中每个元素都是int类型的。

     

    数组中保存的是引用。对象数组未赋值时为null。


    2、二维数组:

    二维数组是一种平面的二维结构,本质上是 数组的数组。


    2.1、二维数组的创建和赋值:
    2.1.1、等长数组:

    int[][] a = new int[2][2];


    2.1.2、可变数组:

    int[][] a = new int[2][];  a[0] = new int[2];  a[1] = new int[3];

     

    以下创建为错误:

     

    int[][] a = new int [][2];


    2.2、初始值:

    int[][] a = new int[][]{{1},{1,2}};


    2.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、交换变量:
    3.1、不使用中间变量交换整数的方法:

    int a = 1;  int b = 2;  a = a + b;  b = a – b;  a = a – b;


    3.2、通过方法实现两个整数的互换:

    调用一下方法后并不会调用两个数:

     

    public void swap(int a, int b){      int temp = a;      a = b;      b = temp;  }

     

    传递数组,使之能够交换后改变:

     

    public void swap(int[] a){      int temp = a[0];      a[0] = a[1];      a[0] = temp;  }


    4、Arrays数组类:

    public class Arrays          extends Object  此类包含用来操作数组(比如排序和搜索)的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

     

    equals方法:

     

    equals  public static boolean equals(int[] a,                               int[] a2)  如果两个指定的 int 型数组彼此相等,则返回 true。如果两个数组包含相同数量的元素,并且两个数组中的所有相应元素对都是相等的,则认为这两个数组是相等的。换句话说,如果两个数组以相同顺序包含相同的元素,则两个数组是相等的。此外,如果两个数组引用都为 null,则认为它们是相等的。  参数:  a - 将测试其相等性的一个数组  a2 - 将测试其相等性的另一个数组  返回:  如果两个数组相等,则返回 true

     

    copyOfRange方法:

     

    static  <T,U> T[]   copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType)  将指定数组的指定范围复制到一个新数组。


    5、三维数组:
    5.1、定义:

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


    5.2、循环赋值:

    int[][][] a = new int[1][2][3];  for(int i=0; i<a.length; i++){      for(int j=0; i<a[i].length; j++){          for(int k=0; k<a[i][j].length; k++)              System.out.println(a[i][j][k]);      }  }

    转自:http://cristalspring.blog.163.com/blog/static/14432742520130169238709/

    展开全文
  • java中一维数组的使用(初级)

    千次阅读 2017-07-01 10:27:13
    介绍java中一维数组的使用方法,分别介绍数组的声明、分配空间、赋值、及使用;数组的静态赋值、动态赋值;数组间的赋地址、赋元素;数组的遍历等常用的方法
  • 一、 数组的创建 首先我们Java虚拟机(JVM)包含五部分:Java栈,Java堆,PC寄存 器,方法区和本地方法栈 ...一维数组 2>二维数组 int[] arr={1,2,3,4,5}; int[][] brr={ {1,2} , {3,4} , {5,6} ...
  • 一维数组初始化: 动态初始化:(声明并开辟数组) 数据类型[ ] 数组名称=new 数据类型[长度] int[ ] data=new int [5] :声明并开辟一个长度为5的数组 数组通过下标索引来获取元素,下标默认从0开始。数组下标...
  • 一维数组的定义: //动态初始化 int []a; int b[]; int []c=new int [3]; int d[]=new int [3]; //通过下标赋值 //a,b这种定义方式必须在使用前给a,b声明长度,否则编译会出问题: //(The local ...
  • * 当一维数组作为形式参数时的 * */ public class ArrayTest02 { public static void main(String[] args) { int[] a1 = {1, 2, 3}; int[] a2 = new int[4]; String[] s1 = {"hello", "world"}; String[] s2 ...
  • JAVA中一维数组和二维数组的定义

    万次阅读 多人点赞 2008-12-30 15:28:00
    java中数组被看成是一个对象在定义数组时,有两种定义方法:int[] a 和int a[];第二种是C/C++对数组定义方式,对于JAVA...1 一维数组的定义 //定义包含三个元素的一维数组 //方法1,先new对象,然后再初始化每个元
  • 一维数组和二位数组的声明、创建与赋值: 一维数组: 例: int[] a = new int[n]; int[] b = new int[]{1,2,3,4,5}; int[] c = {1,2,3,4,5}; 二维数组: 例: int[][] a = new int[m...
  • Java中一维数组的排序方式

    千次阅读 2017-06-12 10:08:38
    我们知道数组中是固定数量的同类型数据的组合,那么既然是同中类型,就可以进行排序。以下我们将介绍几种常见的数组的排序方式。  int[] scores = new int[]{3,5,6,58,4,2,96,17}   冒泡排序法。将相邻的元素...
  • 主要介绍了Java编程一维数组转换成二维数组,分享了相关代码示例,小编觉得还是挺不错的,具有一定借鉴价值,需要的朋友可以参考下
  • 一维数组实质上是一组相同类型数据的线性集合,是数组中最简单的一种数组。本文将重点介绍一维数组的创建、初始化和使用。 创建一维数组 为了在程序中使用一个数组,必须声明一个引用该数组的变量,并指明整个变量...
  • 下面小编就为大家带来一篇浅谈java中一维数组、二维数组、三维数组、多维数组。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 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...
  • 主要介绍了Java获取一维数组的最小值实现方法,需要的朋友可以参考下
  • java代码-JAVA中String数组初始化,一维数组和二维数组初始化
  • Java一维数组之和

    千次阅读 2017-05-28 13:52:15
    java计算一维数组之和
  • 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}; // 定义...
  •  实际上是一维数组.的每个元素还是 一个一维数组, 元素是数组的数组package day04; /** * 二维数组 * 1) 二维数组是假的! 实际上是一维数组.的每个元素还是 * 一个一维数组, 元素是数组的数组. */ public ...
  • Java:二维数组给一维数组赋值的情况

    千次阅读 2020-06-06 19:58:59
    1、一维数组的声明格式: (1)数据类型 数组名【】 (2)数据类型【】 数组名 2、为一维数组分配内存格式: 数组名 = new 数据类型【长度】 3、在声明数组的同时分配内存格式: 数据类型 数组名【】 = new 数据类型...
  • 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中的二维数组 (Two Dimens...
  • 一维数组 ★定义一个数组 ☆方法1: 格式: int(数组格式)[](两个方括号) test(数组名) = new(表示初始化) int(数组格式) [(数字)例:100](表示数组里可以存放多少数据) 意思是创建新的100个存放int的数组交给...
  • 前言:最近这两天在csdn论坛经常看到有人因为自定义的数据的实例化而导致报NullPointerException...1、自定义一维数组:(可能比较常见的就是在Swing应用的,就举Swing的例子) import java.awt.*; import javax.swi
  • java一维数组二维数组

    2018-12-17 19:42:50
    Java数组相关资料,部分题目。有兴趣的同学可以了解一下
  • java基础 一维数组

    千次阅读 2018-01-03 20:29:18
    一维数组 1.数组的概念 (1)数组 是个容器 保存的是数据 保存相同数据类型数据 数组定义 数据类型[] 数组名 = 初值 其中数据类型代表:数组中盛放数据的 数据类型 int[] array = new int[5]; 数组使用下标...
  • java代码-Java一维数组练习

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 124,160
精华内容 49,664
关键字:

java中一维数组

java 订阅