zoukankan      html  css  js  c++  java
  • Java开发知识之Java数组

              Java开发知识之Java数组

    一丶数组简介

      首先,不管是Java 还是 C++ 还是其它语言.都有数组. (有可能叫法不同) 数组简而言之就是存储一段连续相同数据类型的数据结构

    在Java中数组可以看成是一个对象. C++ 中数组就是数组. Java中的数组其实是封装的数组.虽然是由基础类型组成.但可以当对象使用. C++中的则不可以.

    数组可以分为一维数组. 二维数组. 三维数组 .高维数组..

    二丶一维数组

      使用数组我们就要学会声明

    1.数组的声明

      在Java中数组是new出来的.所以我们可以使用new关键字. 有两种方式

    先声明后new 

      数组元素类型 数组名字[];    //定义

      数组元素类型[] 数组名字;   //定义

      数组名字 = new 数组元素类型[个数];   //分配内存,分配了内存才可以使用

      数组元素类型 数组名[] = new 数组元素类型[个数];

    关于第一种,想必C++开发人员比较熟悉.在C++中数组的定义就是这样定义的.

    Java中数组只是定义.并没有实际内存来存放数据.所以下面我们必须要用new关键字分配内存.

    [] 运算符. 关于数组元素类型.我们可以是int ,如果是int 那么数组每个元素的大小都是int类型大小. 也可以是对象.

    如果是对象,那么数组元素大小都是 数组元素类型的大小.

    代码:

    int Array1[];
    Array1 = new int[10];  //定义的时候括号在前在后都可以
            
    int []Array2 = new int[100];//括号在前也可以

    int arr[] = new int[5]; 了解内存模式

    元素有5个. arr[0] - arr[4];

    下标也是5个,用来访问数组内容的. 但是数组下标都是从0开始的. 也就是0位置的元素是arr[0]  5位置的元素是arr[4]

    下标计算方法:  数组元素的最大个数 - 1;  比如你new了 100个.元素个数100个. 100-1 就是下标最大值了. 从0 - 100 -1;

    2.一维数组的初始化.

      在我们定义数组的同事可以进行初始化.这也方便我们的编程

    语法1: 

      数组元素类型 数组名[] = new 数组元素类型[]{值,值,值};

    语法2:

      数组元素类型 数组名[] = {值,值,值};

    代码例子:

      

    int Array1[] = new int[] {1,2,3,4,5,6,7,8,9,10};
        
    int Array2[] =  {1,2,3,4,5,6,7,8,9,10};

    3.一维数组的使用

      数组一般用来遍历的.数组的遍历使用for循环.或者foreach都可以.数组可以看成一个对象.那么数组元素的大小就在对象中存储着.所以我们可以直接使用.不用再计算数组的大小了

    for循环

        

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

    输出结果

     三丶二维数组

      上面讲了一维数组的操作.以及一维数组的简单理解模型(如下图),那么二维数组可以看成一个平面.其实在内存中还是一维数组.不过如果要理解的话内存模型想象成一个平面即可.

    1.二维数组的创建

      二维数组跟一维数组一样.只不过你是二维的所以需要两个 []运算符

    定义:

      数组元素类型 数组名称[][];

      数组元素类型[][] 数组名称;

    内存申请:

      数组元素类型[][] 数组名称 = new 数组元素类型[个数][个数];

      数组元素类型  数组名称[][] = new 数组元素类型[个数][个数];

    第二种方式:定义二维数组.不指定一维数组大小

    a = new int[2][];  一个二维数组. a[0] 跟 a[1]

    a[0] = new int[2]; 为a[0] 分为2个一维数组.

    a[1] = new int[3]; 为a[1] 分配3个以为数组

    内存模型图:

    此时 a[0] 跟 a[1] 可以理解为是以为数组首地址.

    注意一下使用的时候 new关键字如何使用即可. 

    二维数组内存模型

    代码: a = new int[2][4];

    二维数组的大小可以计算出来的. 2 * 4 = 8; 总共8个. 因为是int类型. 所以是 8 * int(4) = 32; 所以所占内存是32个字节;

    2 4 的意思就是 分配了两个一维数组. 每个一维数组的大小是4个元素.

    所以看下面内存模型图:

     2.二维数组初始化

      二维数组初始化跟一维数组一样.都是使用大括号进行初始化. 只不过多了两个[][]

    语法:

      数据元素类型 数组名称[][] = {值,值,值}

    语法2

      数据元素类型 数组名称[][] = {{值,值},{值,值},{值,值}};

    第二种初始化方法.因为我们是二维数组.是一个平面.所以可以理解为需要x y的值. 内部的大括号就是x y 的值.

    代码:

      

        int Array1[][] = new int[][] {{1,2},{3,4},{5,6},{7,8},{9,10}}; //定义并且初始化
        
            
            for (int i = 0; i < Array1.length; i++)
            {
                for (int j = 0; j < Array1[i].length; j ++) //注意这里.Array[i]代表的是一维数组. Array[i].length代表的就是一维数组组大小.
                {
                    System.out.println(Array1[i][j]);
                }
            }

     四丶数组的基本操作

      对于数组来说,我们会定义.还要会使用.

    1.遍历数组.

      遍历数组一般使用for循环.foreach也可以.

    一维数组遍历的两种方式

            int Array1[] = new int[]{1,2,3,4,5,6,7,8,9,10};
            for (int i = 0; i < Array1.length; i++) {
                System.out.print(" " + Array1[i]);
            }
            System.out.println(" ");
            for(int s:  Array1) {
                System.out.print(" " + s);
            }
            System.out.println(" ");
        }

    输出结果:

      

    注意增强for循环

      for (元素数据类型 变量名: 元素变量){};

    遍历的时候. 我们的变量名就是元素变量中的值了. 上面第一个循环是 Array[i] 需要用下标. 增强for循环则不用.

    二维数组的遍历

      

            int Array1[][] = new int[][]{{1,2},{3,4},{5,6},{7,8},{9,10}};
            for (int i = 0; i < Array1.length; i++) {
                for (int j = 0; j < Array1[i].length;j++) {
                    System.out.print(" " + Array1[i][j]);
                }
                
            }
            System.out.println(" ");
            
            for(int[]  A:  Array1) {
                for (int B  :A) {
                    System.out.print(" " + B);
                }
            }
            System.out.println(" ");
        }

    二维数组中.第二种遍历方式需要遍历两次, 第一次遍历完毕之后 A变量就相当于一维数组. 然后继续进行一次遍历. 此时B才是数组里面的值.

    2.数组的填充

        C++中可以使用ZeroMemory或者memset对一块内存按照指定方式填写指定值. 比如常见的就是数组清零了. Java也可以这样做.Java中我们可以使用Arrays类的静态方法

    fill(数组[],填充的值) ps:注意是一维数组.

    例子:

      

    int Array1[] = new int[]{1,2,3,4,5,6,7,8,9,10};
    Arrays.fill(Array1, 0);
    for(int s:Array1) {
    	System.out.print(s);
    }

    输出结果:

      

    可以看出.输出结果都为0. 填充的值为0就是0. 填充的值为x.值就是x(x是一个数值)

    fill函数有很多重载.比如常用的.指定一个范围.进行填充

    file(数组[],开始位置,结束位置,填充的值);

            int Array1[] = new int[]{1,2,3,4,5,6,7,8,9,10};
            //int Array1[][] = new int[][]{{1,2},{3,4},{5,6},{7,8},{9,10}};
            Arrays.fill(Array1, 0);
            Arrays.fill(Array1, 2,9,12);
            for(int s:Array1) {
                System.out.print(" " + s);
            }

    首先数组全部清零.然后从下标2开始.结果都赋值为12

    输出结果:

    3.数组复制

      C++中的数组是申请的 内存.可以直接使用内存操作. memmove memcpy一个是进行内存移动.一个是内存拷贝.就能实现内存的赋值.如果用于数组.就可以进行数组拷贝了.

      Java中都是Arrays类进行操作数组的.

    Arrays中的静态方法 copyOf(数组[],大小) 就可以进行赋值.返回一个新数组

    例子:

      

        int Array1[] = new int[]{1,2,3,4,5,6,7,8,9,10};
            int Array2[] = Arrays.copyOf(Array1, Array1.length);
            //int Array1[][] = new int[][]{{1,2},{3,4},{5,6},{7,8},{9,10}};
            ;
            for(int s:Array2) {
                System.out.print(" " + s);
            }
            

    4.范围进行数组复制

      Arrays还可以支持范围复制

    copyOfRange(数组,开始索引,结束索引)

    例子:

      

        int Array1[] = new int[]{1,2,3,4,5,6,7,8,9,10};
            int Array2[] = Arrays.copyOfRange(Array1, 0,3);
            //int Array1[][] = new int[][]{{1,2},{3,4},{5,6},{7,8},{9,10}};
            ;
            for(int s:Array2) {
                System.out.print(" " + s);
            }

    我们复制了三个. 从0开始.所以输出的1 2 3.三个元素的值. 结束索引是多大.那么我们新的数组元素大小就有多大.什么意思

    意思就是我们拷贝了3个元素大小. 那么Array2.length 就是3.

     5.数组的排序

      可以使用Arrays类中的静态方法 sort进行排序.

     Arrays.sort(数组) 可以对任意数据进行破爱须.

    他有很多重载方法.

    int Array1[] = new int[]{1,2,6,4,3,6,7,10,9,8};
    Arrays.sort(Array1);
            
    for(int s:Array1) {
        System.out.print(" " + s);
    }

    6.数组的查找

      有的时候我们需要查找指定值. 可以使用Arrays.binarySerach()方法进行查找.

    返回值索引  binarySearch(数组[],要查找的值) ; 有很多重载方法. 在使用查找之前.需要进行数组排序.

    因为BinarySearch是一个二分查找法.

            int Array1[] = new int[]{1,2,6,4,3,6,7,10,9,8};
            Arrays.sort(Array1);
            int nIndex = Arrays.binarySearch(Array1, 2);
            System.out.println("索引值为" + nIndex);
            for(int s:Array1) {
                System.out.print(" " + s);
            }

    如果查询不存在.就返回负数. 负数的值.根据排序后.判断应该插入在哪里. 比如我们要查询4. 假设数组中没有4. 那么返回值就是-3. 

    意思就是如果有4的话.下标应该是在3索引位置. 但是没有.所以返回负数.

    五丶数组的算法实现

      5.1冒泡排序

        冒泡排序我们上变也用过,就是Arrays.sort() 那么我们可以自己实现一个.

    冒泡排序基本思想:

      冒泡排序的核心思想就是相邻的元素进行比较.进行排序. 冒泡排序是双层for循环. 外层循环是排序的轮数. 内层循环就是比较相邻的数.

    如下图所示:

    第一轮63不短的跟下一个相邻的元素进行比较.进而得出了.63最大.放到数组最末尾.

    此时数组的值最末尾是63 然后进行第二轮比较.依次类推. 一直到完全排序完毕即可.

    public static void Sort(int arr[],int nSize) {
            for (int i = 1; i < arr.length; i++){
                for (int j = 0; j < arr.length-i;j++) {
                    if (arr[j] > arr[j + 1]) {
                        int nTemp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = nTemp;
                    }
                }
            
            }
        }

    首先是外层循环.总共循环轮数是 数组大小.

    内层循环.内层循环的比较每次都要从0开始比较.比较的大小是数组大小的长度-1; 但是这样比较会很浪费.每次都要比较整个数组.(虽然可以实现)但为了减少比较次数. 所以 -i 也就是剩余比较次数会越来越少.

     然后内部代码就是判断. j位置是否小于j+1的位置. 如果是就使用交换算法进行交换.

      5.2直接选择排序

     直接选择排序的原理就是.将指定排序位置与其他数组元素分别进行对比. 如果满足条件.就交换元素的值.注意.不是交换相邻的元素.而是把满足条件的元素预指定的排序位置交换.

    比如有楼梯10层. 你选择一层. 跟一其他楼层相比. 小了就位置交换楼层编号. 最终组成了1 - 10层的编号. (这里的小了指高低,如果低了那么就是1楼)

    如下:

    第一轮.选择最大的数据放在最后.

    第二轮. 从中继续选出大于数组中其他元素的最大值.放在最后.

    依次类推.

    使用直接选择排序的话.需要有一个变量用来记录. 使用双for循环

    算法:

      

        public static void Sort2(int Arr[]) {
            int nIndex = 0;
            for (int i = 1; i < Arr.length;i++) {
                for (int j = 1; j < Arr.length - i;j++) {
                    if (Arr[j] > Arr[nIndex]) {
                        nIndex = j; //记录最大的数字
                    }
                }
                //进行交换数值.最大的数值放在数组的末尾
                int nTemp = Arr[Arr.length -i];
                Arr[Arr.length -i] = Arr[nIndex];
                Arr[nIndex] = nTemp;
            }
        }

    跟冒泡排序类似, 外层控制比较几轮. 内层控制相邻比较次数. 只不过唯一不同就是使用了nIndex值.来保存数值中元素最大的值的索引位置.然后下方交换的时候使用这个索引.排序到数组的最末尾. 注意-i -i的意思就是第一次吧最大值放到末尾.第二次把最大值放到末尾的前一个位置. 比如第一次 xxxx  63 .末尾放了63. 因为外层控制轮数. 所以第二次最大值放到 最大数组- i位置. 也就是成了 xxxx 26  63 ,依次类推.

    六丶数组学习总结

      通过上面简介了数组怎么操作.其实可以进行一下总结.

    1.数组的定义与使用

    数组的定义:

      数组元素类型 维数 数组名字;

      数组元素类型  数组名 维数;   维数代表的意思就是[] .有几维就是几个花括号. 

    数组的内存分配.

      数组元素类型 维数 数组名字 = new 数组元素类型  维数[个数];  //定义之后要分配内存才能使用

    数组的初始化

      数组元素类型 维数 数组名字 = {值,值,值};

      数组元素类型 维数 数组名字 = new 数组元素类型 维数..{值,值,值};

    如果是高维数.那么初始化的时候.每个值都用花括号进行初始化即可.

    例如:

      数组元素类型[][]  数组名字 = {{值,值},{值,值}};

    2.类Arrays对数组进行操作的方法

    Arrays.fill(数组,填充的值); //对数组进行填充操作. 重载方法 fill(数组,范围开始,范围结束,填充的值); 对指定范围数组进行填充.

    Arrays.copyOf(数组[],复制后新数组的长度); 复制数组至指定长度.

    Arrays.copyOfRange(数组,指定的数组开始索引的位置.,数组范围的最后索引的位置): 将指定数组的指定长度.复制到一个新数组当中. 实现范围复制. 最后一个参数是新数组元素个数.

    Arrays.sort(数组); 数组排序.,有重载

    Arrays.binarySearch(数组,要查找的值): 二分查找法.返回找到的值所在数组的索引,有重载

    3.排序算法

    最后就是掌握排序算法了.

  • 相关阅读:
    Spring Cloud Hystrix Dashboard的使用 5.1.3
    Spring Cloud Hystrix 服务容错保护 5.1
    Spring Cloud Ribbon 客户端负载均衡 4.3
    Spring Cloud 如何实现服务间的调用 4.2.3
    hadoop3.1集成yarn ha
    hadoop3.1 hdfs的api使用
    hadoop3.1 ha高可用部署
    hadoop3.1 分布式集群部署
    hadoop3.1伪分布式部署
    KVM(八)使用 libvirt 迁移 QEMU/KVM 虚机和 Nova 虚机
  • 原文地址:https://www.cnblogs.com/iBinary/p/9755410.html
Copyright © 2011-2022 走看看