Java数组概述

已于 2023-09-16 16:22:46 修改
阅读量930 收藏
点赞数
分类专栏： Java基础 笔记 文章标签： 数据结构
于 2022-11-26 20:36:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangjh11234/article/details/128050700
版权

数组

数组是什么

        数组就是用来存储一批同种类型数据的内存区域（可以理解成容器)。

 例子

// 20,10,80,60,90
int[] arr = {20,10,80,60,90};

// 牛二，西门，狗蛋
String[] name={"牛二","西门","狗蛋"}

假如用变量存储这些名字，然后完成随机点名功能，怎么实现?存在有什么问题?

String name1 =“张誉";
string name2 = "刘疏桐";
string name3 ="田启峰";
        ...
        ...
string name68="张学颖";
string name69="李沁霖";
String name70=“陈侃";

        代码繁琐:大量变量的定义。

        业务功能实现麻烦。

使用数组完成：

String[] names ={"张誉","刘疏桐","田启峰"，...,"张学颖","李沁霖","陈侃"};

 结论:数组适合做一批同种类型数据的存储。

关于数组同学们需要学会什么

一.数组的定义


1.静态初始化数组

静态初始化数组

        定义数组的时候直接给数组赋值。

静态初始化数组的格式:

//完整格式
数据类型[] 数组名= new 数据类型[]{元素1，元素2，元素3... };
double[] scores = new double[]{89.9,99.5，59.5，88.0};
int[] ages = new int[]{12，24，36};
//简化格式
数据类型[]数组名= {元素1，元素2，元素3，... };
int[] ages = {12，24，36};

package com.wjh.array;

public class arrayDemo {
    public static void main(String[] args) {
        //学会使用静态初始化的方式定义数组
        //数据类型[] 数组名 = {元素1，元素2，元素3，... };


        //double[] sores = new double[]{99.5,88.0,75.5};    //完整写法
        double[] sores = new double[]{99.5,88.0,75.5};  //简化写法

        //int[] ages = new int[]{12,24,36}; //完整写法
        int[] ages = new int[]{12,24,36};   //简化写法

        //String[] names = new String[]{"潘金莲","武松","西门庆"};  //完整写法
        String[] names = new String[]{"潘金莲","武松","西门庆"};    //简化写法
        

    }
}

数组的基本原理

//double[] sores = new double[]{99.5,88.0,75.5};    //完整写法
        double[] sores = new double[]{99.5,88.0,75.5};  //简化写法

        System.out.println(sores);      //[D@4eec7777

注意:数组变量名中存储的是数组在内存中的地址，数组是引用类型。


（1）数组的访问

 数组名称[索引]
//取值
system.out. println( arr[0]);     // 12
//赋值
arr[2] = 100;
system.out.println(arr[2]);    // 100

数组的长度属性:length

获取数组的长度（就是数组元素的个数)system. out.print1n(arr.length); // 3

问题:数组的最大索引可以怎么表示?

数组名.length - 1;    //前提:元素个数大于0,比如3就是0,1,2
package com.wjh.array;

import java.util.Random;

import java.util.Scanner;

public class arrayDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random r = new Random();
        /*
        * 访问数组的元素
        * */
        int[] ages = {12,24,36};

        //取值，数组名称[索引]
        System.out.println(ages[0]);    //12
        System.out.println(ages[1]);    //24
        System.out.println(ages[2]);    //36

        //赋值 数组名称[索引] = 数据;
        ages[2] = 100;
        System.out.println(ages[2]);    //100

        //访问数组的长度
        System.out.println(ages.length);    //length意为长度    //3

        int[] arr = {};
        System.out.println(arr.length);


    }
}

（2）数组的几个注意事项

数组的几个注意事项:

        “数据类型[ ]  数组名”也可以写成“数据类型  数组名 []”。

int[] ages =.. .;
int ages[] =...;

double[] scores = ...;
double scores[] = ...;

        什么类型的数组存放什么类型的数据，否则报错。
     

   int[] arrs = new int[]{30，40，"狗蛋"};    //报错


        数组一旦定义出来，程序执行的过程中，长度、类型就固定了。

package com.wjh.array;

import java.util.Random;

import java.util.Scanner;

