数组的基础知识
- 数组的创建
- 列表元素的修改
- 普通 for 循环遍历数组
- for-each loop 遍历数组
- 逆序遍历数组
- 用 for-each 循环求数组最大值
- 求数组最小值
- 返回最大值的位置
- 返回最小值的位置
- 查找元素
- 检查元素是否在数组中
- for-each 检查元素是否在数组中
- 字符串的比较
- 字符串比较 == 比较内存地址
- euqals 比较内容
- 字符串字面量
- 自定 equals 方法比较对象
- Point 类比较
- 自定义 equals 的比较逻辑
数组的创建
数组是就是，一系列的值；数组创建之后大小不能变化。
ArrayList 也叫做动态数组，创建之后可以动态增删元素。
int[] arr = new int[3]; // 默认值 0 String[] colors = new String[4]; // 默认值 null double[] c = new double[4]; // 默认值是 0.0 boolean[] bs = new boolean[4]; // false
new 关键字表示分配新的内存空间来保存数据。
列表元素的修改
int[] arr = {1, 2}; // 直接指定元素 String[] list = {"a", "b"};
list[1] = "lucy"; // 就是修改 list 列表的第二个值
lucy
普通 for 循环遍历数组
// 遍历数组 for (int i = 0; i < list.length; i++)
{
System.out.println(list[i]);
}
a
lucy
for-each loop 遍历数组
// for-each loop for (String s : list)
{
System.out.println(s);
}
a
lucy
int[] arr = {1, 2, 3, 4, 6, 10, 20};
遍历数组是最基本的操作，但是有时候需要按照相反的顺序遍历数组
for (int i = arr.length - 1; i >= 0; i--)
{
System.out.println(arr[i]);
}
20
10
6
4
3
2
1
逆序遍历数组
有的同学对于arr.length - 1不理解，是这样，数组中的元素索引是从 0 开始的，所以一个数组如果有 3 个元素，索引就是 0 1 2，所有最后一个元素的索引是数组的长度减去 1.
public static void reverseDisplay(int[] arr) { for (int i = arr.length - 1; i >= 0; i--)
{
System.out.println(arr[i]);
}
}
reverseDisplay(arr)
20
10
6
4
3
2
1
用 for-each 循环求数组最大值
/** 返回最大值 */ public static int maxForEachLoop(int[] arr) { int max = arr[0]; // 假设，第一个元素是最大的 for (int v : arr)
{ if (v > max) // 如果遇到更大的值，就更新最大值 {
max = v;
}
} return max;
}
熟悉了 for-each 循环之后，会发现，这种写法其实更加简洁。
/** 返回最大值 */ public static int max(int[] arr) { int max = arr[0]; // 假设，第一个元素是最大的 for (int i = 0; i < arr.length; i++)
{ if (arr[i] > max)
{
max = arr[i];
}
} return max;
}
很明显，利用 regular for loop 要比 for-each loop 稍微麻烦一点。
求数组最小值
/** 返回最小值 */ public static int minForEachLoop(int[] arr) { int min = arr[0]; // 假设，第一个元素是最小的 for (int v : arr)
{ if (v < min)
{
min = v;
}
} return min;
}
max(arr)
20
min(arr)
1
上面的方法是求数组中元素的最大值和最小值，我们用 for-each 可以简化代码，但是有时候我们想要知道，最大值的索引，就得用普通 for 循环了。
返回最大值的位置
// 返回最大值的位置 public static int posOfMaxValue(int[] arr) { int maxIndex = 0; // 假设最大值的索引是 maxIndex for (int i = 0; i < arr.length; i++)
{ if (arr[i] > arr[maxIndex])
{
maxIndex = i;
}
} return maxIndex;
}
int[] arr = {1, 2, 3, 4, 6, 10, 20};
posOfMaxValue(arr)
6
这个方法返回的是最大值在数组中的索引，而不是最大值本身。在有的算法，比如选择排序中，我们往往需要知道在某些元素中，最大值的位置，就可以用到这个方法。
返回最小值的位置
// 返回最大值的位置 public static int posOfMinValue(int[] arr) { int minIndex = 0; // 假设最大值的索引是 maxIndex for (int i = 0; i < arr.length; i++)
{ if (arr[i] < arr[minIndex])
{
minIndex = i;
}
} return minIndex;
}
int[] arr = {1, 2, 3, 4, 6, 10, 20};
posOfMinValue(arr)
0
查找元素
查找一个元素在数组中的位置，如果不存在就返回 -1；如果存在返回这个元素的索引。
比如说，字符串有indexOf(String s)方法，查找字符串 s，在另外一个字符串第一次出现的位置；如果字符串 s 在另外一个字符串中没有出现，那么就返回 -1。我们可以自定义数组的方法，名称是 find
/** 查找一个值 value 在数组 arr 中的位置；如果不存在返回 -1*/ public static int find(int[] arr, int value) { for (int i = 0; i < arr.length; i++)
{ if (arr[i] == value)
{ return i; // 如果找到了直接返回位置 }
} return -1; // 如果找不到返回 -1 }
int[] arr = {2, 3, 1};
find(arr, 2)
0
int[] arr = {2, 3, 1};
find(arr, 3)
1
find(arr, 100)
-1
检查元素是否在数组中
我们有的时候并不需要知道一个元素在一个数组中的位置，只是要知道元素是否在数组中存在即可，这个时候可以用普通 for 循环来做；要求返回 true 或者 false。
有的同学，我可以调用上面的 find 方法，然后把结果跟 -1 比较，就能判断在不在了，但是这种方法相对繁琐，我们可以直接定义方法，判断一个元素是否在数组中出现。这类方法的方法名可以是 find，in，contain，have。
/** 查找一个值 value 在数组 arr 中的位置；如果不存在返回 -1*/ public static boolean have(int[] arr, int value) { for (int i = 0; i < arr.length; i++)
{ if (arr[i] == value)
{ return true; // 如果找到了直接返回位置 }
} return false; // 如果找不到返回 -1 }
int[] arr = {2, 3, 1};
have(arr, 200)
false
have(arr, 3)
true
上面的代码用的是普通 for 循环，但是我们这次不关心 value 在数组中的位置，只关心有没有。既然这样的话，我就可以使用 for-each 循环来简化代码，减少代码出错的机会。
for-each 检查元素是否在数组中
public static boolean have(int[] arr, int value) { for (int elt : arr)
{ if (elt == value)
{ return true;
}
} return false;
}
但是，其实在这里，我们不关心，元素在数组中的位置，所以我们可以使用 for-each 简化代码，代码如下：
for (int value : arr)
{
System.out.println(value);
}
2
3
1
字符串的比较
需要的注意是，查找元素是否在数组中，涉及到数组元素的比较。如果是原始类型，比如 int，double，boolean，char 类型，我们是可以直接用==来比较两个元素是否相等；但是对于 String 以及其他的对象类型，我们知道 == 实际上比较的是，两个对象在内存对地址是否一致。
对于字符串来说，== 比较就是两个字符串在内存地址；所以比较字符串或者对象是否相等，我们需要用字符串的 equals 方法。
所以查找字符串是否在字符串数组中的方法，下面写法是错误的：
字符串比较 == 比较内存地址
public static boolean have(String[] arr, String value) { for (String elt : arr)
{ if (elt == value) // 注意比较内容是否一致，不能用 == 要用 equals 方法 { return true;
}
} return false;
}
比较字符串的内容是否相等应该用 equals 方法，正确代码如下：
euqals 比较内容
public static boolean haveEquals(String[] arr, String value) { for (String elt : arr)
{ if (elt.equals(value)) // 注意比较内容是否一致，不能用 == 要用 equals 方法 { return true;
}
} return false;
}
String[] list = {new String("a"), "b", "c"};
have(list, "a")
false
字符串字面量
因为new String("a")是用运算符 new 创建的，也就是要在内存中分配新的内存空间；所以这个字符串对象和字符串字面量 "a" 在内存中的位置是不同的，所以尽管都是 a，也找不到。
String[] list = {"a", "b", "c"};
have(list, "a")
true
因为 "a" 是字符串字面量，内容相同的字符串字面量在 Java 是保存在内存的同一位置的，所以用 have 可以找到。
String[] list = {new String("a"), "b", "c"};
haveEquals(list, "a");
true
因为字符串字面量 "a" 和字符对象 new String("a")，尽管在内存中保存地址不同，但是内容是相同的，都是 a，所以可以正确的的找到。要注意对象类型的比较，equals 才是比较是否是相同的类型。
自定 equals 方法比较对象
Point 类比较
class Point { private int x, y; public Point(int x, int y) { this.x = x; this.y = y;
} public int getX() {return x;} public int getY() {return y;} public boolean equals(Point other) { if (other == null)
{ return false;
} return x == other.getX() && y == other.getY();
}
}
Point p231 = new Point(2, 3);
Point p232 = new Point(2, 3);
System.out.println(p231 + " " + p232)
REPL.$JShell$55$Point@74517d53 REPL.$JShell$55$Point@7a969da9
通过代码的运行结果，观察 @ 之后的内容，发现两个对象其实是在不同的地址。
Point p = p231;
System.out.println(p231 + " " + p)
REPL.$JShell$55$Point@74517d53 REPL.$JShell$55$Point@74517d53
通过观察地址，我们可以知道 p 就是对象 p221 的 alias name，也就是别名，所以用 == 比较结果肯定是 true; 因为我们知道，p 也好，p231 也好本质上是保存了对待在内存中的地址，而不是对象本身。
p == p231
true
p231 == p232
false
p231.equals(p232)
true
对于对象类来说，两个对象比较，判断是否相等或者是相同对象的逻辑是可以自己定义的，就像是 toString 是可以自己定义。我们可以规定，什么样的两个对象是相等的。对于两个长方形，如果左上角的顶点相同，并且长和宽也相同，我们就可以认为这是两个相同的长方形。
自定义 equals 的比较逻辑
class Rect { private Point point; private int w, h; public Rect(Point p, int w, int h) { this.w = w; this.h = h; this.point = p;
} public Point getPoint() {return point;} public int getW() {return w;} public int getH() {return h;} public boolean equals(Rect other) { if (other == null) {return false;} // return point == other.getPoint() && w == other.getW() && h == other.getH(); return point.equals(other.getPoint()) && w == other.getW() && h == other.getH();
} public String toString() { return point.getX() + " " + point.getY() + " " + w + " " + h;
}
}
Rect r1 = new Rect(new Point(2, 3), 2, 3);
Rect r2 = new Rect(new Point(2, 3), 2, 3);
r1 == r2 // 两个对象在内存中的地址不同
false
r1.equals(r2) // 相等的逻辑是我们自己定义的，只要左上角坐标和长款一致，就是相同的长方形
true
r1
2 3 2 3
r2
2 3 2 3
语雀导出的 markdown 可以包含换行和 wrap，对于代码来说排版尤为重要，否则普通的无法导入到公众号。 2023 对自己好点，但行好事，莫问前程。
【竞赛报名/项目咨询请加微信：mollywei007】
