【Java】7 再识数组|数组的根本操纵

欢迎来到爱书不爱输的程序猿的博客, 本博客致力于知识分享，与更多的人进行学习交换
目前,已开了以下专栏,欢迎关注与引导
1️⃣Java基础知识系统学习(连续更文中…)
2️⃣UML的应知应会(已更完)
3️⃣MySQL的应知应会(连续更文中…)
4️⃣算法与数据结构体系(连续更文中…)
5️⃣软考中级：软件设计师系列(连续更文中…)
还有更多文章在主页,欢迎访问爱书不爱输的程序猿
    本文收录于Java基础知识系统学习专栏,次专栏是针对初学者打造,完成从0到1的超过
  

---

  
1.遍历数组

• 遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现。
  
• 遍历一维数组已经讲过了
  
• 此处介绍遍历二维数组的方法:使用双层for循环，通过数组的length属性可获得数组的长度
  

1. public class Trap{                                           //创建类
2.         public static void main(String[] args){                  //主方法            
3.                 int b[][] = new int[][]{{1},{2,3},{4,5,6}};          //定义二维数组
4.                 for(int k = 0;k < b.length; k++){
5.                         for(int c = 0;c < b[k].length; c++)
6.                         {                 //循环遍历二维数组的每个元素
7.                                 System.out.print(b[k][c]);                  //将数组中的元素输出
8.                         }
9.                         System.out.println();                           //输出空格
10.                 }
11.         }
12. }

复制代码

• 使用for-each语句遍历数组
  

1. public class Tautog { // 创建类
2.         public static void main(String[] args) { // 主方法
3.                 int arr2[][] = { { 4, 3 }, { 1, 2 } }; // 定义二维数组
4.                 System.out.println("数组中的元素是："); // 提示信息
5.                 int i = 0; // 外层循环计数器变量
6.                 for (int x[] : arr2) { // 外层循环变量为一维数组
7.                         i++; // 外层计数器递增
8.                         int j = 0; // 内层循环计数器
9.                         for (int e : x) { // 循环遍历每一个数组元素
10.                                 j++; // 内层计数器递增
11.                                 if (i == arr2.length && j == x.length) { // 判断变量是二维数组中的最后一个元素
12.                                         System.out.print(e); // 输出二维数组的最后一个元素
13.                                 } else
14.                                         // 如果不是二维数组中的最后一个元素
15.                                         System.out.print(e + "、"); // 输出信息
16.                         }
17.                 }
18.         }
19. }

复制代码

2.填充更换数组元素

   数组中的元素定义完成后，可通过Arrays类的静态方法fill()来对数组中的元素进行更换。
该方法通过各种重载情势可完成对任意类型的数组元素的更换。
  2.1 fill(int[] a,int value)

• 该方法可将指定的int值分配给int型数组的每个元素
  

1. //语法:
2. fill(int[] a, int value);
3. //a：要进行元素替换的数组
4. //value：要存储数组中所有元素的值

复制代码

2.2 fill(int[] a,int fromIndex,int toIndex,int value)

• 该方法将指定的int值分配给int型数组指定范围中的每个元素
  
• 填充的范围从索引fromIndex（包括）不绝到索引toIndex（不包括） [fromIndex,toIndex)
  
  
  
  • 如果fromIndex == toIndex，则填充范围为空
    
  
  

1. //语法:
2. fill(int[] a, int fromIndex, int toIndex, int value);
3. //a：要进行填充的数组
4. //fromIndex：要使用指定值填充的第一个元素的索引（包括）
5. //toIndex：要使用指定值填充的最后一个元素的索引（不包括）
6. //value：要分配给数组指定范围中的每个元素的值

复制代码

• 如果指定的索引位置大于或即是要进行填充的数组的长度，则会报出ArrayIndexOutOf-BoundsException
  

3.对数组进行排序

• 通过Arrays类的静态方法sort()可以实现对数组的排序
  
• sort()方法提供了多种重载情势，可对任意类型的数组进行升序排序
  

1. //语法:
2. Arrays.sort(object);
3. //object是指进行排序的数组名称

复制代码

• 示例:
  

