Java的数组

已于 2023-05-15 20:04:26 修改
阅读量98 收藏
点赞数 1
文章标签： java
于 2023-05-15 20:03:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LH495562/article/details/130691565
版权

  • 课程的回顾

  • 数组的定义与作用

  • 创建与使用数组

  • 数组的遍历

  • 数组的案例解析

0、课程的回顾

1.方法与函数的创建方式

有四种：无参无返回值，无参有返回值，有参无返回值，有参有返回值

2.方法与函数调用

格式：方法名（实参1；实参2；实参3....）；

比如：findMax（23,56,45）；

注意：实参的个数与顺序及类型一定要与方法声明的时候的形参的个数、顺序、类型保持一致

package Shangke;
//.验证哥德巴赫猜想：任何一个大于6的偶数，都能分解成两个质数的和，要求输入一个整数，输出这个
//      数被被分解成哪两个质数的和。
//比如：12->7+5
import java.util.Scanner;
public class day2221 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个大于6的偶数：");
        int even = sc.nextInt();
        fing (even);
        sc.close();
    }
    public static boolean  geDe(int a ){
        boolean flag=true;
        for (int i=2;i<a;i++){
            if (i%2==0){
                break;
            }
        }//此处可以不用
        if (flag){
            flag=true ;
        }
        return flag ;
    }
    //2.将一个偶数分解为两个质数的和
    public static void fing (int even){
        if (even>6&&even%2==0){//8.38-3=5
            for (int i=3;i<=even-3;i++){
                //质数1+质数2=even
                boolean c =  geDe(i);//是质数1
                boolean d =  geDe(even-i);//是质数2
                if (c&&d){//等价于啊&&b==true表达式
                    System.out.println(even+"="+i+"+"+(even-i));
                    // 终止循环
                    break;
                }

            }
        }else{
            System.out.println("判断的数不符合条件");
        }
    }

}

一、数组的定义与作用

数组是一种批量存储数据类型相同的数据的容器，方便存取大量，提高存储效率，大大节省空间，简化代码。

比如：要存取某个学校的所有学生的课程成绩，如果每个学生的成绩都定义一个变量来存取，非常不现实，此时只能使用数组来存取

创建数组的代码：int[] score =new int[3000];

二、创建与使用数组

1.根据数组存储的行列数，可以分为一维数组与多维数组（二维数组）

2.关于一维数组：存储了一行数据的数组

说明：数组是一种比较特殊的变量，他包含有两部分的空间，一个是保存数组地址的栈内存（后进先出）另一个是用于保存数组内容（数据）的堆内存。

2.1一维数组的创建与使用

数组的创建方式有两种：一种是动态方式，另一种是静态

格式一：动态方式：

数组类型[]数组名称=new数据类型[数组的长度/大小];

比如：int[] ages = new int[100];

存取数组中的数据：

//存数据

数组名称[位置号/索引号]=数值；

//取数据

数组类型 变量名=数组名[位置号/索引号]；

说明：

（1）数组中存取的每一个数据又称为元素，

（2）每个元素在数组中是按顺序存放的，同时每个元素都有自己的位置号（索引号，下标）方便 找到他们

（3）每个元素的位置号（索引号）从0 开始，最大的索引号是数组的长度减1.

（4）在使用数组元素的时候，通过 数组名[索引号]来存取。

package Shangke;

public class day2222 {
    public static void main(String[] args) {
        //go1();
        go2();
    }
    //1.1一维数组的创建，动态方式
    public static void go1(){
        //1.1创建一个长度为10的整型数组，其中最大的索引号为10-1=9
        //其中的元素依次为ages[0],ages[1],ages[2],...ages[9],
        //所有元素有默认的初始值，此处初始值为0
        int[] ages=new int[10];
        //1.2存取元素的值
        ages[0]=16;
        ages[1]=18;
        ages[8]=20;
        ages[9]=17;
        System.out.println("ages[0]="+ages[0]);
        System.out.println("ages[8]="+ages[8]);
        // ages[10]=17;
        // ages[11]=17;
        int temp=ages[9]+2;
        ages[8]+=3;
        System.out.println("temp="+temp);
    }
}

格式二：静态方式：

数组类型[]数组名称={元素1，元素2，元素3，....}

或

数组类型[]

数组名称=new 数组类型[]{元素1，元素2，元素3，....}

