【Java】数组的定义与使用

数组:一组相同数据类型的集合,长度固定
类集:动态数组
基本概念
1.动态初始化
数组是引用数据类型,有内存分配问题.
语法:声明并初始化数组
数据类型 [ ] 数组名称 = new 数据类型 [长度]
声明并开辟长度为3的整型数组
int[ ] date = new int [3];
当数组开辟新空间之后,可采用以下方式进行操作:
a.当开辟数组空间后,所有数组内容为其数据类型默认值
b.通过数组下标来访问每个元素.
访问数组元素使用数组名称[索引下标],索引从零开始.
当访问下标超出数组长度时,会抛出运行时异常
c…数组属性length:表示数组长度
数组名称.length:返回此数组长度
静态初始化:在声明数组的同时向数组中每个元素赋值
int [ ] date = new int [ ]{1,3,5};
d.通过for循环来遍历数组
for-each循环
for(int temp :date){
//代码体
}
例如:定义一个int型数组

public class ArrayDemo{ 
    public static void main(String[] args) { 
        int[] x = new int[3] ; // 开辟了一个长度为3的数组 
        System.out.println(x.length) ; 
        x[0] = 1 ; // 数组第一个元素 
        x[1] = 2 ; // 数组第二个元素 
        x[2] = 3 ; // 数组第三个元素 
        for (int i = 0; i<x.length ; i++) {
            System.out.println(x[i]) ; // 通过循环控制索引下标更改 
        }
    }
}
    

2.数组引用传递
引用数据类型
int [ ] date = new int [3]
date称为数组的引用(保存在栈内存),任何一个引用一定指向一块堆内存空间.
只要看见关键词new,就一定在堆上分配空间.

public class ArrayDemo{ 
    public static void main(String[] args) { 
        int[] x = null ;
        x = new int[3] ;
        System.out.println(x.length) ; 
        x[0] = 10 ; // 数组第一个元素 
        x[1] = 20 ; // 数组第二个元素 
        x[2] = 30 ; // 数组第三个元素 
        for (int i = 0; i<x.length ; i++) { 
            System.out.println(x[i]) ; // 通过循环控制索引下标更改
        }
    }
}

引用传递空间:同一块堆内存空间可以被不同的栈内存所指向
例如:多个栈内存指向相同的堆内存

public class ArrayDemo{ 
    public static void main(String[] args) { 
        int[] x = null ;
        int[] temp = null ; // 声明对象
        x = new int[3] ;
        System.out.println(x.length) ; 
        x[0] = 1 ; // 数组第一个元素 
        x[1] = 2 ; // 数组第二个元素 
        x[2] = 3 ; // 数组第三个元素 
        for (int i = 0; i<x.length ; i++) { 
            System.out.println(x[i]) ; // 通过循环控制索引下标更改 
        }
        temp = x ; //如果要发生引用传递，不要出现[] 
        temp[0] = 55 ; // 修改数据
        System.out.println(x[0]) ; 
    }
}

引用传递的内存分析都是类似的:同一块堆被不同的栈内存指向.
内存分为两部分:
栈内存:方法中的局部变量,方法的形参,引用
堆内存:存放数组内容,类对象内容(共享内存)
注:给主方法使用,方法的形参引用
引用传递:多个栈内存共享(指向)一块堆内存地址
3.数组静态初始化
在声明数组同时捋数组内容赋值.
数组长度依然固定,长度为给的值的个数
完整格式:推荐使用
数据类型[ ] 数组名称 =new 数据类型[ ] {值1,值2,值3…}
eg:采用静态初始化定义数组

public class ArrayDemo{ 
    public static void main(String[] args) { 
        int[] x = {1,2,5,55,555,223,45545,666465,6443} ; // 静态初始化定义数组 
        System.out.println(x.length) ; 
        for (int i = 0; i<x.length ; i++) { 
            System.out.println(x[i]) ; 
        }
    }
}

简化格式:
数据类型[] 数组名称 = {值1,值2,值3…}
匿名数组:没有任何栈内存指向的数组空间(没起名字)

2.二维数组(表格)[了解]
定义:
动态初始化:
数据类型[ ] [ ] 对象数组 = new 数据类型[行个数][列个数] ;
静态初始化:
数据类型[][] 对象数组 = new 数据类型[][]{{值，值，…},{值，值，…},…} ;
eg:定义了一个二维数组

public class ArrayDemo{ 
    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.println("data{"+x+"]["+y+"]="+data[x][y]+"、") ;
            }
            System.out.println(); 
        }
    }
}

3.数组与方法的相互操作(重点)
数组是引用传递
a.方法接收数组
b.方法返回数组
c.方法修改数组

a.方法接收数组

public class ArrayDemo{
    public static void main(String[] args) { 
        int[] data = new int[] {1,2,3,4,5} ; 
        printArray(data) ; // 其效果等价于 int[] temp = data ; 
    }
    public static void printArray(int[] temp) { 
        for (int i = 0 ; i<temp.length ; i++) { 
            for (int i = 0 ; i<temp.length ; i++) { 
        }
    }
}

b.方法返回数组

public class ArrayDemo{
    public static void main(String[] args) { 
        int[] data = init() ; 
        printArray(data) ; 
    }
     // 定义一个返回数组的方法 
     public static int[] init(){
        return new int[] {1,2,3,4,5} ; // 匿名数组 
     }
     public static void printArray(int[] temp) { 
        for (int i = 0 ; i<temp.length ; i++) {
            System.out.println(temp[i]) ; 
        }
    }
}

c.方法修改数组

public class ArrayDemo{
    public static void main(String[] args) { 
        int[] data = init() ; 
        bigger(data) ;
        printArray(data) ; 
    }
     // 定义一个返回数组的方法 
     public static int[] init(){
        return new int[] {1,2,3,4,5} ; // 匿名数组 
     }
     // 将数组中每个元素的值扩大5倍 
     public static void bigger(int[] arr){ 
        for (int i = 0 ; i<temp.length ; i++) {
            arr[i]*=5 ; // 每个元素扩大5倍 
        }
    }
    public static void printArray(int[] temp) { 
        for (int i = 0 ; i<temp.length ; i++) { 
            System.out.println(temp[i]) ; 
        }
    }
}

4.Java对数组支持
a.数组排序
java.untl.Array.sort(数组名称):支持所有基本数据类型,默认为升序排序,内部使用双轴快速排序.
b.数组拷贝
数组部分拷贝:将一个数组的部分内容替换为另一个数组的部分内容(必须是连续的)
● 数组拷贝
System.arraycopy(源数组名称,源数组开始点, 目标数组名称,目标数组开始点,拷贝长度);
目标数组A： 1、2、3、4、5、6、7、8、9 源数组B： 11、22、33、44、55、66、77、88、99 替换后： 1、55、 66、77、5、6、7、8、9

public class ArrayDemo{
    public static void main (String [] args){
        int[] dataA = new int [] {1,2,3,4,5,6,7,8,9};
        int[] dataB = new int[]{11,22,33,44,55,66,77,88,99} ; 
        System.arraycopy(dataB,4,dataA,1,3) ;
        printArray(dataA) ; 
    }
    public static void printArray(int[] temp) {
        for (int i = 0 ; i<temp.length ; i++) { 
            System.out.println(temp[i]) ; 
        }
        System.out.println() ; 
    }
}

数组全拷贝
类集动态扩容使用的就是此方法
java,util,Arrays,copyOf(源数组名称,新数组长度):
int[ ] newDate