数组（超详细）

已于 2022-10-28 19:59:30 修改
阅读量4.9k 收藏 49
点赞数 12
分类专栏： Java 文章标签： java 前端 javascript
于 2022-10-17 11:34:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62420605/article/details/127357798
版权

一，数组

1.1数组的概念

        数组在内存当中是一块连续的空间，可以保存相同类型的多个数据的容器

1.2数组的特点

        ①数组中保存的数据必须是相同的数据类型

        ②数组是定长的（数组一旦定义 那么长度是不可改变的）

 二，数组的创建

2.1动态初始化

        语法1：数据类型[ ] 数组名 = new 数据类型 [长度]

        语法2：数据类型 数组名 = new 数据类型 [长度]       

例子：


public class demo {
    public static void main(String[] args) {
        //数据类型[ ] 数组名 = new 数据类型 [长度]
        int[] arr = new int[4];

        //存数据
        arr[0] = 11;
        arr[1] = 12;
        arr[2] = 13;
        arr[3] = 14;
        //数据
        System.out.println("第一个元素"+arr[0]);
        System.out.println("第二个元素"+arr[1]);
        System.out.println("第三个元素"+arr[2]);
        System.out.println("第四个元素"+arr[3]);
        //获取数组长度
        System.out.println("数组的长度："+arr.length);
        //ArrayIndexOutOfBoundsException 数组下标越界
        System.out.println("第四个元素(会报错数组下标越界)"+arr[4]);
    }
}

2.2静态初始化

        语法1：数据类型[ ]  数组名 = {数据1，数据2，数据3，.......};

        语法2：数据类型  数组名[ ] = {数据1，数据2，......}; 

        语法3：数据类型[ ]  数组名 = new  数据类型[ ]{数据1，数据2，.......};

        注意：数组静态初始化必须在一起，不能分开；

        注意：数组直接输出到内存地址，基本类型在栈中，引用类型在堆中

例子：

public class demo2 {
    public static void main(String[] args) {
        String[] names = new String[]{"cxk","尼古拉斯","赵四","王五"};
        //直接打印数组names  地址：[Ljava.lang.String;@4554617c
        System.out.println(names);
        //存数据
        names[0]="基尼太美";
        names[0]="赵六";

        //取数据
        System.out.println("第一位元素："+names[0]);
        System.out.println("第二位元素："+names[1]);
        System.out.println("第三位元素："+names[2]);
        System.out.println("数组地址不变:"+names);

        //获取数组的长度
        System.out.println("获取到数组的长度："+names.length);
    }
}

2.3数组使用的细节

        ① 数组中每一个数据都称之为数组元素

        ② 数组中每一个元素都有对应的下标

        ③ 数组的下标范围是0~数组的长度-1

        ④ 数组的长度：通过数组名.length获取

        ⑤ 数组的长度如果超过边界会报错（ArrayIndexOutOfBoundsException 数组下标越界）   

  三，数组的遍历

遍历: 获取，保存数组中每一个元素（循环）

import java.util.Scanner;

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

        //定义一个数组
        int[] arr1 = {10,12,7,8,4,5};
        //遍历出数组中的元素
        for (int i = 0; i < arr1.length ; i++) {
            //arr[i]表示数组中每一个元素
            System.out.println(arr1[i]);
        }
        System.out.println("-------------------------------------");

        Scanner sc = new Scanner(System.in);
        //创建长度为4的int类型的数组
        int[] arr = new int[4];
        //遍历
        for (int i = 0; i < arr.length; i++) {
            //数组的下标从0开始，那么就需要i+1来表示
            System.out.println("请输入第"+(i+1)+"个元素");
            //存数据
            arr[i] = sc.nextInt();
        }
        //取值
        for (int i = 0; i < arr.length; i++) {
            System.out.println("数组的第"+(i+1)+"元素为："+arr[i]);
        }


    }
}

  四,数组的默认值

        数组在创建的时候没有赋值的话是有默认值的

                整数型数组的默认值：0；

                浮点型数组的默认值：0.0；

                布尔型数组的默认值：false；

                字符型数组的默认值：0  ，'  '，"\u000"

                引用数据类型数组默认值：null （赋值之后存的是地址，没有值的时候就是null ，"  "只是表示空字符串，但还是有地址的）

                ① null是一种特殊的值，表示当前对象在内存当中没有指向任何地址

                ② " "表示空字符串，在内存当中，是有对应的地址    

 五，数组的扩容

5.1，实现数组的扩容和缩容

        1，扩容和缩容

                步骤一：定义一个数组，然后新数组的长度要比原数组增加和减少

                步骤二：将原来的数组和元素拷贝到新数组当中

                步骤三：将原来数组的变量指向新数组

  例子：数组的扩容


