Java的数组

最新推荐文章于 2024-10-31 15:56:11 发布
最新推荐文章于 2024-10-31 15:56:11 发布
阅读量145 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47697162/article/details/115128777
版权
本文详细介绍了Java中的数组，包括声明、创建、初始化、内存分析和使用方法。通过示例展示了普通For循环、For-Each循环、数组作为参数传递和返回值。还涵盖了二维数组的使用，以及Arrays类提供的排序、填充等操作。此外，文章还提到了冒泡排序算法，并探讨了稀疏数组的概念和转换方法。
摘要由CSDN通过智能技术生成

Java的数组

1.什么是数组

截图

2.数组的声明及创建

截图

package com.bin.array;

public class Demo1 {
    public static void main(String[] args) {
        int[] nums;//1.声明一个数组
        nums = new int[10];//2.创建数组，这里表示可以存放十个整数类型的数字

        //声明和创建写一起
        //int[] nums = new int[10];

        //3.赋值
        nums[0] = 1;
        nums[1] = 1;
        nums[2] = 1;
        nums[3] = 1;
        nums[4] = 1;
        nums[5] = 1;
        nums[6] = 1;
        nums[7] = 1;
        nums[8] = 1;
        nums[9] = 1;

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

    }
}

3.三种初始化

截图

4.内存分析

截图

例子：
1.字符串：其对象的引用都是存储在栈中的，如果是编译期已经创建好(直接用双引号定义的)的就存储在常量池中，如果是运行期（new出来的）才能确定的就存储在堆中。对于equals相等的字符串，在常量池中永远只有一份，在堆中有多份。

// demo
String s1 = "china";  
String s2 = "china";  
String s3 = "china";  
String ss1 = new String("china");  
String ss2 = new String("china");  
String ss3 = new String("china");  
1234567

在这里插入图片描述
说明：黄色这3个箭头，对于通过new产生一个字符串（假设为”china”）时，会先去常量池中查找是否已经有了”china”对象，如果没有则在常量池中创建一个此字符串对象，然后堆中再创建一个常量池中此”china”对象的拷贝对象。这也就是有道面试题：String s = new String(“xyz”);产生几个对象？一个或两个，如果常量池中原来没有”xyz”,就是两个。

2.基础类型的变量和常量：变量和引用存储在栈中，常量存储在常量池中。
代码如下：

// demo
int i1 = 9;  
int i2 = 9;  
int i3 = 9;   
public static final int INT1 = 9;  
public static final int INT2 = 9;  
public static final int INT3 = 9; 
1234567

在这里插入图片描述
说明：编译器先处理int i1 = 9;首先它会在栈中创建一个变量为i1的引用，然后查找栈中是否有9这个值，如果没找到，就将9存放进来，然后将i1指向9。接着处理int i2 = 9;在创建完i2的引用变量后，因为在栈中已经有9这个值，便将i2直接指向9。这样，就出现了i1与i2同时均指向9的情况。而创建常量的时候，则是将9放入常量池中，栈中的INT1、INT2、INT3均指向常量池中已有的9。

3.成员变量和局部变量：成员变量就是方法外部，类的内部定义的变量；局部变量就是方法或语句块内部定义的变量。局部变量必须初始化。局部变量的数据存在于栈内存中，栈内存中的局部变量随着方法的消失而消失。成员变量存储在堆中的对象里面，由垃圾回收器负责回收。

4.数组的四个特性

截图

5.数组的使用

  • 普通的For循环
  • For-Each循环
  • 数组作为方法传入
  • 数组作为返回值
public class Demo2 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
//        for(int array : arrays){    //for-each遍历
//            System.out.println(array);
//        }
         //printArrays(arrays);
        int[] result = reverse(arrays);
        printArrays(result);
    }

    public static void printArrays(int[] arrays){
        for (int i = 0; i < arrays.length ; i++) {
            System.out.print(arrays[i]+" ");
        }
    }
    
    //逆置数组
    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;
    }
}

6.二维数组的使用

截图

public class Demo3 {
    public static void main(String[] args) {
        int[][] arrays = {{2,3},{4,5},{5,6},{6,7}};
        int[][] nums =new int[5][6];
//        System.out.println(arrays[2][1]);
//        System.out.println(arrays[3][0]);
//
//        System.out.println(arrays.length);  //数组长度
//        System.out.println(arrays[0].length);

        printArray(arrays);

    }
    public static void printArray(int[][] array){
        for (int i = 0; i < array.length ; i++) {
            for (int j = 0; j < array[i].length ; j++) {
                System.out.println(array[i][j]);
            }
        }
    }
}

7.Arrays类

截图

import java.util.Arrays;