1. import java.util.Arrays; //导入java.util.Arrays类
3. public class Taxis { // 创建类
4.         public static void main(String[] args) { // 主方法
5.                 int arr[] = new int[] { 23, 42, 12, 8 }; // 声明数组
6.                 Arrays.sort(arr); // 将数组进行排序
7.                 for (int i = 0; i < arr.length; i++) { // 循环遍历排序后的数组
8.                         System.out.println(arr[i]); // 将排序后数组中的各个元素输出
9.                 }
10.         }
11. }

复制代码

• 上述实例是对整型数组进行排序。
  
• Java中的String类型数组的排序算法是根据字典编排次序排序的，因此数字排在字母前面，大写字母排在小写字母前面
  

4.复制数组

4.1copyOf()方法

1. //语法:
2. copyOf(arr, int newlength);
3. //arr：要进行复制的数组
4. //newlength：int型常量，指复制后的新数组的长度

复制代码

  

• 如果新数组的长度大于数组arr的长度，则用0填充
  
  
  
  • 根据复制数组的类型来决定填充的值，整型数组用0填充，char型数组则使用null来填充;
    
  
  
• 如果复制后的数组长度小于数组arr的长度，则会从数组arr的第一个元素开始截取至满意新数组长度为止。
  

  

• 示例:
  

1. import java.util.Arrays; //导入java.util.Arrays类
3. public class Cope { // 创建类
4.         public static void main(String[] args) { // 主方法
5.                 int arr[] = new int[] { 23, 42, 12 }; // 定义数组
6.                 int newarr[] = Arrays.copyOf(arr, 5); // 复制数组arr
7.                 for (int i = 0; i < newarr.length; i++) { // 循环变量复制后的新数组
8.                         System.out.println(newarr[i]); // 将新数组输出
9.                 }
10.         }
11. }

复制代码

4.2copyOfRange()方法

1. //语法:
2. copyOfRange(arr, int formIndex, int toIndex);
3. //arr：要进行复制的数组对象
4. //formIndex：指定开始复制数组的索引位置。
5. //toIndex：要复制范围的最后索引位置

复制代码

  formIndex必须在0至整个数组的长度之间。新数组包括索引是formIndex的元素。
toIndex可大于数组arr的长度。新数组不包括索引是toIndex的元素
  5.查询数组

• Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象
  
• 该方法返回要搜索元素的索引值
  

5.1binarySearch(Object[] a, int fromIndex, int toIndex, Object key)

1. //语法:
2. binarySearch(Object[] a, int fromIndex, int toIndex, Object key);
3. //a：要搜索的数组
4. //fromIndex：要搜索的第一个元素的索引（包含fromIndex）
5. //toIndex：要搜索的最后一个元素的索引（不包含toIndex）
6. //key：要搜索的值

复制代码

如果key包罗在数组中，则返回搜索值的索引；否则返回-1或"-"（插入点）。插入点是搜索键将要插入数组的那一点，即第一个大于此键的元素索引

• 进一步举例说明:
  

1. int arr[] = new int[]{4,25,10};   //创建并初始化数组
2. Arrays.sort(arr);                                 //将数组排序
3. int index = Arrays.binarySearch(arr,0,1,8);

复制代码

• 代码中变量index的值是元素“8”在数组arr中索引在0～1内的索引位置。
  
• 由于在指定的范围内并不存在元素“8”，index的值是"-"（插入点）。
  
• 如果对数组进行排序，元素“8”应该在“25”的前面，因此插入点应是元素“25”的索引值2，以是index的值是-2。
  

   在调用binarySearch(Object[] a, Object key)之前必须对数组进行排序（通过sort()方法）。
  

• 如果没有对数组进行排序，则结果是不确定的。
  
• 如果数组包罗多个带有指定值的元素，则无法包管找到的是哪一个。
  

  5.2binarySearch(Object[],int fromIndex,inttoIndex,Object key)

• 在指定的范围内检索某一元素
  

1. //语法:
2. binarySearch(Object[] a, int fromIndex, int toIndex, Object key);
3. //a：要进行检索的数组
4. //fromIndex：指定范围的开始处索引（包含）
5. //toIndex：指定范围的结束处索引（不包含）
6. //key：要搜索的元素

