Java数组

最新推荐文章于 2024-09-27 00:45:01 发布
最新推荐文章于 2024-09-27 00:45:01 发布
阅读量476 收藏 5
点赞数 2
文章标签： java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lian__xue/article/details/122850954
版权

Java数组

1.数组概述

  • 数组是相同类型数据的有序集合。
  • 其中，每一个数据称为一个数组元素。

2.数组声明创建

  • 首先必须声明数组变量，才能在程序中使用数组。

    public class Demo01 {
    public static void main(String[] args) {
        int[] nums;//1.定义
        int nums2[];
    }
}

  • Java语言使用new操作符来创建数组。

    public class Demo01 {
    public static void main(String[] args) {
        int[] nums;//1.定义
        nums = new int[10];
    }
}

  • 数组的元素是通过索引访问的，数组索引从0开始。

  • 获取数组长度：

    public class Demo01 {
    public static void main(String[] args) {
        int[] nums;//1.定义
        nums = new int[10];//2.创建一个数组
        //3.赋值
        nums[0] = 0;
        nums[1] = 1;
        nums[2] = 2;
        nums[3] = 3;
        nums[4] = 4;
        nums[5] = 5;
        nums[6] = 6;
        nums[7] = 7;
        nums[8] = 8;
        nums[9] = 9;
        //计算所有元素和
        int sum = 0;
        for(int i = 0;i<nums.length;i++){
            sum = sum + nums[i];
        }
        System.out.println(sum);
    }
}

  • 内存分析

    数组对象本身是在堆中。

  • 初始化

    public class Demo02 {
    public static void main(String[] args) {
        //静态初始化
        int[] a = {1,2,3,4};
        System.out.println(a[0]);
        //动态初始化
        int[] b = new int[10];
        b[0] = 10;
        System.out.println(b[0]);
    }
}//没有初始化默认是0

  • 下标合法区间[0,length-1]

3.数组使用

  • For-each循环

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

    public class Demo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //JDK1.5   arrays.for
//        for (int array : arrays) {
//            System.out.println(array);
//        }
        printArrays(arrays);
        int[] reverse = reverse(arrays);
        printArrays(reverse);
    }
    //打印数组元素
    public static void printArrays(int[] arrays){
        for(int i = 0;i<arrays.length;i++){
            System.out.println(arrays[i]);
        }
    }
    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        //反转操作
        for (int i=0,j=result.length-1;i<arrays.length;i++,j--){
            result[j] = arrays[i];
        }
        return result;
    }
}

4.多维数组

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

5.Arrays类

public class Demo05 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,22,55,33,10};
        System.out.println(a);
        System.out.println(Arrays.toString(a));
        //printArrays(a);
    }
    public static void printArrays(int[] a){
        for(int i=0;i<a.length;i++){
            if(i==0){
                System.out.print("[");
            }else if (i==a.length-1){
                System.out.print("]");
            }else {
                System.out.print(a[i]+",");
            }
        }
    }
}
  • 具有以下常用功能：
    • 给数组赋值：通过fill方法。
    • 对数组排序：sort方法，升序。
    • 比较数组：通过equals方法比较数组中元素值是否相等。
    • 查找数组元素：binarySearch方法能对排序好的数组进行二分查找。

冒泡排序：总共有八大排序。

public class Demo06 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,22,55,33,10};
        int[] b = sort(a);
        System.out.println(Arrays.toString(b));
    }
    //冒泡排序
    //1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，就交换他们你的位置
    //2.每一次比较，都会产生出一个最大，或者最小的数字；
    //3.下一轮，可以少一次排序
    //4.一次循环直到结束
    public static int[] sort(int[] a){
        //外层循环，判断我们要走多少次
        int t;
        for (int i = 0; i < a.length-1; i++) {
            boolean flag = false;//减少没有意义的比较
            //内层循环，比较判断两个数，如果第一个数大，则交换位置
            for (int j = 0; j < a.length-1-i; j++) {
                if(a[j+1]<a[j]){
                    t = a[j];
                    a[j] = a[j+1];
                    a[j+1] = t;
                    flag = true;
                }
            }
            if(flag==false){
                break;
            }
        }
        return a;
    }
}

时间复杂度O(n^2)

6.稀疏数组

  • 当数组中大部分元素为0，或者为同一值得数组时，可以使用稀疏数组来保存该数组。
  • 处理方式：
    • 记录数组一共有几行几列，有多少个不同值。
    • 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小规模。
