Java的数组使用

最新推荐文章于 2024-08-29 18:44:48 发布
最新推荐文章于 2024-08-29 18:44:48 发布
阅读量48 收藏
点赞数
文章标签： java 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45503872/article/details/134273436
版权

数组的定义：

package The_First_Stage.The_beginner_level_Java_SE.Arrawy;

/**
 * 数组的作用：用来存储相同类型的数据
 * 以int类型数据为案例：数组用来存储int类型数据
 * 1》声明定义数组
 * int【】 arr   定义一个int类型的数组，名字为arr
 * int arr2【】
 * 如果数组只声明，没有后续操作，那么这个数组相当于没有定义
 * int 【】 arr3=null； 空  数组赋值为null和和什么都没有赋值 不一样的效果
 *
 * 2》创建
 * arr=new int【4】；  给数组开辟了一个长度为4的空间
 * int 【】arr=new int【4】；声明和创建和为一句话
 * 3》赋值
 * arr[0]=12;
 * arr[1]=1255;
 * arr[2]=1;
 * arr[3]=232;
 * ====================arr[4]=16452;-------------数组索引越界
 *
 * 4》使用
 *System.out.println(arr[1]);
 *数组的长度
 * System.out.println(arr.length);
 *
 *
 */
public class TestArray02 {
    public static void main(String[] args) {


    }
}

数组的使用：

package The_First_Stage.The_beginner_level_Java_SE.Arrawy;

import java.util.Scanner;

/**
 * 功能：键盘录入十个学生的成绩，求和，求平均数
 *
 */
public class TestArray03 {
    public static void main(String[] args) {
        int[] scores=new int[10];
        int sum=0;
        Scanner sc=new Scanner(System.in);
        for (int i = 0; i < 10; i++) {
            System.out.println("请录入第"+(i+1)+"个学生的成绩");
            int score=sc.nextInt();
            scores[i]=score;
            sum+=score;
        }
        System.out.println("十个学生的成句之和为"+sum);
        System.out.println("十个学生成绩平均数为："+sum/10);

        //求取第6个学生的成绩
//        System.out.println(scores[5]);

        //数组的遍历----》方式一
//        for (int i = 0; i <= 9; i++) {
//            System.out.println(scores[i]);
//        }
        //增强for循环 ----------》方式二
        //对scores数组进行遍历，遍历出来每个元素都用int类型的num接收：
//        int count=0;
//        for(int num:scores){
//            //每次豆浆num在控制台输出
//            System.out.println("第"+count+"个学生的成绩为："+num);
//        }
/**
 * 增强for循环
 * 优点：代码简单
 * 缺点：单纯的增强for循环不能涉及跟索引相关的操作
 */
//方式三：利用普通的for循环：逆向遍历：
        for (int i=9;i>=0;i++){
            System.out.println(scores[i]);
        }
    }
}

求取数组中的最大值

package The_First_Stage.The_beginner_level_Java_SE.Arrawy;

/**
 * 求最大值
 */
public class TestArray04 {
    public static void main(String[] args) {
        //1.定义一个数组
        int[] arr = {12, 3, 7, 4, 8, 125, 9, 45, 666, 36};
        //2.求出数组中的最大值：
        int num = getMaxNum(arr);
        System.out.println("当前数组中最大的数为：" + num);

    }
    public static int getMaxNum(int[] arr) {
        int maxNum = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > maxNum) {
                maxNum = arr[i];
            }
        }
        return maxNum;
    }
}

查询元素对应的索引

package The_First_Stage.The_beginner_level_Java_SE.Arrawy;

public class TestArray05 {
    public static void main(String[] args) {
        int[] arr={12,34,56,7,3,10};

        System.out.println(arr[2]);

        //查询56对应的索引
        int index=getindex(arr,56);
       if (index!=-1){
           System.out.println("元素对应的索引："+index);
       }else {
           System.out.println("查无此书！");
       }
    }
    public static int getindex(int []arr,int ele){
        int index=-1;//初始值只要不是数组的索引就行
        for (int i=0;i<arr.length;i++){
            if(arr[i]==ele){
                index=i;//只要找到了元素，那么index就变成i
                break;
            }
        }
        return index;
    }
}

数组添加元素

package The_First_Stage.The_beginner_level_Java_SE.Arrawy;

import java.util.Scanner;

