java Array数组_1

于 2022-06-27 11:36:55 发布
阅读量231 收藏 1
点赞数
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41765786/article/details/125478341
版权

文章目录

一、数组的基本知识

1.1 引入数组

功能：从键盘输入10个学生的分数，求和，并求平均分，输出。
思路1：定义一个变量sum、avg，分别存储总分、平均分；定义10个变量score1、score2、score3…score10，分别存储一个分数。
缺点：定义的变量太多。
在这里插入图片描述
思路2：定义一个变量sum、avg，分别存储总分、平均分；定义1个变量score，依次存储一个分数。借助循环，完成功能。
缺点：不能同时存储10个分数。
在这里插入图片描述
思路3：定义一个变量sum、avg，分别存储总分、平均分；定义一个数组，由10个元素组成，每个元素相当于是1个变量，总体构成一个更大的变量。
在这里插入图片描述
优点：变量只有一个scoreArr，也可以同时存储10个分数
数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素element，每个元素可以通过一个索引index（下标）来访问它们。数组的基本特点：
1. 长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2. 在内存中分配连续的空间，每个元素占用的空间大小是相同的
3. 同一个数组其元素的类型必须是相同类型，不允许出现混合类型。
4. 数组类型可以是任何数据类型，包括基本类型和引用类型。
5. 数组变量属于引用数据类型

1.2 声明数组

type[] arr_name;  //方式一（推荐使用这种方式）
type  arr_name[]; //方式二

public class Test1{
	public static void main(String[] args){
		* 数组 多个性质相同或者相近的数据的集合  array
        * java数据类型  基本数据类型 八个
        *              引用类型     String  array
        * */
        /*
        * 数组的声明和创建
        * int[] arr; 推荐
        * int ar[];
        * 数组中的每个数据叫做元素
        * */
        int[] arr={5,7,56,85,13,54,95,51};
                // 0 1  2  3  4  5  6  7
        // 数组的长度属性 数组中能装多少个元素 长度属性是int值 数组的长度一旦创建就不可以改变了
        int l =arr.length;
        System.out.println(l);
        // 数组拥有索引属性 索引 index 就是元素的编号 从0开始,从前向后依次递增
        // 根据索引或者数组中的指定的元素
        int e=arr[5];
        System.out.println(e);
        // 数组中的元素是可以修改的
        arr[5]=100;
        System.out.println(arr[5]);

        for (int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

	}
}

注意事项
 声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。
 声明一个数组的时候并没有数组真正被创建。
 构造一个数组，必须指定长度。

1.3 数组的初始化

数组的初始化方式总共有三种：静态初始化、默认初始化、动态初始化。

1 静态初始化
声明数组、分配空间、元素赋值合并在一起实现。

int [] scoreArr = new int[] {10,20,30,70,60,79,45,34,23,100} ;
int[] scoreArr = {10,20,30,70,60,79,45,34,23,100};
int[] scoreArr = new int[10]{10,20,30,70,60,79,45,34,23,100};//该方式是错误的

2 默认初始化

int a2[] = new int[2];    //默认值是0,0
boolean[] b = new boolean[2];   //默认值： false,false
String[] s = new String[2];    //默认值：null,null

3.动态初始化
元素的赋值和声明数组、分配空间分开实现

int []  scoreArr = new int[10];
scoreArr[0] = 56;
scoreArr[1] = 78;
scoreArr[9] = 100;

测试代码
public class Test2 {
    public static void main(String[] args) {
        // 静态初始化  静态创建 在创建数组的时候支架将元素的值自定义指定
        //double[] arr={10.1,4.56,6.12,3.14,5.23,6.0,7.1};//声明和创建必须在同一行
                    //  0    1     2   3    4   5    6
        double[] arr;
        arr=new double[]{10.1,4.56,6.12,3.14,5.23,6.0,7.1};// 声明和创建可以分开
        //double[] arr =new double[10]{1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9,10.1};// 错误的
        for (int i = 0; i <arr.length ; i++) {
            System.out.println(arr[i]);
        }

        // JVM自动初始化 动态创建 创建数组时,仅仅规定数组的长度(容量) 元素的值交给JVM自动初始化
        /*
        * byte short int long  0
        * char \u0000 ' '
        * float double 0.0
        * boolean false
        * String 引用类型  null 空引用
        * */
        char[] carr=new char[10];
        for (int i = 0; i <carr.length ; i++) {
            System.out.println(carr[i]);// \u0000
        }
        String[] iarr=new String[10];
        for (int i = 0; i < iarr.length; i++) {
            System.out.println(iarr[i]);
        }
    }
}

1.4 数组内存分配

1. 声明数组
在方法中声明的基本数据类型的变量,仅仅占用栈内存的空间,引用类型的数据创建时,会占用堆内存,但是声明变量不会在堆内存中产生空间的占用

public static void main(String[] args) {
    String s;
    int[] arr;
}

在这里插入图片描述
2.给数组分配空间
1基本数据类型的变量在方法中创建完毕后,仅仅占用栈内存,引用类型要占用两个空间,堆内存上存放数据,栈内上引用堆内存上的地址
2 数组的元素在内存上是连续的
3 栈内存上存储的是数组首元素的地址

public static void main(String[] args) {
    int i=10;
    String s="asdf";
    int[] arr={5,7,1,6,8};
}

在这里插入图片描述

3.给数组元素赋值

public static void main(String[] args) {
    int i=10;
    String s="asdf";
    int[] arr=new int[5];
    
}

在这里插入图片描述

arr[0]=5;
arr[1]=6;
arr[2]=7;
arr[3]=3;
arr[4]=1;

在这里插入图片描述

总结：
1.栈内存