public class arrayDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random r = new Random();
        /*目标：
        *     理解数组的注意事项
        * */
        //1.“数据类型[] 数组名”也可以写成“数据类型 数组名 []”。
        int[] ages = {11,23,45};
        int ages1[] = {11,23,45};

        //什么类型的数组存放什么类型的数据，否则报错。
        //String[] names = {"武松","潘金莲",23};   //报错；原因，类型不同

        //3.数组一旦定义出来，程序执行的过程中，长度、类型就固定了
        int[] ages2 = {11,23,45};
        System.out.println(ages2[3]);   //报错;原因：长度越界
        
    }
}


2.动态初始化数组

数组的动态初始化

定义数组的时候只确定元素的类型和数组的长度，之后再存入具体数据。

数组的动态初始化格式:

数据类型[]数组名= new 数据类型[长度];
int[] arr = new int[3];
//后赋值
arr[0] = 10;
system.out.println(arr[0]);    // 10

package com.wjh.array;

import java.util.Random;

import java.util.Scanner;

public class arrayDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random r = new Random();
        /*目标：
        *     数组的动态初始化的定义与使用
        * */
        double[] scores = new double[3];    //[0.0 , 0.0 , 0.0]

        //赋值
        scores[0] =99.5;
        System.out.println(scores[0]);  //99.5

        System.out.println(scores[2]);  //0     //默认值为0


        String[] names = new String[90];
        names[0] = "潘金莲";
        names[2] = "疾风剑豪";
        System.out.println(names[0]);   //潘金莲
        System.out.println(names[1]);   //null  //String数组的默认值是null
        System.out.println(names[2]);   //疾风剑豪


    }
}

 

 
（1）动态初始化数组的元素默认值

元素默认值规则:


两种初始化的的使用场景总结、注意事项说明:

        ①动态初始化:只指定数组长度，后期赋值，适合开始知道数据的数量，但是不确定具体元素值的业务场景。

        ②静态初始化:开始就存入元素值，适合一开始就能确定元素值的业务场景。

        ③两种格式的写法是独立的严，不可以混用。

int[] arrs = new int[3]{30,40,50};    //错误
package com.wjh.array;

import java.util.Random;

import java.util.Scanner;

public class arrayDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random r = new Random();
        /*目标：
        *     掌握动态初始化数组的元素默认值的规则
         * */
        //1.整型的元素默认值都是0
        int[] arr = new int[10];
        System.out.println(arr[0]);     //0
        System.out.println(arr[9]);     //0

        //2.字符型的元素默认值也都是0？
        char[] chars = new char[100];
        System.out.println((int)chars[0]);      // 0
        System.out.println((int)chars[99]);     // 0

        //3.浮点型的元素默认值都是0.0
        double[] scores = new double[90];
        System.out.println(scores[0]);       //0.0
        System.out.println(scores[89]);      //0.0

        //4.布尔类型的数组默认值
        boolean[] booleans = new boolean[100];
        System.out.println(booleans[0]);    //false
        System.out.println(booleans[99]);   //false

        //5.引用类型数组的默认值
        String[] names = new String[90];
        System.out.println(names[0]);   //null
        System.out.println(names[89]);   //null

    }
}



二.数组的遍历

数组遍历介绍

        遍历:就是一个一个数据的访问。

        为什么要遍历?搜索、数据统计等等都需要用到遍历。

int[] ages - {20，30，40，50};
for (int i = 0; i < ages.length; i++) {
system.out.println( ages[i]);
}

 

package com.wjh.array;

import java.util.Random;

import java.util.Scanner;

public class arrayDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random r = new Random();
        /*目标：
        *     学会数组元素数组的遍历
         * */
        int[] arr = {12,24,36,12,98};
        //           0  1  2  3  4

        System.out.println("----原始遍历方式----");

        //原始遍历方式
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);

        System.out.println("-------");

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

        System.out.println("----终极数组遍历形式---");

        //终极数组遍历形式
        for(int i = 0;i < arr.length;i++){
            System.out.println(arr[i]);
        }

        //快捷键  arr.for+名+回车快速生成
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

    }
}

 
三.数组的案例

1.数组元素求和

案例  数组遍历-求和
        需求:某部门5名员工的销售额分别是:16、26、36、6、100，请计算出他们部门的总销售额。

分析:
        把这5个数据拿到程序中去--->使用数组

