java基础之数组

最新推荐文章于 2023-04-18 20:13:19 发布
最新推荐文章于 2023-04-18 20:13:19 发布
阅读量163 收藏
点赞数
分类专栏： Java基本语法 文章标签： java 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61033369/article/details/127876794
版权

一、数组的定义与基本语法

1、定义

a.数组的四个基本特点：
1、其长度是确定的，数组一旦被创建，它的大小就是不可以改变的；
2、其元素必须是相同类型，不允许出现混合类型。
3、数组中的元素可以是任何数据类型，包括基本类型和引用类型。
4、数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
数组本身就是对象，java中对象是堆中的，因此无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

b.数组边界：
下标的合法区间：[0,length-1],如果越界就会报错：
public static void main(String[] args){
int[] a = new int[2];
System.out.println(a[2]);
}

c.小结：

​ 1、数组是相同数据类型（数据类型可以为任意类型）的有序集合。

​ 2、数组也是对象，数组元素相当于对象的成员变量。

​ 3、数组长度是确定的，不可变的。如果越界，则报：ArrayIndexOutOfBoundsException

2、基本语法

  • 变量的类型 变量的名字 = 变量的值
//java语言使用new操作字符来创建数组，语法如下：
//dataType[] arrayRefVar = new dateType[arraySize];

public static void main(String[] args) {
        int[] nums;//1、声明了一个数组。首选
        //方式二：int nums2[];//知道即可

        nums = new int[10];//2、创建一个数组。这里面可以存放10个int类型的数字

        //3、给数组元素中赋值
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;

        //System.out.println(nums[9]);//未赋值的元素默认为0

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

二、数组的三种初始化

  • 三种初始化
public static void main(String[] args) {
        //静态初始化  创建+赋值
        int[] a = {1,2,3,4,5,6,7,8};
        System.out.println(a[2]);

        //动态初始化:包含默认初始化
        int[] b = new int[10];
        b[2] = 5;
        System.out.println(b[2]);
    
       //数组的默认初始化：
        /*
        数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间
        其中的每个元素也被按照实例变量同样的方式被隐式初始化
         */
    }

三、数组的使用

  • 数组使用：
    1、普通的for循环
    2、for-each循环
    3、数组作为方法入参
    4、数组作返回值

例1：普通的for循环

public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5,89,6};

        //打印全部的数组元素
        for (int i= 0; i <arrays.length;i++){
            System.out.println(arrays[i]);
        }
    }

例2：for-each循环

public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5,89,6};

        //打印计算所有元素的总和
        int sum = 0;
        for (int i = 0; i < arrays.length;i++){
            sum = sum + arrays[i];//sum += arrays[i];
        }
        System.out.println("sum="+sum);
        System.out.println("***************");
        //查找最大元素
        int max = arrays[0];
        for (int i = 1; i < arrays.length;i++){
            if(arrays[i]>max){
                max = arrays[i];
            }
        }
        System.out.println("max="+max);
    }

例3：数组作为方法入参

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

     	for (int array : arrays) {
        System.out.println(array);
            }

例4：数组作为返回值

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

        //printArray(arrays);
        int[] reverse = reverse(arrays);
        printArray(reverse);
    }

    //打印数组元素
    public static void printArray(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=result.length-1 ; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }

四、二维数组

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

二维数组：
int a[][] = new int[2] [5];

解析：以上二维数组a可以看成一个两行五列的数组

