数组类型

数组

存储同一个类型的容器---数组,数组一旦定义好,大小不可变。

数组的初始化

Java中的数组的初始化有以下两种方式。
1.动态初始化 : 在定义数组时只指定数组的长度，由系统自动为元素赋初值的方式称作动态初始化。

//类型[] 数组名 = new 类型[长度];
int[] arr = new int[4];

2.静态初始化: 在初始化数组时还有一种方式叫做静态初始化，就是在定义数组的同时就为数组的每个元素赋值。

//类型[] 数组名 = new 类型[]{元素，元素，……};
int[] arr = new int[]{1,2,3,4};
//类型[] 数组名 = {元素，元素，元素，……};  
int[] arr = { 1, 2, 3, 4 };

执行动态初始化时,程序员只需指定数组的长度,即为每个数组元素指定所需的内存空间,系统将负责为这些元素分配初始值。指定初始值时,将按如下规则:
数组元素的类型为基本类型中的整数类型时(byte、short、int和long),则数组的元素值是0
数组元素的类型为基本类型中的浮点类型时(float、double),则数组的元素值是0.0
数组元素的类型为基本类型中的字符类型时(char),则数组的元素值是'\u0000' 数组元素的类型为基本类型中的浮点类型时(boolean),则数组的元素值是false
数组元素的类型为引用类型时(类、接口、数组),则数组的元素值是null

数组的应用

获取指定位置上的元素---数组名[下标]
获取数组的长度---length属性
数组的内存地址表示:I@15db9742
{数组类型
I如果这个对象是一个数组或者是集合,这一位就表示数组或者集合中的元素类型
@表示后面跟的是一串地址
15db9742表示的是这个的对象的地址的哈希码的十六进制表示形式

遍历数组

int[] a = new int[5];
A:普通的for循环
for (int i = 0; i < a.length; i++) {
    System.out.println(a[i]);
}
B:增强for循环       
//表示把数组元素依次取出赋值给i
for (int i : a) {
    System.out.println(i);
}
Arrays.toString(a);

获取数组中最大值

int[] a = new int[5];
int max=0;
for (int i = 0; i < a.length; i++) {
    if (a[i]>a[max]){
        max=i;
    }
}
for (int i : a) {
    if (max<i){
        max=i;
    }
}

数组排序

选择

for (int i = 0; i < arr.length - 1; i++) {
    int minPos = i;
    for (int j = i+1; j < arr.length; j++) {
        if (arr[j] < arr[minPos]) {
            minPos = j;//找出当前最小元素的位置
        }
    }
    if(arr[minPos]!=arr[i]) {
        swap(arr,minPos,i);
    }
}
public static void swap(int[] arr,int a,int b){
    int temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}

冒泡

for (int i = 0; i <arr.length-1; i++) {
    for (int j = 0; j < arr.length - i - 1; j++) {
        if(arr[j]>arr[j+1]) {
            swap(arr,j,j+1);
        }
    }
    
}

Arrays.sort()----只能从小到大排

查找数组的位置

A. 遍历
B. 折半查找---要求有序数组---时间复杂度O(log2n)

int[] a = {2, 3, 5, 7, 5};
int min = 0;
int max = a.length - 1;
int mid;
int number = 0;
while (min <= max) {
    mid = (min + max) / 2;
    if (a[mid] > number) {
        max = mid - 1;
    } else if (a[mid] < number) {
    min=mid+1;
    }else {
        System.out.println(a[mid]);
    }
}

反转数组

for (int start=0,end=a.length-1;start<=end;start++,end--){
    int temp=a[start];
    a[start]=a[end];
    a[end] = temp;
}

如果访问的下标不存在,会出现ArrayIndexOutOfBoundsException---数组下标越界异常
编译的时候不报错---编译检查的是语法错误

数组的扩容/复制

System.arraycopy(要复制的数组,要复制的起始下标,要存放的数组,存放的起始位置,复制几个)
Arrays.copyOf(要扩容的数组,扩容之后的大小)-----数组在扩容完成之后,堆内存地址已经发生改变

Arrays.copyOf(arr.len);
int[] arr2=new int[len];
if(len<arr.length){
    System.arraycopy(arr,0,arr2,0,len);
}else{
    System.arraycopy(arr,0,arr2,0,arr.length);
}

二维数组

二维数组的每一个元素就是一维数组---是一个存放数组的数组

定义格式

int[][] arr=new int[3][5];---定义包含了3个一位数组的二维数组,每个一维数组包含5个元素
int[1][3]=5;
数据类型[][] 数组名=new 数据类型[二维数组的大小][];
int[][] arr=new int[5][];----表示二维数组里面包含了五个一位数组
arr[0]=new int[5];arr[1]=new int[3];---每个一维数组的大小可以不同
arr[3][0]=8;--NullPointerException---空指针异常
针对null的任何操作都会出现空指针异常
数据类型[][] 数组名[]={{元素1,....,元素n},{}......{}}
int[][] arr={{2,3},{1},{3,5,6}};

笔试题总结

对于数组int[] x,y[]均已初始化,下面各项正确的是:---BC
A.y[0]=x[0]
B.y[0]=x;
C.y[0][0]=x[0]
D.y[0][0]=x
E.y[0]=x[0][0]
注意:[]在变量名之前紧跟的是数据类型,以后定义的每一个变量都拥有这个[];如果在变量名之后,那么[]属于当前变量
应用--如果只使用一层循环,遍历出来的是一唯数组

练习:杨辉三级

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
a[i][j]==a[i-1][j]+a[i-1][j-1];

public static void main(String[] args) {
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int [][] arr=new int[n][];
    for (int i=0;i<n;i++ ) {
        arr[i]=new int[i+1];
        for (int j=0;j<arr[i].length;j++ ) {
            if (j==0||i==j) {
                arr[i][j]=1;
            }else {
                arr[i][j]=arr[i-1][j]+arr[i-1][j-1];
            }
        }
        for(int a:arr[i]){
            System.out.print(a+"\t");
        }
        System.out.println();
    }
}

数组