int[ ] money = {16，26，36，6，100};


        遍历数组中的每个数据，然后在外面定义求和变量把他们累加起来。

int sum = 0;
for (int i = o; i < money. length; i++) {
// i =0 1 2 3 4
sum += money[i];
package com.wjh.array;

import java.util.Random;

import java.util.Scanner;

public class arrayDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random r = new Random();
        /*目标：
        *       某部门5名员工的销售额分别是:16、26、36、6、100，请计算出他们部门的总销售额
         * */

        int sum=0;    //2.定义一个累计的元素

        int[] money = {16,26,36,6,100}; //1.把这些数据用到程序中用数组记住

        for(int i=0;i<money.length;i++){
            sum+=money[i];  //3.累加
            System.out.println(sum);    //3.每次累加的值
        }
        System.out.println("总数="+sum);  //44.输出184

    }
}


2.数组求最值

案例 数组元素求最大值

案例
数组元素求最大值
颜值:15        颜值:9000        颜值:10000        颜值:20000        颜值:9500        颜值:-5

分析:
        ①把颜值数据拿到程序中去，用数组装起来。

int[] faceScores = {15, 9000，10000，20000，9500,-5};

       ② 重点：定义一个变量用于记录最大值，这个变量建议默认存储第一个元素值作为参照。

int max = facescores[0];

        ③遍历数组的元素，如架该元素大于变量存储的元素，则替换变量存储的值为该元素。

for (int i = 1; i < faceScores . length; i++) {
if(faceScores[i] > max){
//替换
max= facescores[i];
}
}

package com.wjh.array;

import java.util.Random;

import java.util.Scanner;

public class arrayDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random r = new Random();
        /*目标：
        *       数组元素求最大值
         * */
        int[] yz ={15,9000,10000,20000,9500,-5};    //①把颜值数据拿到程序中去，用数组装起来。
        //         0   1    2     3     4    5
        int max = yz[0];    //②定义一个变量用于记录最大值，
                            // *重点*：这个变量建议默认存储第一个元素值作为参照。

        for(int i = 0;i < yz.length;i++){  //③遍历数组的元素
            if(yz[i] > max){    //如架该元素大于变量存储的元素
                max = yz[i];    //则替换变量存储的值为该元素。
            }

        }
        System.out.println(max);


    }
}

3.猜数字游戏

 需求

开发一个幸运小游戏，游戏规则如下:
游戏后台随机生成1-20之间的5个数（无所谓是否重复)，然后让大家来猜数字

        (1)未猜中提示:“未命中”，并继续猜测

        (2)猜中提示:“运气不错，猜中了”，并输出该数据第一次出现的位置且输出全部5个数据，最
        终结束本游戏。

分析：

       ① 随机生成5个1-20之间的数据存储起来--->使用数组

        ② 定义一个死循环，输入数据猜测，遍历数组，判断数据是否在数组中，如果在，
进行对应提示并结束死循环;如果没有猜中，提示继续猜测直到猜中为止。

package com.wjh.array;

import java.util.Random;

import java.util.Scanner;

public class arrayDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random r = new Random();
        /*目标：
        * 开发一个幸运小游戏，游戏规则如下:
游戏后台随机生成1-20之间的5个数（无所谓是否重复)，然后让大家来猜数字
 (1)未猜中提示:“未命中”，并继续猜测
 (2)猜中提示:“运气不错，猜中了”，并输出该数据第一次出现的位置且输出全部5个数据，最终结束本游戏。
         * */

        //1.定义一个动态初始化的数组存储5个随机的1-20之间的数据
        int[] nums = new int[5];

        //2.动态的生成5个1-20之间的随机数并存入数据中
        for(int i=0;i< nums.length;i++){
            //  i=0 1 2 3 4 5
            nums[i] = r.nextInt(20) + 1;
        }

        OUT:
        //3.使用一个死循环让用户进行猜测
        while(true){
            System.out.println("请输入1-20之间的1个整数猜测：");
            int guessNum = sc.nextInt();

            //4.遍历数组中的每个数据，看是否有数据相同，给出提示
            for(int i=0;i<nums.length;i++){
                if(nums[i] ==  guessNum){
                    System.out.println("运气不错，猜中了");
                    System.out.println("这数据索引是："+i);    //在数组中的第几个位置
                    break OUT;    //跳出以OUT:该位置的循环语句
                }
            }
            System.out.println("未命中，再来一次");
        }

        //5.输出数组的全部元素，让用户看到在数组中的存在。
        for(int i = 0; i < nums.length; i++) {
            System.out.print(nums[i]+" ");
        }
        System.out.println("游戏结束！");

    }
}

 
4.随机排名

