数组的详解

一. 一维数组

概念：一组数据的容器（数组可以存放多个数据）

注意：
1.数组是引用数据类型
2.数组中的数据又叫做元素
3.每个元素都有编号叫做下标/索引
4.下标从0开始
5.数组初始化后，会在内存中开辟一连串连续的空间
6.数组一旦初始化后长度不可以改变（数组没有扩容和删除）
7.数组的操作：添加、修改、查询

数组的声明：数据类型[] 数组名;
数组的初始化：
静态初始化：数据由程序员指定，长度由系统分配
动态初始化：长度由程序员指定，数据由系统分配(默认值)
整数类型：0
浮点类型：0.0
字符类型：' '
布尔类型：false
引用类型：null(空)
静态初始化 vs 动态初始化
一开始就知道数据：静态初始化
一开始就知道长度：动态初始化

public static void main(String[] args){
//静态初始化1
//String[] names = new String[]{"椎名空","爱田奈奈","水野朝阳","桃谷绘里香","铃原爱蜜莉"};
//静态初始化2
//String[] names;
//names = new String[]{"椎名空","爱田奈奈","水野朝阳","桃谷绘里香","铃原爱蜜莉"};
//静态初始化3
String[] names = {"椎名空","爱田奈奈","水野朝阳","桃谷绘里香","铃原爱蜜莉"};
//设置指定下标上的元素
names[3] = "小泽玛利亚";
//获取指定下标上的元素
String n = names[3];
System.out.println("获取指定下标上的元素：" + n);//林成
//ArrayIndexOutOfBoundsException - 数组下标越界异常
//System.out.println(names[100]);
//获取元素个数
int len = names.length;
System.out.println("获取元素个数：" + len);//5
System.out.println("-----------");
//遍历 - for循环
for(int i = 0;i<names.length;i++){
System.out.println(names[i]);
}
System.out.println("-----------");
//遍历 - foreach(增强for循环)
for(String str:names){//遍历数组，依次把元素赋值给str
System.out.println(str);
}
/**
遍历时要使用到下标，就用for循环遍历
遍历时要不使用到下标，就用foreach遍历
*/
}

1.1 一维数组的案列

	*/
需求：定义一个10个长度的int数组，获取最大值
*/
public static void main(String[] args){
int[] is = {3,2,4,35,34,5,25,34,32,18};
int max = is[0];//假设数组中第0个下标位置的元素为最大值
for(int i = 1;i<is.length;i++){
if(max < is[i]){
max = is[i];
}
}
System.out.println("最大值为：" + max);
}

1.2 数组的排序 - 冒泡排序

