概述
数组:最常见的一种数据结构。是具有相同数据类型的一组数据的集合。在Java中同样将数组看作一个对象,可根据数组的维数将数组分为一维数组,二维数组......
一维数组
一维数组实质上是一组相同类型数据的线性集合,当在程序中需要处理一组数据,或者传递一些数据时,可以应用这种类型的数组。
创建一维数组
数组作为对象允许使用new关键字进行内存分配。在使用数组之前,必须首先定义数组变量所属的类型。
一维数组的创建有两种方式
1.先声明,在用new关键字进行内存分配
声明有两种方式 数组元素类型 数组名字[ ];
数组元素类型 [ ] 数组名字;
数组元素类型决定了数组的数据类型,它可以是Java中任意的数据类型,声明数组后我们还不能立即访问它的任何元素,因为声明数组只是给出了数组名字和元素的数据类型,要想使用它还要为它分配内存空间,在位数组分配内存空间时必须指明数组的长度,格式如下:
数组名字=new 数组元素的类型[数组元素的个数]
数组名字:被连接到数组变量的名称
数组元素的个数:指定数组中变量的个数,即数组的长度
通过上面可知,使用new关键字为数组分配内存时,必须指定数组元素的类型和数字元素的个数,即数组的长度
2.声明的同时为数组分配内存
数组元素的类型 数组名=new 数组元素的类型[数组元素的个数];
初始化数组
int arr[ ]=new int [ ]{1,2,3,5,25};
int arr[ ]={34,23,12,6};
数组元素赋值
数组名[索引]=值;
例题
package a;
public class A {
public static void main(String[] args) {
int d[]=new int [] {//创建并初始化一维数组
31,28,31,30,31,30,31,31,30,31,30,31
};
for(int i=0;i<12;i++) {//利用循环输出信息
System.out.println((i+1)+"月有"+d[i]+"天");//输出每月天数
}
}
}
结果
如果将12改成11,那么只会输出11个月,但是将12改成13,会输出12个月然后报错
这个错误是数组越界,是比较常见的错误
我们为此有两种解决办法
1.将i<某数,改为 数组名.length,这是数组长度的意思,这样就不会出错
2.使用foreach循环
其原理就是遍历数组,只不过更简洁
例题
package a;
public class A {
public static void main(String[] args) {
// TODO Auto-generated method stub
//Scanner sc=new Scanner(System.in);
int []arr=new int [] {
5,13,96
};//for循环遍历数组
for(int i=0;i<arr.length;i++) {
int temp =arr[i];
System.out.println(temp);
}
//foreach循环遍历数组
for (int temp:arr) {
System.out.println(temp);
}
}
}
二维数组
数组元素类型 数组名字[ ] [ ] ;
数组元素类型 [ ] [ ] 数组名字;
分配内存
数组名 =new 数组元素的类型[ 行数] [列数];
设置初始值
数组名= new 数组元素的类型[ ] [ ]{{值1,值2,...},{值1,值2,...},{值1,值2,...}};
数组元素赋值
数组名[行号] [列号]=值;
package a;
public class A {
public static void main(String[] args) {
int a[][]=new int[3][4];//定义一个3行4列的二维数组
for(int i=0;i<a.length;i++) {//遍历数组
for(int j=0;j<a[i].length;j++) {//.length是数组长度
System.out.print(a[i][j]);//输出
}System.out.println();
}
}
}
填充替换数组
使用Arrays这个类,具体格式为
Arrays.fill(数组名,替换的值);
例题:
package a;
import java.util.Arrays;//导入类
public class h {
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[]=new int [5];//创建数组
Arrays.fill(arr, 8);使用同一个值填充数组
for (int i=0;i<arr.length;i++) {//遍历数组
System.out.println("第"+i+"个元素是"+arr[i]);
}
}
}
替换部分元素(前改后不改)
Arrays.fill(数组名,前索引,后索引,替换的值);
package a;
import java.util.Arrays;//导入类
public class h {
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[]=new int [] {45,12,5,10};//定义并初始化数组
Arrays.fill(arr,1,2, 8);//使用fill方法替换数组指定范围内的元素
for (int i=0;i<arr.length;i++) {//遍历数组
System.out.println("第"+i+"个元素是"+arr[i]);
}
}
}
复制数组元素(空位补0,溢出去掉)
新数组名=Arrays.copyOf(旧数组名,新数组长度);
package a;
import java.util.Arrays;//导入类
public class h {
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[]=new int [] {23,42,12};//定义数组
int newarr[]= Arrays.copyOf(arr,5);//复制数组到新数组中
for (int i=0;i<newarr.length;i++) {//遍历数组
System.out.println(newarr[i]);
}
}
}
复制数组部分元素(前在后不在)
新数组名=Arrays.copyOfRange(旧数组名,前索引,后索引);
package a;
import java.util.Arrays;//定义类
public class h {
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[]=new int [] {23,42,12,84,10};//定义数组
int newarr[]= Arrays.copyOfRange(arr,1,4);//复制数组到新数组
for (int i=0;i<newarr.length;i++) {//遍历数组
System.out.println(newarr[i]);
}
}
}
数组元素排序
Arrays.sort(数组名);
查询数组元素(先排序再查询)
索引=Arrays.binarySearch(数组名,元素);
package a;
import java.util.Arrays;//导入类
public class h {
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[]=new int [] {1,8,9,4,5};//定义数组
Arrays.sort(arr);//对数组进行排序
int i=Arrays.binarySearch(arr, 4);//找到数组中元素4的值
System.out.println("4的索引位置是"+i);//输出
}
}
查询部分元素 (先排序再查询,前含后不含)
索引=Arrays.binarySearch(数组名,前索引,后索引,元素);
package a;
import java.util.Arrays;//导入类
public class h {
public static void main(String[] args) {
// TODO Auto-generated method stub
String arr[]=new String []{"ab","cd","ef","yz"};//定义string型数组
Arrays.sort(arr);//排序
int i=Arrays.binarySearch(arr,1,3,"cd");//在指定范围内搜索元素cd的索引位置
System.out.println("cd的索引位置是:"+i);//输出
}
}
ps:string是字符串
排序
冒泡排序
冒泡算法由双层循环实现,其中外层循环用于控制排序轮数
例题
package a;
public class h {
public static void main(String[] args) {
// TODO Auto-generated method stub
int []arr= {63,4,24,1,3,15};//定义数组
h soter=new h();//创建冒泡排序的对象
soter.sort(arr);//调用排序方法
}
public void sort(int[]arr) {//创建一个
for (int i=1;i<arr.length ;i++) {//比较两个数,大的往后
for (int j=0;j<arr.length-i;j++) {
if(arr[j]>arr[j+1]) {//交换数
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
showArray(arr);//输出
}
public void showArray(int[]arr) {
for(int i:arr) {
System.out.print(">"+i);
}System.out.println();
}
}
直接排序
将最大的数放到最后,固定不动,第二次再将最大的数放到最后,固定不动,往后继续。
例题:
package a;
public class h {
public static void main(String[] args) {
// TODO Auto-generated method stub
int []a= {64,4,24,1,3,15};//定义数组
int d;//最大值
for(int i=1;i<a.length ;i++) {//外循环,要轮几次
d=0;//初始化
for(int j=1;j<a.length-i;j++) {//比大小
if(a[j]>a[d]) {//最大值转换
d=j;
}
}
int t=a[a.length-i];//将索引赋给临时变量t
a[a.length-i]=a[d];//将最大值放到已经空掉的索引内,达到交换的目的
a[d]=t;//将之前索引的值赋给临时变量
}
for(int i:a) {//遍历数组
System.out.print(">"+i);
}
}
}
反转排序
就是第一个数和最后一个数交换,第二个数和倒数第二个数交换,第三个数和倒数第三个数交换,以此类推。就像一面镜子,如果是单数中间那个不会交换。