需求：

        某公司开发部5名开发人员，要进行项目进展汇报演讲，现在采取随机排名后进行汇报。请先依次录入5名员工的工号，然后展示出一组随机的排名顺序。

分析

        ①在程序中录入5名员工的工号存储起来--->使用数组。

        ②依次遍历数组中的每个元素，随机一个索引数据，让当前元素与该索引位置处的元素进行交换。

package com.wjh.array;

import java.util.Random;

import java.util.Scanner;

public class arrayDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random r = new Random();
        /*目标：
        * 某公司开发部5名开发人员，要进行项目进展汇报演讲，现在采取随机排名后进行汇报。
        * 请先依次录入5名员工的工号，然后展示出一组随机的排名顺序。
         * */

        //1.动态初始化一个数组，存储5个工号
        int[] id = new int[5];

        //2.定义一个循环，循环5次，一次录入一个工号存入对应的位置

        for (int i = 0; i < id.length; i++) {

            //正式录入工号
            System.out.println("请输入第"+(i+1)+"名员工的工号：");
            int idInt = sc.nextInt();

            //存入到数组中去
            id[i] = idInt;
        }

        //4.遍历数组中的每个元素，然后随机一个索引出来，让该元素与随机的索引位置处的元素进行交换（本节的重点）
        //id = {12,25,30,29,56}
        for (int i = 0; i < id.length; i++) {
            //当前遍历的元素值：id[i]

            //随机一个索引位置出来
            int index = r.nextInt(id.length);   //0-max最大长度：0-4

            //定义一个临时变量存储index的值
            int temp = id[index];
            id[index] = id[i];
            id[i] = temp;

            //4.遍历数组元素输出就是随机排名的结果
            for (i = 0; i < id.length; i++) {
                System.out.print(id[i]+" ");
            }
        }
        
    }
}


5.数组排序

数组排序

        就是对数组中的元素，进行升序(由小到大)或者降序（由大到小）的操作。

数组排序的技术

        冒泡排序：

        冒泡排序的思想

                每次从数组中找出最大值放在数组的后面去。

        实现冒泡排序的关键步骤分析

                确定总共需要做几轮:数组的长度-1

                每轮比较几次:

         

        

package com.wjh.array;

import java.util.Random;

import java.util.Scanner;

public class arrayDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random r = new Random();
        /*目标：
        * 冒泡排序 5 4 6 2 1
         * */

        //定义一个数组，存储一些数据
        int[] nums = {5,4,6,2};
        //            0 1 2 3

        //2.定义一个循环控制比较的轮数

        for (int i = 0;i < nums.length-1; i++) {
            //i == 1   比较的次数3  j = 0 1 2   位置
            //i == 2   比较的次数2  j = 0 1
            //i == 3   比较的次数1  j = 0

            //3.定义一个循环控制每轮比较的次数,占位
            for(int j=0;j<nums.length-i-1;j++){
                //判断j当前位置的元素值是否大于后一个元素的值，若较大，则交换
                if (nums[j] >  nums[j+1]){
                    int temp = nums[j+1];
                    nums[j+1] = nums[j];
                    nums[j] = temp;
                }

            }
        }
        //遍历数组内容输出
        for (int i = 0; i < nums.length; i++) {
            System.out.print(nums[i]+" ");
        }



    }
}

        

        选择排序

        快速排序

        插入排序

数组搜索相关的技术

        二分搜索

        分块查找

        哈希表查找


四.数组的内存图

1.Java内存分配、数组内存图

Java 内存分配介绍

        栈

        堆

        方法区

        本地方法栈

        寄存器


package com.wjh.array;

import java.util.Random;

import java.util.Scanner;

public class arrayDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random r = new Random();

        int a = 12;
        System.out.println(a);  //12

        int[] arr= {11,22,33};

        System.out.println(arr);    //[I@12edcd21   //访问的是 地址

        arr[0] = 44;
        arr[1] = 55;
        arr[2] = 66;
        System.out.println(arr[0]);     //44
        System.out.println(arr[1]);     //55
        System.out.println(arr[2]);     //66


    }

    }