public class demo8 {
    public static void main(String[] args) {
        //定义数组 长度要比原数组长（短）
        int[] oldArr = {1,4,5,6,};
        //创建新数组长度比原来数组加1
        int[] newArr = new int[oldArr.length+1];
        //将原来数组的元素拷贝到新数组
        for (int i = 0; i < oldArr.length; i++) {
            newArr[i]=oldArr[i];
        }
        //将数组指向新数组的地址
        oldArr=newArr;
        for (int i = 0; i < oldArr.length; i++) {
            System.out.println(oldArr[i]);
        }
    }
}

例子：数组的缩容

public class demo9 {
    public static void main(String[] args) {
        //定义原数组
        int[] arr1={1,2,3};
        //定义新数组
        int[] arr2 = new int[arr1.length-1];
        //数组拷贝
        for (int i = 0; i < arr2.length; i++) {
            arr2[i] = arr1[i];
        }
        //将原数组地址指向新地址
        arr1 = arr2;

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

5.2数组拷贝

        数组拷贝有三种方式

                ①通过自定义将原数组的元素拷贝到新数组当中

                ②System类中提供了一个数组拷贝方式

                ③Arrays类中提供了数组拷贝的方式

 System类提供的方式

public class demo11 {
    public static void main(String[] args) {
        int arr1[] = {1,2,3,4,5,6};
        int arr2[] = new int[arr1.length+5];



        /*
        * 参数1：原数组
        * 参数2：原数组起始位置
        * 参数3：目标数组
        * 参数4：目标数组起始位置
        * 参数5：数组拷贝长度
        *
        * */
        System.arraycopy(arr1,2,arr2,3,arr1.length-2);
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]+"\t");
        }
    }
}

Arrays类中提供数组拷贝的方式

import java.util.Arrays;

public class demo10 {
    public static void main(String[] args) {
        int arr[] = {1,2,3,4,5,6};
        //Arrays提供的数组拷贝方法
        //第一个参数，原数组 第二个参数：新数组长度
        arr = Arrays.copyOf(arr,arr.length+1);

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

六，数组的排序

6.1冒泡排序

1，冒泡排序的思想

       ①将相邻的两个元素进行比较，如果前面一个元素比后面一个元素大，就交换位置（一轮一轮比较）直到比较完整的数组。

                        在这一轮可以将最大元素交换到最后

        ②以上操作完成数组的长度-1     

例子：基本实现

public class MaoPao {
    public static void main(String[] args) {
        int arr[] = {1,99,2,44,5,22,45};
        sort1(arr);
    }

    public static void sort1(int[] arr){
        //比较轮数 length-1
        for (int i = 0; i < arr.length-1; i++) {
            //比较次数，每一轮的次数length-1 最后的元素已经没有相邻的了
            for (int j = 0; j < arr.length-1; j++) {
                if (arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]+"\t");
        }
    }
}

 优化1：减少次数的对比（优化次数）


public class MaoPao {
    public static void main(String[] args) {
        int arr[] = {1,99,2,44,5,22,45};
        sort1(arr);
        sort2(arr);
    }
    //冒泡排序的优化实现
    /*
    * 4    3   2   1        3
    * 3    2   1   4        2
    * 2    1   3   4        1
    * 1    2   3   4        0
    * */

    public static void sort2(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {//轮数
            for (int j = 0; j < arr.length-1-i; j++) {//次数
                if (arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }

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

优化2：优化轮数

package com.qfedu;

public class MaoPao {
    public static void main(String[] args) {
        int arr[] = {1,99,2,44,5,22,45};
        sort3(arr);
    } 
public static void sort3(int[] arr){
     for (int i = 0; i < arr.length-1; i++) {
         //假设当前这一轮已经排序完成
         boolean flag = true;

         for (int j = 0;j<arr.length-i-1;j++){
             if (arr[j]>arr[j+1]){
                 int temp = arr[j];
                 arr[j]=arr[j+1];
                 arr[j+1]=temp;
                 flag=false;
             }
         }
         //
         System.out.println("第"+(i+1)+"轮的结果：");
         for (int j = 0; j < arr.length; j++) {
             System.out.println(arr[j]+"\t");
         }
         System.out.println();
         if (flag){
             break;
         }
     }
 }
}

6.2选择排序

       1， 选择排序升序思想

                ①将当前这个位置上的元素与后面每一个元素进行比较，如果有比当前位置小的元素就先记录下来，等所有的元素比较完成之后，进行交换，这个过程可以将最小的值交换到当前位置

                ②以上操作可以将最小的，选择到指定位置，循环以上操作，进行每一个位置挑选

例子：

  public static void sort1(int[] arr){
       for (int i = 0; i <arr.length-1; i++) {//负责选择的位置
           int min=i;
           for (int j = i+1; j < arr.length; j++) {//i+1表示与后面每一个元素作比较 每一个都要遍历所以 不能length-1
               if (arr[min]>arr[j]){
                   min=j;
               }
           }
           //将最小值与当前值进行交换
           if (min !=i){
           int temp=arr[i];
           arr[i]=arr[min];
           arr[min]=temp;
       }
   }
       //遍历数据
       for (int i = 0; i <arr.length ; i++) {
           System.out.print(arr[i]+"\t");
       }
   }

6. 3，Arrays工具类排除方法

package com.qfedu;

import java.util.Arrays;

public class demo5 {
    public static void main(String[] args) {
        int[] arr={22,11,87,45};
        Arrays.sort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]+"\t");
        }
        System.out.println("-----------------");
        String[] names={"cxk","main","sdsad","sdaw"};//字符串按照首字母ABC表进行排序
        Arrays.sort(names);
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]+"\t");
        }
    }
}