public class Demo07 {
    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 (int j = 0; j < 11; j++) {
                if(array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值个数："+sum);
        //2.创建一个稀疏数组
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        //遍历二维数组，将非0的值存放稀疏数组
        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];
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组：");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0]+" "+array2[i][1]+" "+array2[i][2]);
        }
        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];
        }
        System.out.println("还原数组：");
        for (int[] ints:array1) {
            for (int anInt:ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}
LI TANG MING TIAN
关注
java数组元素_Java数组
weixin_39633500的博客
02-16 982
数组是编程语言中最常见的一种数据结构，不同语言对数组的实现及处理也不尽相同。那么Java中的数组又是怎样的呢？我们该如何定义和使用数组呢？所以，下面让我们一起来学习数组的相关知识。一、数组的分类在Java中，数组就是一个变量，用于将相同数据类型的数据存储在内存中。其中，一个数据被称为数组元素。Java数组是引用数据类型，其分类为：(1)一维数组：1. 数组创建的格式：DataType[] Arra...
java 数组 切片
qq_43615820的博客
01-20 1192
【代码】java 数组 切片。
Java数组求和
m0_73811154的博客
09-05 1210
求出该数组中满足要求的元素和，要求是：求和的元素个位和十位都不能是7，并且不是偶数。* 要求：元素是{68，27，95，88，171，996，51，210}* 定义一个数组，用静态初始化完成数组元素初始化。* 判断该元素是否满足条件，如果满足条件就累加。* 遍历数组，获取到数组中的每一个元素。* 定义一个球和变量，初始值为0。* 输出求和变量的值。
java数组详解
m0_74890428的博客
11-10 2259
数组的两种定义格式： 格式1：数据类型[] 变量名;范例： int[] arr;定义了一个int类型的数组，数组名是arr格式2：数据类型 变量名[];范例： int arr[];定义了一个int类型的变量，变量名是arr数组
Java数组类型
m0_63293142的博客
12-12 875
定义一个数组类型的变量，使用数组类型“数据类型[]”的语法，例如，int[]。和单个基本类型变量不同，数组变量初始化必须使用new int[5]或{... ...}表示创建一个可容纳5个int元素的数组内存空间。Java的数组有几个语法特点：●数组所有元素初始化为默认值，整型都是0，浮点型是0.0，布尔型是false；●数组一旦创建后，大小就不可改变，所以说数组长度固定；●访问数组中的某一个元素，需要使用索引。数组索引从0开始。例如，5个元素的数组，索引范围是0~4。
Java数组及引用
qq_64552046的博客
03-12 1814
Java数组及引用
Java数组的练习
zssxcj的博客
10-14 1822
(4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值 (如array[0]=0,array[2]=2)。定义一个int型的一维数组，包含10个元素，分别赋一些随机整数， 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。(1)创建一个名为ArrayTest004的类，在main()方法中声明array1和array2两个变量， 他们是int[]类型的数组。(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
java数组回收_Java数组深入
weixin_26876073的博客
02-25 697
Java数组深入内存中的数组前边提到：数组是一种引用类型，数组引用变量只是一个引用，当它指向有效内存的时候才可以通过数组变量来访问数组元素，也就是说数组变量和数组元素在内存中是分开放的。可以这么理解，一个人名就是一个引用变量，通过这个人名找到这个人，获取他的所有信息，就是通过引用变量访问其真实对象的过程。例如数组int[]arr中arr是一个数组引用变量，但他并没有初始化，也就是说没有指向一块内存...
JAVA数组拆分
Liulelelele_的博客
07-11 3322
java数组拆分
Java数组练习题(带答案).doc
03-15
Java数组是Java编程语言中的基本数据结构之一，用于存储固定数量的同类型元素。了解和熟练掌握数组的使用是学习Java的重要环节。本篇练习题涵盖了数组的基本概念、操作和异常处理，下面是针对题目中涉及知识点的详细...
java数组
04-20
Java数组是程序设计中不可或缺的基础概念，它是一种数据结构，允许我们存储同类型的多个元素。在Java中，数组是对象，具有固定的大小，一旦创建，其长度就不能改变。本篇文章将深入探讨Java数组的各个方面，包括创建...
Java数组与内存控制
09-20
### Java数组与内存控制 #### 一、Java数组在内存分配方面的知识 ##### 1.1 数组初始化 - **声明数组的时候如何分配内存：** - 在Java中，数组的声明并不直接分配内存，而仅仅是创建了一个数组引用变量。例如： ...
java数组结构图
11-15
对数组的总结和分析，通过这个结构记住它，在开发的过程中使用
比较Java数组和各种List的性能小结
09-01
首先，Java数组是最基础的数据结构，它提供了固定大小的连续内存空间来存储相同类型的数据。由于其物理结构的特性，数组在随机访问时具有极高的效率，因为可以直接通过索引来访问元素。但是，插入和删除元素时，如果...
工厂模式的介绍及实现
户伟伟的博客
09-25 95
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 141
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
智能BI平台项目
2302_79400545的博客
09-22 222
BI商业智能：数据可视化、报表可视化系统。
Android系统：系统架构
liufeismart2024的博客
09-23 481
Android的系统结构的设计混合了分层设计和分块设计。
java 数组
05-30
Java 数组是一种用于存储同一类型数据的集合。它们是基本数据结构之一，非常重要，被广泛应用于各种算法和数据处理场景中。 Java 数组可以存储基本类型数据（如 int、float、double 等）以及对象类型（如 String、自定义类对象等）。 Java 数组的特点包括： 1. 数组长度固定，一旦创建就无法改变。 2. 数组元素必须是相同的数据类型。 3. 数组下标从 0 开始，最大下标为长度减 1。 Java 中创建数组的语法为： ``` dataType[] arrayName = new dataType[arrayLength]; ``` 其中，dataType 表示数据类型，arrayName 表示数组名称，arrayLength 表示数组长度。 例如，创建一个长度为 5 的 int 类型数组，可以使用以下语句： ``` int[] array = new int[5]; ``` 可以使用索引来访问数组元素，例如： ``` array[0] = 1; array[1] = 2; int sum = array[0] + array[1]; ``` 在 Java 中，数组可以使用 for 循环遍历，例如： ``` for (int i = 0; i < array.length; i++) { System.out.println(array[i]); } ``` 也可以使用增强型 for 循环遍历，例如： ``` for (int element : array) { System.out.println(element); } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值