  1. stack memory
  2. 存放局部变量、数组名，没有默认值
  3. 每调用一个方法会开辟一个栈帧，方法执行完立刻回收该栈帧，后进先出

2.堆内存

  1. heap memory
  2. 存放真正的数组元素，有默认值
  3. 方法执行完毕后不会立刻释放资源，由垃圾回收器负责回收；程序员不用操心 但时间不确定

3.数组元素的默认值
在这里插入图片描述

1.5 数组的遍历

JDK1.5提供了增强的for循环功能，可以简化遍历数组的操作，但是不能进行和索引相关的操作，遍历数组过程中不能修改数组中某元素的值。功能其实没有增加。
for循环遍历数组

public class Test3{
	public static void main(String[] args){
		int[] arr = {5,4,3,1,9,2,7,8,0,6};
		//普通的for循环遍历
		for(int i= 0;i<arr.length;i++){
			system.out.printIn(arr[i]);
		}
	}
}

foreach循环遍历数组

public class Test2 {
    public static void main(String[] args) {
        String[] arr={"asdf","qwer","zxcv","abcd"};
        double[] darr={10.1,2.3,5.6,3.8,4.7};

        // 1.5 增强型for循环   foreach循环
        for(String str:arr){
            System.out.println(str);
        }

        for(double dou:darr){
            System.out.println(dou);
        }
    }
}

foreach循环使用特征

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

        double[] darr={10.1,2.3,5.6,3.8,4.7};
        /*
        * 1 for循环通过索引定位元素,可以通过索引修改元素值的
        * 2 foreach 通过中间变量临时存储元素的值,修改中间变量不会对元素造成修改
        * 3 foreach 语法更加简单,没有索引
        * 4 当我们仅仅需要数组中的每个元素,不需要修改元素,也不用索引做其他的事,就可以使用 foreach循环
        * */

        // 修改数组中的元素
        /*for (int i = 0; i < darr.length; i++) {
            darr[i]*=10;
        }*/
        for (double v : darr) {
            v*=10;
        }
        // 遍历数组
        for(double value:darr){
            System.out.println(value);
        }
    }
}

1.6 常见异常

 NullPointerException：空指针异常
 ArrayIndexOutOfBoundsException：数组索引越界异常（超过下界或者上界）

public class Test3 {
    public static void main(String[] args) {
        /*
        * 1 动态创建数组时,中括号中放的是数组的长度(容量),容量一定是int类型 和数组的具体类型无关
        * 2 数组的长度不能是负数,会出现NegativeArraySizeException(创建时)
        * 3 如果数组赋值为null 则代表数组没有在堆内存上创建,此时使用数组会出现异常NullPointerException
        * 4 索引如果越界会出现ArrayIndexOutOfBoundsException
        * */

        String[] arr ={"asdf","qwer","zxcv","aaaa","bbbb","cccc"};
       /* System.out.println(arr[-1]);*/

        for (int i = 0; i <arr.length ; i++) {
            System.out.println(arr[i]);
        }
    }
}

