数组

最新推荐文章于 2022-09-30 08:47:41 发布
最新推荐文章于 2022-09-30 08:47:41 发布
阅读量328 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42865575/article/details/81708705
版权

数组的定义

  • 引言：为什么定义数组？
  • 方法不能返回多个值，将欲返回的多个值放在数组中，就可以间接实现返回多个值的效果。
public double getInfo(){
    double weight = 95.5;       
    double height = 1.69;
    return weight, height;//出错
}

1、相同数据类型——数据在内存中的数据类型。
2、基本数据类型元素构成的数组也是引用类型。

int [] ageArray = {22,34,56};//存放int类型数据的数组
double [] priceArray = new double[]{9.9,1};//存放double类型数据的数组，输出的1为1.0（double）
String [] nameArray = new String[3];//存放String类型数据的数组


----------
    double [] scores = new double[3];
    scores[0] = 99.0;
    scores[1] = 100.0;
    scores[2] = 88;
    System.out.println(scores[2]);//输出88.0，即内存中存储的数据是同一个类型——double类型

1、 定义数组

  • 定义：数组是相同数据类型的数据按顺序组成的一种引用数据类型。

2、声明数组

  • 声明一位数组：数组元素数据类型 [ ] 数组名;
    double [] scores;
  • 声明二维数组：数组元素数据类型[ ][ ] 数组名;
    String [] [] accounts;

3、实例化数组