2.两个变量指向同一个数组
 

package com.wjh.array;

import java.util.Random;

import java.util.Scanner;

public class arrayDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random r = new Random();
        /*目标：
         *
         * */
        int[] arr1 = {11,22,33};

        int[] arr2 = arr1;

        System.out.println(arr1);        //[I@4eec7777
        System.out.println(arr2);       //[I@4eec7777

        arr2[1] = 99;
        System.out.println(arr1[1]);    //99

        System.out.println(arr2[0]);    //11
        System.out.println(arr2[1]);    //99
        System.out.println(arr2[2]);    //33

    }
}

 
五.数组使用的常见问题

问题1∶如果访问的元素位置超过最大索引，执行时会出现ArrayIndexOutOfBoundsException(数组索引越界异常)
       

问题2 : 如果数组变量中没有存储数组的地址，而是null,，在访问数组信息时会出现NullPointerException(空指针异常)

package com.wjh.array;

import java.util.Random;

import java.util.Scanner;

public class arrayDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Random r = new Random();
        /*目标：
         *
         * */
        int[] arr = {11,22,33};
        arr = null;
        System.out.println(arr.length); //报错，null没有指向任何东西
        System.out.println(arr); //报错，null没有指向任何东西
        System.out.println(arr[1]); //报错，null没有指向任何东西
        System.out.println("程序结束");
    }
}


六.Debug工具的使用

Debug工具

        IDEA自带的断点调试(排错)工具，可以控制代码从断点开始一行一行的执行，然后详细观看程序执行的情况。

DEBUG工具基本使用步骤:

        ①在需要控制的代码行左侧，点击一下，形成断点

        ②选择使用Debug方式启动程序，启动后程序会在断点暂停

        ③控制代码一行一行的往下执行