public static void main(String[] args) {

    //[4][2]
    /*
        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}};
   
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
            System.out.println(array[i][j]);
        }
    }

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

五、Arrays类

package com.siKongYan.Array;

import java.util.Arrays;

public class ArrayDemo06 {

    public static void main(String[] args) {

        int[] a = {1,2,3,5236,586,125,36529856,1253};

        //System.out.println(a);//[I@77459877
        //打印数组元素
        //System.out.println(Arrays.toString(a));
        Arrays.sort(a);//数组进行排序  升序
        System.out.println(Arrays.toString(a));

        Arrays.fill(a,2,4,0);//2~4之间（第2和3个）元素被数组填充
        System.out.println(Arrays.toString(a));
        //printArray(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.print(a[i]+"]");
            }else{
                System.out.print(a[i]+", ");
            }
        }

    }
}

六、冒泡排序

  • 冒泡排序
    1、比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
    2、每一次出现，都会产生出一个最大，或者最小的数
    3、下一轮就可以少一次排序
    4、依次循环，直到结束
    我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为O(n2)

  • 冒泡排序代码1：

package com.siKongYan.Array;

import java.lang.reflect.Array;
import java.util.Arrays;

public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a = {25,23,56,35,2,12,5,586,963};

        int[] sort2 = sort(a);
        System.out.println(Arrays.toString(sort2));
    }
}
  • 冒泡排序代码2：
    public static int[] sort(int[] array){
        //临时变量
        int temp = 0;

        //外层循环，判断我们这个要走多少次
        for (int i = 0; i < array.length-1; 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;
    }
  • 冒泡排序代码3：
    public static int[] sort2(int[] array){
        //临时变量
        int temp = 0;
        //外层循环，判断我们这个要走多少次
        for (int i = 0; i < array.length-1; i++) {

            boolean flag = false;
            //内层循环：比较两个数的大小，果第一个数比第二个数大，则交换位置
            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;
                    flag = true;
                }
            }
            if (flag==false){
                break;
            }
        }
        return array;
    }

七、稀疏数组

package com.siKongYan.Array;

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("***************");

        //转换为稀疏数组保存
        //1、获取有效值的个数
        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;

        //3、遍历二维数组，将非零的值，存放稀疏数组中
        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];
                }
            }
        }
        //4、输出稀疏数组
        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]);

        }
        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];
        }

        //3、打印
        System.out.println("输出还原的数值");

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

    }
}
司空颜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java基础数组
youngbird1998的博客
04-13 1012
数组(array)是一种用于存储多个相同类型数据的存储模型 数组的定义格式分别为： java中的数组需要先初始化，然后才能使用 初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值 动态初始化： 动态初始化：初始化时只指定数组长度，由系统为数组分配初始值 例子：int [ ] arr = new int[3]; 数据元素访问： 数组内部保存的数据的访问方式 格式：数组名[索引] 索引是数组中数据的编号方式作用： 索引用于访问数...
Java基础篇：数组
热门推荐
张维鹏的博客
10-10 3万+
数组是一种线性数据结构，是一个使用连续的内存空间存放相同的数据类型的集合容器，与其他容器相比，数组的区别主要在于性能与保存基本类型的能力。 在Java中，数组是一种效率最高的存储和随机访问对象的方式，通过寻址公式，随机访问的时间复杂可以达到O(1)，但是为了保持空间的连续性，在数组中插入、删除数据时，都需要移动后面数据，该操作的时间复杂度为O(n)。另外，由于空间上连续，所以数组对CPU缓存比较友好，借助CPU的缓存机制，预读数组中的数据，提高访问效率。但是，由于数组是定长
Java中的数组——详解！
最新发布
m0_74968164的博客
04-18 2万+
一维数组、二维数组、
Java基础（五）★数组
SHEN_DEMO的博客
03-28 368
数组存储一组同一个类型数据的容器---数组数组对每一个存入的数字都会自动编号，编号是从0开始的---下标定义格式：数据类型[] 数组名 = new 数据类型[表示数组能存放的元素个数];---适用于一些知道元素个数而不知道具体元素的场景int[] arr = new int[5]; --- 表示定义了一个能存储5个int类型的数据的数组Java中对数组中的元素进行了自动的编号。---编号是从0开始...
Java基础之数组拷贝
12-22
在java中，我们可以将一个数组变量直接拷贝给另一个数组变量。但拷贝后，两个数组变量引用的是同一个数组。若改变其中一个数组中的内容，另一个数组也会同时改变。 （注：如果想打印数组内的所有值，可以使用Arrays....
java基础之数组常用操作总结(必看篇)
08-30
数组是Java编程中的基础知识，掌握数组的操作是Java开发者的必备技能。本文将总结Java数组中的常用操作，包括求数组中最大值和最小值、查找数组中是否存在某个元素、对数组进行排序等。 一、求数组中最大值和最小值...
Educoder题目：Java入门 - 数组基础答案解析.md
11-01
Educoder题目：Java入门 - 数组基础答案解析
java基础之 接收返回数组失败1
08-08
在Java编程中，数组是一种非常基础且重要的数据结构，它用于存储同类型的多个元素。然而，在实际编程过程中，我们可能会遇到各种与数组操作相关的错误，其中"java.lang.ArrayIndexOutOfBoundsException"是一个常见的...
Java实现字符数组全排列的方法
09-03
在实际编程中，全排列的算法不仅适用于字符数组，还可以应用于数字数组或其他可比较类型的数组，为解决各种排列组合问题提供基础。理解并掌握这种算法，对于提升Java编程能力，特别是在处理复杂问题时，是非常有帮助...
Java基础--数组练习2
07-25
Java基础之数组练习2
Java基础之循环+数组.md
05-08
对于新接触Java的学员来说，Java基础中必学数组和循环结构，这里有分享，想学的朋友可以看看此文章，学习更多Java知识。
java数组基础详解
08-28
java数组基础详解 Java数组是Java编程语言中的一种基本数据结构，用于存储相同类型的数据。数组是一个对象，包含多个元素，每个元素都是相同类型的数据。Java数组可以通过多种方式进行初始化，包括静态初始化和动态...
Java基础学习笔记之数组详解
08-25
总的来说，理解和熟练掌握数组的使用是Java编程的基础，包括如何定义、初始化、遍历以及处理多维数组。这些知识对于编写复杂的程序至关重要。在实际开发中，数组常用于数据的存储和处理，尤其是在算法和数据结构中...
Java数组详解（Java基础）
辰兮要努力
04-16 2187
本章小结了Java数组的基本语法，分享给新学习的小伙伴，分享获取新知大家一起进步。 文章目录一.引言二.数组三.数组的使用四.数组的内存分配 一.引言 回顾数据类型： （1）基本类型 byte short int long float double char boolean （2）引用类型 类 数组 接口 枚举 注解 变量：内存中的一块存储空间, 存储的就是常量。 特点：一个变量只能...
Java基础之数组篇
#include<?>
03-26 1193
【参考原文】http://www.cnblogs.com/chenssy/p/3463719.html概述是什么 通过new关键字创建并组装他们，通过使用整形索引值访问它的元素，并且它的尺寸是不可变的！ 数组是一个简单的复合数据类型，它是一系列有序数据的集合，它当中的每一个数据都具有相同的数据类型，我们通过数组名加上一个不会越界下标值来唯一确定数组中的元素。 数组是一个特殊的对象不管在其他语言
java基础-数组
明立的博客
12-06 1514
关于java中数组的知识点，具体可从一下几个方面进行论述： 1.什么是数组： java中的数组本质上是一个包含具有相同数据类型的元素的集合。是的，没错，这里说的元素，集合之类的，和数学中的意义其实没有多大的差别。就相当于，如果有一个大叔，手里拿着一个袋子，袋子里面装了一些品种一致的金鱼。那么，那个金鱼大叔，就是你的程序，手里的袋子，就是一个数组，袋子里面的金鱼，就是数组中的元素。但是，一但袋子里
JAVA语言学习中重要的知识点之——数组
weixin_43952295的博客
12-08 1001
在为大家分享课程之前，说个题外话。 2018马上就要过完，今年的年度编程语言我们都看好Java。其实在软件开发这个行业里面，哪个编程语言都有自己的优势，只是在目前的大趋势下，Java仍然是最受欢迎的一门编程语言。我个人从事Java开发近10年，中途有4年在做Android，后来因为答应老婆到她所在的公司担任Java讲师一枚，到现在为止也带了好几年的学生毕业后送到了IT企业工作，薪水都很不错。 学习...
Java基础：数组元素访问详解与数据类型介绍
在Java基础理论知识中，数组元素的访问是编程入门的重要概念。数组在Java中是一种数据结构，它允许将多个相同类型的值组织在一起，通过索引来访问这些值。数组的访问语法是在数组名后面加上一个方括号和索引号，例如...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值