20200306学习Java笔记：数组

最新推荐文章于 2024-11-08 14:58:24 发布
最新推荐文章于 2024-11-08 14:58:24 发布
阅读量110 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44671533/article/details/104706317
版权
本文详细介绍了Java中的数组，包括数组的定义、声明与创建、三种初始化方式及其内存分析，强调了数组的基本特点如固定长度和元素类型一致性。还探讨了数组边界、使用技巧，如循环遍历和作为参数、返回值。此外，文章涉及多维数组的使用，并讲解了Arrays类的功能，如数组复制。最后，展示了冒泡排序的实现原理，并简述了稀疏数组这一特殊的数据结构。
摘要由CSDN通过智能技术生成

数组

数组定义

  • 相同类型数据的有序集合
  • 数组描述的是相同类型的若干个数据，按照一定次序排列组合而成
  • 其中每一个数据称为元素

数组声明创建

在这里插入图片描述

package array;

public class ArrayDemo01 {
    //数组类型[] 数组名字
    public static void main(String[] args) {
        int sum=0;
        int []a;//1.定义
        a=new int [10];//2.存放10个int类型数字
        			//int a=new int[10];声明时创建
        //3.给数组赋值，不赋值则默认值为0
        for (int i = 0; i <10; i++) {
            a[i]=(i+1);
        }
        for(int i=0;i<a.length;i++)
        {
            sum+=a[i];//遍历数组，a[0]~a[9],对其内容求和.
        }
        for (int x:a){
            System.out.println(x);//输出数组中的内容
        }
    }
}

三种初始化及内存分析

内存分析

声明的时候数组还没产生，通过new才被创建，开辟空间，然后赋值才完成数组的建立。

在这里插入图片描述

三种初始化

在这里插入图片描述

package array;

public class ArraysDemo02 {
    public static void main(String[] args) {
        int[]a={1,2,3,4,5,6,7,8};//静态初始化，创建+赋值。放几个数据，数组空间就是多大
        int[]b=new int[10];//动态初始化，系统默认赋值：0、null···
        b[0]=10；
    }
}

数组的四个基本特点

  • 数组一旦被创建，内容的长度/数组的大小就是确定的，不能被改变。
  • 一个数组内的元素类型必须是相同的。
  • 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
  • 数组变量属于应用类型，数组也可以看成是对象，数组中的元素相对于是该对象的成员变量。Java中对象是在堆中的，数组对象也在堆中。

数组边界

下标的合法区间：[0,length-1]，越界就会报错。

数组的使用

package array;

public class ArraysDemo03 {
    //打印数组
    public static void printArrays(int[]arrays)
    {
        for (int i = 0; i <arrays.length; i++) {
            System.out.print(arrays[i]+"\t");
        }
    }
    //反转数组
    public static int[] reverse(int[]arrays)
    {
        int[] result=new int[arrays.length];
        for (int i = 0,j=(arrays.length-1); i<result.length; i++,j--)
        {
                result[j]=arrays[i];
        }
        return result;
    }
    public static void main(String[] args) {
        int[]a={1,2,3,4,5,6,7,8};
        int[]b=reverse(a);
        printArrays(b);
    }
}
  • for循环和for-each循环
  • 作为方法参数
  • 作为返回值

多维数组

package array;

public class ArraysDemo04 {
    public static void main(String[] args) {
        int[][]arrays={{1,2},{2,3},{3,4,5},{4,5,8,7}};
        //二维数组的遍历
        for (int i = 0; i <arrays.length; i++) {
            for (int j = 0; j <arrays[i].length; j++) {
                System.out.println("arrays = " + arrays[i][j]);
            }
        }
    }
}


String name[][] = { { "张三", "李四", "王五" }, { "张六", "李七", "王八" },
				{ "张九", "李十", "王十一" } };
		for (String[] str1 : name) {
			for (String str2 : str1) {
				System.out.println(str2);
			}
		}//用增强for循环遍历二维数组

在这里插入图片描述

数组应用

Arrays类

在这里插入图片描述

package array;

import java.util.Arrays;

public class ArraysDemo05 {
    public static void main(String[] args) {
        int[]a={2,5,9,5,2,6,0,5,1,4};
        System.out.println(a);//直接打印数组：[I@723279cf
        System.out.println(Arrays.toString(a));
        //以字符串形式打印：[2, 5, 9, 5, 2, 6, 0, 5, 1, 4]
        Arrays.sort(a);//排序
        System.out.println(Arrays.toString(a));
        //以字符串形式打印：[0, 1, 2, 2, 4, 5, 5, 5, 6, 9]
        Arrays.fill(a,2,4,0);
        //将下标2~4填充为0：[0, 1, 0, 0, 4, 5, 5, 5, 6, 9]
       int[]b={1,2,3,4,5};
        Arrays.equals(a,b);//比较两个数组是否相同
        System.out.println(Arrays.equals(a,b));//false
    }
}

还有复制数组到另一个数组等方法，通过JDK文档可以详细了解。