口诀：
N个数字来排序
两两相比小靠前
外层循环N-1
内层循环N-1-i

	public static void main(String[] args){
int[] is = {39,77,27,20,45,62};
for(int i = 0;i<is.length-1;i++){
for(int j = 0;j<is.length-1-i;j++){
if(is[j] > is[j+1]){
int temp = is[j];
is[j] = is[j+1];
is[j+1] = temp;
}
}
}
for(int num : is){
System.out.println(num);
}

1.3 数组的查找

1.3.1顺序查找：从头到尾遍历

for(int i = 0;i<is.length;i++){
if(is[i] == num){
System.out.println("查找到了");
}
}

1.3.2 二分法查找

前提：先排序

	public static void main(String[] args){
int[] is = {39,77,27,20,45,62};
int num = 77;
//排序
Arrays.sort(is);
int start = 0;
int end = is.length-1;
while(start <= end){
int mid = (start+end)/2;
if(num >is[mid]){
start = mid+1;
}else if(num < is[mid]){
end = mid-1;
}else{
System.out.println("查找到了");
break;
}
}

1.4 数组的复制

/**
知识点：数组的复制1
缺点：修改源数组，新数组的数据也随之改变
*/
public static void main(String[] args){
//源数组
String[] names = {"樱井步","深田咏美","濑亚美莉","吉泽明步"};
//新数组
String[] newNames = names;
//修改源数组
names[0] = "林成";
//遍历新数组
for(String name : newNames){
System.out.println(name);
}

/**
知识点：数组的复制2
*/
public static void main(String[] args){
//源数组
String[] names = {"樱井步","深田咏美","濑亚美莉","吉泽明步"};
//新数组
String[] newNames = new String[names.length];
//将源数组中数据依次赋值给新数组
for(int i = 0;i<names.length;i++){
newNames[i] = names[i];
}
//修改源数组
names[0] = "林成";
//遍历新数组
for(String name : newNames){
System.out.println(name);
}

1.5 数组的扩容

/**
知识点：数组的扩容
*/
public static void main(String[] args){
//源数组
String[] names = {"樱井步","深田咏美","濑亚美莉","吉泽明步"};
//新数组
int capacity = names.length + (names.length>>1);//新容量：是源数组长度的1.5倍
String[] newNames = new String[capacity];
//把源数组所有的数据迁移到新数组中
for(int i = 0;i<names.length;i++){
newNames[i] = names[i];
}
//将新数组的地址赋值给源数组
names = newNames;
//遍历源数组
for(String name:names){
System.out.println(name);
}

1.6 数组的删除

/**
知识点：数组的删除1
缺点：数组原本是存放数据的，删除元素后，数组长度变短
*/
public static void main(String[] args){
//源数组
String[] names = {"樱井步","深田咏美","濑亚美莉","吉泽明步"};
//新数组
String[] newNames = new String[names.length-1];
//将源数组的数据迁移到新数组中，要删除的元素(深田咏美)除外
int index = 0;//新数组的下标
for(String name:names){
if(!name.equals("深田咏美")){
newNames[index] = name;
index++;
}
}
//将新数组的地址赋值给源数组
names = newNames;
//遍历源数组
for(String name:names){
System.out.println(name);
}

/**
知识点：数组的删除2
*/
public static void main(String[] args){
//源数组
String[] names = {"樱井步","深田咏美","濑亚美莉","吉泽明步"};
//数据的迁移
for(int i = 1;i<names.length-1;i++){
names[i] = names[i+1];
}
names[names.length-1] = null;
//遍历源数组
for(String name:names){
System.out.println(name);
}

1.7 数组的参数和返回值

	/**
需求：设计一个方法，传入数组，返回最大值和最小值
*/
public static void main(String[] args){
int[] is = {1,2,3,4,5,6};
int[] newArr = method(is);
System.out.println("最大值为：" + newArr[0]);
System.out.println("最小值为：" + newArr[1]);
}
public static int[] method(int[] is){
int max = is[0];
int min = is[0];
for(int i = 1;i<is.length;i++){
if(max < is[i]){
max = is[i];
}
if(min > is[i]){
min = is[i];
}
}
return new int[]{max,min};
}

1.8 可变参数

/**
注意：可变参数底层就是数组
需求：设计一个方法，传入五个int值，求和
*/
public static void main(String[] args){
int sum = add(1,2,3,4,5,6,7);//实参作为元素，压入到数组中
System.out.println(sum);
}
//is就是数组
public static int add(int... is){
int sum = 0;
for(int num : is){
sum += num;
}
return sum;
}
//注意：可变参数后不能接其他参数
public static void method(int a,String... ss){}

/**
知识点：main方法中的args参数
编译：javac Test10.java
运行：java Test10 小红 小绿 小黄
把小红 小绿 小黄 三个元素压入args数组中
*/
public static void main(String[] args){
for(String str : args){
System.out.println(str);
}
}

1.9 Arrays工具类

public class Test11{
/**
知识点：Arrays工具类
Arrays：java给我们提供的专门操作数组的工具类
工具类：类里的所有方法都是静态的（直接使用类名调用）
API：java类的使用说明书
*/
public static void main(String[] args){
int[] is = {39,77,27,20,45,62};
//排序: 20 27 39 45 62 77
Arrays.sort(is);
//查找(返回值：如果元素在数组中就返回下标，否则返回 -插入点-1 )
int index =
Arrays.binarySearch(is,42);
System.out.println("查找元素的下标为：" + index);
//替换
Arrays.fill(is,888);
Arrays.fill(is,1,4,666);
//拷贝
int[] copyOf = Arrays.copyOf(is,is.length*2);
int[] copyOfRange = Arrays.copyOfRange(is,3,8);
//获取数组的字符串表示(将数组转换为字符串)
System.out.println(Arrays.toString(copyOfRange));
}

二. 二维数组

含义：包含了多个一维数组

​ 声明：数据类型[][] 数组名;
​
​ 数组的初始化：
​ 静态初始化：数据由程序员指定，长度由系统自动分配
​ 动态初始化：长度由程序员指定，数据由系统赋默认值

整数类型：0

浮点类型：0.0

字符类型：’ ’

布尔类型：false

引用类型：null

//静态初始化1
//String[][] names = new String[][]{{"深田咏美","爱田奈奈","京香julia"},{"明日花绮罗","小峰由衣","泽村丽子","小泽玛利亚"}};
//静态初始化2
//String[][] names;
//names = new String[][]{{"深田咏美","爱田奈奈","京香julia"},{"明日花绮罗","小峰由衣","泽村丽子","小泽玛利亚"}};
//静态初始化3
String[][] names = {{"深田咏美","爱田奈奈","京香julia"},{"明日花绮罗","小峰由衣","泽村丽子","小泽玛利亚"}};
//设置指定下标上的元素
names[0][2] = "林成";
//获取指定下标上的元素
String name = names[0][2];
System.out.println("获取指定下标上的元素：" + name);
//获取长度
System.out.println("获取二维数组中一维数组的个数：" + names.length);//2
System.out.println("获取二维数组中第一个一维数组的元素个数：" + names[0].length);//3
System.out.println("获取二维数组中第二个一维数组的元素个数：" + names[1].length);//4
System.out.println("------------");
//遍历 - for循环
for (int i = 0; i < names.length; i++) {
for (int j = 0; j < names[i].length; j++) {
System.out.println(names[i][j]);
}
}
System.out.println("------------");
//遍历 - foreach
for (String[] strings : names) {
for (String string : strings) {
System.out.println(string);
}
}
}

2.1 二维数组的动态初始化

/** 需求：使用动态初始化二维数组，其中第一个一维数组有3个元素，第二个一维数组有4个元素
*/
//动态初始化：标注二维数组中有2个一维数组
String[][] names = new String[2][];
//把长度为3的一维数组赋值给二维数组中下标为0的位置
names[0] = new String[3];
//把长度为4的一维数组赋值给二维数组中下标为1的位置
names[1] = new String[4];
System.out.println("获取二维数组中一维数组的个数：" + names.length);//2
System.out.println("获取二维数组中第一个一维数组的元素个数：" + names[0].length);//3
System.out.println("获取二维数组中第二个一维数组的元素个数：" + names[1].length);//4

}

最后

以上就是甜蜜鞋子为你收集整理的数组的详解数组的详解的全部内容，希望文章能够帮你解决数组的详解数组的详解所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。