public class TestArray07 {
    public static void main(String[] args) {
        //给定一个数组，在数组下标为2的位置上添加一个元素91

        int[] arr = {12, 34, 56, 7, 3, 10};
        //输出增加元素前的数组
        System.out.print("增加元素前的数组：");
        for (int i = 0; i < arr.length; i++) {
            if (i != arr.length - 1) {
                System.out.print(arr[i] + ",");
            } else {
                System.out.print(arr[i]);
            }
        }
//从键盘接受数据
        Scanner sc=new Scanner(System.in);
        System.out.print("\n请录入你要添加元素的指定下标:");
        int index=sc.nextInt();
        System.out.print("请录入你要添加的元素:");
        int ele=sc.nextInt();

        //增加元素
        insertEle(arr,index,ele);
/**
 * arr[5]=arr[4];
 *  arr[4]=arr[3];
 *  arr[3]=arr[2];
 */

        //输出后增加元素后的数组
        System.out.print("\n增加元素后的数组：");
        for (int i = 0; i < arr.length; i++) {
            if (i != arr.length - 1) {
                System.out.print(arr[i] + ",");
            } else {
                System.out.print(arr[i]);
            }
        }
    }

    /**
     * 提起一个添加元素的方法：
     * 在数组的指定位置上添加一个指定的元素
     * 在哪个数组的哪个位置添加哪个元素
     * 不确定因素：形参：哪个数组，哪个位置，哪个元素
     * 返回值：无
     */
public static  void  insertEle(int []arr,int index ,int ele){

    for (int i = arr.length - 1; i >= (index+1); i--) {
        arr[i] = arr[i - 1];
    }
    arr[index] = ele;


}



}

删除数组元素

/**
 * @Author zhengwang
 * @Date 2023/11/7 10:45
 * @PackageName:The_First_Stage.The_beginner_level_Java_SE.Arrawy
 * @ClassName: TestArray08
 * @Description: TODO 给定一个数组，删除下标为2元素
 * @Version 1.0
 */
package The_First_Stage.The_beginner_level_Java_SE.Arrawy;


import java.util.Arrays;

public class TestArray08 {
    public static void main(String[] args) {
        int[] arr = {12, 34, 56, 7, 3, 10};
//输出删除前的数组：
        System.out.println("删除前的数组" + Arrays.toString(arr));
        //删除
//        arr[2]=arr[3];
//        arr[3]=arr[4];
//        arr[4]=arr[5];
        int index = 2;
        for (int i = index; i <= arr.length - 2; i++) {
            arr[i] = arr[i + 1];
        }
        arr[arr.length - 1] = 0;

        //输出删除后的数组
        System.out.println("删除后的数组" + Arrays.toString(arr));


    }
}


/**
 * @Author zhengwang
 * @Date 2023/11/7 11:02
 * @PackageName:The_First_Stage.The_beginner_level_Java_SE.Arrawy
 * @ClassName: TestArray09
 * @Description: TODO
 * @Version 1.0
 */
package The_First_Stage.The_beginner_level_Java_SE.Arrawy;

import java.util.Arrays;

public class TestArray09 {
    public static void main(String[] args) {
        int[] arr = {12, 34, 56, 7, 3, 10,34,45,56,7,666};
//输出删除前的数组：
        System.out.println("删除前的数组" + Arrays.toString(arr));

        //找到要删除的元素对应的索引即可
        int index = -1;
        for (int i=0;i<arr.length;i++){
            if (arr[i]==333){
                index=i;
                break;
            }
        }

        //删除
//        arr[2]=arr[3];
//        arr[3]=arr[4];
//        arr[4]=arr[5];
//        int index = 2;
       if (index!=-1){
           for (int i = index; i <= arr.length - 2; i++) {
               arr[i] = arr[i + 1];
           }
           arr[arr.length - 1] = 0;
       }else {
           System.out.println("根本没有你要删除的元素！");
       }

        //输出删除后的数组
        System.out.println("删除后的数组" + Arrays.toString(arr));


    }
}

可变参数

/**
 * @Author zhengwang
 * @Date 2023/11/7 14:09
 * @PackageName:The_First_Stage.The_beginner_level_Java_SE.Arrawy
 * @ClassName: TestArray12
 * @Description: TODO1)可变参数：作用提供了一个方法，参数的个数是可变的，解决了部分方法重载问题
 * int...num
 * double...num
 * boolean...num
 *
 * 2)可变参数在JDK1.5之后加入的新特性
 *3)方法的内部对可变参数的处理跟数组是一样的
 *4)可变参数和其它数据一起作为形参的时候，可变参数一定要放到最后
 * 5）我们自己在写代码的时候，建议不要使用可变参数
 * @Version 1.0
 */
package The_First_Stage.The_beginner_level_Java_SE.Arrawy;

public class TestArray12 {
    public static void main(String[] args) {
//        method01(10);
//        method01();
//        method01(20,30,40);
        method01(30,40,50,60,70);
//        method01(new int[]{11,22,33,44});
    }
    public static  void  method01(int num2,int...num){
        System.out.println("--------------1");
        for (int i:num){
            System.out.println(i+"\t");
        }
        System.out.println();
        System.out.println(num2);
    }

}

数组的复制

