学习JavaEE的日子 day10 一维数组的深入，二维数组
day10
1.eclipse的使用
Eclipse是一款功能强大的集成开发环境（IDE），主要用于开发Java应用程序。
1.项目（Project）：项目是为满足特定需求而创建的代码文件集合。一个工作区可以包含多个项目，而您的代码必须归属于某个项目，不能单独存在。
2.创建Java文件：在Eclipse中创建Java文件非常简单。您可以按照以下步骤进行操作：
在Eclipse的导航菜单中选择“File（文件）”>“New（新建）”>“Java Project（Java项目）”。
输入项目名称并点击“Finish（完成）”。
在项目上右键单击，选择“New（新建）”>“Class（类）”。
输入类名和包名，并选择所需的选项。
包名字：com.xxx.xxx
点击“Finish（完成）”即可创建Java文件。
注意：补全代码：alt+/
2.一维数组的深入
2.1 数组的排序 – 冒泡排序
口诀：
N个数字来排序两两相比小靠前外层循环N-1内层循环N-1-i
public static void main(String[] args) {
int[] arr = {18,32,81,63,20,9};
for(int i = 0;i<arr.length-1;i++){
for (int j = 0; j < arr.length-1-i; j++) {
if(arr[j] > arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
for (int element : arr) {
System.out.print(element + " ");
}
}
更多排序见《java十大经典排序》
2.2 数组的查找 – 线性查找
public static void main(String[] args) {
int[] arr = {18,32,81,63,20,9};
int num = 81;//需要查找的元素
for (int i = 0; i < arr.length; i++) {
if(num == arr[i]){
System.out.println("找到该元素了，下标为：" + i);
break;
}
}
}
* 知识点：
*
*
2.3 数组的查找 – 二分法查找
前提：必须先排序，再二分法查找！！！！
public static void main(String[] args) {
int[] arr = {18,32,81,63,20,9};
//排序 -- 9,18,20,32,63,81
Arrays.sort(arr);
int num = 81;//需要查找的元素
int start = 0;
int end = arr.length-1;
while(start <= end){
int mid = (start + end)/2;
if(num > arr[mid]){
start = mid+1;
}else if(num < arr[mid]){
end = mid-1;
}else{
System.out.println("找到该元素了，下标为：" + mid);
break;
}
}
2.4 数组的复制
2.4.1 数组的复制1
注意：以下方法，复制后，改变源数组，新数组里的数据也会发生改变
public static void main(String[] args) {
//源数组
String[] names = {"麻生希","椎名空","水菜丽","朝桐光"};
//新数组
String[] newNames = names;
//改变源数组的数据
names[1] = "杨健平";
//遍历新数组
for (String element : newNames) {
System.out.println(element);
}
}
2.4.2 数组的复制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[1] = "杨健平";
//遍历新数组
for (String element : newNames) {
System.out.println(element);
}
}
2.5 数组的扩容
需求：扩容后的长度是原来的1.5倍
public static void main(String[] args) {
//源数组
String[] names = {"麻生希","椎名空","水菜丽","朝桐光"};
//获取数组长度
int oldCapacity = names.length;
//计算新的长度
int newCapacity = oldCapacity + (oldCapacity>>1);
//新数组 - [null,null,null,null,null,null]
String[] newNames = new String[newCapacity];
//遍历源数组，将数据赋值给新数组
for (int i = 0; i < names.length; i++) {
newNames[i] = names[i];
}
//将新数组的地址赋值给源数组
names = newNames;
//遍历源数组
for (String element : names) {
System.out.println(element);
}
}
2.6 数组的删除
2.6.1 数组的删除1
缺点：这种方式的删除数组，会让数组的空间越变越小。数组是用来存储数据的，越变越小会使得存储数据不方便
public static void main(String[] args) {
//源数组
String[] names = {"麻生希","椎名空","水菜丽","朝桐光"};
//新数组
String[] newNames = new String[names.length-1];
//遍历源数组，将"椎名空"以外的元素赋值到新数组中
int index = 0;
for (String element : names) {
if(!element.equals("椎名空")){
newNames[index] = element;
index++;
}
}
//将新数组的引用赋值给源数组
names = newNames;
//遍历源数组
for (String element : names) {
System.out.println(element);
}
}
2.6.2 数组的删除2
public static void main(String[] args) {
//源数组
String[] names = {"麻生希","椎名空","水菜丽","朝桐光"};
//元素的迁移
for (int i = 1; i < names.length-1; i++) {
names[i] = names[i+1];
}
//将最后一个元素赋为null
names[names.length-1] = null;
//遍历源数组
for (String element : names) {
System.out.println(element);
}
}
2.7 数组作为方法的参数和返回值
需求：设计一个方法，传入int类型的数组，返回最大值和最小值
public static void main(String[] args) {
int[] arr = {18,32,81,63,20,9};
int[] maxAndMin = getMaxAndMin(arr);
System.out.println("最大值为：" + maxAndMin[0]);
System.out.println("最小值为：" + maxAndMin[1]);
}
public static int[] getMaxAndMin(int[] arr){
int max = arr[0];
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if(max < arr[i]){
max = arr[i];
}
if(min > arr[i]){
min = arr[i];
}
}
return new int[]{max,min};
}
}
小结：
方法的返回值只能有一个
如果想返回多个数据，就可以将多个数据存入一个数组中
2.8 可变参数
需求：设计一个方法，传入n个int值，获取最大值并返回
public static void main(String[] args) {
int max = getMax(1,2,3,4,10,5,6,7,8,9,0);//实参作为元素压入到数组中
System.out.println("最大值为：" + max);
}
//int... arr 就是数组
public static int getMax(int... arr){
int max = arr[0];
for(int i = 1; i < arr.length; i++) {
if(max < arr[i]){
max = arr[i];
}
}
return max;
}
//可变参数后不能添加其他参数
public static void method(String str,int... arr){}
} //错误的
小结：
1.可变参数就是数组
2.实参就是数组里的元素
3.可变参数后不能添加其他参数
2.9 地址值
int[] arr = {1,2,3,4,5};
System.out.println(arr);//[I@6d03e736
double[] arr2 = {1.1,2.2,3.3};
System.out.println(arr2);//[D@568db2f2
打印数组的时候，实际出现的是数组的地址值。
数组的地址值：就表示数组在内存中的位置。
以[I@6d03e736为例：
6d03e736：就是数组在内存中真正的地址值。（十六进制的）
2.10 数组常见问题
空指针异常(NullPointerException)
数组越界异常(ArrayIndexOutOfBoundsException)
当访问了数组中不存在的索引，就会引发索引越界异常。
避免：
针对于任意一个数组，索引的范围：
最小索引：0
最大索引：数组的长度 - 1
数组名.length - 1
2.11 Arrays工具类
概念：Arrays是Java给我们提供的专门操作数组的工具类
理解：
1.工具类 - 该类中所有的方法都是静态的，直接使用类名调用
2.API - Java提供类的使用说明书
public static void main(String[] args) {
int[] arr = {18,32,81,63,20,9};
//排序 - [9, 18, 20, 32, 63, 81]
Arrays.sort(arr);
//查找(底层还用二分法去查找元素，所以必须先排序，再查找！)
//返回值规则：如果搜索的元素包含在数组中就返回元素的下标; 否则，返回（-插入点-1）
int index = Arrays.binarySearch(arr, 28);
System.out.println("查找元素的下标为：" + index);
//拷贝数组（目标数组，新的长度）- [9, 18, 20, 32, 63, 81, 0, 0, 0, 0]
int[] copyOf = Arrays.copyOf(arr, 10);
//拷贝区间数组（目标数组，开始下标-包含，结束下标-排他）- [18, 20, 32, 63, 81, 0, 0]
int[] copyOfRange = Arrays.copyOfRange(copyOf, 1, 8);
//替换元素 - [666, 666, 666, 666, 666, 666, 666]
Arrays.fill(copyOfRange, 666);
//替换区间元素（目标数组，开始下标-包含，结束下标-排他，替换的值） - [666, 666, 888, 888, 888, 666, 666]
Arrays.fill(copyOfRange, 2, 5, 888);
//将数组转换为字符串
String str = Arrays.toString(copyOfRange);
System.out.println(str);
}
3.二维数组
理解：二维数组中包含了多个一维数组
概念：
1.数组是引用数据类型
2.数组中的元素在内存中是连续的
3.数组中的数据称之为元素
4.每个元素都有编号称之为下标
5.下标从0开始
6.数组一旦初始化成功，长度不可改变
数组的声明：数据类型[][] 数组名;
数组的初始化：
静态初始化：程序员指定元素，长度由系统自动分配
动态初始化：
public static void main(String[] args) {
//静态初始化一：
//String[][] names = new String[][]{{"麻生希","椎名空","水菜丽"},{"爱田奈奈","古川伊织","水野朝阳","铃原爱蜜莉","桃谷绘里香"}};
//静态初始化二：先声明，再初始化
//String[][] names;
//names = new String[][]{{"麻生希","椎名空","水菜丽"},{"爱田奈奈","古川伊织","水野朝阳","铃原爱蜜莉","桃谷绘里香"}};
//静态初始化三：简写第一种写法
String[][] names = {{"麻生希","椎名空","水菜丽"},{"爱田奈奈","古川伊织","水野朝阳","铃原爱蜜莉","桃谷绘里香"}};
//通过下标设置元素
names[1][2] = "巴得伟";
//通过下标获取元素
String str = names[1][2];
System.out.println("通过下标获取元素：" + str);
//获取长度
System.out.println("获取二维数组中一维数组的个数：" + names.length);//2
System.out.println("获取二维数组中第一个一维数组元素的个数：" + names[0].length);//3
System.out.println("获取二维数组中第二个一维数组元素的个数：" + names[1].length);//5
//遍历二维数组
//思路：先循环获取二维数组中的一维数组，再循环获取一维数组中的元素
//遍历 -- 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循环
for (String[] ss : names) {
for (String element : ss) {
System.out.println(element);
}
}
}
动态初始化：程序员指定长度，由系统自动分配元素
整数类型：0
浮点类型：0.0
字符类型：’ ’
布尔类型：false
引用类型：null
public static void main(String[] args) {
//动态初始化一：
//String[][] names = new String[2][3];//2表示2个一维数组，2表示每个一维数组有3个元素
//动态初始化二：先声明，再初始化
String[][] names;
names = new String[2][3];//2表示2个一维数组，2表示每个一维数组有3个元素
//通过下标设置元素
names[0][0] = "巴得伟1";
names[0][1] = "巴得伟2";
names[0][2] = "巴得伟3";
names[1][0] = "巴得伟4";
names[1][1] = "巴得伟5";
names[1][2] = "巴得伟6";
//通过下标获取元素
String str = names[1][2];
System.out.println("通过下标获取元素：" + str);
//获取长度
System.out.println("获取二维数组中一维数组的个数：" + names.length);//2
System.out.println("获取二维数组中第一个一维数组元素的个数：" + names[0].length);//3
System.out.println("获取二维数组中第二个一维数组元素的个数：" + names[1].length);//5
//遍历二维数组
//思路：先循环获取二维数组中的一维数组，再循环获取一维数组中的元素
//遍历 -- 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循环
for (String[] ss : names) {
for (String element : ss) {
System.out.println(element);
}
}
}
需求：使用动态初始化声明二维数组，其中第一个一维数组有3个元素，第二个一维数组有5个元素
public static void main(String[] args) {
String[][] names = new String[2][];
String[] s1 = {"麻生希","椎名空","水菜丽"};
String[] s2 = {"爱田奈奈","古川伊织","水野朝阳","濑亚美莉","明日花绮罗"};
names[0] = s1;
names[1] = s2;
for (String[] ss : names) {
for (String element : ss) {
System.out.println(element);
}
}
}