[Java学习笔记]-数组

已于 2022-07-24 20:07:43 修改
阅读量213 收藏
点赞数 2
分类专栏： java基础 文章标签： java 排序算法 leetcode
于 2022-05-20 20:26:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/noob0208/article/details/124889351
版权

[Java学习笔记]-数组

数组

数组的定义

//数组声明
int[] nums;            //定义一个 nums 的一维数组
nums = new int[10];    //nums[]数组里存放 10 个 int 类型的值

数组的赋值

nums[0] = 1;          
nums[1] = 2;
nums[2] = 3;
nums[3] = 4;            //给 nums[i]数组赋值
nums[4] = 5;
nums[5] = 6;
nums[6] = 7;
nums[7] = 8;
nums[8] = 9;
nums[9] = 10;

计算数组nums[ ]的和

//计算 nums[i]的和
int sum =0;
for (int i = 0; i <nums.length; i++) {
    sum = sum + nums[i];
}
System.out.println("和为: "+sum);

//输出
和为: 55

底层的简单了解

//定义 array 数组
int[] array = new int[10];

创建一个一维数组在底层的运作原理
在这里插入图片描述

下标越界

输出没有定义的内容

int[] arrays = new int[10];
System.out.println(arrays[10]);
//数组中是 0-9，没有第 10 个元素

在这里插入图片描述

数组与循环

Array.length

public class Demo1 {
    public static void main(String[] args) {
      int[] arr = new int[10];
      
      for (int i = 0; i <nums.length; i++) {
          arr[i] = i + 1;
      }
      for (int i = 0; i <nums.length; i++) {
          System.out.println("arr["+i+"]="+arr[i]);
      }
  }
}

在这里插入图片描述

引用数据类型

开发中引用数据类型，用于保存其他内存空间的首地址，保存地址之后，cpu 可以通过对应的引用数据类型，得到相应的地址，从而访问地址对应内存空间

class Demo1 {
    public static void main(String[] args) {
        int[] arr1 = new int[10];
        int[] arr2 = new int[10];

        arr1[5] = 100;
        arr2[5] = 200;

        System.out.println(arr1[5]);
        System.out.println(arr2[5]);
        
        // 这里只是将首地址进行了赋值操作
        arr1 = arr2;
        arr1[5] = 2000;

        System.out.println(arr1[5]);
        System.out.println(arr2[5]);
    }
}

在这里插入图片描述

数组和方法的关系

public static return methodName (arrayType[] arrayName)

arraytName 是一个数组类型的变量,引用数据类型的变量,传递的是数组的首地址,所以 assignIntArray 函数才能成功的进行赋值

class Demo1 {
    public static void main(String[] args) {
        int[] array = new int[10];
        // 调用赋值数组中元素的方法
        assignIntArray(array);
        // 调用打印数组中元素的方法
        printIntArray(array);
    }


    /**
     * 数组赋值
     * @param arr
     */
    public static void assignIntArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i + 1;
        }
    }

    /**
     * 打印数组
     * @param arr
     */
    public static void printIntArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println("arr[" + i + "] = " + arr[i]);
        }
    }
}

在这里插入图片描述

三种初始化

//静态初始化: 创建+赋值
int[] a = {1,2,3,4,5,6,7,8,9};
//Demo1[] mans = {new Demo1(),new Demo1()}; 
System.out.println(a[2]);

在这里插入图片描述

//动态初始化
int[] b = new int[10];
b[0]=12;
System.out.println(b[0]);

在这里插入图片描述

数组的使用

普通使用

package com.Muz1.Arrays;
public class Demo2 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        
        //打印数组全部元素
        System.out.println("====================================");
        System.out.println("打印数组全部元素");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"  ");
        }
        System.out.println();
        System.out.println("====================================");
        
        //计算所有元素的和
        System.out.println("计算所有元素的和");
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println("sum="+sum);
        System.out.println("====================================");
        
        //查找最大元素
        System.out.println("查找最大元素");
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i]>max){
                max = arr[i];
            }
        }
        System.out.println("max="+max);
    }
}

在这里插入图片描述

增强型 for 循环

int[] arr = {1,2,3,4,5};
for (int array : arr) {
    System.out.println(array);
}

在这里插入图片描述

//可利用函数打印数组
public class Demo3 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        
        printArray(arr);
        
    }
    //打印数组函数
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+"");
        }
    }
}

在这里插入图片描述

反转数组

