Java数组

数组： 存储同一种数据类型的集合容器.

数组的特点：
    1. 只能存储同一种数据类型的数据。
    2. 一旦初始化，长度固定。 
    3. 数组中的元素与元素之间的内存地址是连续的。
    
注意： Object类型的数组可以存储任意类型的数据。 

数组的三种初始化方式：

1.静态初始化

       除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

                   例 int[] a={1,2,3};//静态初始化基本类型数组

                        Man[] mans={new Man(1,1),new Man(2,2)};//静态初始化引用类型数组

2.动态初始化

        数组定义与为数组元素分配空间并赋值的操作分开进行

        int[] a1=new int[2];//动态初始化元素，先分配空间

          a1[0]=1;//给数组元素赋值

          a1[2]=2;

3.数组的默认初始化

       数组是引用类型，他的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化

         实例：int a2[]=new int[2];//默认值0，0

          boolean[] b=new boolean[2];//默认值 false，false

          String[] s=new String[2];//默认值null

使用建议：

如果不确定数组当总的具体内容，用动态初始化；

否则，已经确定了具体的内容，用静态的初始化；

如何获得数组的长度：

数组名称.length
/*
如何获取数组的长度，格式：
数组名称.length

这将会得到一个int数字，代表数组的长度
数组一旦创建，程序运行期间。长度不可改变
 */
public class sz{
    public static void main(String[] args) {
     int[]ArrayA=new int[3];
     int[]arryB={10,20,30,40,50,60,20,20,10};
     int len=arryB.length;
     System.out.println("arryB的数组长度时"+len);

     int[]arrayC=new int[3];
        System.out.println(arrayC.length);
        arrayC=new int[5];
        System.out.println(arrayC.length);
    }
}

数组的遍历输出：

public class sz { 
    public static void main(String[] args) {
        char[] chArr={'A','B','C'};
        for(int i=0;i<chArr.length;i++)
            System.out.print(chArr[i]+" ");
        //传统的遍历输出方式
        System.out.println();
        for(char i:chArr){
            System.out.print(i+" ");            
        }
        //整体每一个都遍历，用此比较简便
        int[][] arr={{1,2,3},{4,5,6},{7,8,9}};
        for(int i[]:arr){
            for(int j:i)
                System.out.print(j);
            System.out.println();
        }
        //二维数组的遍历输出
        String str="OK";
        String str1="OK";
        System.out.println(str==str1);//结果为true
        
        String str2=new String("OK");
        String str3=new String("OK");
        System.out.println(str2==str3);//结果为false
        System.out.println(str2.equals(str3));//结果为true,比较对象的值
 
        int[][] arry2d1={{1,3,5},{2,4,6}};
        int[][] arry2d2={{111,3,5},{2,444,6}};       
        int[][][] arry={arry2d1,arry2d2};
        for(int[][] a:arry){
            for(int[] b:a){
                for(int c:b){
                    System.out.print(c+" ");
                }
                System.out.println();
            }
            System.out.println();
        }//三维数组的遍历输出               
    }    
}

数组语言反转：

数组元素反转思路
1.数组元素反转，其实就是对称位置的元素交换。
2.通常遍历数组用的是一个索引，int i=0,
现在表示对称位置需要两个索引
int min=0;
int max=array.length-1;

3.如何交换两个变量的值？
int a=10；
int b=20;
如果是两个装满水的水杯，如何交换？
int temp=a;
a=b;
b=temp;

 

代码描述：用第三个变量倒手。
4.什么时候停止交换？
（1）min=max
(2)min>max
什么时候应该交换？
min<max

 

pac
/*
* 数组元素的反转
* 原数组{1，2，3，4}
* 反转后的数组{4，3，2，1}
* 要求不能使用新数组，就用原来的唯一一个数组
* */
public class DEmo07ArrayReverse {
    public static void main(String[] args) {
        int[] array={20,3,40,56,70};
        //遍历打印原来的数组
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("============");
        //反转
        /*
        * 初始化语句 int min=0,max=array.length-1
        * 条件判断 min<max
        * 步进表达式 min++,max--
        *循环体 用第三个变量倒手
        * */
        for (int min=0,max=array.length-1;min<max;min++,max--){
            int temp=array[min];
            array[min]=array[max];
            array[max]=temp;
        }
        //再次打印输出数组后来的样子
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

}

结果展示：