public class day2222 {
    public static void main(String[] args) {
        //go1();
        go2();
    }
    //1.1一维数组的创建，动态方式
    public static void go1(){
        //1.1创建一个长度为10的整型数组，其中最大的索引号为10-1=9
        //其中的元素依次为ages[0],ages[1],ages[2],...ages[9],
        //所有元素有默认的初始值，此处初始值为0
        int[] ages=new int[10];
        //1.2存取元素的值
        ages[0]=16;
        ages[1]=18;
        ages[8]=20;
        ages[9]=17;
        System.out.println("ages[0]="+ages[0]);
        System.out.println("ages[8]="+ages[8]);
        // ages[10]=17;
        // ages[11]=17;
        int temp=ages[9]+2;
        ages[8]+=3;
        System.out.println("temp="+temp);
        //分步创建数组对象
        int[]ss;//声明数组
        //此数组中的元素new出后都有默认值为0
        ss=new int [8];
        ss[0]=20;
        ss[2]=22;
        ss[7]=25;
        System.out.println("ss[2]="+ss[2]);
        //输出默认值为0
        System.out.println("ss[4]="+ss[4]);
        //创建引用类型的数组，比如：String类型
        //m
        // String默认值为null。java中对象的默认值为null。可以作为对象是否存在有内容。
        String []names=new String [8];
        names [0]="小美";
        names [1]="Tom";
        names [2]="Ben";
        names [7]="小帅";
        System.out.println("names[7]="+names[7]);
        System.out.println("names[3]="+names[3]);
        //1.4创建double类型的数组,元素默认值都为0.0.
        double[]money =new double[5];
        money[0]=89999;
        money[1]=666688;
        money[2]=6757335.33f;
        System.out.println("money[1]="+money[1]);
        System.out.println("money[3]="+money[3]);
        //1.5所有数组的长度都用length属性获取
        System.out.println("数组ages的长度："+ages.length);
        System.out.println("数租ss的长度："+ss.length);
        System.out.println("数组names的长度："+names.length);
        //names.length-1就是names的最大下标，也就是最后一个元素
        System.out.println("names的最后一个元素："+names[names.length-1]);
    }
    //2.通过静态方式创建一维数组
    public static void go2(){
        //静态方式格式一
        int []level={56,23,90,11,21};
        //静态方式格式二
        int[]score;
        //错误score={56,23,90,11,21};
        score=new int[]{50,23,90,11,21};
        //从新给数组赋值或取值，操作和动态创建一样，都是用数组对象+下标去引用
        level[1]=39;
        level[3]=50;
        //拿到最大的下标区最大的一个元素的值
        level[level.length-1]=88;
        int max= level.length-1;
        level[max]=88;
        System.out.println("level[max]="+level[max]);
        System.out.println("score[max]="+score[score.length-1]);
        System.out.println("level的长度="+ level.length);
    }
}

三、数组的遍历

数组存储了大量的数据，经常会需要拿到所有元素的值，获取所有元素的操作法，成为遍历；

说明：遍历需要获取数组的长度，进而拿到最大下标；

数组长度=数组对象.length

数组最大下标=数组长度-1

遍历数组中需要用到for循环语句，可以从前往后，也可以的从后往前遍历数组元素

package Shangke;

public class day2223 {
    public static void main(String[] args) {
        // fore();
           go();
    }//main

    //1.遍历整型数组
    public static void fore() {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8,};
        //数组元素的所有下标
        // //每三个元素输出一行
        for (int i = 0; i <= arr.length - 1; i++) {
            System.out.print(arr[i] + "");
            //从前往后遍历，i就是数组元素的所有下标
           
            if ((i + 1) % 3 == 0) {
                System.out.println();
            }
        }//fore1
        System.out.println();
        //从后往前遍历
        for (int i = arr.length - 1; i >= 0; i--) {
            System.out.print(arr[i] + "");
        }
    }

    //2.遍历字符串数组
    public static void go() {
        String[] hero = {"青铜", "白银", "王者", "铂金", "钻石"};
        // String str ="abcde";
        //    str.length;
        //正序输出
        for (int i = 0; i <= hero.length - 1; i++) {
            System.out.print(hero[i]);
        }
            System.out.println();
            System.out.println("----------------");
//2.反序输出
        for (int i = hero.length - 1; i >= 0; i--) {
            System.out.print(hero[i] );
            }


public static void go3(){
Scanner sc = new Scanner(System.in);
String[] names=new String[5];
//循环赋值
for(int i=0;i<names.length;i++){
System.out.print("请输姓名：");
names[i]=sc.next();
}
//遍历字符串数组
for(int i=0;i<names.length;i++){
System.out.print(names[i]+" ");
}
//关闭
sc.close();
}
}
    }
}

四、数组的应用与Arrays工具

4.1数组的应用

遍历数组，数组元素的最大最小值得元素，求和，求平均，找某个元素等

package Shangke;

import java.util.Arrays;

public class day2225 {
    public static void main(String[] args) {
               play();
    }
    //遍历数组，数组元素的最大最小值得元素，求和，求平均，找某个元素等
    public static void play(){
        int[] arr={1,2,3,4,5,7,6,8,9,10};
       //找最大最小值
               findmaxmin(arr);
                //  calcSumAvg(arr);//求和
          //排序
            dispArr(arr);
            Arrays.sort(arr);
            dispArr(arr);
    }
    //找到数组中最大最小值并输出他们
    //如果有返回值则void应该改为int
    public static void findmaxmin(int[]arr){//arr是形参，可以和之后实参名相同
       //1,2,3,4,5,6,7,8,9,10
       //那第一个元素，作为计较参考值
        int max=arr[0];
       // int maxIndx=0
        int min =arr[0];
        for(int i =0;i< arr.length;i++){
            if (max<arr[i]){
                max=arr[i];
            }
            if (min>arr[i]){
                min=arr[i];
            }
        }
        System.out.println("最小值是："+min);
        System.out.println("最大值是："+max);
    }
    //求元素的和及平均值
    public static void calcSumAvg(int[] arr) {
        int sum=0;
        for(int i =0;i< arr.length;i++){
            //sum=sum+arr[i];
            //求和
            sum=sum+arr[i];
        }//for
        System.out.println("和值："+sum);
        System.out.println("平均值："+sum/ arr.length);
    }