程序员希西子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java多线程基础-01、数组概述.rar
11-20
本资料“Java多线程基础-01、数组概述”将带你入门Java的多线程世界，并结合数组这一基本数据结构进行讲解。 首先，我们需要理解什么是线程。线程是操作系统分配CPU时间的基本单位，一个进程可以有多个线程，它们...
JAVA数组的排序方法实例.docx
06-28
### JAVA数组的排序方法实例 #### 内容概述： 本文档详细介绍了两种在Java中对数组进行排序的方法：冒泡排序法与使用`Arrays.sort()`方法实现数组递增排序。这两种方法是Java编程中常见的排序手段，对于理解数组...
java数组概述
weixin_51755941的博客
03-02 840
目录 一.数组 二.数组的优缺点 一.数组 1.java语言中的数组是一种引用数据类型，不属于基本数据类型，数组的父类是Object。 2.数组实际上是一个容器，可以同时容纳多个元素（数组是一个数据的集合）字面意思：“一组数据” 3.数组当中可以储存“基本数据类型”的数据，也可以储存“引用数据类型”的数据 4.数组因为是引用类型，所以数组对象是堆内存当中（数组是存储在堆当中的）。 5.数组当中如果存储的是“java对象”的话，实际上存储的是对象的“引用地址” 6....
Java 数组概述
Darklovy
11-26 190
在&nbsp;Java&nbsp;中是具有相同数据类型的一组数据的集合。 数组中的每个元素具有相同的数据类型。在&nbsp;Java&nbsp;中同样将数组看做一个对象，虽然基本数据类型不是对象，但由基本数据类型组成的数组却是对象。 在程序设计中引入数组可以更有效地管理和处理数据。 根据数组的维数可分为： 一维数组 二维数组 多维数组 ...
Java数组--数组的概述
qq_45028878的博客
02-22 147
数组的定义 数组是相同类型数据的有序集合 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成 其中，每一个数组元素可以通过一个下标来访问它们 数组声明创建 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法： dataType[]arrayRefVar;//首选的方法 或 dataType arrayRefVar[];//效果相同 Java语言使用new操作符来创建数组，语法如下： dataType[] arrayRefVar=new dataType[
#Java数组概述
m0_64785784的博客
03-20 676
#Java数组概述 ##1.数组的定义 数组是相同类型数据的有序集合 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成 其中，每一个数据乘坐一个数组元素，每个数组元素可以通过一个下标来访问他们 ##2.数组声明创建 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法 如下 int [] age; //首选的方法 int age []; //效果相同，但不是首选方法 在Java中使用new操作符来创建数组 如下 int [] age= new int
Java数组概述及三维数组拓展分析
江南、寻你的博客
03-06 983
Java数组的概述详解，超详细！！！
java 数组 内存_Java数组概述及内存图详解
weixin_36115763的博客
02-16 106
数组概述和定义格式说明数组的作用：用来存储同种数据类型的多个值数组的概念：数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。数组既可以存储基本数据类型，也可以存储引用数据类型。数组定义格式:数据类型[] 数组名 = new 数据类型[数组的长度];数组的初始化什么是数组的初始化？就是为数组开辟连续的内存空间，并为每个数组元素赋值数组初始化两种方式：静态初始化 给出初始化值。动态初始化 ...
27-Java数组概述
yelitoudu的博客
06-19 104
Java数组概述：数组是什么、为啥要学数组、以及学数组需要掌握什么
java数组概述——静态数组和动态数组的使用及对比
快乐学习，daydayup!
12-28 1438
java数组概述——静态数组和动态数组的使用及对比
JAVA数组概述和定义格式说明
weixin_41505382的博客
07-15 170
数组概述 数组就是一个容器，可以从存储多个数据类型一致的元素。 数组既能存储基本类型的元素，也能存储引用数据类型的元素。 数组的定义语法 JAVA中的数组，必须先初始化，才能使用 所谓初始化，就是为数组中的数组元素分配内存空间，并为数组的元素赋值。 动态初始化：由我们为数组指定长度，由系统为数组元素赋值默认值。 方式一： int[ ] arr=new int[3]; 方式二：int arr[ ]=new int[3]; 静态初始化：由我们为数组元素赋值，由系统计算长度。 int[ ] arr
java数组初始化详解修正版.doc
06-28
### Java 数组初始化详解 #### 一、概述 在 Java 中，数组是一种基本的数据结构，用于存储固定数量的同类型元素。数组初始化是指为数组分配内存，并为其中的元素设置初始值的过程。根据不同的初始化方式，Java ...
JAVA数组常用函数介绍及实例.docx
06-28
### JAVA数组常用函数详解 #### 一、概述 在Java编程语言中，数组是一种非常基础且重要的数据结构，用于存储相同类型的数据集合。为了方便操作和管理数组中的数据，Java提供了一系列内置的方法来帮助开发者更高效...
java数组总结共9页.pdf.zip
10-30
在这个"java数组总结共9页.pdf.zip"的文档中，我们很可能会找到关于Java数组的全面概述，包括其定义、创建、初始化、操作以及一些重要的特性。下面是对Java数组的详细解释。 一、数组的定义 在Java中，数组是一种...
2024.7.24 作业
qq_64434282的博客
07-24 2453
【代码】2024.7.24 作业。
QT5 FTP 客户端 实现多文件下载 上传
08-01
QT5 FTP 客户端 实现多文件下载 上传
MATLAB车牌识别实现车牌定位仿真系统（可运行）
08-01
车牌定位分为以下步骤： 图像预处理：读取图像并对其进行预处理，例如灰度化、降噪和增强等。 车牌区域定位：使用图像处理技术，例如边缘检测、连通区域检测和形态学操作等，找到车牌的大致位置。 车牌区域精确定位：通过进一步的图像处理技术，例如投影、边缘检测和形态学操作等，对车牌区域进行精确定位。 字符分割：将车牌区域中的字符进行分割，形成单独的字符图像。 字符识别：使用字符识别算法，例如模板匹配、神经网络或支持向量机等，对分割的字符进行识别。 本设计非常适合新手学习使用，进阶研究等二次开发。欢迎大家多多下载交流学习研究。
年度销售回款计划表（依据项目回款率制定，月度分解.xlsx
最新发布
08-01
销售统计，调查问卷，库存明细，跟进表，业绩统计表，差异分析 ，产品清单 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
Java数组详解：声明、使用与操作
1. **数组概述** - 数组是一种引用数据类型，类似于容器，用于存储固定数量和类型的数据集合。 - 作为引用类型，数组在内存中分配连续的空间来存储元素，通过数组名间接访问这些元素。 - 数组元素的类型既可以是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员希西子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值