java数组详解

java数组

一、声明变量

形如:

①dataType[] arrayRefVar;   //常用

②dataType arrayRefVar[]; 

 

具体：

①double[] myList;   //常用

②double myList[];

 

二维数组：

具体：

①String[][] str;  //常用

②String str[][];

二、实例化

数组是定长的！

 

实例化形如：

①正常方法（定长法）：

arrayRefVar = new dataType[arraysize]; //arrayRefVar上面已经声明

 

具体：

double[] myList=new double[20];

或

int size=20;

double[] myList=new double[size];

 

上面这句话做了两件事：

（1）、使用 dataType[arraySize] 创建了一个数组对象。

（2）、把新创建的数组对象的引用赋值给变量 arrayRefVar。

 

  *这里size虽然为变量，但是实例化的时候，生成对象，对象就是定长。

       甚至可以这样写：

public class trydt {

 

    public static void main(String[] args) {

       // TODO Auto-generated method stub

       int[] a;

       int b;

       Scanner scan=new Scanner(System.in);

       b=scan.nextInt();

       a=new int[b];

       System.out.println(a.length);

       }

}

 

输入：5

输出：5

 

结论：走到这一步时，b会有值。可以生成数组对象（存于堆中），即使后面b变了，对这个对象没影响。

若为循环内生成，则一次生成一个对象，照样不影响。

 

②穷举法（顺带已经给数组赋值了）：

int stuScores[] = new int[]{68, 96, 85, 79, 21, 36, 58};

int stuScores[]={45,68,98,12,65};

//穷举法已经对数组赋了初值。

 

注意：

int stuScores[] = new int[7]{68, 96, 85, 79, 21, 36, 58};

这样写是错误的，穷举法不能给长度。

 

int stu[]=new int[5];

stu={44,33,22,11,15};

这样也是错误的。

int stu[];

stu={56,52,12};

这样还是错误的。

 

网上摘抄：

java中提供了一种创建数组对象并同时赋予初始值的简化书写形式。

这就是一种简化，只能按最上面的两种写法。

• 初值问题：

       当声明一个数组后，如果没有赋初始值，访问的是当前数组类型的默认值。

某网友尝试：

1、int类型定义的数组，初始化默认是0

2、String类型定义的数组，默认值是null

3、char类型定义的数组，默认值是0对应的字符

4、double类型定义的数组，默认值是0.0

5、float类型定义的数组，默认值是0.0

 

• 本节大注意

数组声明时（前面）的[]里不要写任何东西。

二.1 二维（多维）数组实例化

最高维叫一维，即下面长度为2的是第一维。

可以认为是高维数组的每个元素都是一个低维数组。

①正常方法：

type arrayName = new type[arraylenght1][arraylenght2];

具体：

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

这可以看成一个二行三列的数组。

 

注意：

a[1]=new int[4];//第二行（第一维第二个元素）竟然可以动态安排数组长度，尽管上面已经安排好了长度。

   

②动态初始化：

定义不规则数组：

String s[][]=new String[2][];

 

 

s[0]=new String[2];

s[1]=new String[3]; //后面这个可以先不实例化

注：即只声明高阶的，高阶里面包含低阶的，低阶在高阶声明之后可以自由声明（不规则数组）。数组的数组。

更高阶的可以依次递归。

●里面一阶数组可以用各种实例化的方法。

 

注意：①低阶数组的数据类型不能改变！

String s[][]=new String[2][];

s[0]=new int[2];//这是错误的

②虽然我们可以这样：int stuScores[] = new int[]{68, 96, 85, 79, 21, 36, 58};//一阶穷举

也可以这样：String s[][]=new String[2][];//先只声明高阶的，低阶之后再声明。

却不能 String s[][]=new String[2][]{{"abc","bcd"},{"apq","rst"}};

穷举和定长混合。

 

③穷举法（顺带已经给数组赋值了）：

这样可以创建出来不规则数组

String[][] stuNames = new String[][]{{"小强1", "小强2", "小强3", "小强4", "小强5", "小强6", "小强7"}, {"小强1", "小强2", "小强2", "小强2", "小强2", "小强2"}, {"小强1", "小强2", "小强2", "小强2", "小强2"},{}};

stuNames[3]=new String[]{"sd","sda"};

注意：这里穷举第一维长度可以用括号扩展！

 

 

三、数组赋值

一些概念上的东西详见《面向对象之变量》。

 

为什么这里说是赋值而不是初始化。因为实例化时会自动调用构造方法为对象（指内存中那块地址）初始化，有默认初值的。

 

①可以这样赋值

int stu=new int[5];

stu[0]=3;

stu[1]=4;

stu[2]=1;

//谁说一定要都赋值完了？默认值不好吗？

②也可以用循环赋值

public class TestArray{

       public static void main(String[] args){

              int count=0;

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

              {

                     a[i]=count;

                     count++;

              }

       }

}

 

③最后就是穷举法的赋值了

四、处理数组

数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者 foreach 循环。

①列出元素操纵。

形如：a[1]=10;

这种。

②正常循环操作。

a.length;给出数组长度，这个方法很重要。

③foreach 循环。

public class TestArray {

    public static void main(String[] args) {

     double[] myList = {1.9, 2.9, 3.4, 3.5};

 

// 打印所有数组元素

for (double element: myList){

    System.out.println(element);

        }

    }

}

 

它能在不使用下标的情况下遍历数组。

五、数组分类

一些概念上的东西详见《面向对象之变量》。

本章很多关于变量、引用、数据类型的东西要和《面向对象之变量》穿插着看。

 

解释，数组是引用数据类型：

       数组类型的变量，其存储单元存放的是数组对象的引用。

       新创建的数组对象的引用可以赋值给数组变量。

      

①数组元素是基本数据类型

上面列举的就是。即数组对象存储单元（简称数组，下同）存放的各元素都是基本数据类型的数据。

数组内存空间直接存的是数据。

②数组元素是引用数据类型

数组存的各元素都是引用数据类型的。

数组内存空间存的是引用值。

 

所以：

看下面这个代码：

package com.array;

 

public class ArrTest {

 

    public static void main(String[] args) {

       // TODO Auto-generated method stub

       Student[] stu=new Student[3];

       Student a=new Student();

       a.setStuNo("112");

       a.setAge(12);

       stu[0]=a;

      

       System.out.println(stu[0]);

      

       a.setStuNo("33");

      

       System.out.println(stu[0]);

       //这个代码证明 传递引用时，不论哪个引用变量导致内存中对象变了，

       //其余的引用变量的"值"都会变

    }

}

 

输出结果为：

学生编号=112, stuName=null, gender=null, age=12, score=0

学生编号=33, stuName=null, gender=null, age=12, score=0

 

   这串代码告诉我们：虽然“对象”已经存数组了，但在其他地方改变这个“对象”，数组里存的依然会变。因为存进数组的是引用值（理解为数组的这个元素就是一个引用变量），内存中的对象没有存入数组中，其他的引用导致内存中的对象改变，数组中这个引用指向的对象（同一个对象）自然会改变。