java数组

数组

1. 数组概述

  1. 数组：相同类型数据的有序集合
  2. 描述相同类型的若干个数据，按照先后排序组合而成
  3. 每个数据称作一个数组元素，可通过下标来访问

2. 数组声明创建

  1. 使用前必须声明数组变量

    dataType(类型)[] arrayRefVar(变量名);		//首选方法
或
dataType arrayRefVar[]		//不是首选方法

  2. Java使用new操作符来创建数组，语法如下：

    dataType[] arrayRefVar = new dataType[arraysize];

  3. 数组元素通过索引访问，数组索引从0开始

  4. 获取数组长度：array.length

    package com.jam.array;

public class Demo01 {
    public static void main(String[] args) {
        //变量类型   变量名字 = 变量的值
        //数组类型
        int[] nums; //1.声明一个数组

        nums = new int[5]; //2.创建一个数组

        //3.给数组元素赋值
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        //输出nums的长度
        System.out.println(nums.length);
    }
}

3. 数组使用

  1. 普通for循环

  2. for-each循环

    package com.jam.array;

public class Demo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //for-each循环，在JDK1.5后使用，没有下标。最适合打印输出
        for (int array : arrays){
            System.out.println(array);
        }
    }
}

  3. 数组作方法入参

    package com.jam.array;

public class Demo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //for-each循环，在JDK1.5后使用，最适合打印输出
        for (int array : arrays){
            System.out.print(array);
        }
        System.out.println();

        int[] result = reverse(arrays);
        for (int i: result) {
            System.out.print(i);
        }

    }
    //反转数组
    public static int[] reverse(int[] arrays){	//数组作方法入参
        int len = arrays.length;
        int[] result = new int[arrays.length];

        //反转操作
        for (int i = 0; i < arrays.length; i++) {
            result [i] = arrays[len-1-i];
        }
        return result;
    }
}

  4. 数组作返回值

    package com.jam.array;

public class Demo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //for-each循环，在JDK1.5后使用，最适合打印输出
        for (int array : arrays){
            System.out.print(array);
        }
        System.out.println();

        int[] result = reverse(arrays);
        for (int i: result) {
            System.out.print(i);
        }

    }
    //反转数组
    public static int[] reverse(int[] arrays){
        int len = arrays.length;
        int[] result = new int[arrays.length];

        //反转操作
        for (int i = 0; i < arrays.length; i++) {
            result [i] = arrays[len-1-i];
        }
        return result;		//数组做返回值
    }
}

4. 多维数组

  1. 多维数组：数组嵌套，例：二维数组（矩阵）

  2. 二维数组的创建

    int a[][] = new int[2][5];
//建立一个两行五列的数组

  3. 二维数组的使用

    package com.jam.array;

public class Demo05 {
    public static void main(String[] args) {
        //建立一个四行两列的数组
        /*
            1,2     arrays[0]
            2,3     arrays[1]
            3,4     arrays[2]
            4,5     arrays[3]
         */
        int[][] arrays = {{1,2},{2,3},{3,4},{4,5}};

        for(int i = 0; i < arrays.length;i++ ){
            for (int j = 0; j < arrays[i].length; j++) {
                System.out.print(arrays[i][j]);
            }
            System.out.println();
        }
    }
}

5. Arrays类

  1. 数组工具类Arrays

  2. Arrays类中的方法都是static修饰的静态方法，在使用时可直接使用类名进行调用，而“不用”对象来调用。

  3. 具有以下常用功能：

    1. 给数组赋值：通过fill方法

    2. 对数组排序：通过sort方法，按升序

    3. 比较数组：荣光equals方法比较数组中元素值是否相等

    4. 查找数组元素：通过binarySearch方法能对排序好的数组进行二分法操作

      package com.jam.array;

import java.util.Arrays;

public class Demo06 {
    public static void main(String[] args) {
        int[] a = {1,3,2,4,5,8,6};
        int[] b = {1,3,2,4,5,8,6};
        //输出a数组元素
        System.out.println(Arrays.toString(a));

        //用equals方法比较数组元素值是否相同
        System.out.println("a[]==b[] :"+ Arrays.equals(a,b));

        //用sort升序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

        //用binarySearch方法查找元素
        System.out.println(Arrays.binarySearch(a,1));

        //用fill方法赋值
        Arrays.fill(a,1,3,0);
        System.out.println(Arrays.toString(a));


    }

6. 稀疏数组