——声明数组仅仅给出了元素的数据类型和数组名字，要使用数组就必须为它分配内存空间，即实例化数组。当实例化一个数组时就申请了一段连续的内存空间存储数组中的元素。

  • 数据分配内存空间时指定数组长度
  • `数组名 = new 数组元素数据类型 [数组元素个数];
  • 这种方式实例化数组后系统会为数组中的元素赋默认值，例如float数组中元素的默认值是0.0f，引用类型数组中的元素的默认值是null。
  • String [] nameArray;
    nameArray= new String[3];
    等价于
    String [] nameArray=new String [3];

一维数组

public class Test {
    public static void main(String[] args) {
        String [] nameArray;//声明数组
        nameArray=new String[3];//实例化数组，表明可以存储三个数据
    //上面两个式子等价于 String [] nameArray=new String [3];
        System.out.println(nameArray[2]);//输出null


----------


        double [] scores = new double[5];
        scores[0] = 3.4;
        scores[1] = 3.6;
        scores[2] = 4.0;
        scores[3] = 5.5;
        scores[4] = 6.6;
        System.out.println(scores[2]);//输出4.0
    }
}

二维数组

public class Test2 {
    public static void main(String[] args) {
        //double [][] wages=new double [2][30];
        double [][] wages;
        wages = new double [2][30];//表明有两个一维数组，每个一维数组中可存储30个数据
        System.out.println(wages[0][14]);//输出0.0
    }
}


----------
public class Test2 {
    public static void main(String[] args) {
        int [][] scores;
        scores = new int [2][];//实例化数组，有两个一维数组
        scores[0]=new int [2];//第一个一位数组中可存储2个数据
        scores[1]=new int [30];//第二个一维数组中可存储30个数据
        scores[1][5]=24;//对第二个一维数组中的第六个元素赋值
        System.out.println(scores[1][5]);//输出24
    }
}


----------
  • 穷举法
  • int [] scores = {99,100,88,96,66};
    等价于
    int [] scores = new int [] {99,100,88,96,66}
    一维数组
public class Test2 {
    public static void main(String[] args) {
        int [] scores1 = {99,100,88,96,66};
        int [] scores2 = new int [] {65,77,88,90,47}
        System.out.println(scores1[3]);//输出96
        System.out.println(scores2[3]);//输出90
    }
}

二维数组

对称二维数组
public class Test2 {
    public static void main(String[] args) {
        int [][] scores1 = {{99,100,88},{96,66,77}};;
        int [][] scores2 = new int [][] {{98,80,88},{78,69,85}};;
        System.out.println(scores1[1][1]);//输出66
        System.out.println(scores2[0][2]);//输出88
    }
}

非对称二维数组
public class Test2 {
    public static void main(String[] args) {
        int [][] scores1 = {{99,100,},{96,66,77}};;
        int [][] scores2 = new int [][] {{80,88},{78,69,85}};;
        System.out.println(scores1[1][1]);//输出66
        System.out.println(scores2[0][0]);//输出80
    }
}

注意：

public static void main(String[ ] args){
        int[ ] scoreArray = new int[5];
        scoreArray = {60, 80, 90, 70, 85};//错误
        int[ ] ageArray;
        ageArray = {21, 16, 28};//错误
}

上面这种穷举法只能用于初始化数组，即必须和声明数组代码放在一条语句中完成，

正确
public static void main(String[ ] args){
        int[ ] scoreArray = {60, 80, 90, 70, 85};
        int[ ] ageArray = {21, 16, 28};
}

数组的操作

操作数组元素

  • 数组中的数据通过数组名和数组下标来操作数据，下标从0开始：
  • 为元素赋值
public class Test2 {
    public static void main(String[] args) {
        double [] scores = new double[5];
        scores[0] = 3.4;
        scores[1] = 3.6;
        scores[2] = 4.0;
        scores[3] = 5.5;
        scores[4] = 6.6;
    }
}
  • 获取元素值
public class Test2 {
    public static void main(String[] args) {
        double [] scores = new double[5];
        scores[0] = 3.4;
        scores[1] = 3.6;
        scores[2] = 4.0;
        scores[3] = 5.5;
        scores[4] = 6.6;
        System.out.println(scores[4]);//输出6.6
    }
}

遍历数组元素

  • 由于数组内存空间是连续的且从下标0开始，所以可以使用for循环遍历数组。
传统for循环

一维数组

public class Test2 {
    public static void main(String[] args) {
        int [] numbers = new int[] {21,99,3,1024,16};
        System.out.println(numbers.length);//获取数组长度5
        for(int i=0;i<numbers.length;i++) {
            System.out.print(numbers[i]+",");
            //遍历数组，不加ln表示不换行，以逗号分隔
        }
    }
}

二维数组

public class Test2 {
    public static void main(String[] args) {
        double [][] scores = {{100.0,88.7},{99.8,66.0,78.5}};
        for(int i=0;i<scores.length;i++) {//获取有几个一维数组，有 2个
            double [] score = scores[i];//将每个一维数组定义在新的一维数组中
            for(int j=0;j<score.length;j++) {
                System.out.print(score[j]+",");//输出不同一位数组中的值
            }
        }
    }
}
加强for循环####

语法：
for (集合中元素数据类型 元素名 : 数组名) {
}

一维数组

public class Test2 {
    public static void main(String[] args) {
        int [] numbers = new int[] {21,99,3,1024,16};
        for(int number:numbers) {
            System.out.println(number);//注意不加[i];
        }
    }
}

二维数组

public class Test2 {
    public static void main(String[] args) {
        double [][] scores = {{100.0,88.7},{99.8,66.0,78.5}};
        for(double [] score:scores) {
            for(double sco:score) {
                System.out.println(sco);//不加[i]
            }
        }
    }
}

数组越界

public static void main(String[ ] args) {
    int[ ] scores = new int[1];//总共有可存储一个数据
    scores[0] = 90;
    scores[1] = 85;
    System.out.println(scores[1]);
}

值传递与引用传递

值传递

  • 值传递（pass by value）是指在调用函数时将实际参数 复制 一份传递到函数中，这样在函数中如果对 参数 进行修改，将不会影响到实际参数。
public class array2 {
         //将参数复制到函数中，无法通过函数改变参数
        public static void main(String[] args) {
            int x=6;
            test(x);
            System.out.println(x);//输出6
        }
        public static void test(int i) {
            System.out.println(i);//输出6
            i=0;
            System.out.println(i);//输出0
        }
}

引用传递

  • 引用传递（pass by reference）是指在调用函数时将实际参数的地址 直接 传递到函数中，那么在函数中对 参数 所进行的修改，将影响到实际参数。
public class array2 {
    //将实际参数的地址传递到函数中去，通过外部函数在此地址的改变参数即会影响参数
    public static void main(String [] args) {
        int [] numbers= {6};
        print(numbers);
        System.out.println(numbers[0]);//输出2
    }
    public static void print(int [] i) {
        i[0] = 2;
    }
}

数组的排序

冒泡排序

  • 冒泡排序法是最基本的排序法之一，冒泡排序法的运行机制是通过循环遍历元素并调整相邻元素顺序来实现的一种简单排序方法。
  • 冒泡排序的实质是 相邻两个元素比较，然后按照升序或降序调换位置。
public class Test2{
    public static void main(String [] args){
        int [] array={21, 99, 3, 1024, 16};//升序排列
        for(int loopTime=1;loopTime<array.length;loopTime++){//只是控制内部for循环的次数
            for(int i=0;i<array.length-loopTime;i++){
            //该for循环每循环一次就会将较大的数据放在适当的位置，
            //比如loopTime=1；则将最大数据放在最后;loopTime=2；则将第二大数据放在倒数第二个元素位置；
            //array.length-loopTime:从提高代码的性能角度出发，减少该循环“多余”的循环次数
                int currentData = array[i];//当前遍历出来的数据
                int nextData = array[i+1];//当前数据下标对应的下一个元素的数据
                if(currentData>nextData){//如果当前元素大于其后面的元素，则意味着需要调换两个元素之间的位置
                    array[i] = nextData;
                    array[i+1]=currentData;
                }
            }
        }
        for(int data:array){
            System.out.print(data+" ");
        }
    }
}

插入排序

  • 每循环一次都将一个待排序的元素所对应的数据按其顺序大小插入到前面已经排序的序列的合适位置，直到全部插入排序完为止，其难点在于如何在前面已经排好序的序列中找到合适的插入位置。该排序方法有很多，比如直接插入排序、二分插入排序、希尔排序等等。
        //{1,2,4,5,3}————>{1,2,3,4,5}
public class Test2{
    public static void main(String [] args){
        int [] numbers = {1,2,6,5,3,4,5};
        for(int i=2;i<numbers.length;i++) {
            int data = numbers[i];
            //找位置
            int j=0;
            for(;j<i;j++) {
                if(numbers[j]>numbers[i]) {
                    break;
                }
            }

            if(j==i) {
                continue;
            }
            //做移动
            for(int k=i;k>j;k--) {
                numbers[k]=numbers[k-1];
            }
            //插入
            numbers[j]=data;//数据给插入的位置
        }

        for(int number:numbers) {
            System.out.println(number);
        }
    }
}
  • 插入排序的实质：
    1、将数组分为有序区和无序区，定义一个标记无序区第一个元素的定位变量，
    2、将该元素与前面的有序区内元素遍历比较，找到该元素应该插入位置，
    3、然后将应插入位置到待插入元素所在位置之间的元素后移一位，
    4、最后再将待插入元素插入到应插入的位置，有序区扩增一位，无序区减少一位，定位变量再次后移，锁定后面无序区第一位元素位置。
public class Test2{

    public static void main(String [] args){
        int [] array={1,2,6,7,2,9,12,2};//升序排列
        for(int i=1;i<array.length;i++){//i为待排序数据的下标，由于将第一个元素是有序的，所以i从1开始；i<array：这样才能遍历完后续数组，进而实现全部排序；
            int willSortData=array[i];//将待排序数据保存到变量willSortData中
            int j=0;
            /*
             *查找待插入数据“应该”插入的下标位置
             */
            for(;j<i;j++){//j<i:和待排序数据前面（i）的所有元素进行比较，以找到“应该”插入的下标位置。说明：不能这样写j<=i，因为无需自己和自己比对
                if(willSortData<array[j]){//如果条件成立意味着待插入数据小于其前面的某个元素值
                    break;//当if条件成立时就找到了该待插入数据“应该”插入的下标位置，所以这时必须终止循环
                }
            }//for循环执行结束意味着找到了待插入数据“应该”插入的下标位置

            if(i==j){//i与j相等意味着不用排序，下面代码也不用执行
                continue;//停止不用排序这次循环，进入下次循环
            }

            /*
             *下面循环用于元素后置
             */
            for(int k=i;k>j;k--){//int k=i:待插入数据所在位置就是元素后移开始的下标位置；k>j：待插入数据“应该”插入位置（j）就是元素后移结束位置
                array[k]=array[k-1];//元素后置
            }

            /*
             *下面代码用于将待插入数据插入到“应该”插入的下标位置
             */
            array[j]=willSortData;
        }//该循环体每循环完一次就代表着本次待插入数据已经和前面元素是有序的了

        for(int data:array){
            System.out.print(data+" ");
        }
    }
}

数组元素查找

二分法查找

  1. 搜索数据与有序数组（比如升序）中间元素比较以确定在中间元素左边还是右边，
  2. 如果在右边，则调整最小搜索索引值，然后进入下次循环；
  3. 如果在左边，则调整最大搜索索引值，然后进入下次循环；
public class Test2{

    public static void main(String [] args){
        int [] numbers = {1,4,6,7,9,12};
        int data =4;
        int low=0;
        int high=numbers.length-1;
        while(low<=high) {
            int middle=(low+high)/2;
            if(numbers[middle]<data) {
                low=middle+1;//+1是因为middle所代表的值不包括在内
            }else if(numbers[middle]>data) {
                high=middle-1;//同理
            }else {
                System.out.println(middle);//输出1
                break;
            }
        }
    }
}
奈奈宇宙
关注
java 二维数组存对象_面向对象深入和二维数组
weixin_31520593的博客
02-23 768
【008】1. 抽象类和抽象方法(1) 简述抽象方法的特征1、抽象方法只有声明，没有方法体并且以分号结尾2、抽象方法只能声明在抽象类中(含有抽象方法的类必须是抽象类)3、抽象类中可以包含0个或多个抽象方法4、抽象方法必须被子类实现5、如果子类不能实现父类中的抽象方法，那么子类也必须是抽象类总结：abstract可以修饰类和方法(2) 什么情况下使用抽象方法?通过抽象方法，可以避免自雷设计的随意性，...
二维数 组
ya985860612的专栏
12-04 792
package cn.jbit.ch09; public class Test2 { public static void main(String[] args) { // 二维数组 String [][] person=new String[9][5]; person[0][0]="张三"; person[0][1]="10"; person[0][2]="女";
Java中的数组（详细案例）
菠萝吹雪爱Java的博客
09-30 1303
Java中数组常用的方法案例
java入门基础(四)
qq_45798550的博客
08-15 2303
（一）对象和类 类:类是对象的抽象(不存在) 对象:对象是类的实现(具体存在) 现实生活中先有对象再有类 Java中先有类再有对象 面向对象:是一种思想,在开发过程中关注于对象进行开发 类中相同的行为和特征在Java中如何表示 特征:变量 行为:方法 类的定义: 1.public class 类名{} 2.定义成员变量 格式:public 数据类型 变量名 3.定义成员方法 格式:public 返回值数据类型 方法名称(参数){} 类的使用(对象): 1.通过类创建对象 格式:类名 对象名=
二维数组动态赋值
qq_43178688的博客
02-18 4086
```java import java.util.Scanner; public class Test2 { public static void main(String[] args) { Scanner sc = new Scanner(System.in); //输入数组的行和列 System.out.print("请输入数组行...
Java数组
热门推荐
qq_63762763的博客
03-27 4万+
一. Java数组01 1.数组的定义 数组是相同类型数据的有序集合。 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。 其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们。 二.Java数组02 1.数组的声明与创建 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法: ``··dataType[] arrayRefVar;//首选的方法 或 dataType arrayRefVar[];//效果相同，但不是首选方法 Java语言使用
三维数组操作_labview三维数组_labview_三维数组_
10-02
在LabVIEW编程环境中，三维数组是一种非常重要的数据结构，它能够有效地存储和处理大量多维数据。本篇文章将深入探讨如何在LabVIEW中创建、操作和应用三维数组，以实现如标题和描述所述的功能。 首先，让我们理解...
读取二维数组所有数据_labview读取数组_
09-29
在LabVIEW编程环境中，二维数组是一种常见的数据结构，用于存储多行多列的数据。本教程将深入探讨如何在LabVIEW中有效地读取二维数组的所有数据，这对于数据分析、处理和可视化至关重要。 首先，让我们理解二维数组...
C语言数组入门之数组的声明与二维数组的模拟
12-31
语言中指针与数组这两个概念之间的联系是密不可分的，以至于如果不能理解一个概念，就无法彻底理解另一个概念。 C语言中的数组值得注意的地方有以下两点： C语言中只有一维数组，而且数组的大小必须在编译期就作为一...
python将三维数组展开成二维数组的实现
01-21
这篇文章尝试用“曲线救国”的方法来解决二维数组叠加成三维数组的问题。 但天道有轮回，苍天绕过谁。好不容易把数组叠加在一块儿了，新的需求又出现了：将三维数组展开成二维数组。有借有还，再借不难。今天就来...
多维数组的运算
01-06
一、多维数组 简单来讲，多维数组就是“数字的集合”，数字排成一列的集合、排成长方形的集合、排成三维状或者（更加一般化）N 维状的集合都称为多维数组。 如上所述，数组的维数可以通过 np.dim()函数获得。此外，...
Java自学习day6-二维数组的创建、长度、遍历
加油鸭
04-18 200
二维数组的使用 1.理解： 对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。 其实，从数组底层的运行机制来看，其实没有多维数组。 2. 二维数组的使用: ① 二维数组的声明和初始化 ② 如何调用数组的指定位置的元素 ③ 如何获取数组的长度 ④ 如何遍历数组 ⑤ 数组元素的默认初始化值 :见 ArrayTest3.java ⑥ 数组的内存解析 :见 ArrayTest3.java public class ArrayTest2 { public
spark_3_2_0-master-3.2.3-1.el7.noarch.rpm
09-16
Ambari+Bigtop 一站式编译和部署解决方案 https://gitee.com/tt-bigdata/ambari-env
浙大城市学院在河南2021-2024各专业最低录取分数及位次表.pdf
09-16
全国各大学在河北2021-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
第4周玩转案例分析.pdf
09-16
第4周玩转案例分析
基于MATLAB的教室人数统计系统源代码+使用说明，带有丰富的人机交互GUI界面
09-16
基于MATLAB的教室人数统计，带有丰富的人机交互GUI界面。实现教室人数的计数统计，进而统计出勤率，上课认真听讲的比例。原先预设总人数，未出勤或者书本遮住脸部、趴着玩手机等必然无法采集到人脸，从而对应数量缺失，得出出勤率或听讲率。该课题采用肤色原理进行人脸定位和人脸分割。本课题中，为了界面GUI的美观，刻意将分割出的人脸单独显示在GUI对应的axes里
java-ssm+jsp药品销售网站系统实现源码(项目源码-说明文档)
09-16
药品销售系统的主要使用者分为管理员、用户和医生，实现功能包括管理员；管理员个人中心、用户管理、医生管理、药品信息管理、药品分类管理、订单配送管理、系统管理、订单管理，用户；个人中心、订单配送管理、订单管理，医生：个人中心、药品信息管理、药品分类管理，前台首页：首页、药品信息、我的、跳转到后台、购物车、客服等功能。 项目关键技术 开发工具：IDEA 、Eclipse 编程语言: Java 数据库: MySQL5.7+ 后端技术：ssm 前端技术：jsp 关键技术：jsp、spring、ssm、MYSQL、MAVEN 数据库工具：Navicat、SQLyog
AI健身体能测试之基于paddlehub实现引体向上计数个数统计源码+模型+视频例子+视频结果文件.zip
最新发布
09-16
使用环境： paddlepaddle==2.4.2 paddlehub==2.4.0 理论上安装最新paddle环境也行。 实现的细节参考博文：https://blog.csdn.net/FL1623863129/article/details/142307043
C语言指针数组与数组指针详解
"数组指针和指针数组是C语言中两个重要的概念，它们在内存布局和使用上有显著差异。理解这两个概念对于深入学习C语言至关重要。本文将详细讲解它们的区别。 一、指针数组和数组指针的内存布局 1. 指针数组：指针...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值