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.排序算法

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