  1. 是一种数据结构

  2. 数组大部分元素为0，或为同一值数组时，可使用稀疏数组保存

  3. 稀疏数组处理方式：

    1. 记录数组有几行几列，有多少个不同的值

    2. 把不同的值的元素、行列和值记录在一个小规模数组中，缩小程序规模

    3. 如图（左：原始数组，右：稀疏数组） 7*7的数组

      image-20220211165128593

    4. 代码

      package com.jam.array;

public class Demo08 {
    public static void main(String[] args) {
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;

        //打印稀疏数组
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                System.out.print(array1[i][j]+" ");
            }
            System.out.println();
        }
        System.out.println("==============");
        int sum = 0;
        //1.查找不为0的元素个数
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 0 ){
                    sum++;
                }
            }
        }
        //2.建立稀疏数组
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = array1.length;
        array2[0][1] = array1[1].length;
        array2[0][2] = sum;

        //3.遍历二维数组，将非零值，放在稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
        //4.输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0] +"\t"
                        +array2[i][1] +"\t"
                        +array2[i][2] +"\t");

        }
        //5.稀疏数组反向输出原来数组
        int[][] array3 =new int[array2[0][0]][array2[0][1]];
        for (int i = 1; i < array2.length ; i++) {
            int row = array2[i][0];
            int column = array2[i][1];
            array3[row][column] = array2[i][2];
        }

        //输出array3的值
        System.out.println("==========================");
        for (int i = 0; i < array2[0][0]; i++) {
            for (int j = 0; j < array2[0][1]; j++) {
                System.out.print(array3[i][j] + " ");
            }
            System.out.println();
        }
    }
}

7. 附加：内存分析

  1. java内存

    1. 堆
      1. 存放new对象和数组
      2. 被所有线程共享，不会存放别的对象引用
    2. 栈
      1. 存放基本变量类型（包含基本类型的具体数值）
      2. 引用对象的变量（存放引用在堆里的具体地址）
    3. 方法区
      1. 可被所有线程共享
      2. 包含所有的class和static变量

  2. 代码

    package com.jam.array;

public class Demo01 {
    public static void main(String[] args) {
        //变量类型   变量名字 = 变量的值
        //数组类型
        int[] array; //1.声明一个数组

        array = new int[10]; //2.创建一个数组

        //3.给数组元素赋值
        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;
        
        System.out.println(nums[10]);
    }
}

  3. 画图分析

    image-20220204153800988

8. 附加：三种初始化

  1. 静态初始化

    int[] a = {1,2,3}
Man[] mans = {new Man(1,1),new Man(2,2)}

  2. 动态初始化

    int[] a = new int[2];
a[0] = 1;
a[1] = 2;

  3. 数组默认初始化

    1. 数组是引用类型
    2. 数组分配空间，每个未赋值的元素都默认为初始值（隐式初始化）

  4. 代码

    package com.jam.array;

public class Demo03 {
    public static void main(String[] args) {
        //静态初始化：创建 + 赋值
        int[] a = {1,2,3,4,5,6};
        System.out.println(a[0]);
        
        //动态初始化：声明 + 创建  需后期自己赋值，未赋值的元素为默认初始值
        int[] b = new int[10];
        b[0] = 10;

        System.out.println(b[0]);
        System.out.println(b[1]);
    }
}

9. 数组特点

  1. 数组长度确定，一旦创建，无法更改
  2. 元素类型必须相同
  3. 数组元素可统一为一种类型：基本类型 / 引用类型
  4. 数组是对象，对象放在堆中

10. 冒泡排序

  1. 排序一共有八种
  2. 冒泡排序最为出名
  3. 冒泡排序代码简单，两层循环，外层冒泡轮数，里层依次比较
  4. 时间复杂度为O（n2）
posted @   Jam_liu  阅读(73)  评论(0)  编辑  收藏  举报
相关博文：
·  java基础语法
·  java基本结构
·  Java 数组
·  java数组
·  Day08.Java数组
阅读排行：
· winform 绘制太阳，地球，月球 运作规律
· AI与.NET技术实操系列（五）：向量存储与相似性搜索在 .NET 中的实现
· 超详细：普通电脑也行Windows部署deepseek R1训练数据并当服务器共享给他人
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 上周热点回顾（3.3-3.9）
//
点击右上角即可分享
微信分享提示
AI IDE Trae