    //专门遍历数组
    //传一个数组对象，作为形参
    public static void dispArr(int[]arr){//传一个数组变量参数
        for(int i =0;i< arr.length;i++){
            System.out.print(arr[i]+"");
        }
        System.out.println();
    }

    }

4.2 Arrays工具使用

从大到小排序：代码如下

int[] arr ={12,10,9,14,15};

Arrarys.sort(arr);

LH495562
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java数组结构图
11-15
对数组的总结和分析，通过这个结构记住它，在开发的过程中使用
java数组
04-20
Java数组是程序设计中不可或缺的基础概念，它是一种数据结构，允许我们存储同类型的多个元素。在Java中，数组是对象，具有固定的大小，一旦创建，其长度就不能改变。本篇文章将深入探讨Java数组的各个方面，包括创建...
Java数组
热门推荐
qq_63762763的博客
03-27 4万+
一. Java数组01 1.数组的定义 数组是相同类型数据的有序集合。 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。 其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们。 二.Java数组02 1.数组的声明与创建 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法: ``··dataType[] arrayRefVar;//首选的方法 或 dataType arrayRefVar[];//效果相同，但不是首选方法 Java语言使用
Java 数组
Naion的博客
03-22 2万+
本文章介绍了Java中数组的一些概念和一些方法的使用。
java数组倒序
weixin_46409629的博客
03-24 2621
java数组倒序
初始java数组
AgoniTop的博客
03-24 4844
1.初始化定义 2.数组的三种打印方式 3.数组引用null 4.浅谈引用变量的影响 5.与数组相关的字符串操作 以及javaJVM内存简单介绍 6.浅谈二维数组与C的区别
Java 数组删除一个元素
sxlzs_的博客
09-06 2479
根据下标删除一个数组元素。
java数组操作
wmy01234的博客
07-25 2151
java数组操作
Java数组类型
HHYZBC的博客
04-26 4919
数组的概述 数组(Array)，是多个相同类型数据按一定顺序排列 的集合，并使用一个名字命名，并通过编号的方式 对这些数据进行统一管理。 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括 基本数据类型和引用数据类型。 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是 这块连续空间的首地址。 数组的长度一旦确定，就不能修改。 我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。 数组的分类： 按照维度：一维数组、二维数组、三维数组、… 按照元素的数据类
JAVA数组去重方法
weixin_55076626的博客
03-20 1万+
当判断两个元素是否相同时，HashSet会先调用hashCode()方法比较它们的哈希值，如果哈希值不同，那么这两个元素也就不相同了；如果哈希值相同，还会继续调用equals()方法比较它们的值，如果equals()方法返回true，那么这两个元素即被视为相同元素，新元素就不能被添加进去。当向HashSet中添加元素时，HashSet会先计算元素的hashCode值，然后根据hashCode值将元素放入不同的桶(bucket)中。当多个元素放入同一个桶中时，它们会以链表的形式存储。
Java数组常用操作
Lilip_的博客
04-19 7677
 1.数组长度  2.数组填充  3.数组复制  4.数组比较  5.数组排序  6.在数组中搜索指定元素  7.把数组转换成字符串 数组的常用操作包括数组的充、复制、比较、排序等。Java提供了相应对数组的操作的系统函数（方法），利用系统函数（方法）可以对数组进行各种操作。 1、数组长度 数组长度指的是数组的大小，也就是数组包含元素的个数。如果想获得数组的长度，可以用其本身的 length 属性获得。使用方法就是在数组名后加 “.length”。代码如下： public class Main
Java数组输出
weixin_44824428的博客
12-28 2661
Java数组输出
java数组遍历 删除remove(示例代码)
09-04
在Java编程中，数组是一种基本的数据结构，用于存储固定数量的相同类型的数据。然而，当涉及到动态添加或删除元素时，数组并不方便，因为它在创建时必须指定长度，并且一旦创建，长度就不能改变。这时，我们可以转向...
Java数组练习题(带答案).doc
03-15
Java数组是Java编程语言中的基本数据结构之一，用于存储固定数量的同类型元素。了解和熟练掌握数组的使用是学习Java的重要环节。本篇练习题涵盖了数组的基本概念、操作和异常处理，下面是针对题目中涉及知识点的详细...
初识JAVA数组
09-04
【初识JAVA数组】 在Java语言中，数组是一种基本的复合数据类型，它代表了有序数据的集合。数组的关键特性是其元素具有相同的类型，并且可以通过一个数组名称和下标来唯一地确定每个元素的位置。Java支持一维数组和...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 480
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 572
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 686
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1197
JVM-垃圾回收与内存分配
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1191
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值