冒泡排序

两层循环，外层表示循环轮数，内层表示比较的次数。

1.比较两个相邻元素，根据大小关系交换位置。借助中间变量。
2.每一轮比较结束都会产生一个最大或者最小值。
3.下一轮比较的次数减少一次。
4.内外两层循环，直到结束

package array;

import java.util.Arrays;
import java.util.Scanner;

public class ArraysDemo06 {
    //冒泡排序法
        /*
        1.比较两个相邻元素，根据大小关系交换位置。
        2.每一轮比较结束都会产生一个最大或者最小值。
        3.下一轮比较的次数减少一次。
        4.内外两层循环，直到结束
         */
        public static int[] sort(int[] arrays){
            int temp=0;
            //外层循环
            for (int i = 0; i <arrays.length-1; i++) {
                //内层循环
                boolean flag=false;//通过flag标识位减少没有意义的比较
                for (int j = 0; j <arrays.length-i-1; j++) {
                    if(arrays[j]>=arrays[j+1]){
                        temp=arrays[j];
                        arrays[j]=arrays[j+1];
                        arrays[j+1]=temp;
                        flag=true;//产生比较的情况下，flag=true
                    }
                }
                if(flag==false)//没有产生比较交换，则跳出循环,减少循环的次数
                    break;
            }
            return arrays;
        }
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.print("请输入数组容量：");
        int n=scanner.nextInt();
        int[]a=new int[n];
        for (int i = 0; i <a.length; i++) {
            a[i]=(int)(Math.random()*100+1);
        }
        System.out.println("随机数组为："+Arrays.toString(a));//原数组作为字符串输出
        sort(a);                               //冒泡排序
        System.out.println("经过冒泡排序数组顺序为："+Arrays.toString(a));
        Arrays.sort(a);
        System.out.println("调用类函数排序结果为： "+Arrays.toString(a));//类的排序函数
        scanner.close();
        
    }
}

稀疏数组（一种数据结构）

在这里插入图片描述

package array;

import java.util.Arrays;

public class ArraysDemo07
{   //创建一个二维数组，11*11,0表示没有棋子，1:黑棋，2：白棋
    public static void main(String[] args) {
        int[][] a1=new int[11][11];
        a1[1][2]=1;
        a1[2][3]=2;
        //遍历二维数组，输出原始数组
        for (int[] ints:a1) {
            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(a1[i][j]!=0)
                    sum++;
            }
        }
        System.out.println("有效值的个数为："+sum);
        //创建一个稀疏数组
        int[][]a2=new int[sum+1][3];
        a2[0][0]=11;
        a2[0][1]=11;
        a2[0][2]=sum;