/**
 * @Author zhengwang
 * @Date 2023/11/7 14:53
 * @PackageName:The_First_Stage.The_beginner_level_Java_SE.Arrawy
 * @ClassName: TestArray13
 * @Description: TODO
 * @Version 1.0
 */
package The_First_Stage.The_beginner_level_Java_SE.Arrawy;

import java.util.Arrays;

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

        //给定一个数组：
        int[] arr={1,3,7,2,4,8};
        //toString:对数组进行遍历查看，返回的是一个字符串，这个字符串比较好看
        System.out.println(Arrays.toString(arr));

        //binarySearch：二分法查找，找出指定数组中的指定元素对应的索引
        //这个方法的使用的前提:一定要查看的是一个有序的数组：
        //sort：排序----》升序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.binarySearch(arr,4));


        int[] arr2={1,3,7,2,4,8};
        //copyOf:完成数组的复制
        int [] newArr=Arrays.copyOf(arr2,4);
        System.out.println(Arrays.toString(newArr));

        //copyOfRange:区间复制：
        int [] newArr2=Arrays.copyOfRange(arr2,1,4);//[1,4)---->1,2,3位置
        System.out.println(Arrays.toString(newArr2));

        //equals：比较两个数组的值是否一样：
        int[] arr3={1,3,7,2,4,8};
        int[] arr4={1,3,7,2,4,8};
        System.out.println(Arrays.equals(arr3,arr4));//true
        System.out.println(arr3==arr4);// false  ==比较左右两侧的值是否相等  比较的是左右的地址值，返回结果一定是false

        //fill：数组的填充
        int[] arr5={1,3,7,2,4,8};
        Arrays.fill(arr5,11);
        System.out.println(Arrays.toString(arr5));




    }
}


/**
 * @Author zhengwang
 * @Date 2023/11/7 16:19
 * @PackageName:The_First_Stage.The_beginner_level_Java_SE.Arrawy
 * @ClassName: TestArray14
 * @Description: TODO
 * @Version 1.0
 */
package The_First_Stage.The_beginner_level_Java_SE.Arrawy;

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

public class TestArray14 {
    public static void main(String[] args) {
        //给一个源数组
        int [] srcArr={11,22,33,44,55,66,77,88};
        //给一个目标数组：
        int [] destArr=new int[10];

        //复制
        System.arraycopy(srcArr,1,destArr,3,3);
        //遍历查看目标数组：
        System.out.println(Arrays.toString(destArr));
    }
}

二维数组的遍历

/**
 * @Author zhengwang
 * @Date 2023/11/7 16:36
 * @PackageName:The_First_Stage.The_beginner_level_Java_SE.Arrawy
 * @ClassName: TestArray15
 * @Description: TODO--二维数组的定义与遍历
 * @Version 1.0
 */
package The_First_Stage.The_beginner_level_Java_SE.Arrawy;

public class TestArray15 {
    public static void main(String[] args) {
        //定义一个二维数组
        int[][] arr=new int[3][];//本质上定义了一个一维数组，长度为3
        int[] a1={1,2,3};
        arr[0]=a1;
        arr[1]=new int[]{4,5,6,7};
        arr[2]=new int[]{9,10};

        //读取6这个元素
//        System.out.println(arr[1][2]);
        //遍历二维数组
        //方式1：外层普通for循环+内层普通for循环：
//        for (int i = 0; i <= 2; i++) {
//            for (int j=0;j<arr[i].length;j++){
//                System.out.print(arr[i][j]+"\t");
//            }
//            System.out.println();
//        }
        //方式2：外层普通for循环+内层增强for循环
//        for (int i=0;i<arr.length;i++){
//            for (int num:arr[i]){
//                System.out.print(num+"\t");
//            }
//            System.out.println();
//        }

        //方式3：外层增强for循环+内层增强for循环
//        for (int[]a:arr){
//            for (int num:a){
//                System.out.print(num+"\t");
//            }
//            System.out.println();
//        }
         //方式5：外层增强for循环+内层普通for循环
        for (int[]a:arr){
            for (int i=0;i<a.length;i++){
                System.out.print(a[i]+"\t");
            }
            System.out.println();
        }
    }
}


/**
 * @Author zhengwang
 * @Date 2023/11/7 16:57
 * @PackageName:The_First_Stage.The_beginner_level_Java_SE.Arrawy
 * @ClassName: TestArray16
 * @Description: TODO
 * @Version 1.0
 */
package The_First_Stage.The_beginner_level_Java_SE.Arrawy;

public class TestArray16 {
    public static void main(String[] args) {
        int[][] arr=new int[3][2];
        //本质上：定义一维数组，长度为3，每个数组“格子”中，有一个默认的长度为2的数组

        arr[1]=new int[]{1,2,3,4};
        //数组遍历
        for (int[] a:arr){
            for (int num:a){
                System.out.print(num+"\t");
            }
            System.out.println();
        }
    }
}