public class Demo3 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};      //定义数组
        int[] reverse = reverse(arr); //进行反转操作
        printArray(reverse);          //利用输出函数进行输出
    }
    
    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        //反转的操作
        for (int i = 0 , j=arrays.length-1 ; i < arrays.length; i++ , j--) {
            result[j] = arrays[i];
        }
        return result;
    }
    //打印数组函数
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }
}

在这里插入图片描述

多维数组

多维数组就是数组的数组
在这里插入图片描述

int[][] array = {{1,2},{2,3},{3,4},{4,5}};
/**
 *      1,2     array[0]
 *      2,3     array[1]
 *      3,4     array[2]
 *      4,5     array[3]
 */

打印输出

int[][] array = {{1,2},{2,3},{3,4},{4,5}};
System.out.println(array[0][0]);
System.out.println(array[0][1]);

在这里插入图片描述

利用 for 循环打印输出

int[][] array = {{1,2},{2,3},{3,4},{4,5}};
for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array[i].length; j++) {
        System.out.println(array[i][j]);
    }
}

在这里插入图片描述

Array 类

自己写输出函数方法

import java.util.Arrays;
public class Demo5 {
    public static void main(String[] args) {
        int[] a = {15,86,1586,3,874,861,68,456,1,8564,684};
        
        System.out.println(Arrays.toString(a));    //Arrays 类方法
        printArrays(a);                            //自己定义的函数
    }
    public static void printArrays(int[] a){
        for (int i = 0; i < a.length; i++) {
            if(i == 0){
                System.out.print("["+a[i]+", ");
            } else if (i == a.length - 1) {
                System.out.print(a[i]+"]");
            }else {
                System.out.print(a[i]+", ");
            }
        }
    }
}

在这里插入图片描述
运行结果效果一样

冒泡排序(1/8)

八种排序方法其一

import java.util.Arrays;
public class Demo6 {
    public static void main(String[] args) {
        int[] array = {2,5,84,86,984,231,5,84,56,45,64,5468,4,3,54,5,3,6,4};
        int[] sort = sort(array);   //调用完自己的写的排序方法之后，返回一个数组
        System.out.println(Arrays.toString(sort));  //输出数组
    }
    //冒泡排序
    public static int[] sort(int[] array){
        //临时变量
        int temp = 0;
        //外层循环，判断要走多少次
        for (int i = 0; i < array.length; i++) {
            //内层循环，判断两位数，交换位置
            for (int j = 0; j < array.length - 1 - i; j++) {
                if(array[j+1]<array[j]){  //<升序输出，>降序输出
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        return array;
    }
}

在这里插入图片描述
升序输出

稀疏数组

稀疏数组可以看做是普通数组的压缩，但是这里说的普通数组是值无效数据量远大于有效数据量的数组
形如：

              0 0 0 0 0 0 0 0 0 0 0
              0 0 1 0 0 0 0 0 0 0 0
              0 0 0 0 2 0 0 0 0 0 0
              0 0 0 0 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 0 0 0 0
              0 0 0 0 0 0 0 0 0 0 0

其稀疏数组形式：

              11 11 2
              1  2  1
              2  4  2

输出一个棋盘

package com.Muz1.Arrays;
public class Demo7 {
    public static void main(String[] args) {
        //创建一个二维数组 11*11    0:没有棋子     1:黑棋     2:白棋
        int[][] arr1 = new int[11][11];
        arr1[1][2] = 1;
        arr1[2][3] = 2;
        //输出原始数组
        System.out.println("输出原始数组");
        for (int[] ints : arr1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}

在这里插入图片描述

有效值的个数

//转换为稀疏数组保存
//获取有效值的个数
int sum = 0;
for (int i = 0; i < 11; i++) {
    for (int j = 0; j < 11; j++) {
        if(arr1[i][j] != 0){
            sum++;
        }
    }
}
System.out.println(sum);

在这里插入图片描述

输出稀疏数组

package com.Muz1.Arrays;
public class Demo7 {
    public static void main(String[] args) {
        //创建一个二维数组 11*11    0:没有棋子     1:黑棋     2:白棋
        int[][] arr1 = new int[11][11];
        arr1[1][2] = 1;
        arr1[2][3] = 2;
        
        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(arr1[i][j] != 0){
                    sum++;
                }
            }
        }
        System.out.println(sum);

        //创建一个稀疏数组
        int[][] arr2 = new int[sum+1][3];
        arr2[0][0] = 11;
        arr2[0][1] = 11;
        arr2[0][2] = sum;
        //遍历二维数组，将非零值存放
        int cout = 0;
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                if(arr1[i][j] != 0){
                    cout++;
                    arr2[cout][0] = i;
                    arr2[cout][1] = j;
                    arr2[cout][2] = arr1[i][j];
                }
            }
        }
        System.out.println("输出稀疏数组");
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i][0]+"\t"
                    +arr2[i][1]+"\t"
                    +arr2[i][2]+"\t");
        }
    }
}