复制代码

  

• 使用该方法前，同样要对数组进行排序，这样才能获得正确的索引值。
  
• 如果要搜索的元素key在指定的范围内，则返回搜索键的索引；否则返回-1或"-"(插入点)
  
• 如果范围中的全部元素都小于指定的键，则插入点为toIndex
  
  
  
  • 这包管了当且仅当此键被找到时，返回的值将大于即是0
    
  
  

  6.数组比力

• 两个数组相等意味着此中的元素数量必须雷同，而且每个雷同位置的元素也必须相等可以用equals()方法来判断
  
• 对于根本类型，是由其包装类中的equals()方法来比力的，
  
  
  
  • 比方:int元素实际是由Integer.equals()来负责比力
    
  
  

6.1Arrays类提供了 equals()方法来比力一维数组是否相等

1. int[] a1 = new int[] {1, 2, 3, 4};
2. int[] a2 = new int[] {1, 2, 3, 4};
3. System.out.println("a1 == a2: " + Arrays.equals(a1, a2));
4. a2[3] = 11;
5. System.out.println("a1 == a2: " + Arrays.equals(a1, a2));

复制代码

6.2 Arrays类提供了 deepEquals()方法来比力多维数组

1. int myarr[][] = {{12,0},{45,10}};
2. int arr[][] = {{12,0},{45,10}};
3. System.out.println(Arrays.equals(myarr,arr));   //false               
4. System.out.println(Arrays.deepEquals(myarr,arr)); //true

复制代码

6.3 equals()与deepEquals()

6.3.1对于完全雷同的数组 , 为何使用Arrays.equals()比力两个二维数组的结果是false?而比力一维数组的结果就是true?

• 首先,看二维数组使用Arrays.equals()方法时的源码
  

1.     public static boolean equals(int[] a, int[] a2) {
2.         if (a==a2)
3.             return true;   //1.如果名字相同，返回true
4.         if (a==null || a2==null)
5.             return false;  //2.如果其中一个为空，返回false
7.         int length = a.length;
8.         if (a2.length != length)
9.             return false;  //3.如果两个数组长度不同，返回false
11.        for (int i=0; i<length; i++) {
12.             Object o1 = a[i];
13.             Object o2 = a2[i];
14.             if (!(o1==null ? o2==null : o1.equals(o2)))
15.                 return false;        //4.进行对比，不同，返回false
16.         }  
18.         return true;       //5.走到这一步就说明数组中每个元素都相等，返回true
19.     }

复制代码

  

• 很显着，在第4步的时候，因为在Java中，对象类型的变量（如Object）存储的是对象的引用（地点），而不是对象自己的值。
  
• 因此，在这个语句中，变量o1得到的是数组a中第i个元素的引用，而不是该元素的值。以是结果就是false
  

  

• 看一维数组使用Arrays.equals()方法时的源码
  

1. public static boolean equals(int[] a, int[] a2) {
2.         if (a==a2)
3.             return true;
4.         if (a==null || a2==null)
5.             return false;
7.         int length = a.length;
8.         if (a2.length != length)
9.             return false;
11.         for (int i=0; i<length; i++)
12.             if (a[i] != a2[i])
13.                 return false;
15.         return true;
16.     }

复制代码

• 可以看到,在for循环中比力的是值
  

6.3.2deepEquals()和equals()的区别

• deepEquals用于判定两个指定数组彼此是否深层相等
  
• equals用于判定两个数组是否相等，如果两个数组以雷同次序包罗雷同元素，则返回true，否则返回false
  
• 而且,由上述内容可知,如果要比力多维数组，则需要使用deepEquals()方法
  

7.参数与返回值

7.1 数组作为函数的参数

1. public static void printArray(int[] array) {
2.   for (int i = 0; i < array.length; i++) {
3.     System.out.print(array[i] + " ");
4.   }
5. }

复制代码

7.2数组作为函数的返回值

1. public static int[] reverse(int[] list) {
2.   int[] result = new int[list.length];
4.   for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
5.     result[j] = list[i];
6.   }
7.   return result;
8. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。