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.排序算法
最后就是掌握排序算法了.
以上是 Java开发知识之Java数组 的全部内容， 来源链接： utcz.com/z/394129.html