七，二分查找法

        二分查找法（折半查找法）

                前提：数组的元素是有序的

        思路

                首先找到这个数组的中间数，与找到的中间元素比较，如相等就代表查找的数找到了

                如果传入的数比中间数大，那么就表示想找的数在元素中间值的右边，所以最大值的下标等于中间值的下标-1

                如果传入的数比中间数小，那么就表示想找的数在元素中间值的左边，所以最小值的下标等于中间值的下标+1

例子：

public class demo6 {
    public static void main(String[] args) {
        int[]  arr= {1,2,3,4,5,6,7};//数组必须有顺序
        System.out.println(seach2(arr,4));
    }
    public static int seach2(int[] arr,int num){
        //1，获取到最大值，最小值
        int min = 0;
        int max = arr.length-1;

        while(min<=max){
            //2，获取到中间值
            int middle = (min+max)/2;

            //3，将查找的数与中间值作比较
            if(num>arr[middle]){
                min=middle+1;
            }else if(num<arr[middle]){
                max=middle-1;
            }else{
                return middle;
            }
        }
        return -1;
    }
}

Y星球一号
关注
  • 12
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
MATLAB数组字符串千字超详细解析
10-09
MATLAB中的字符串是一种特殊的数组类型，它是由一串字符组成的序列，可以用来存储和处理文本信息。字符串在MATLAB中的表示形式是用单引号或双引号括起来的一段文本 MATLAB中的字符串是一种特殊的数组类型，它可以用来存储和处理文本信息。字符串数组的每个元素都是一个字符，我们可以使用下标运算符()来访问字符串中的元素，也可以使用字符串函数来处理和操作字符串数组。在MATLAB中，字符串是非常常见的数据类型，例如在文本处理、信号处理、图像处理等领域中都有广泛的应用。 总之，MATLAB数组字符串可以在许多领域中被广泛应用，它可以用于存储和处理文本信息，例如文件、报告、日志、标签、单位、描述等，以及生成和输出处理结果的报告、日志等。通过使用MATLAB数组字符串，可以提高工作和研究的效率和准确性。
PHP 数组教程 定义数组
10-29
数组array是一组有序的变量,其中每个变量被叫做一个元素。
JS数组基础
01-08
本文介绍了数组的基本属性、数组的排序、基本判断语句 创建数组 var myarr= new Array(); 数组索引从0开始，0代表第一个 var myarr=new Array(); //定义数组 myarr[0]=80; myarr[1]=60; myarr[2]=99; [removed](第一个人的成绩是:+myarr[0]); [removed](第二个人的成绩是:+myarr[1]); [removed](第三个人的成绩是:+myarr[2]); 数组属性length 如果我们想知道数组的大小，只需引用数组的一个属性leng
js多维数组转一维数组
06-16
js基础代码实现
超详细的javascript数组方法汇总
10-23
主要对javascript的数组方法进行了详细的汇总，包括了最常用的的数组方法，还有扩展方法，很全面，感兴趣的小伙伴们可以参考一下
JAVA中一维数组的简单使用！
qq_45620589的博客
12-15 1125
JAVA中一维数组的简单使用！ 一、数组的概述 1.数组的常见概念： 数组名 下标(或索引) 元素 数组的长度 2. 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括 基本数据类型和引用数据类型。 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是 这块连续空间的首地址。 3. 数组的长度一旦确定，就不能修改。 我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度...
java合法的数组声明_Java数组01：数组的声明和创建、内存分析
weixin_36162235的博客
02-24 507
一、数组概述数组的定义：数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标访问他们。二、数组声明创建2.1、数组的声明创建首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：dataType[] arrayRefVar; //首选的方法//或dataType arrayRe...
数组的三种定义方式
小灰~的博客
12-25 7万+
1.数组的定义 用于存储同一类型数据的集合，其实数组就是一个容器。 连续的存储单元 2.数组的好处 自动给数组中的元素从零开始编号。自动给下标，从零开始0-1-2-3-…… 3.书写格式 元素类型[] 数组名 = new元素类型[]{元素，元素，元素……}; 格式1：int [] arr = new int[5]; ...
数组（Array)——数组介绍
热门推荐
Sun.ME的博客
02-12 10万+
Arrays(数组) 数组是一个固定长度的存储相同数据类型的数据结构，数组中的元素被存储在一段连续的内存空间中。它是最简单的数据结构之一，大多数现代编程语言都内置数组支持。 为何使用数组存储一堆变量 与单独为每一个元素声明一个变量名相比，我们可以使用数组的索引值访问数组中的每一个元素。 例如：我们需要实现一个系统来存储办公室所有员工的年龄，传统的存储方式如下： 我们为办公室的每一个员工创建一...
数组的基本知识
m0_63783532的博客
10-31 3208
数组：按照一定个数排列起来的，具有相同类型的数据元素的集合。一维数组：若线性表中的数据元素为非结构的简单元素，则称为一维数组。一维数组的逻辑结构：线性结构。定长的线性表。声明格式：数据类型 变量名称[长度] int a[5];二维数组：若一维数组中的元素又是一维数组结构，则称为二维数组。二维数组的逻辑结构（可以看成非线性结构也可以看成线性结构）：1.非线性结构：每一个数据元素既在一个行表中，又在一个列表中。2.线性结构：该线性表的每个数据元素也是一个定长的线性表。
数组
02-15
数组
matlab 三维 数组 千字超详细解析
10-09
Matlab中，三维数组是一种可以包含多个二维矩阵的数据类型。它们在科学计算和数据处理中很常见，可以用于存储和处理三维数据，例如图像、音频、视频等。 创建一个三维数组可以使用Matlab中的cat函数或者直接使用方括号[]。cat函数可以在指定维度上连接两个或多个数组， 三维数组的使用场景广泛，可应用于医学影像处理、机器学习、计算流体力学、气象预报等领域。三维数组的目标是帮助用户存储和处理三维数据，以便在科学计算和数据处理中进行分析和可视化。适用于工程师、科学家、研究人员、教师和学生等人群使用。 它可以帮助用户存储和处理三维数据，以便在科学计算和数据处理中进行分析和可视化。三维数组的目标是提高工作和研究的效率和准确性，帮助用户更好地理解和解决实际问题。
树状数组超详解外加大量题解
10-31
我见过的树状数组的最详细解答，没有之一，保证你能看懂，如果有图解就更完美了。
string模拟实现
m0_73969414的博客
04-23 1494
c++中string的模拟实现，面试必会知识点
C语言案例——输出 Fibonacci 数列（斐波那契数列）的前 40 项
最新发布
悟道子HD
04-25 363
输出 Fibonacci 数列（斐波那契数列）的前 40 项 #include void main() { int a[40]= {1,1}; int i; printf( "%12d%12d",a[0],a[1]); for(i=2; i
javaweb-SpringBoot基础
kussm_的博客
04-20 1349
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
大数据Hive中的UDF：自定义数据处理的利器（上）
孙中明
04-21 1087
在大数据技术栈中，扮演着数据仓库的关键角色，它提供了丰富的数据操作功能，并通过类似于SQL的HiveQL语言简化了对Hadoop数据的处理。然而，内置函数库虽强大，却未必能满足所有特定的业务逻辑需求。此时，用户定义函数（UDF）的重要性便凸显出来。Hive UDF）是Hive中的一种扩展机制，它允许用户通过编写自定义的Java代码来扩展Hive的功能，实现Hive内置函数无法提供的一些特定数据处理逻辑。在深入探讨Hive UDF的实现之前，让我们首先确保开发环境的准备妥当。对于UDF的编写，推荐使用。
Java | 冒泡排序算法实现
yingzix688的博客
04-24 729
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
JUC(java.util.concurrent) 的常见类
weixin_43497876的博客
04-20 1334
Callable 是一个 interface（类似之前的 Runnable，用来描述一个任务，但是没有返回值）也是描述一个任务的，有返回值。方便程序猿借助多线程的方式计算结果.创建线程计算 1 + 2 + 3 + ... + 1000, 不使用 Callable。
int定义数组超范围
07-28
回答: 当我们定义一个int类型的数组时，如果超出了数组的范围，会抛出ArrayIndexOutOfBoundsException异常。在引用\[1\]的代码中，如果我们尝试访问超出数组长度的索引，例如arr\[3\]，就会抛出这个异常。这是因为数组的索引是从0开始的，所以在长度为3的数组中，最大的有效索引是2。如果我们尝试访问索引3，就会超出数组的范围，导致异常的抛出。所以在编写代码时，我们需要确保数组的索引不超过数组的长度范围。\[1\] #### 引用[.reference_title] - *1* *2* [【Java】数组超详细解析](https://blog.csdn.net/xiaoliii0401/article/details/131595478)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值