public class Demo4 {
    public static void main(String[] args) {
        int[] a ={1,2,3,3214,321,42,64};
        System.out.println(a);//哈希值：[I@1b6d3586

        //打印数组元素Arrays.toString
        System.out.println(Arrays.toString(a));
        printArray(a);

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

        Arrays.fill(a,2,4,0);//数组的2-4填充，不包含4
        System.out.println(Arrays.toString(a));

        Arrays.fill(a,0);//数组填充
        System.out.println(Arrays.toString(a));
    }
    public static void printArray(int [] a){
        for (int i = 0; i < a.length ; i++) {
            if(i==0){
                System.out.print("[");
            }
            if (i==a.length-1){
                System.out.println(a[i]+"]");
            }else {
                System.out.print(a[i]+", ");
            }
        }
    }
}

8.冒泡排序

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int[] a = {2,32,44,6,43,9,10,77,96};
        BubbleSort(a);   //将a进行冒泡排序
        System.out.println(Arrays.toString(a));//Arrays类的toString方法打印a

    }
    
    public static int[] BubbleSort(int[] a){
        int temp = 0;//定义一个临时变量
        for (int i = 0; i < a.length-1 ; i++) {
            boolean flag = false;//定义一个标签，用来标记一趟冒泡排序有没有发生元素交换
            for (int j = 0; j < a.length-i-1 ; j++) {
                if (a[j+1]>a[j]){
                    temp = a[j+1];
                    a[j+1] = a[j];
                    a[j] = temp;
                    flag = true;//若发生交换则为true
                }
            }
            if(flag == false){//在一趟排序中未发生元素交换在，证明已有序
                break;
            }
        }
        return a;
    }
}

9.稀疏数组

截图

package com.bin.array;

import java.util.Arrays;

