2021-08-27 Java数组

最新推荐文章于 2021-09-27 20:32:58 发布
最新推荐文章于 2021-09-27 20:32:58 发布
阅读量424 收藏 1
点赞数
分类专栏： Java学习 文章标签： java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hjr2651/article/details/119960426
版权

Java数组

一、数组概述

相同类型数据的有序组合

下标从0开始

数组是引用类型，父类是Object

数组特点

  1. 其长度是确定的。数组一旦被创建,它的大小就是不可以改变的。
  2. 其元素必须是相同类型不允许出现混合类型。
  3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
  4. 数组变量属引用类型数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。
  5. 数组成员是对象的话，存储的是对象地址。
  6. 数组元素类型要统一，int只能是int。注意：引用类型，父类数组可以放子类元素，子类和父类都有的方法，调用时不用转型，子类独有方法需要向下转型。
  7. 数组元素，内存地址连续。是一种简单的数据结构。
  8. 数组第一个元素内存地址为整个数组对象的内存地址。

数组优点缺点

  1. 优点：查询效率最高的数据结构

    • 地址连续
    • 类型相同，占用大小一样
    • 知道首元素内存地址，因为地址连续，可以计算出其他元素内存地址，直接用地址定位，效率高
    • 数组中100个元素和100万个元素检索效率一样，因为它是数学表达式计算的，不是一个个找的。

  2. 缺点：随机增删效率低。

    因为随机增删后边元素要统一向前或向后移动。除最后一个元素。

  3. 缺点：不能存储大数据量

    因为很难在内存上找到一块连续的特别大的内存空间。

二、声明和创建

  1. 声明

    int[] nums1;	//首选，int[],表示int数组数据类型。跟int作用一样。
int nums2[];	//C 语言风格

  2. 创建

    int[] nums = new int[10];

  3. 赋值

    nums[0] = 1;
//没赋值，默认值为0；

  4. 练习

    package com.guyuer.array;

public class ArrayDemo01 {
    public static void main(String[] args) {

        int[] nums = new int[10];
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            nums[i] = i+1;
            System.out.println("nums["+i+"]="+nums[i]);
            sum += nums[i];

        }
        System.out.println("总和"+sum);

    }
}

  5. 内存分析

    堆、栈、方法区

  6. 三种初始化方法

    • 静态初始化
    • 动态初始化
    • 默认初始化

  7. 练习

    package com.guyuer.array;

public class ArrayDemo02 {
    public static void main(String[] args) {
        //1静态初始化
        int[] a = {1,2,3,4,5,6,7,8,9,10};
        //2动态初始化
        int[] b = new int[10];
        b[0]=1;
        //3默认初始化
        System.out.println(b[1]);//没被赋值有默认值0；
    }
}

三、数组使用

练习

package com.guyuer.array;

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5,6,7,8,9};
        //增强型for循环,arrays.for
//        for (int array : arrays) {
//            System.out.println(array);
//        }
        PrintArray(arrays);
        int[] rev = ReverseArray(arrays);
        for (int j : rev) {
            System.out.println(j);
        }
    }


    //打印数组元素
    public static void PrintArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
        System.out.println();
    }

    //反转数组
    public static int[] ReverseArray(int[] arrays){
        int[] result = new int[arrays.length];
        for (int i = 0; i < arrays.length; i++) {
            result[i] = arrays[arrays.length-i-1];
        }
        return result;
    }
}

四、多维数组

多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组

定义

int[][] = new int[2][5];
//两行五列

图解

多维数组

练习

package com.guyuer.array;

public class ArrayDemo05 {
    public static void main(String[] args) {
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};
        /**
         * 1 2
         * 2 3
         * 3 4
         * 4 5
         */

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

    }
    //打印数组元素
    public static void PrintArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
        System.out.println();
    }
}

五、Arrays类

工具类当中方法大部分是静态的

实际开发都是查工具

面试可能会碰到

Java提供数组工具类Arrays

  • 给数组赋值:通过fill法
  • 对数组排序:通过sort方法，按升序。
  • 比较数组:通过 equals方法比较数组中元素值是否相等。
  • 查找数组元素:通过 binarySearch方法能对排序好的数组进行二分查找法操作。
System.out.println(Arrays.toString(a))；

Arrays.sort(a);//升序排序

六、冒泡排序

最为出名的排序算法之一。

冒泡排序

  1. 比较数组中,两个相邻的元素,如果第一个数比第二个数大,我们就交换他们的位置。
  2. 每一次比较,都会产生出一个最大,或者最小的数字。
  3. 下一轮则可以少一次排序!
  4. 依次新环,直到结束。
package com.guyuer.array;

import java.util.Arrays;