二、数组的常见应用方式

2.1 数组合并

将两个数整数数组合并成一个数组

public class Test4 {
    public static void main(String[] args) {
        int[] arr1={1,2,3,4};
        int[] arr2={11,22,33,44,55,66,77,88,99,1010,2020};
        int[] arr3=combain(arr1,arr2);
        // 遍历数组3
        for (int i : arr3) {
            System.out.println(i);
        }
    }
    // 定义一个方法,将两个整数数组合并并返回
    public static int[] combain(int[] arr1,int[] arr2){
        int[] arr3=new int[arr1.length+arr2.length];

        // 遍历数组1 将元素复制到arr3
        for (int i = 0; i <arr1.length ; i++) {
            arr3[i]=arr1[i];
        }
        // 遍历数组2 将元素复制到arr3
        for (int i = 0; i <arr2.length ; i++) {
            arr3[arr1.length+i]=arr2[i];
        }

        return arr3;
    }
}

2.2 查询数组元素

可以查询指定索引的元素的内容，直接按照索引定位即可；
可以按照指定内容元素的索引，需要逐个比较，直到找到为止，或者比较到数组的末尾也没有找到。

public class Test1 {
    public static void main(String[] args) {
        char[] arr={'a','c','d','g','v','d','c','a','v','x'};
        char element='v';

        int index =firstIndexOf(arr,'v');
        System.out.println(index);
        int index2=lastIndexOf(arr,'v');
        System.out.println(index2);

        // 判断一个数组中是不是有且仅有一个指定的元素
        if(index==-1){
            System.out.println("没有");
        }else if(index==index2){
            System.out.println("一个");
        }else{
            System.out.println("至少两个");
        }
    }
    // 定义一个方法, 在给定数组中查找目标元素,如果找到了 返回元素的第一次出现的索引 如果没找到返回-1
    public static int firstIndexOf(char[] arr,char element){
        for (int i = 0; i <arr.length ; i++) {
            if(arr[i]==element){
                return i;
            }
        }
        return -1;
    }
    // 定义一个方法, 在给定数组中查找目标元素,如果找到了 返回元素的最后一次出现的索引 如果没找到返回-1
    public static int lastIndexOf(char[] arr,char element){
        for (int i = arr.length-1; i>=0 ; i--) {
            if(arr[i]==element){
                return i;
            }
        }
        return -1;
    }
}

总结1：数组按照索引查询数据，效率最高；不管索引是哪个，花费的时间是一样的；
原理：分配连续的空间，且每个元素的空间大小是相同的，所以指定索引的元素位置=数组的起始位置+每个元素的大小*索引，无需进行逐个比较。
在这里插入图片描述
总结2：数组按照内容查询数据效率低下；
一般需要从第一个元素逐次比较，直到找到位置；或者比较到数组的最后一个元素也没有找到，则确认无该元素。
如果数组的数据是大小有序的，可以通过折半查找的方式来提高查询效率。

3.3 删除数组元素

删除指定索引的元素

public class Test1 {
    public static void main(String[] args) {
        int[] arr={5,7,3,1,2,6,8,4};
        //数组中目前有多少个有效元素
        int size =arr.length;
        // 删除之前遍历
        for (int i = 0; i <size ; i++) {
            System.out.println(arr[i]);
        }
        // 删除指定索引处的元素
        int index =3;
        // 向前移动元素
        for (int i=index;i<arr.length-1;i++){
            arr[i]=arr[i+1];
        }
        // 将最后一个元素置为0
        arr[arr.length-1]=0;
        // 有效元素减少一个
        size--;

        System.out.println("___________________");
        // 删除之后遍历
        for (int i = 0; i <size ; i++) {
            System.out.println(arr[i]);
        }
    }
}

数组的优点：

  1. 一个数组可以存储多个元素
  2. 按照索引查询元素效率高

数组的缺点：

  1. 按照内容查询元素，效率低下(和按照索引插叙相比,相对慢,但是事实上任然很快)
  2. 进行删除和添加时候需要大量的移动元素，效率低下；
  3. 长度固定