在这里插入图片描述

还原稀疏数组

继续上面的写

//还原稀疏数组
int[][] arr3 = new int[arr2[0][0]][arr2[0][1]];
//还原元素值
for (int i = 1; i < arr2.length; i++) {
    arr3[arr2[i][0]][arr2[i][1]] = arr2[i][2];
}
//打印
System.out.println("输出还原数组");
for (int[] ints : arr1) {
    for (int anInt : ints) {
        System.out.print(anInt+"\t");
    }
    System.out.println();
}

在这里插入图片描述

完整Demo

package com.Muz1.Arrays;
public class Demo7 {
    public static void main(String[] args) {
        //创建一个二维数组 11*11    0:没有棋子     1:黑棋     2:白棋
        int[][] arr1 = new int[11][11];
        arr1[1][2] = 1;
        arr1[2][3] = 2;

        System.out.println("输出原始数组");
        for (int[] ints : arr1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(arr1[i][j] != 0){
                    sum++;
                }
            }
        }
        System.out.println(sum);

        //创建一个稀疏数组
        int[][] arr2 = new int[sum+1][3];
        arr2[0][0] = 11;
        arr2[0][1] = 11;
        arr2[0][2] = sum;
        //遍历二维数组，将非零值存放
        int cout = 0;
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                if(arr1[i][j] != 0){
                    cout++;
                    arr2[cout][0] = i;
                    arr2[cout][1] = j;
                    arr2[cout][2] = arr1[i][j];
                }
            }
        }
        System.out.println("输出稀疏数组");
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i][0]+"\t"
                    +arr2[i][1]+"\t"
                    +arr2[i][2]+"\t");
        }

        System.out.println("==================================================");
        //还原稀疏数组
        int[][] arr3 = new int[arr2[0][0]][arr2[0][1]];
        //还原元素值
        for (int i = 1; i < arr2.length; i++) {
            arr3[arr2[i][0]][arr2[i][1]] = arr2[i][2];
        }
        //打印
        System.out.println("输出还原数组");
        for (int[] ints : arr1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

    }
}

在这里插入图片描述

总结

以上就是Java数组的学习，本文仅仅简单介绍了Java数组的使用。欢迎各师傅关注,交流,讨论。