public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a = {4,2,6,9,4,5,7,9,0};
        sort(a);

    }

    //冒泡排序
    public static void sort(int[] array){
        for (int j = 0; j < array.length-1; j++) {  //判断走多少遍
            boolean flag = true;
            for (int i = 0; i<array.length-1-j; i++){       //每遍循环次数
                if(array[i]>array[i+1]) {
                    int temp = array[i];
                    array[i] = array[i + 1];
                    array[i + 1] = temp;
                    flag = false;
                }

            }
            if(flag == true){
                break;
            }
        }
        System.out.println(Arrays.toString(array));
    }


}

七、稀疏数组

  1. 当一个数组中大部分元素为0,或者为同一值的数组时,可以使用稀疏数组来保存该数组。

  2. 稀疏数组的处理方式是

    • 记录数组一共有几行几列,有多少个不同值
    • 把具有不同值的元素和行列及值记录在一个小规模的数组中,从而缩小程序的规模
    • 如下图:左边是原始数组,右边是稀疏数组

    稀疏数组

练习

package com.guyuer.array;

import java.util.Arrays;

public class ArrayDemo08 {
    public static void main(String[] args) {
        //创建一个二维数组，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();
        }
        System.out.println("==========================================");
        //获取有效值个数
        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){
                    continue;

                }
                count += 1;

            }
        }
        System.out.println("有效数字"+count+"个");
        //创建一个稀疏数组
        int[][] array2 = new int[count+1][3];
        array2[0][0]=array1.length;
        array2[0][1]=array1[0].length;
        array2[0][2]=count;

        //遍历二维数组将非0值存到稀疏数组
        int k = 1;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if(array1[i][j]!=0){
                    array2[k][0] = i;
                    array2[k][1] = j;
                    array2[k][2] = array1[i][j];
                    k++;
                }
            }
        }

        //打印稀疏数组
        System.out.println("==========================================");
        System.out.println("稀疏数组");

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

        System.out.println("还原数组");
        //还原稀疏数组
        //1.读取稀疏数组值
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //2.给元素还原值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
            }

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

补充

1.main()方法的String[ ] args参数作用？

数组长度可为0

如public static void main(String[] args){}中的args数组就是长度为为0的数组。

main()方法的长度为0的数组有什么用？

留给用户，用户在控制台上输入参数，会被自动转换到这个数组

例如：java ArrayTest abc def xyz

JVM会将abd def xyz通过空格的方式分离，分离完成后，自动放到String[] args数组中。

args数组主要是接受用户输入参数的。

使用：在控制台javac 文件名.java / java 文件名 参数 就会有

在IDEA，Configurations页面，program arguments行输入，作用相同

作用：系统输入用户名和密码才能进入

package com.guyuer.array;

public class ArrayDemo09 {
    public static void main(String[] args) {
        if(args.length != 2){
            System.out.println("错误！请输入用户名和密码");
        }
        if(args[0].equals("GY") && args[1].equals("123")){
            System.out.println("登录成功");
        }
        else {
            System.out.println("验证失败");
        }
    }
}

2. 数组扩容

线新建大容量数组，再将小容量数组元素一个个拷贝到大容量数组。因为数组长度一旦确定无法改变。数组扩容效率较低。

可以再创建数组对象时，预估一下。

3. 数组拷贝

System.arraycopy();

源码

public static native void arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);
//native表示C++写的
//五个参数
//源数组对象，源起始位置，拷贝到的数组对象，目标数组的起始位置，拷贝长度。

练习

package com.guyuer.array;