总结:
1数组是一种引用类型的数据,占用堆内存
2 多个元素在堆内存上是连续的
3 根据索引查询元素效率非常高
4 增删元素效率非常低

鑫~阳的技术博客
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【番外】数组平分
qq_34465338的博客
02-07 1458
水友求助的题目！
java实现avg函数_PostgreSQL avg()函数
weixin_33581873的博客
02-16 1347
PostgreSQL的AVG函数是用来找出各种记录中的一个字段的平均值。为了理解AVG函数考虑表COMPANY有如下记录：testdb# select * from COMPANY;id | name | age | address | salary----+-------+-----+-----------+--------1 | Paul | 32 | California| 2...
Java数组1
Denovo的博客
01-03 412
** Java数组1 ** //元素类型[] 数组名 = new 元素类型[元素个数或数组长度]; int[] arr = new int[3]; 内存的划分： 1，寄存器。（CPU处理） 2，本地方法区。（Java虚拟机） 3，方法区。 4，栈内存。 存储的都是局部变量。（定义在方法中的变量，而且变量所属作用域一旦结束，该变量就自动释放） {//局部代码块。限定局部变量的生命周期。 ...
Java中的数组1
weixin_44580278的博客
07-28 137
数组对于所有编程语言来说都是重要的数据结构之一，Java语言中提供的数组是用来储存固定大小的同类型元素。数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。 声明数组变量：必须声明数组变量，才能在程序中使用数组。下面是数组变量的语法格式。 dataType[] arrayRefvar;（推荐使用这种）还有一种是：dataType arrayRefver[];效果和第一种相同，但基本不使用这种方式 数组的初始化：数组的初始化主要有两种方式：静态初始化，动态初始化，1、数组静态初始化：
avg是java关键字_浅谈AVG游戏中的脚本
weixin_34970098的博客
02-25 534
最近因为笔记本数据丢失，翻网盘的时候找到了大学时候写的基于XNA的2D游戏引擎的代码，和为这个引擎写的使用示例。其中比较大点的示例就是一个ACT游戏，一个AVG游戏和一个A*寻径算法。因为当时的AVG游戏的脚本没有加密，就拿出来了看了一下。谈到脚本，我想大家都不陌生，通过简易快速和可扩展性俘获大家的脚本语言比比皆是。之前在百度博客的时候，就有很多人问道过AVG游戏的脚本。其实AVG游戏的脚本，就是...
array_sum_java_SUM_array_
10-03
在Java编程语言中，`array_sum`通常指的是计算数组元素之和的过程。这个程序的核心是遍历数组并使用内置的数学运算符累加每个元素。`array_sum_java_SUM_array_`可能是一个Java程序示例，专门设计来演示如何实现这个...
java关于数组（学习笔记）
12-21
数组的索引从0开始，最后一个元素的索引是length-1。数组的这种特性使得随机插入和删除元素的效率较低，因为这通常需要移动大量其他元素。 在Java中，我们可以声明和初始化数组，这有两种方式：静态初始化和动态...
JNI-array-arg.rar_JNI-array-arg_jni_jni 数组_jni array
09-24
数组作为传出参数时，JNI同样提供了`New{Type}Array`函数来创建新的数组，然后通过`Set{Type}ArrayRegion`或`SetObjectArrayElement`设置元素。例如，创建一个新的`int[]`数组并填充数据： ```c++ jintArray newArr...
Array_input.zip_array ip_tcp传输数组
09-19
1. 定义一个包含IP地址的数组，例如`String[] ipAddresses`。 2. 使用`ObjectOutputStream`将数组序列化为字节流。例如： ```java ByteArrayOutputStream byteStream = new ByteArrayOutputStream(); ...
Java array 数组用法源码集.rar
07-10
Java array 数组用法源码集，比如测试数组、划分成绩等级、从方法中返回数组、二分查找法、求二维数组的长度、锯齿数组、处理二维数组等，相信通过这些基础的数组操作实例，会对你了解Java中的数组有很好的帮助作用...
java avg_JPA 查询AVG简单示例
weixin_29524677的博客
02-16 2547
JPA教程 - JPA查询AVG简单示例JPQL中的聚合查询的语法与SQL的语法非常相似。有五个支持的聚合函数AVGCOUNTMINMAXSUM结果可以分组在GROUP BY子句中，并使用HAVING子句进行过滤。聚合JPQL查询可以使用同一查询中的许多聚合函数：SELECT d, COUNT(e), MAX(e.salary), AVG(e.salary)FROM Department d J...
Java版AVG游戏开发入门示例[3]——脚本引擎的制作及应用
【Java究竟怎么玩?】
05-12 8829
源码下载地址:http://code.google.com/p/loon-simple/downloads/list 根据wikipedia的解释：脚本语言（Script language，scripting language，scripting programming language），是为了缩短传统的编写-编译-链接-运行（edit-compile-link-run）过程而创建的计算
Java：实现一个方法 avg
yufy0528的博客
03-14 1291
以数组为参数, 求数组中所有元素的平均值 在方法中先使用循环求出数组中所有元素的和，再求平均值。 代码如下： import java.util.Scanner; public class TestDemo2 { public static int avg(int[] array) { int sum = 0; for (int i = 0; i &...
java avg_大家来看看那个sum方法和avg方法，结果显示是0
weixin_36155754的博客
02-13 391
该楼层疑似违规已被系统折叠隐藏此楼查看此楼package com.task02;import java.util.Arrays;class Student{private String name; //声明封装name性性private int stuno;private float math;private float english;private float computer;publ...
java递归实现数组的不断均匀分割
qq_52135683的博客
12-11 849
java，递归，分割数组
java 根据指定数值均匀的分配到Liat数组
qq_39613976的博客
04-30 682
/** * * @param totalNum 传入的数值 * @param count 分配的集合数量 * @return 返回集合 */ public static List<Integer> random(int totalNum, int count) { List<Integer> redList = new ArrayList<&gt...
JAVA——实现数组求平均分
东城庞太师
11-14 6547
题目： 1.键盘录入班级人数 2.根据录入的班级人数创建数组 3.利用随机数产生0-100的成绩(包含0和100) 4.要求: (1)打印该班级的不及格人数 (2)打印该班级的平均分 (3)演示格式如下: 请输入班级人数: 键盘录入:100 控制台输出:...
Java入门姿势【数组篇】
LSFZ88888的博客
08-05 221
在学习Java中我们最最常用到的也是最为基础的知识点：【数组】。在计算机领域中数组是非常重要的存在。 那么在学习Java中我们应该如何学习 数组 呢~~~开始我的扯~皮~ 数组一词源于程序设计，所谓数组，是相同数据类型的元素按一定顺序排列的集合。就像并排停的一排车、货架中一排同型号商品。 数组是非常重要的学习知识点，举个小例子可以清晰的知道在没有学习数组前，这些费劲巴拉的操作如何被简化： 需要实现功能：从键盘输入10个学生的分数，求和，并求平均分，输出。 思路1：定义一个变量sum、avg，分别存
java 数组表达式_Java Array数组 遍历 四种方式（包含 Lambda 表达式遍历）
最新发布
05-26
Java中的数组是一种特殊的对象，它可以存储固定大小的同类型元素集合。在访问数组元素时，我们需要使用数组下标来定位元素。下面介绍四种遍历Java数组的方式。 1. 使用for循环遍历数组 ```java int[] arr = {1, 2, 3, 4, 5}; for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } ``` 2. 使用增强for循环遍历数组 ```java int[] arr = {1, 2, 3, 4, 5}; for (int num : arr) { System.out.println(num); } ``` 3. 使用Arrays类的toString()方法输出数组内容 ```java int[] arr = {1, 2, 3, 4, 5}; System.out.println(Arrays.toString(arr)); ``` 4. 使用Lambda表达式遍历数组 ```java int[] arr = {1, 2, 3, 4, 5}; Arrays.stream(arr).forEach(System.out::println); ``` 以上四种方式都可以用于遍历Java数组，选择哪种方式取决于具体情况和个人喜好。其中，增强for循环和Lambda表达式遍历方式比较简洁和方便，但是在一些特殊情况下可能会有性能问题。而使用for循环遍历数组和使用Arrays类的toString()方法输出数组内容则比较通用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值