public class Demo5 {
    public static void main(String[] args) {
        //1.创建一个二维数组11*11  0:没有棋子，  1：黑棋   2：白棋
        int[][] array1 =new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始数组
        System.out.println("输出原始数组");

        for(int[] ints:array1){
            for(int anInt:ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

        //转换为稀疏数组保存

        //读取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11 ; i++) {   //for-each的方法遍历二维数组
            for (int j = 0; j < 11; j++) {
                if(array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值个数："+sum);

        //2.创建一个稀疏数组
        //创建稀疏数组的大小
        int[][] array2 = new int[sum+1][3];

        //稀疏数组第一行保存整个数组的基本情况，11行 11列 有效值个数为sum
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组，将数组中非零的值存到稀疏数组中
        int count = 0;//记录遍历到第几个非零数
        int count = 0;
        for (int i = 0; i < array1.length; i++) {  //遍历array1
            for (int j = 0; j < array1.length; j++) {
                if(array1[i][j] != 0){
                    count++;
                    array2[count][0] = i;  //稀疏数组固定是三列，count来记录遍历到第几个有效数字，将其作为行
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
        
        //输出稀疏数组
        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");

        }

        System.out.println("-----------------");
        System.out.println("还原数组");
        //还原
        int[][] arrays3 = new int[array2[0][0]][array2[0][1]];
        for (int i = 1; i < array2.length; i++) {
            arrays3[array2[i][0]][array2[i][1]] = array2[i][2];
        }

        //输出还原数组
        System.out.println("输出还原数组");
        for(int[] ints:arrays3){    //for-each的方法遍历二维数组
            for(int anInt:ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}
Biu biu biu ??
关注
算法设计-最全详细知识总结-递推+递归法+分治法+动态规划+贪心算法+回溯算法+分支法（Java版）
数据挖掘+大数据研发+算法学习
06-04 2586
一：算法基础 1.算法基础介绍 2.欧几里德算法介绍 二：递归 2.hanoi塔问题 1.基本介绍 2.应用领域和范围 3.核心思想和算法框架 4.经典方法 快排 三：分治 1.基本介绍 2.应用领域和范围 3.核心思想和算法框架 4.经典方法 四：动态规划 1.基本介绍 2.应用领域和范围 3.核心思想和算法框架 4.经典方法 五：贪心算法 1.基本介绍 2.应用领域和范围 3.核心思想和算法框架 4.经典方法 六：回溯法 1.基本介绍...
Java 数组
chen2745213271的博客
04-28 3058
今天介绍一下Java中的数组，数组在所有的编程语言中，基本是重要的数据结构之一。在Java中的数组是用来存放一组固定相同大小的数据。 1.数组的存储方式 基本数据类型：在存放基本数据类型时，数据本身是直接存放在数组中 引用数据类型：在存放引用数据类型时，存放数据的内存地址在数组中 原因是在上面说了数组存放的是一组固定相同大小的数据，而引用数据类型的长度不一，所以存放的内存地址，而数组本身也是一组引用类型 2.数组的声明 声明数组时可以声明多种数据类型，但是声明后该数组存放的数据类型只能存放声明的
2021-05-20
weixin_51186288的博客
05-20 92
01、什么是数组 数组是相同数据类型的有序集合 数组的描述是相同类型的若干个数据，按照一定的先后次序排列组合而成 其中，每一个数据称作一个数据元素，每个数组元素可以通过一个下标来访问 02、数组的声明和创建 首先必须声明数组变量，才能在数组中使用数组，数组语法： detaType[] arrayRefVar;//首选的方法 detaType arrayRefVar[];//效果相同不建议使用 java语言使用new操作符来创建数组，语法： dataTy.
从零开始的Java笔记——运算符
qq_40509784的博客
05-24 216
从零开始的Java笔记（day5——运算符） 说明：本文章的day天数并非博主按照实际操作天数进行创作，而是根据内容多少进行分类。为提高效率，可能存在一天创作多篇文章的可能性，希望阅读者不要过多计较，如果本系列文章对您有所帮助，那将会是我的荣幸！ 本次笔记的重点运算符算术运算符/和%+的作用++的运用赋值运算符"="扩展赋值运算符关系运算符逻辑运算符条件运算符位运算符运算符总结运算符优先级 运算符 算术运算符 ：+，-，，/，%，++（自增），–（自减） 赋值运算符 ： = 扩展赋值运算符：+=，-=，
Java数组详解
weixin_51980361的博客
08-05 4254
学习笔记 — 数组和二维数组用法详解，包括声明创建、初始化、数组遍历以及内存图过程等
java数组
m0_55834564的博客
04-23 1782
目录 一维数组 1.先声明，用new关键字进行内存分配 二维数组 1.先声明，用new关键字进行内存分配 练习题： 一维数组 1.先声明，用new关键字进行内存分配 例如： 数组元素类型 数组名字[]; 数组元素类型[] 数组名字; 声明一维数组，代码如下： int arr[]; //声明int型数组，数组中的每个元素都是int型数值 数值名字 = new 数值元素的类型[数组元素的个数]; 数组下标从0开始 publi...
Java数组和字符串
bala_jiang的博客
03-31 2462
介绍Java数组和字符串的定义和使用。目录前言一、数组（一）、数组概述（二）、数组的使用1.数组的声明和初始化（1）、静态初始化（2）、动态初始化（3）、数组默认初始化值2. 数组的长度3.数组元素访问和遍历数组4.数组的扩容与拷贝（三）、二维数组（四）、数组工具类1.boolean equals(数组1，数组2）2.String toString(数组）3.void fill(数组，值）4.void sort(数组)5.int binarySearch(数组，值)二、字符串（一）、字符串概述。
Java数组详解：从基础到高级应用
xycxycooo的博客
08-09 2180
数组（Array）是一种线性数据结构，用于存储一组相同类型的元素。数组中的每个元素通过索引（Index）进行访问，索引通常从0开始。数组的大小在创建时确定，且在Java中是固定的。Java数组是编程中的基本构建块，理解并熟练掌握数组的概念、操作和应用场景，对于编写高效、可维护的代码至关重要。通过合理使用数组，可以实现复杂的逻辑和功能，提高代码的可读性和可维护性。在实际编程中，应遵循数组的最佳实践，避免数组的局限性，合理选择替代方案。通过不断练习和应用，可以提升编程技能，编写出更清晰、更高效的代码。
Java数组练习题(带答案).doc
03-15
Java数组是Java编程语言中的基本数据结构之一，用于存储固定数量的同类型元素。了解和熟练掌握数组的使用是学习Java的重要环节。本篇练习题涵盖了数组的基本概念、操作和异常处理，下面是针对题目中涉及知识点的详细...
Java数组与内存控制
09-20
### Java数组与内存控制 #### 一、Java数组在内存分配方面的知识 ##### 1.1 数组初始化 - **声明数组的时候如何分配内存：** - 在Java中，数组的声明并不直接分配内存，而仅仅是创建了一个数组引用变量。例如： ...
java数组结构图
11-15
对数组的总结和分析，通过这个结构记住它，在开发的过程中使用
服务器虚拟化
Hellc007的博客
10-30 595
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 980
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
java_方法递归调用
HHppGo的博客
10-27 466
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
ssm智慧社区电子商务系统+vue
weixin_44832324的博客
10-28 1217
系统能否进行正常工作，功能模块能否实现，程序代码是否有错误，这些都需要通过系统测试来进行判断，测试是程序开发中必不可少的步骤，就算系统一步不差的被开发出来了，但进行测试时总能发现一个之前从没遇到过的问题[26]。在系统开发的整个过程当中都需要不断进行系统测试，根据经验发现，前期的一个小问题，将会酿成后期的一个大问题，所以越早发现，越早解决，才能保证后续的编码、测试和设计能够顺利进行。目前，系统测试所使用的方法主要是黑盒测试，系统测试的目的包括：根据客户的需求来设计用户界面；
Java复习24（PTA)
2301_79272475的博客
10-30 286
Java复习24（PTA)：多种排序的book类*
JavaScript的第十一天
最新发布
全栈学习ing
10-31 538
在使用offset系列时需注意该属性为css属性，一般用于和javascript结合使用来获取信息，所以在使用该属性时只能获取值而不能改变值。最近的具有定位属性的祖先元素顶部边缘左侧边缘。
java 数组
05-30
Java 数组是一种用于存储同一类型数据的集合。它们是基本数据结构之一，非常重要，被广泛应用于各种算法和数据处理场景中。 Java 数组可以存储基本类型数据（如 int、float、double 等）以及对象类型（如 String、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值