1. Java数组基础概念与核心特性数组是Java中最基础且重要的数据结构之一它是一组相同类型数据的集合通过下标索引访问元素。在实际开发中数组的使用频率极高无论是算法题解、数据处理还是系统设计都离不开它。Java数组有几个关键特性需要特别注意固定长度数组一旦创建其长度就不可改变类型安全所有元素必须是同一数据类型内存连续数组元素在内存中是连续存储的零基索引数组下标从0开始计算// 数组声明与初始化示例 int[] numbers new int[5]; // 声明长度为5的整型数组 String[] names {Alice, Bob, Charlie}; // 声明并初始化字符串数组注意数组长度使用length属性获取不是length()方法这与String不同2. 数组的内存模型与性能特点理解数组在JVM中的内存分配机制对编写高效代码至关重要。数组在内存中被分配为连续的空间块这使得它具有O(1)时间复杂度的随机访问能力但同时也带来了一些限制。2.1 内存布局分析当声明一个数组时JVM会在堆内存中分配连续空间。例如int[100]数组会分配400字节连续内存假设int占4字节。这种连续内存分配带来两个重要特性CPU缓存友好连续内存访问能充分利用CPU缓存行减少缓存未命中预取效率高现代CPU能预测并预取连续内存数据// 内存访问模式对比 int[] arr new int[10000]; // 顺序访问高效 for(int i0; iarr.length; i) { arr[i] i; } // 随机访问效率较低 Random rand new Random(); for(int i0; iarr.length; i) { int index rand.nextInt(arr.length); arr[index] i; }2.2 多维数组实现原理Java中的多维数组实际上是数组的数组。例如二维数组int[][]可以理解为每个元素都是int[]的一维数组。// 二维数组内存分配示例 int[][] matrix new int[3][4]; /* 内存结构 matrix - [引用1, 引用2, 引用3] | | | v v v [int,int,int,int] // 第一行 [int,int,int,int] // 第二行 [int,int,int,int] // 第三行 */重要提示不规则数组每行长度不同也是合法的但会增加访问复杂度3. 数组操作的高级技巧与性能优化掌握了数组基础后我们需要了解一些高级操作技巧和性能优化方法这些在实际工程和面试中都非常实用。3.1 数组拷贝的四种方式对比Java提供了多种数组拷贝方法各有适用场景方法速度适用场景注意事项System.arraycopy最快大批量数据拷贝需要处理边界条件Arrays.copyOf快数组扩容/缩容创建新数组clone()中等需要完全副本浅拷贝手动循环慢需要特殊处理每个元素代码量多但灵活// 数组拷贝示例 int[] source {1, 2, 3, 4, 5}; int[] dest new int[5]; // 1. System.arraycopy System.arraycopy(source, 0, dest, 0, source.length); // 2. Arrays.copyOf int[] copy Arrays.copyOf(source, source.length); // 3. clone() int[] cloned source.clone(); // 4. 手动循环 int[] manual new int[source.length]; for(int i0; isource.length; i) { manual[i] source[i]; }3.2 数组排序与查找优化Arrays类提供了丰富的排序和查找方法合理使用能显著提升性能int[] numbers {5, 3, 9, 1, 7}; // 快速排序修改原数组 Arrays.sort(numbers); // 并行排序大数据量时更高效 Arrays.parallelSort(numbers); // 二分查找必须先排序 int index Arrays.binarySearch(numbers, 7);性能提示对于超过1000个元素的数组parallelSort()通常比sort()更快4. 常见数组问题与解决方案在实际开发中我们会遇到各种数组相关的问题这里总结几个典型场景的解决方案。4.1 数组越界异常处理ArrayIndexOutOfBoundsException是新手最常见的错误之一。防御性编程可以有效避免// 不安全的访问 int[] arr new int[5]; int value arr[5]; // 抛出ArrayIndexOutOfBoundsException // 安全的访问方式 public static int safeAccess(int[] array, int index) { if (array null) { throw new IllegalArgumentException(数组不能为null); } if (index 0 || index array.length) { throw new IndexOutOfBoundsException( String.format(索引%d越界数组长度%d, index, array.length)); } return array[index]; }4.2 对象数组去重技巧对象数组去重有多种实现方式各有优缺点// 方法1使用HashSet保持顺序 public static T T[] removeDuplicates(T[] array) { SetT seen new LinkedHashSet(); Collections.addAll(seen, array); return seen.toArray((T[]) Array.newInstance(array.getClass().getComponentType(), 0)); } // 方法2Java8 Stream API public static T T[] removeDuplicatesStream(T[] array) { return Arrays.stream(array) .distinct() .toArray(size - (T[]) Array.newInstance(array.getClass().getComponentType(), size)); } // 方法3手动去重不创建新集合 public static String[] removeDuplicatesManual(String[] array) { int end array.length; for (int i 0; i end; i) { for (int j i 1; j end; j) { if (array[i].equals(array[j])) { array[j] array[end - 1]; end--; j--; } } } return Arrays.copyOf(array, end); }5. 数组与集合的互操作在实际开发中经常需要在数组和集合之间转换Java提供了丰富的API支持这种转换。5.1 数组转集合的陷阱与正确方式直接将数组转为集合有一些需要注意的陷阱String[] strArray {a, b, c}; // 方式1Arrays.asList有陷阱 ListString list1 Arrays.asList(strArray); // 问题返回的ArrayList是Arrays的内部类不支持add/remove操作 // 方式2new ArrayList(Arrays.asList()) ListString list2 new ArrayList(Arrays.asList(strArray)); // 完全可变的List // 方式3Java8 Stream ListString list3 Arrays.stream(strArray) .collect(Collectors.toList()); // 方式4Collections.addAll ListString list4 new ArrayList(); Collections.addAll(list4, strArray);5.2 集合转数组的最佳实践集合转数组也有多种方式推荐使用带类型参数的版本ListString list Arrays.asList(a, b, c); // 方式1toArray() - 返回Object[] Object[] array1 list.toArray(); // 方式2toArray(T[]) - 推荐方式 String[] array2 list.toArray(new String[0]); // 最佳实践传入空数组 // 方式3Java8 Stream String[] array3 list.stream().toArray(String[]::new);性能提示toArray(new String[0])在现代Java版本中性能优于toArray(new String[list.size()])6. Java数组在算法中的应用数组是算法实现的基础数据结构许多经典算法都基于数组操作。这里介绍几个典型应用场景。6.1 双指针技巧双指针是处理数组问题的强大技术常见于排序、搜索等问题// 示例移除有序数组中的重复元素 public int removeDuplicates(int[] nums) { if (nums.length 0) return 0; int slow 0; for (int fast 1; fast nums.length; fast) { if (nums[fast] ! nums[slow]) { slow; nums[slow] nums[fast]; } } return slow 1; } // 示例两数之和有序数组 public int[] twoSum(int[] numbers, int target) { int left 0, right numbers.length - 1; while (left right) { int sum numbers[left] numbers[right]; if (sum target) { return new int[]{left 1, right 1}; } else if (sum target) { left; } else { right--; } } return new int[]{-1, -1}; }6.2 滑动窗口技术滑动窗口是处理子数组/子串问题的有效方法// 示例最小长度子数组和 public int minSubArrayLen(int target, int[] nums) { int left 0, sum 0; int minLen Integer.MAX_VALUE; for (int right 0; right nums.length; right) { sum nums[right]; while (sum target) { minLen Math.min(minLen, right - left 1); sum - nums[left]; } } return minLen Integer.MAX_VALUE ? 0 : minLen; }7. 数组相关的Java新特性随着Java版本更新数组操作也引入了一些新特性和改进。7.1 Java 8的Stream API支持Java 8为数组提供了强大的Stream操作支持int[] numbers {1, 2, 3, 4, 5}; // 数组转Stream IntStream stream Arrays.stream(numbers); // 常用操作示例 int sum Arrays.stream(numbers).sum(); double avg Arrays.stream(numbers).average().orElse(0); int max Arrays.stream(numbers).max().getAsInt(); int[] evenNumbers Arrays.stream(numbers) .filter(n - n % 2 0) .toArray(); // 二维数组处理 int[][] matrix {{1, 2}, {3, 4}, {5, 6}}; int[] flattened Arrays.stream(matrix) .flatMapToInt(Arrays::stream) .toArray();7.2 Java 9的数组增强方法Java 9为Arrays类添加了一些实用方法// 数组比较 int[] a {1, 2, 3}; int[] b {1, 2, 3}; boolean equal Arrays.equals(a, b); // true // 数组不匹配查找 int[] c {1, 2, 4}; int mismatchIndex Arrays.mismatch(a, c); // 返回2 // 数组分段并行处理 Arrays.parallelPrefix(a, (x, y) - x y); // a变为[1, 3, 6] Arrays.parallelSetAll(a, i - i * 2); // a变为[0, 2, 4]8. 性能调优与内存管理对于大型数组应用性能调优和内存管理尤为重要。8.1 大数组的内存考虑处理大型数组时需要注意内存问题// 可能导致内存不足的声明 // int[] hugeArray new int[Integer.MAX_VALUE]; // 需要8GB内存 // 更安全的方式 public static int[] createLargeArray(int size) { if (size 0) { throw new IllegalArgumentException(数组大小不能为负数); } try { return new int[size]; } catch (OutOfMemoryError e) { System.err.println(无法分配数组: 内存不足); return new int[0]; } }8.2 数组与缓存友好代码编写缓存友好的数组处理代码// 缓存不友好的访问方式列优先访问行优先存储的数组 int[][] matrix new int[10000][10000]; for (int col 0; col matrix[0].length; col) { for (int row 0; row matrix.length; row) { matrix[row][col] row col; } } // 缓存友好的访问方式行优先 for (int row 0; row matrix.length; row) { for (int col 0; col matrix[row].length; col) { matrix[row][col] row col; } }性能测试对于10000x10000数组行优先访问可比列优先快5-10倍9. 数组在面试中的常见问题数组是技术面试中最常考察的数据结构之一这里总结一些典型问题和解法。9.1 经典面试题解析旋转数组public void rotate(int[] nums, int k) { k % nums.length; reverse(nums, 0, nums.length - 1); reverse(nums, 0, k - 1); reverse(nums, k, nums.length - 1); } private void reverse(int[] nums, int start, int end) { while (start end) { int temp nums[start]; nums[start] nums[end]; nums[end] temp; start; end--; } }多数元素出现次数n/2的元素public int majorityElement(int[] nums) { int count 0; Integer candidate null; for (int num : nums) { if (count 0) { candidate num; } count (num candidate) ? 1 : -1; } return candidate; }9.2 二维数组面试题旋转图像顺时针90度public void rotate(int[][] matrix) { int n matrix.length; // 先转置矩阵 for (int i 0; i n; i) { for (int j i; j n; j) { int temp matrix[i][j]; matrix[i][j] matrix[j][i]; matrix[j][i] temp; } } // 再翻转每一行 for (int i 0; i n; i) { for (int j 0; j n / 2; j) { int temp matrix[i][j]; matrix[i][j] matrix[i][n - 1 - j]; matrix[i][n - 1 - j] temp; } } }10. 实际工程中的数组应用在真实项目开发中数组有许多特定的应用场景和优化技巧。10.1 批量数据处理数组非常适合处理批量数据操作// 批量更新用户状态 public void batchUpdateUserStatus(int[] userIds, UserStatus status) { if (userIds null || userIds.length 0) { return; } // 分批处理避免大事务 int batchSize 100; for (int i 0; i userIds.length; i batchSize) { int end Math.min(i batchSize, userIds.length); int[] batch Arrays.copyOfRange(userIds, i, end); updateUserStatusBatch(batch, status); } } private void updateUserStatusBatch(int[] userIds, UserStatus status) { // 实际数据库操作 }10.2 高性能计算在数值计算密集型应用中数组能提供最佳性能// 向量点积计算 public static double dotProduct(double[] a, double[] b) { if (a.length ! b.length) { throw new IllegalArgumentException(向量长度必须相同); } double sum 0.0; for (int i 0; i a.length; i) { sum a[i] * b[i]; } return sum; } // 使用SIMD指令优化的矩阵乘法Java 16 public static double[][] matrixMultiply(double[][] a, double[][] b) { int m a.length; int n b[0].length; int p b.length; double[][] result new double[m][n]; for (int i 0; i m; i) { for (int k 0; k p; k) { double aik a[i][k]; for (int j 0; j n; j) { result[i][j] aik * b[k][j]; } } } return result; }11. 数组的替代方案与选择虽然数组很基础但在某些场景下可能有更好的替代方案。11.1 ArrayList与数组的对比ArrayList是基于数组实现的动态数组比较两者的特点特性数组ArrayList长度固定动态增长内存占用更小稍大有额外开销访问速度更快直接内存访问稍慢方法调用线程安全不安全不安全功能方法少丰富基本类型支持直接支持需要包装类11.2 其他替代数据结构根据具体场景可能需要考虑其他数据结构LinkedList频繁插入删除HashSet快速查找去重TreeSet有序不重复集合HashMap键值对存储ByteBuffer二进制数据处理// 根据场景选择数据结构示例 public class DataStructureChooser { // 需要快速随机访问 public static void processWithArray(int[] data) { // 数组处理逻辑 } // 需要频繁增删 public static void processWithLinkedList(ListInteger data) { // 链表处理逻辑 } // 需要去重 public static void processWithSet(SetString data) { // 集合处理逻辑 } }12. Java数组的未来发展随着Java语言的发展数组也在不断演进了解这些趋势有助于编写面向未来的代码。12.1 Valhalla项目与值类型数组Java的Valhalla项目将引入值类型这会影响数组的实现// 可能未来的值类型数组语法预览 // inline class Point { // final int x; // final int y; // } // // Point[] points new Point[1000]; // 可能直接在栈上分配12.2 数组与模式匹配的结合Java的模式匹配特性可以与数组很好结合// 使用模式匹配处理数组 Object obj new int[]{1, 2, 3}; if (obj instanceof int[] arr arr.length 0) { System.out.println(第一个元素: arr[0]); }13. 最佳实践与编码规范编写高质量数组相关的代码需要遵循一些最佳实践。13.1 数组使用规范防御性拷贝当返回内部数组时应该返回拷贝而非原始数组参数校验对传入的数组参数进行null检查和长度检查文档注释明确说明数组参数和返回值的约束条件// 良好的数组方法示例 /** * 计算数组平均值 * param numbers 非空且至少包含一个元素的数组 * return 数组元素的平均值 * throws IllegalArgumentException 如果数组为null或空 */ public static double calculateAverage(final int[] numbers) { if (numbers null || numbers.length 0) { throw new IllegalArgumentException(数组不能为null或空); } long sum 0; for (int num : numbers) { sum num; } return (double) sum / numbers.length; }13.2 性能敏感场景的优化对于性能关键路径上的数组操作避免不必要的数组拷贝考虑使用System.arraycopy代替循环拷贝对于基本类型优先使用特化数组而非包装类数组考虑重用数组而非频繁创建新数组// 数组重用示例 public class ArrayReuser { private int[] buffer new int[1024]; public void processData(int[] input) { if (input.length buffer.length) { buffer new int[input.length * 2]; } System.arraycopy(input, 0, buffer, 0, input.length); // 处理buffer中的数据... } }14. 调试与性能分析技巧有效调试和优化数组相关的代码需要特定技巧。14.1 数组内容可视化调试现代IDE都提供数组可视化功能但有时需要自定义// 自定义数组toString方法 public static String arrayToString(int[] array) { if (array null) return null; if (array.length 0) return []; StringBuilder sb new StringBuilder([); for (int i 0; i array.length; i) { sb.append(array[i]); if (i array.length - 1) { sb.append(, ); } // 控制输出长度 if (i 20 array.length 25) { sb.append(... ).append(array.length - 25).append( more); break; } } sb.append(]); return sb.toString(); }14.2 数组操作性能分析使用JMH进行数组操作性能测试BenchmarkMode(Mode.AverageTime) OutputTimeUnit(TimeUnit.NANOSECONDS) State(Scope.Benchmark) public class ArrayBenchmark { private int[] array new int[1000]; Setup public void setup() { Random rand new Random(); for (int i 0; i array.length; i) { array[i] rand.nextInt(); } } Benchmark public int arrayIteration() { int sum 0; for (int num : array) { sum num; } return sum; } Benchmark public int arrayStreamSum() { return Arrays.stream(array).sum(); } }15. 跨语言数组比较了解Java数组与其他语言数组实现的区别有助于编写更好的代码。15.1 Java与C/C数组对比特性Java数组C/C数组内存管理由JVM管理手动管理边界检查运行时检查无检查多维数组数组的数组连续内存块长度获取length属性需要额外变量存储动态调整不支持需要手动realloc与指针关系无直接指针操作可转换为指针15.2 Java与Python列表对比虽然Python的list常被比作数组但有重要区别# Python列表(实际是动态数组) py_list [1, 2, three, 4.0] # 可以混合类型 py_list.append(5) # 动态增长 # Java数组(固定类型和长度) int[] javaArray {1, 2, 3, 4}; // javaArray[2] three; // 编译错误 // javaArray[4] 5; // 运行时越界异常Java数组的优势在于更好的性能特别是基本类型数组更强的类型安全更可预测的内存占用16. 数组在框架中的应用主流Java框架中都大量使用了数组了解这些用法有助于深入理解框架设计。16.1 Spring中的数组应用Spring框架中数组常用于配置和参数传递// Spring MVC中的数组参数绑定 GetMapping(/users) public String getUsers(RequestParam(id) int[] ids) { // 处理多个ID查询 return userService.getUsersByIds(ids); } // Spring配置中的数组属性 Configuration public class AppConfig { Bean public MyService myService() { MyService service new MyService(); service.setAllowedTypes(new String[]{type1, type2}); return service; } }16.2 Hibernate中的数组映射虽然Hibernate更常用集合但也可以映射数组Entity public class Product { Id private Long id; // 基本类型数组映射 Column private int[] ratings; // 对象数组映射 ElementCollection CollectionTable(nameproduct_tags) private String[] tags; }17. 数组与并发编程在多线程环境下使用数组需要特别注意线程安全问题。17.1 线程安全的数组操作基本数组操作本身是线程安全的但复合操作不是// 不安全的复合操作 public class UnsafeArray { private int[] array new int[10]; public void unsafeIncrement(int index) { array[index]; // 不是原子操作 } } // 安全的替代方案 public class SafeArray { private final AtomicIntegerArray atomicArray new AtomicIntegerArray(10); public void safeIncrement(int index) { atomicArray.incrementAndGet(index); } }17.2 并行数组处理Java 8提供了并行数组操作支持// 并行数组初始化 int[] array new int[1_000_000]; Arrays.parallelSetAll(array, i - i * 2); // 并行排序 Arrays.parallelSort(array); // 并行前缀计算 Arrays.parallelPrefix(array, (left, right) - left right);18. 特殊类型数组处理除了基本类型和对象数组Java还支持一些特殊类型的数组。18.1 枚举数组枚举数组是类型安全且高效的选择public enum Status { NEW, PROCESSING, COMPLETED, FAILED } public class Task { private Status[] history; public void addStatus(Status status) { if (history null) { history new Status[1]; history[0] status; } else { Status[] newHistory Arrays.copyOf(history, history.length 1); newHistory[newHistory.length - 1] status; history newHistory; } } }18.2 泛型数组的限制与解决方案由于类型擦除Java不允许直接创建泛型数组// 非法操作 // T[] array new T[10]; // 解决方案1使用Object数组并强制转换 SuppressWarnings(unchecked) public T T[] createArray(ClassT type, int size) { return (T[]) Array.newInstance(type, size); } // 解决方案2使用集合代替 public T ListT createList(int size) { return new ArrayList(size); }19. 数组的序列化与持久化在不同场景下数组的序列化和持久化有不同考虑。19.1 Java序列化数组默认支持Java序列化// 序列化数组 public byte[] serializeArray(int[] array) throws IOException { ByteArrayOutputStream baos new ByteArrayOutputStream(); try (ObjectOutputStream oos new ObjectOutputStream(baos)) { oos.writeObject(array); } return baos.toByteArray(); } // 反序列化数组 public int[] deserializeArray(byte[] data) throws IOException, ClassNotFoundException { try (ObjectInputStream ois new ObjectInputStream(new ByteArrayInputStream(data))) { return (int[]) ois.readObject(); } }19.2 JSON序列化使用JSON库处理数组// 使用Jackson库 ObjectMapper mapper new ObjectMapper(); // 数组转JSON int[] numbers {1, 2, 3}; String json mapper.writeValueAsString(numbers); // JSON转数组 int[] parsed mapper.readValue(json, int[].class);20. 数组工具类与扩展库除了标准库还有许多优秀的数组处理工具。20.1 Apache Commons LangArrayUtils类提供了丰富的数组操作// 使用ArrayUtils int[] a {1, 2, 3}; int[] b {4, 5, 6}; // 数组合并 int[] combined ArrayUtils.addAll(a, b); // 数组反转 ArrayUtils.reverse(a); // 包含检查 boolean contains ArrayUtils.contains(a, 2);20.2 Guava的数组工具虽然Guava更推荐集合但也提供了一些数组工具// 基本类型工具类 int[] array Ints.toArray(Arrays.asList(1, 2, 3)); int max Ints.max(array); int[] concatenated Ints.concat(array, new int[]{4, 5, 6});21. 数组在JVM语言中的应用其他JVM语言如Kotlin、Scala对数组有不同设计和扩展。21.1 Kotlin中的数组Kotlin对Java数组进行了包装提供更丰富的API// Kotlin数组操作 val numbers arrayOf(1, 2, 3) numbers.forEach { println(it) } // 基本类型数组 val intArray intArrayOf(1, 2, 3) intArray.sortDescending() // 与Java互操作 fun processJavaArray(javaArray: ArrayString) { val kotlinList javaArray.toList() }21.2 Scala中的数组Scala数组与Java数组可以互操作但提供函数式API// Scala数组 val numbers Array(1, 2, 3) val doubled numbers.map(_ * 2) // 与Java互操作 import java.util.Arrays val javaArray Arrays.copyOf(numbers, numbers.length)22. 数组与JNI交互通过JNI在Java和本地代码间传递数组需要特殊处理。22.1 传递数组给本地代码public class NativeArrayHandler { // 本地方法声明 public native void processIntArray(int[] array); static { System.loadLibrary(nativeArray); } public static void main(String[] args) { int[] data new int[100]; new NativeArrayHandler().processIntArray(data); } }对应的C实现#include jni.h JNIEXPORT void JNICALL Java_NativeArrayHandler_processIntArray (JNIEnv *env, jobject obj, jintArray arr) { jint* elements (*env)-GetIntArrayElements(env, arr, NULL); jsize length (*env)-GetArrayLength(env, arr); // 处理数组元素 for (int i 0; i length; i) { elements[i] * 2; } // 释放数组 (*env)-ReleaseIntArrayElements(env, arr, elements, 0); }22.2 从本地代码返回数组JNIEXPORT jintArray JNICALL Java_NativeArrayHandler_createIntArray (JNIEnv *env, jobject obj, jint size) { jintArray result (*env)-NewIntArray(env, size); if (result NULL) { return NULL; } jint temp[size]; for (int i 0; i size; i) { temp[i] i * 10; } (*env)-SetIntArrayRegion(env, result, 0, size, temp); return result; }23. 数组在Android开发中的应用Android开发中数组有特殊的使用模式和优化考虑。23.1 资源数组在XML中定义数组资源!-- res/values/arrays.xml -- resources string-array nameplanets itemMercury/item itemVenus/item itemEarth/item /string-array integer-array nameprime_numbers item2/item item3/item item5/item /integer-array /resourcesJava代码中访问// 获取字符串数组 String[] planets getResources().getStringArray(R.array.planets); // 获取整型数组 int[] primes getResources().getIntArray(R.array.prime_numbers);23.2 性能敏感场景的优化Android开发中尤其需要注意数组使用的性能// 避免在绘制等高频操作中创建数组 public class CustomView extends View { private float[] points new float[1000]; // 复用数组 Override protected void onDraw(Canvas canvas) { // 复用points数组而不是每次创建新数组 populatePoints(points); canvas.drawPoints(points, paint); } private void populatePoints(float[] dest) { // 填充数组数据 } }24. 数组与Java模块系统Java 9引入的模块系统对数组的使用也有一定影响。24.1 跨模块的数组访问当数组类型涉及跨模块访问时// module1 module com.module1 { exports com.module1.types; } package com.module1.types; public class MyType { /* ... */ } // module2 module com.module2 { requires com.module1; } // 在module2中使用MyType数组 MyType[] array new MyType[10]; // 需要模块访问权限24.2 反射与数组通过反射创建和操作数组// 反射创建数组 Class? componentType String.class; Object array Array.newInstance(componentType, 10); // 反射访问数组 String str (String) Array.get(array, 0); Array.set(array, 0, new value);25. 数组与Java记录类Java 16引入的记录类(Record)与数组的交互// 记录类定义 public record Point(int x, int y) {} // 创建记录数组 Point[] points new Point[3]; points[0] new Point(1, 2); points[1] new Point(3,