        //遍历二维数组，将非零的值存放在稀疏数组中
        int count=0;
        for (int i = 0; i <a1.length; i++) {
            for (int j = 0; j <a1[i].length; j++) {
              if(a1[i][j]!=0)
              {
                  count++;
                  a2[count][0]=i;
                  a2[count][1]=j;
                  a2[count][2]=a1[i][j];
              }
            }
        }
        //输出稀疏数组
        System.out.println("输出稀疏数组");
        for (int i = 0; i <a2.length; i++) {
                System.out.println(a2[i][0]+"\t"+a2[i][1]+"\t"+a2[i][2]+"\t");
        }
        System.out.println("将稀疏数组还原");
        //读取稀疏数组,建立新的数组
        int[][]a3=new int[a2[0][0]][a2[0][1]];
         //遍历稀疏数组给其中元素还原值
        for (int i=1;i<a2.length;i++){
              a3[a2[i][0]][a2[i][1]]=a2[i][2];
        }
        for (int i = 0; i <a3.length; i++) {
            System.out.println(Arrays.toString(a3[i]));
        }
    }
}
远行孤帆
关注
java学习笔记：数组
weixin_43854404的博客
01-20 945
java学习笔记：数组1.数组(Array)2.数组的常见概念3.数组的特点：4.数组的分类5. 一维数组的使用① 一维数组的声明和初始化1>静态初始化:数组的初始化和数组元素的赋值同时进行**2>动态初始化：数组的初始化数组元素的赋值分开进行② 如何调用数组的指定位置的元素③ 如何获取数组的长度④ 如何遍历数组⑤ 数组元素的默认初始化值⑥ 数组的内存解析 ：见B站 尚硅谷143、144集6.二维数组的使用① 二维数组的声明和初始化1>静态初始化2>动态初始化② 如何调用数组的指
JAVA基础：数组 （习题笔记）
2301_81819439的博客
11-05 1314
编码题 ；简答题
【Java笔记】第6章：数组
GUIQU的博客
05-18 1666
各位小伙伴大家好！上期小编给大家讲解了Java中的函数，接下来讲讲数组！至此，Java数组讲解完毕。互三必回！持续更新中~！
Java学习笔记：数组
眼泪划过的星空
05-15 742
数组： 1，Java语言中的数组是一种引用类型，不属于基本数据类型，数组的父类是Object。 2，数组实际上是一个容器，可以同时容纳多个元素。（数组是一个数据的集合。） 数组：字面意思是“一组数据”； 3，数组当中可以存储基本数据类型的数据，也可以存储引用数据类型的数据。 4，数组因为是引用类型，所以数组对象是堆内存当中。 5，数组当中如果存储的是“java对象”的话，实际上存储的是对象的“引用（内存地址）” 6，数组一旦创建，在Java中规定，长度不可变。 7，数组分类：一维数组，二维数组。。。 8，
Java学习笔记：数组的排序
Z_jl123的博客
03-08 406
1、冒泡排序 每次拿前一个值跟后一个值进行比较，如果前一个值大就交换，每一轮会把当前的最大值交换到最后，直到排序成功。 2、选择排序 依次在数组中选择一个值，跟后面所有的值进行比较，如果有值比这个值小，就交换。 3、插入排序 把数组分成左右两部分，假设左边部分已经完成排序，依次从第二个元素开始，把每个元素插入到左边合适的位置。 完结 ...
java学习笔记：数组的遍历和打印
01-05 1735
一、遍历数组 通过for循环、for each循环。 for 循环：从 0 开始至 ns.length-1 结束； for each 循环：按照元素依次遍历。 二、打印数组 可以利用for循环、for each循环进行遍历打印，但比较麻烦，为此，java标准库提供了Arrays.toString() 进行打印。 举例： import java.util.Arrays; public class TestReadSet { public static void main(Strin.
JAVA学习笔记08：数组
qq_25732411的博客
07-08 139
【代码】JAVA学习笔记08：数组。
Java学习笔记：数组篇
April945的博客
12-17 219
数组篇目录数组的定义数组的声明和创建三种初始化四个基本特点下标越界数组的使用Arrays类讲解冒泡排序稀疏数组 数组的定义 数组是相同类型数据的有序集合 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成，其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们 数组的声明和创建 首先必须声明数组变量，才能在程序中使用数组，下面是声明数组变量的语法： dataType[] arrayReVar; //首选的方法 dataType arrayReVar[]; //效果相同
Java 随笔记: 数组与数据处理
DaPiCaoMin的博客
03-06 1258
本文介绍了数组的定义、基本使用和注意事项，探讨了数组赋值机制、JVM内存分配以及底层原理。还讨论了数组的拷贝、反转和扩容操作，以及二维数组及其底层原理。此外，还介绍了冒泡排序和顺序查找算法。
Java笔记：数组
gaoch_li的博客
08-16 256
一、数组概述 数组是一个变量，存储相同数据类型的一组数据 声明一个变量就是在内存空间划出一块合适的空间 声明一个数组就是在内存空间划出一串连续的空间 数组长度固定不变，避免数组越界 数组基本要素 标识符：数组的名称，用于区分不同的数组 数组元素：向数组中存放的数据 元素下标：对数组元素进行编号，从0开始，数组中的每个元素都可以通过下标来访问 元素类型：数组元素的数据类型
"Java学习笔记：数组定义、字符串、continue和long类型
综上所述，Java学习笔记中记录了一些关于数组的定义和使用，以及continue关键字的使用以及长整型数字的表示。这些要点都是在学习和使用Java语言中需要注意和掌握的知识点。通过这些要点的学习和掌握，可以使得我们在...
Java入门笔记：数组详解与内存理解
Java笔记渗透是针对基础学习者的教程，主要讲解了数组在Java编程中的基本概念和使用方法。首先，我们来看第三章——数组的遍历与定义。 1. 定义数组： Java提供了三种方式来定义数组： - 第一种是动态创建，使用`...
"Java基础笔记：数组定义与初始化方式详解
本文主要讲述了Java中数组的定义和初始化方式。首先介绍了数组的两种定义格式：格式一是先声明数据类型，再声明变量名，例如int[] arr；格式二是先声明数据类型，再声明变量名加上方括号，例如Int arr[]。然后详细...
JNI学习笔记：数组作为函数参数
大山喵写博客的地方
03-21 2241
1 前言 2 一维数组作为函数参数传值的Demo 2.1 代码示例 2.2 程序分析 2.3 函数释义 3 数组作为返回值的Demo 3.1 代码示例 3.2 函数释义 4 一维数组作为函数参数的总结 1 前言 本文将展示如何从Java代码中，通过JNI接口传递给C++代码一维数组，并进行相关运算以及返回值。Java代码传递数组到C++中，主要通过JNI的函数来...
spring循环依赖解决方式
qq_36400213的博客
11-04 912
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
JAVA-01-变量
最新发布
LJH_laura_li的博客
11-08 184
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 79
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-04 445
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java（排序容易想，但是滑动窗口不容易想到，核心思想：使用滑动窗口算法通过动态调整窗口的大小，遍历所有符合条件的连续子序列，求得最大连续子序列的长度。）
【Java知识】Java基础-对象排序的实现
wendao76的专栏
11-04 395
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值