java 数组的基本概念

1.数组的基本概念

　　数组指的是一组相关变量的集合。例如：如果说现在要定义100个整型变量，如果按照我们以前的思路，我们可能这样定义：

public class demo {
    public static void main(String[] args) {
        int a = 1, b = 2, c = 3, d = 4;  ///... ... 一共写100个
    }
}

　　以上的形式的确可以满足技术要求，但是有一个问题，这100个变量没有任何的逻辑控制，那么就会出现对象不方便管理的情况。那么在这样的情况下，就可以用数组来解决此类问题，数组本身数组引用数据类型，所以数组的定义语法如下:

• 声明并开辟数组：数据类型  数组名称 [ ]  = new 数组类型[ 长度 ] ； // 数据类型  [  ] 数组名称  = new 数组类型[ 长度 ] ,[  ]的位置也可以这样
•  分步完成：
  • 　　声明数组： 数据类型 数组名称 [ ]  = nul ;     //声明的时候才会使用 [ ] ,
  • 　　开辟数组：数组名称 = new 数组类型  [ 长度 ] ；

　　当数组开辟空间之后，那么可以 数组名称[下标 || 索引]  的形式进行访问，但是索引数组的下标都是从0开始的（和python元组概念一样，也是不能越界，会抛出[ArrayIndexOutOfBoundsException]错误）

　　　　　　　　//以上　　定义数组使用的是动态初始化的方式

范例：

public class demo_Array {
    public static void main(String[] args) {
        int data[] = new int[3]; //声明并开辟一个3个长度的数组
        System.out.println(data[0]);
        System.out.println(data[1]);
        System.out.println(data[2]);
    }
}
out：

0
0
0

　　//上面说明动态生成的数组初始化值为0

　　由于数组是一种顺序结构，并数组的长度都是固定的，那么可以使用循环的语句进行输出（和Python概念一样），而且java里面为了方便数组的输出有一个内置方法可以取得数组长度。

　　　　方法 ： “ 数组名称 . length ”   如下

public class demo_Array {
    public static void main(String[] args) {
        int data[] = new int[3]; //声明并开辟一个3个长度的数组
        System.out.println(data.length);
    }
}
out：
3

赋值并循环输出：

 1 public class demo_Array {
 2     public static void main(String[] args) {
 3         int data[] = new int[3]; //声明并开辟一个3个长度的数组
 4         data[0] = 10;　　//赋值语句
 5         data[1] = 20;　　//赋值语句
 6         data[2] = 30;　　//赋值语句
 7         for (int x =0 ; x< data.length;x++){
 8             System.out.println(data[x]);
 9         }
10     }
11 }
out：
10
20
30

　

　　虽然数组的操作很简单，当它也属于引用数据类型，牵涉到内存分配的问题，与对象保存的唯一区别在yu：对象中的堆保存的是属性，而数组中的堆保存的是一组信息；

分步完成的话：

public class demo_Array {
    public static void main(String[] args) {
        int data[] = null;  //声明数组
        data = new int[3];  //开辟数组堆空间
        data[0] = 10;
        data[1] = 20;
        data[2] = 30;
        for (int i =0 ; i< data.length;i++){
            System.out.println(data[i]);
        }
    }
}

　　跟对象的概念基本一样

* 既然数组属于引用数据类型，那么数组也可以发生引用传递：

//引用传递的目标必须也是一个数组

public class demo_Array {
    public static void main(String[] args) {
        int data[] = new int[3]; //声明并开辟一个3个长度的数组
        int temp [] = data; //引用传递的目标必须也是一个数组
        data[0] = 10;
        data[1] = 20;
        data[2] = 30;
        for (int i =0 ; i< data.length;i++){
            System.out.println(data[i]);
        }
    }
}

以上数组的定义格式是属于动态初始化，操作特点是：先开辟数组空间，而后赋值。

那么也有静态初始化：

　　1. 数据类型 数组名称 [ ] = { 值，值，值...... } ； 　　（不推荐）

　　2.数据类型 数组名称 [ ] = new 数据类型 [ ] { 值，值，值...... } ；

静态初始化范例：

public class demo_Array {
    public static void main(String[] args) {
        int data[] = new int[]{1,2,3,4,5}; 
        for (int i =0 ; i< data.length;i++){
            System.out.println(data[i]);
        }
    }
}
out:

1
2
3
4
5

 　　*在实际工作中数组是会存在的，但它的内容大部分情况下都是通过传递的数据动态生成的，很少会出现这种先开辟数组再使用的情况

　　 *java数组有一个最大的缺陷，长度是不能被改变的，就是不能+1-1长度，所以很少会直接生成使用，而是通过传递动态生成

 2.二位数组

　　在之前的数值里面只有一个 [ ]  ,也称为一维数组，而如果要描述更多的数据，可以使用二位数组， 后面有两个[ ] [ ] 。

一维数组：

索引	0	1	2	3	4	5	6	7	8
数据	10	20	30	40	50	60	70	80	90

　　在一维数组里面要找一个数组，只要确定一个索引就可以了 System.out.println(data[0]); ；

二位数据：

索引	列：0	1	2	3	4	5	6	7	8
行：0	10	20	30	40	50	60	70	80	90
1	564	87	3678	453	831	54	12	87	23
2	75	825	8787	687	87	35	54	87	57

　　如果现在要确定蓝色这个数据，需要行列定位，例如：行1，列5 =  [ 1 ][ 5 ]  ;

　　而定义语法有两类：

• 动态初始化： 数据类型 数组名称 [ ][ ] = new 数据类型 [行的个数][列的个数] ；
• 静态初始化：数据类型 数组名称 [ ][ ] = new 数据类型 [ ][ ] { {  值，值，值... ... } }；

　　所谓的二维数组实际上就是将多个一维数组变成了一个大的数组，并且为每一个一维数组设置了一个行号 ； 

静态初始化和输出：

public class demo_Array {
    public static void main(String[] args) {
        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 < data[x].length ; y++){
                System.out.print(data[x][y] + "	");
            }
            System.out.println();
        }
    }
}
out:

1    2    3    
4    5    6    
7    8    9    

　　* 实际开发中二位数组很少出现

3.数组与方法参数的传递 **

 　　数组也可以传递，但是如果传递的是数组，请观察内存分配。

public class demo {
    public static void main(String[] args) {
        int data[] = new int[]{1,2,3};
        change(data);  　　// data = int temp []
        for (int x=0 ; x< data.length; x++) {
            System.out.println(data[x]);
        }
    }
    //此方法定义在主类中，并由主方法直接调用
    public static void change(int temp[]){
        for (int x = 0 ; x < temp.length ; x++){
            temp[x] = temp[x] * 2;
//            System.out.println(temp[x]);
        }
    }
}

观察内存：

另外一种：

public class 数组传递 {
    public static void main(String[] args) {
        int data[] = new int[]{1,2,3};
        int temp[] = data;   //数组传递
        for (int x = 0 ; x < temp.length ; x++){
            temp[x] = temp[x] * 2;
        }
        for (int x=0 ; x< data.length; x++) {
            System.out.println(data[x]);
        }
    }
}

　　*在进行数组的引用传递中，方法对数组的修改一定会影响原始数据。