数组

数组是什么:用于存储一组”相同类型数据”的 数据结构.
例如int arr[] = {3,65,11,2,5,7,-1};

存什么:可以存基本数据类型的数据,也可以存引用数据类型的数据(即存对象地址).
String[] arr2 = {“abc”,”123”,”nba”,”fifa”};
变与不变:数组一旦声明出来,其大小就不能改变了.[不变]
数组里面的数据可以改变.[变]

怎么用:利用数组下标来访问数组中的元素(即某个位置存储的数据).
int arr[] = {3,65,11,2,5,7,-1};
数组元素的下标: 0 1 2 3 4 5 6
下标也叫索引,是从0开始的,不是从1开始的.
数组的”长度”就是一个数组能够容纳数据的”个数”(书架的格子数)
得到数组长度的方式: int len = 数组名.length;//注意length后面没有括号()
数组的元素的下标范围:[0,len-1] 方括号[]代表”闭区间”,[代表>=,]代表<=
int arr[] = {3,65,11,2,5,7,-1};
用arr[0]来引用0下标的数组元素
读取:
System.out.println(arr[0]);//3
System.out.println(arr[3]);//2
System.out.println(arr[6]);//-1
//System.out.println(arr[7]);//编译不会报错(语法没错),但运行的时候会出现异常.
修改:
System.out.println(arr[1]);//65
arr[1] = 33;//修改1下标的数为33
System.out.println(arr[0]);//3
System.out.println(arr[1]);//33

练习:
定义一个大小为3的float类型的数组,访问它的0,1下标的数据,修改2下标的数据.
定义一个大小为3的boolean类型的数组,访问它的0,1下标的数据,修改2下标的数据.

for(数据类型 变量名:数组名){…}
增强for循环遍历数组时,没有现成的下标可以使用,所以如果对特定下标的数组元素要
进行特殊处理的时候,增强for循环不太适用.
凡是要对下标进行访问或操作,不建议用增强for循环了.

int arr[] = {3,65,11,2,5,7,-1};//等号左边是声明(定义)数组,等号右边是对该数组进行
“静态初始化”(与static没关系,是在声明/定义数组的同时就对它进行初始化了.”一步完成”)

int arr[];//数组的声明/定义
//arr = {1,3,2};//error,静态初始化必须与声明/定义”一步完成”,不能拆开.
//arr[] = {1,2,3};//error
arr[0] = 3;//error,数组还没有创建,不能对里面的数据进行修改(赋值).

int arr[] = new int[3];//当在声明数组时,只知道元素的数量,不知道具体值,可以采用
“动态初始化”
…..
arr[0] = 123;
arr[1] = 456;
arr[2] = 789;

1,2,3,4,,,,,,10000装入一个数组.
int arr[] = new int[10000];//当数据量较大,而且有规律的时候,优先使用”动态初始化”
for(int i = 0;i

/**
数组的遍历
*/
class Demo02 
{
    public static void main(String[] args) 
    {
        int []arr = {3,2,1,4,5,2,1,34,5,2134,12,23,5,143,56,2};
        int len = arr.length;// 获取数组的长度(元素的个数)
        //System.out.println(arr[0]);
        //System.out.println(arr[1]);
        //....
        for(int i = 0;i<len;++i){
            System.out.println(arr[i]);//i的最大值能够达到len-1
        }
    }
}

/**
利用增强for循环(for-each)循环遍历数组
*/
class Demo03 
{
    public static void main(String[] args) 
    {
        int []arr = {3,2,1,4,5,2,1,34,5,2134,12,23,5,143,56,2};
        for(int i:arr){//int i不是下标,是用于存储当前从arr中遍历出来的元素的
            //临时变量
            System.out.println(i);          
        }

    }
}

/**
动态初始化数组的时候,对于不同数据类型的数组,会有不同的默认初始化的值:
*/
class Demo05 
{
    public static void main(String[] args) 
    {
        int []arr1 = new int[3];//int型的数组里面的所有元素 会被默认初始化为0
        System.out.println(arr1[0]);//0
        double []arr2 = new double[3];
        System.out.println(arr2[1]);//0.0
        boolean arr3[] = new boolean[5];
        System.out.println(arr3[4]);//
    }
}

/**
特殊的动态初始化方式
*/
class Demo06 
{
    public static void main(String[] args) 
    {
        int[] arr = new int[]{1,3,5,7};

//      method({1,3,5,7});//error,静态初始化的方式不能作为实参
        method(new int[]{1,3,5,7});//ok,特殊的动态初始化

        int []arr2 = new int[4];
        arr2[0]=1;
        //....
        method(arr2);//ok

        int []arr3 = {1,3,5,7};
        method(arr3);//ok

    }
    static void method(int [] array){
        for(int tmp:array){
            System.out.println(tmp);            
        }
    }
}

数组:
是一种存储相同类型数据的 数据结构.
数组一旦创建出来,大小(长度)不可改变,但里面的元素可以改变.
数组的遍历:for/增强for
数组的初始化:
静态初始化:声明的同时直接赋初值.int[] arr = {3,2,1,4};
动态初始化:声明的同时不赋值,后续再赋值.
int[] arr ;
arr = new int[3];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
特殊的动态初始化:(通常用于传参)
new int[]{1,3,5,1,2}