public class ArrayDemo10 {
    public static void main(String[] args) {
        int[] src = {1,2,3,4,5,6,7};
        int[] dest = new int[20];

        System.arraycopy(src,2, dest,2, 3);

        ArrayDemo04 arrayDemo04 = new ArrayDemo04();
        arrayDemo04.PrintArray(dest);

        System.arraycopy(src,0,dest,0,src.length);
        arrayDemo04.PrintArray(dest);

        //字符串数组也可以
    }
}
GuYue2651
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 学习笔记：第七章 数组
人在囧途的博客
04-15 375
Java 学习笔记：第六章 异常机制数组概述和特点数组的定义7.2.1 数组声明7.2.2 初始化7.3.1 数组的遍历7.3.2 for-each 循环7.3.3 数组的拷贝7.3.4 java.util.Array类7.4 多维数组7.5 数组存储表格数据7.6.1 冒泡排序的基础算法7.6.2 冒泡排序的优化算法 数组概述和特点 数组的定义 数组是相同类型数据的有序集合。数组描述的是相同类型...
【Java】《Java语言程序设计与数据结构》V11_基础篇_第07章_复习题答案
$niubx的博客
03-09 1148
（！仅供参考） 第2小节 7.2.1 Q：如何声明一个数组引用变量，如何创建一个数组？ A： 声明数组引用变量：如 double[] list 。 创建一个数组：如 new list[3] 或 {0， 1， 2} 。 7.2.2 Q：什么时候为数组分配内存？ A：当把数组赋值给数组引用变量时。 7.2.4 Q：下列说法哪些是错误的？ （题目略） A： a.数组中的每个元素都有相同的类型。 对。 b.一旦数组被声明，大小就不能改变。 错。 c.一旦数组被创建，大小就不能改变。 对。 d.数组中的元素必须是
为什么说，Java数组声明了大小就不能修改？
weixin_42370303的博客
06-15 4016
当然不可以，形象的说你有200个空间，你现在分配了100个空间，还有一百个空间没有分配使用，这时候就可以从剩下的100个空间中取空间来用，可能现在就用了100-150的空间，数组的内存空间是连续的，你如果直接使用这101的话肯定就覆盖了其它数据了。数组空间是静态分配的，就是初始化的时候就分配好了的，你如果需要修改就要使用链表之类的动态分配空间的类，学过数据结构应该都知道链表的使用。...
java中为什么说数组在创建之后就不能修改大小了
qingyibaicai的博客
10-17 6504
首先： int[]s=new int[10]; s=new int[20]; 这段代码是对的！ s在栈区首先指向一个大小为10的堆区内存空间，后来又指向一个重新创建好的大小为30 的内存空间。 其次： 为什么说数组大小在创建之后不能改变呢，意思就是创建了一个内存大小为20空间的后不能在这个基础上扩展大小，只能另开辟空间。 ...
Java数组3：数组的基本特点
m0_57234734的博客
09-27 223
数组的四个基本特点 数组的长度是确定的，数组一旦被创建，它的大小就是不可改变的。 其元素必须是相同类型，不允许出现混合类型。 数组中的元素可以是任何数据类型，包括基本类型和引用类型。 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。 数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型。 数组对象本身是在堆中的 数组的边界 下标的合法区间：[0，length-1]，越界则会报错 [外链图片转存失败,源站可能有防盗链机制,建
java----数组----最值问题
07-14
定义数组scores并赋值56,90,34,20,统计出最高分,最低分,平均分
Java基础语法测试-基础数据类型-注解-数组-inet-反射-oop-Java代码实现
最新发布
03-09
内容概要：通过带着读者编写Java基础语法测试代码，理解基础数据类型-注解-数组-inet-反射-oop-Java代码实现过程和测试代码 适合人群：初学java语法入门测试代码 能学到什么：①注解、数组、数据类型、inet、method...
Java学习资料-数组
06-15
Java中的数组是编程中不可或缺的基础概念，主要用于存储一组...总之，Java数组提供了一种高效、有序的方式来存储和操作一组相同类型的数据，是编程中常用的数据结构。理解和熟练使用数组是掌握Java编程的关键步骤之一。
Java程序设计课程实验4-数组
12-14
Java程序设计课程实验4-数组Java程序设计课程实验4-数组Java程序设计课程实验4-数组Java程序设计课程实验4-数组Java程序设计课程实验4-数组Java程序设计课程实验4-数组Java程序设计课程实验4-数组Java程序设计课程...
Java基础--数组练习2
07-25
Java基础之数组练习2
Java实现abc字符串排列组合
08-28
主要为大家详细介绍了JAVA实现abc字符串的排列组合，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
数组创建后就不能改变
weixin_44292923的博客
04-09 2756
在运行期间，数组创建后就不能改变 数组一旦创建，程序运行期间，长度不可以改变。 用length去获取长度。 如图，arrayC 先声明了一个长度为3的数组，然后把arrayC改变成了5（但并没有改变数组长度）。 看图中，new int[5]是形成了另一个数组，改变了他的地址值，并没有改变数组，老数组是不改变的，这个很重要。 ...
数组：可变数组和不可变数组
xxx的博客
08-07 2328
1，不可变数组：类：NSArry //对象初始化方法 1> NSArray *arr1 = [[NSArray alloc]initWithObjects:@”one”,@”two”,@”three”,@”four” ,nil]; NSLog(@”%@”,arr1); /*结果：( one, two,
Java的数组长度为什么不能改变？
陈小哥cw
03-04 5679
Java中的数组是定长的！你这样int[] a ={}; 定义出来的数组a 长度为0，已经是定长了，之后再给它赋值是不可以的，因为它的长度定义出来之后是不可改变的了。所以在使用数组的时候，一定要注意长度，不能超过这个长度，负责就数组下表越界了。 如下代码: public class ddd { public static void main(String[] args){ ...
解决数组不可变的问题
mzy1711231996的博客
03-11 491
解决数组不可变的问题 数组拓展学习 *用了Java里的指针。 可以实现这种操作效果 import java.sql.Array; import java.util.Arrays; public class Test { public static void main(String[] args) { // 解决数组不可变的问题 i...
new之后可以改变大小的数组---byte[] ！！！！！！
sklzl1571的博客
05-26 4972
今天写程序时无意间发现了一个“数组”的怪胎，我也不知道为什么用控制台输出下面的程序namespace ConsoleApplication1{    class Program    {        static void Main(string[] args)        {            byte[] buffer = new byte[5];            Conso...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值