day5 2021 2 6 数组全部

数组

数组的定义

数组是相同类型数据的有序结合

其中每一个数据称作一个数组元素，每个数组元素可以通过下标来访问

数组的下标从0开始；

数组的声明与创建

//变量的类型 变量的名字 = 变量的值；

在变量类型后加上[ ]来表示数组 例如

int[ ] nums = 

建立数组：

package com.wang.array;

public class ArrayDemo1 {
    public static void main(String[] args) {
        //变量类型  变量名字  = 变量的值;
        int[] nums ; //声明数组
        nums = new int[10]; //创建数组
        nums[0]=1;
        
    }

}

也可如此建立：（声明和创建写在一起）

int[] nums = new int[10]; 

理解一下以下代码:

package com.wang.array;

public class ArrayDemo1 {
    public static void main(String[] args) {
        //变量类型  变量名字  = 变量的值;
        int[] nums ; //定义数组
        nums = new int[10]; //确定该数组的元素量
        //给数组中的元素依次赋值
        nums[0]=1;
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
        nums[5]=6;
        nums[6]=7;
        nums[7]=8;
        nums[8]=9;
        nums[9]=10;

        int sum = 0;
        //求该数组的和
        for (int i = 0;i<nums.length;i++){
            sum = sum + nums[i];
        }
        System.out.println(sum);
    }
}

JAVA内存分析

堆

存放new的对象和数组

栈

初始化分类

package com.wang.array;

public class ArrayDemo2 {
    public static void main(String[] args) {
    
         //静态初始化：创建 + 赋值
        int[] a = {1,2,3,4};
        
        //动态初始化:包含默认初始化 没有被初始化的元素是0
        int[] b = new int[10];
        

    }
}

数组的基本特点

• 其长度是确定的。
• 其元素必须是相同类型，不允许出现混合类型。
• 下标的合法区间[0–length-1]
• 数组也是对象。数组的元素相当于对象的成员变量

数组的使用

package com.wang.array;

public class ArrayDemo3 {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5};
        //打印全部元素
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i]+" ");
        }
        System.out.println("\n");
        System.out.println("===========");

        //算所有元素的总和
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum = sum + nums[i];
        }
            System.out.println("sum="+sum);

        System.out.println("===========");

        //找出元素最大值
        int max = nums[0];// 妙
        for (int i =0;i< nums.length;i++){
            if (nums[i]>max){
                max = nums[i];
            }
        }
        System.out.println("max="+max);
    }

}

涉及到方法：

反转数组：

package com.wang.array;

public class ArrayDemo4 {
    public static void main(String[] args) {
     int[] nums = {1,2,3,4};
     renums(nums);
    }

    //反转数组

    public static void renums(int[] nums){
        int[] result = new int[nums.length];
        for (int i = 0;i< nums.length;i++){
            int j = nums.length - 1-i;
            result[i] = nums[j];
        }
        for (int i = 0;i< nums.length;i++){
            System.out.print(result[i]+" ");
        }
    }
}

===================================================
输出：
4 3 2 1

另一种反转数组：

package com.wang.array;

import java.util.Arrays;

public class ArrayDemo5 {
    public static void main(String[] args) {
        int[] nums = {1,2,3,4,5};
        int[] re = renums(nums);
        System.out.println(Arrays.toString(re));

    }

    //反转数组

    public static int[] renums(int[] nums){
        int[] result = new int[nums.length];
        for (int i = 0;i< nums.length;i++){
            int j = nums.length - 1-i;
            result[i] = nums[j];
        }
        return result;
    }
}

二维数组

int[][] nums = {{1,2},{3,4},{5,6}}
// nums[1][1]=4 
//nums.length=3
//num[0].length=2
//num[1].length=2
//num[2].length=2

Arrays类

打印数组

package com.wang.array;

import java.lang.reflect.Array;
import java.util.Arrays;

public class ArrayDemo5 {
    public static void main(String[] args) {
        int[] nums = {1,2,3,4,5};
        //打印数组元素
        System.out.println(Arrays.toString(nums));
        //sout（Arrays.toString(数组名)）;
    }

}
===================================================
结果：
[1 2 3 4 5]

数组升序排序

Arrays.sort(数组名);//从小到大对数组元素依次排序

数组填充

Arrays.fill(数组名,数字) 整个数组中的元素都被数字填充
Arrays.fill(数组名，2，4，数字)元素中的2到4被该数字填充

稀疏数组

tring(数组名)）;
}

}

结果：
[1 2 3 4 5]

## 数组升序排序

Arrays.sort(数组名);//从小到大对数组元素依次排序

## 数组填充

Arrays.fill(数组名,数字) 整个数组中的元素都被数字填充
Arrays.fill(数组名，2，4，数字)元素中的2到4被该数字填充

# 稀疏数组