木拖把
关注
专栏目录
【Java】学习笔记-数组的定义与使用
qq_35491579的博客
02-19 845
【Java】学习笔记5-数组的定义与使用 文章目录前言一、数组基本用法1.什么是数组2.创建数组3.数组的使用二、数组作为方法的参数1.基本用法2.理解引用类型内存3.认识 null4.初识 JVM 内存区域划分三、数组作为方法的返回值1.引入库1.引入库1.引入库1.引入库四、数组练习1.引入库1.引入库1.引入库1.引入库五、二维数组1.引入库1.引入库1.引入库1.引入库总结 前言 主要内容： ☑️ 理解数组的基本概念 ☑️ 掌握数组的基本用法 ☑️ 数组与方法互操作 ☑️ 数组相关的问题 提示
【Java】 学习-数组基础题练习
qq_35491579的博客
02-19 719
【Java】 学习-数组基础题练习
Java给定整数数组nums, 判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + num
weixin_51193753的博客
03-19 132
【代码】Java给定整数数组nums, 判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i!= j、i!= k 且 j!= k ，同时还满足 nums[i] + num。
Java笔记——数组
TGFXK的博客
04-29 1086
一、数组的定义 1、基本概念 定义：相同类型的数据统一聚拢在一起，他就是数组 数组可以存放多个同一类型的数据，数组也是一种数据类型，是引用类型。 【定义】： 定义： int[] nums; 初始化： nums = new int[3]; 赋值： nums[0] = 1; nums[1] = 2; nums[3] = 3; //直接定义并初始化 int[] nums = {1,2,3}; //also int[] nums = new int[5]; int[]
java，给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
weixin_45986454的博客
07-14 6200
标题：给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 一、示例 二、题解 暴力法：使用双重for循环，每取出一个值，遍历后面，看是否有nums[j]==target-nums[i] for(int i=0;i<nums.length;i++){ for(int j=i+1;j<nums.length;j++){ if(nums[j]==target-nums[i]){ return new
Java编程定义一个数组nums并初始化，读入一个整数n，如果n在数组中存在，则输出n的下标，不存在则输出-1
Chlin.Rei的博客
06-22 942
Java编程定义一个整数数组nums并初始化，读入一个整数n，如果n在数组中存在，则输出n的下标，不存在，则输出-1.
Java基础知识06
Rookie_QYX的博客
08-18 217
8、数组 8.1 一维数组 8.2 数组的高级操作 8.3 二维数组
Java学习笔记，数组初步
02-06
最多到二维数组（学习容器后，我们一般使用容器，二维数组用的都很少） 5. 数组存储表格数据 表格数据模型是计算机世界最普遍的模型，可以这么说，大家在互联网上看到的所有数据本质上都是“表格”，无非是表格...
Java学习笔记系列-基础篇-数组
嗨
04-25 363
Java学习笔记 Java学习笔记是一个持续更新的系列，工作多年，抽个空对自身知识做一个梳理和总结归纳，温故而知新，同时也希望能帮助到更多正在学习Java 的同学们。 本系列目录 入门篇 计算机基础 计算机编程语言 面向对象的编程思想 基础篇 环境搭建 第一个Java程序 开发工具 Java中的注释 标识符与关键字 变量与常量 数据类型 数组 数组 数组是储存数据类型相同的变量的集合，属于引用数据类型，自身也是堆中的一个对象。 声明方式 在Java中声明数组有两种方式，一是先声明数组长度，后赋值（
Java实现给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
想找我?: 【编程张无忌的个人空间-哔哩哔哩】 https://b23.tv/0yjNTt2
09-14 1823
ByCaesarChang 合作:root121toor@gmail.com ~关注我 带你看更多精品技术和面试必备 输入: [-2,1,-3,4,-1,2,1,-5,4] 输出: 6 解释:连续子数组[4,-1,2,1] 的和最大，为6。 如果 nowSum > 0，则说明nowSum 对结果有增益效果，则 nowSum 保留并加上当前遍历数字 如果 nowSum <= 0，则说明nowSum 对结果无增益效果，需要舍弃，则 nowSum...
Java 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那 两个 整数，并返回它们的数组下标。
爱干饭的猿的博客
11-20 2220
//给定一个整数数组 nums 和一个整数目标值 target， // 请你在该数组中找出和为目标值 target 的那 两个 整数，并返回它们的数组下标。 //你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。 //你可以按任意顺序返回答案。 //示例 1： //输入：nums = [2,7,11,15], target = 9 //输出：[0,1] //解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。 public class T.
Java算法：给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。 示例: 输入: [0,1,0,3,12] 输出: [1,3,12,0,0] 说明:
Ctra_aaa的博客
10-11 1254
题目： 给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。 示例: 输入: [0,1,0,3,12] 输出: [1,3,12,0,0] 说明: 必须在原数组上操作，不能拷贝额外的数组。 尽量减少操作次数。 思路： 解题代码： public void moveZeroes(int[] nums) { int cunt=0; for (int i = 0; i < nums.length; i++) {
Java版本：给你一个整型数组 nums ，在数组中找出由三个数组成的最大乘积，并输出这个乘积
枫
01-04 940
给你一个整型数组 nums ，在数组中找出由三个数组成的最大乘积，并输出这个乘积分析思路解题方法 分析 三个数组成的最大乘积：则只需要找到绝对值较大的数做乘法，分析得到的结果即可 如果数组中全是非负数，则排序后最大的三个数相乘即为最大乘积；如果全是非正数，则最大的三个数相乘同样也为最大乘积。 如果数组中有正数有负数，则最大乘积既可能是三个最大正数的乘积，也可能是两个最小负数（即绝对值最大）与最大正数的乘积。 思路 想要找到符合的数字，则有两种： Java自带的数组排序 线性扫描 解题方法 排序法
java中nums == null || nums.length == 0的区别
weixin_44562445的博客
05-05 1337
int[] nums;//声明 int[] nums = null;//声明，栈中nums存的是null,不指向堆空间的对象，没有指针 int[] nums = new int[0];//声明，在堆中创建了一个对象，栈中nums指向了堆，堆中为数组创建了一个0的空间 语句一，不能打印nums的值 语句二，栈中nums存的是null,不指向堆空间的对象，没有指针。nums.length会出现空指针异常 语句三，在堆中创建了一个对象，栈中nums指向了堆，堆中为数组创建了一个0的空间。nums.length为
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1482
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 286
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
Java语言程序设计-数组访问与学习指南
"少做笔记，多听、多动手"是一个有效的学习方法。课程通常包括理论授课和上机实践，如每周三下午的上课和上机时间。此外，可以参考《JAVA2编程篇》、《JAVA面向对象程序设计教程》以及《Java语言导学》等教材，它们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值