旺仔来了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java数组使用的例子
03-14
Java数组在Java虚拟机（JVM）和Java类库中是一个内置的数据结构，因此其源代码并不直接存在于Java的源代码库中。然而，你可以通过Java的API文档来理解数组的行为和特性。...以下是一个简单的Java数组使用的例子：
java数组结构图
11-15
对数组的总结和分析，通过这个结构记住它，在开发的过程中使用
关于JAVA 数组的使用介绍
09-05
关于Java数组的使用，本文将深入探讨其特点、初始化方式以及一些常见的操作。在Java中，数组是一种重要的数据结构，它允许我们存储同一类型的多个元素。数组提供了高效的数据访问，但也有其局限性，尤其是在与Java...
Java数组与内存控制
09-20
### Java数组与内存控制 #### 一、Java数组在内存分配方面的知识 ##### 1.1 数组初始化 - **声明数组的时候如何分配内存：** - 在Java中，数组的声明并不直接分配内存，而仅仅是创建了一个数组引用变量。例如： ...
Java数组讲解
06-02
### Java数组讲解 #### 1. 数组基本概念与初始化 - **定义**: 数组是一种基本的数据结构，用于存储相同类型的多个元素。这些元素在内存中是连续存储的。 - **初始化**: 可以通过两种方式进行初始化：动态初始化和...
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 5042
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 5201
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 5201
linux上datax 安装以及使用
《深入理解 Java 中的适配器模式》
最新发布
面团到油条的成长日记
08-29 3322
在软件开发的广阔领域中，不同接口之间不匹配的问题时常像个棘手的难题困扰着开发者。而适配器模式就像是一位得力的助手，专门用来解决这类问题。它的关键作用在于把一个类的接口有效地转化为客户端所期望的另一种接口，让原本因接口不相符而不能一起工作的两个类可以共同协作，学习本文希望你能有所收获
操作系统原子操作
zzt_is_me的博客
08-28 3253
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Java设计模式之建造者模式详细讲解和案例示范
weixin_39996520的博客
08-28 2763
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 2037
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
基于jenkins部署maven项目
静水深流
08-26 2752
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
死锁及其产生条件
秋夫人
08-26 1458
死锁是指两个或多个线程（或进程）互相等待对方释放资源，导致所有相关线程都无法继续执行的情况。这是并发编程中的一个常见问题，可能会导致系统部分或完全停止响应。
JVM 内存参数
iOS逆向与安全
08-29 727
它屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在各种平台上不加修改的运行。‌例如，‌可以将最小堆内存设置为2GB（‌-Xms2048m）‌，‌最大堆内存设置为4GB（‌-Xmx4096m）‌。如果初始化的高水位线设置过低，会频繁的触发Full GC，高水位线会被多次调整。一般来说，垃圾回收器都会有默认的对象晋升到老年代的年龄参数阈值，CMS默认是6，G1默认是15，不过这参数值也不是一成不变的，它会根据动态年龄判断规则来重新被赋值。
Java面试宝典-java基础02
杜盟恩的博客
08-27 1288
机器语言是一种指令集的体系，是最早出现的计算机语言。机器语言从属于硬件设备。不同的计算机设备有不同的机器语言．所以机器语言是一种面向机器的语言。计算机指令系统中的指令是由“0”和“1”两种符号组成的代码，并且能被机器直接理解执行，它们被称为机器指令。一个计算机的机器指令的集，就构成了该计算机的机器语言，即计算机可以直接接受、理解的语言。机器语言能利用机器指令精准地描述算法、且编程质量高、所占存储空间小，执行速度快。但是这种程序直观性很差，容易出错，阅读检查和修改调试非常困难。
Java 入门指南：Java IO 模型
Zachyy的博客
08-26 1591
Java中的 IO（Input/Output）模型是管理计算机与外部设备（如磁盘、网络等）之间数据交换的重要机制。它定义了数据如何在应用程序和操作系统之间流动，以及如何处理这些流动过程中的阻塞、非阻塞、同步和异步等问题。Java中常见的IO模型包括 BIO（Blocking I/O，阻塞IO）、NIO（Non-Blocking I/O，非阻塞IO）、AIO（Asynchronous I/O，异步IO）等。
Java【代码 17】httpclient PoolingHttpClientConnectionManager 连接池使用举例
Java与大数据相关实践内容分享！
08-27 1179
Java httpclient PoolingHttpClientConnectionManager 连接池使用举例
java数组使用for循环赋值
04-07
示例代码： ```java int[] arr = new int[5]; for (int i = 0;...以上代码创建了一个长度为5的整型数组arr，然后使用for循环遍历数组，从下标0开始，依次将1到5赋值给数组元素。arr数组的值为[1, 2, 3, 4, 5]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值