Java学习笔记：复制数组、二维数组及Arrays类常用方法

复制数组、二维数组及Arrays类常用方法

• 学习参考网址：https://how2j.cn/p/6235

---

增强FOR循环

• 增强型for循环在遍历一个数组的时候会更加快捷
• 增强型for循环只能用来取值，却不能用来修改数组里的值

public class HelloWorld {
    public static void main(String[] args) {
        int values [] = new int[]{18,62,68,82,65,9};
        //常规遍历
        for (int i = 0; i < values.length; i++) {
            int each = values[i];
            System.out.println(each);
        }
         
        //增强型for循环遍历
        for (int each : values) {
            System.out.println(each);
        }
         
    }
}

---

• 用增强型for循环找出最大的那个数

public class HelloWorld {
    public static void main(String[] args) {
        int values [] = new int[]{18,62,68,82,65,9};
 
        //数组中的内容是
        for (int each : values) {
            System.out.print(each+" ");
        }
        System.out.println();
        int max = -1;
        for (int each : values) {
            if(each>max)
                max = each;
        }
         
        System.out.println("最大的一个值是:"+max);
          
    }
}

 

复制数组

• 数组的长度是不可变的，一旦分配好空间，是多长，就多长，不能增加也不能减少
• 复制数组
• 把一个数组的值，复制到另一个数组中

System.arraycopy(src, srcPos, dest, destPos, length)

• src: 源数组
• srcPos: 从源数组复制数据的起始位置
• dest: 目标数组
• destPos: 复制到目标数组的起始位置
• length: 复制的长度

public class HelloWorld {
    public static void main(String[] args) {
        int a [] = new int[]{18,62,68,82,65,9};
         
        int b[] = new int[3];//分配了长度是3的空间，但是没有赋值
         
        //通过数组赋值把，a数组的前3位赋值到b数组
         
        //方法一： for循环
         
        for (int i = 0; i < b.length; i++) {
            b[i] = a[i];
        }
        
        //方法二: System.arraycopy(src, srcPos, dest, destPos, length)
        //src: 源数组
        //srcPos: 从源数组复制数据的起始位置
        //dest: 目标数组
        //destPos: 复制到目标数组的启始位置
        //length: 复制的长度       
        System.arraycopy(a, 0, b, 0, 3);
         
        //把内容打印出来
        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i] + " ");
        }
 
    }
}

---

• 合并数组
  • 首先准备两个数组，他俩的长度是5-10之间的随机数，并使用随机数初始化这两个数组
  • 然后准备第三个数组，第三个数组的长度是前两个的和
  • 通过System.arraycopy 把前两个数组合并到第三个数组中

public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[(int) (Math.random() * 5)+5];
        for (int i = 0; i < a.length; i++)
            a[i] = (int) (Math.random() * 100);
        int b[] = new int[(int) (Math.random() * 5)+5];
        for (int i = 0; i < b.length; i++)
            b[i] = (int) (Math.random() * 100);
         
        System.out.println("数组a的内容:");
        for (int i : a) {
            System.out.print(i+" ");
        }
        System.out.println();
        System.out.println("数组b的内容:");
        for (int i : b) {
            System.out.print(i+" ");
        }
        System.out.println();
         
        int c[] = new int[a.length+b.length];
        System.arraycopy(a, 0, c, 0, a.length);
        System.arraycopy(b, 0, c, a.length, b.length);
         
        System.out.println("数组c的内容:");
        for (int i : c) {
            System.out.print(i+" ");
        }
         
    }
}

 

二维数组

• 这是一个一维数组, 里面的每一个元素，都是一个基本类型int 

int a[] =new int[]{1,2,3,4,5};

 

• 这是一个二维数组，里面的每一个元素，都是一个一维数组 
• 所以二维数组又叫数组的数组 

int b[][] = new int[][]{
   {1,2,3},
   {4,5,6},
   {7,8,9}
};

---

• 初始化二维数组

public class HelloWorld {
    public static void main(String[] args) {
       //初始化二维数组，
       int[][] a = new int[2][3]; //有两个一维数组，每个一维数组的长度是3
       a[1][2] = 5;  //可以直接访问一维数组，因为已经分配了空间
          
       //只分配了二维数组
       int[][] b = new int[2][]; //有两个一维数组，每个一维数组的长度暂未分配
       b[0]  =new int[3]; //必须事先分配长度，才可以访问
       b[0][2] = 5;
        
       //指定内容的同时，分配空间
       int[][] c = new int[][]{
               {1,2,4},
               {4,5},
               {6,7,8,9}
       };
 
    }
}

---

• 案例演示：
  • 定义一个5X5的二维数组。 然后使用随机数填充该二维数组。
  • 找出这个二维数组里，最大的那个值，并打印出其二维坐标

public class HelloWorld {
    public static void main(String[] args) {
        int a[][] = new int[5][5];
        // 初始化这个数组
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                a[i][j] = (int) (Math.random() * 100);
            }
        }
        // 打印这个数组的内容：
        for (int[] row : a) {
            for (int each : row) {
                System.out.print(each + "\t");
            }
            System.out.println();
        }
 
        int max = -1;// 最大值
        // 最大值的坐标
        int target_i = -1;
        int target_j = -1;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (a[i][j] > max) {
                    max = a[i][j];
                    target_i = i;
                    target_j = j;
                }
            }
        }
 
        System.out.println("找出来最大的是:" + max);
        System.out.println("其坐标是[" + target_i + "][" + target_j + "]");
 
    }
}

 

Arrays类常用方法

• Arrays是针对数组的工具类，可以进行 排序，查找，复制填充等功能。 大大提高了开发人员的工作效率。
• 数组复制 copyOfRange
  • 与使用System.arraycopy进行数组复制类似的， Arrays提供了一个copyOfRange方法进行数组复制。
  • 不同的是System.arraycopy，需要事先准备好目标数组，并分配长度。
  • copyOfRange 只需要源数组就就可以了，通过返回值，就能够得到目标数组了。
  • 除此之外，需要注意的是 copyOfRange 的第3个参数，表示源数组的结束位置，是取不到的。

import java.util.Arrays;
 
public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
 
        // copyOfRange(int[] original, int from, int to)
        // 第一个参数表示源数组
        // 第二个参数表示开始位置(取得到)
        // 第三个参数表示结束位置(取不到)
        int[] b = Arrays.copyOfRange(a, 0, 3);
 
        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i] + " ");
        }
 
    }
}

---

• 转换为字符串
  • 如果要打印一个数组的内容，就需要通过for循环来挨个遍历，逐一打印
  • 但是Arrays提供了一个toString()方法，直接把一个数组，转换为字符串，这样方便观察数组的内容

import java.util.Arrays;
  
public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
        String content = Arrays.toString(a);
        System.out.println(content);
  
    }
}

---

• 排序
  • Arrays工具类提供了一个sort方法，只需要一行代码即可完成排序功能。

import java.util.Arrays;
  
public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
        System.out.println("排序之前 :");
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);
        System.out.println("排序之后:");
        System.out.println(Arrays.toString(a));
  
    }
}

---

• 搜索
  • 查询元素出现的位置
  • 需要注意的是，使用binarySearch进行查找之前，必须使用sort进行排序
  • 如果数组中有多个相同的元素，查找结果是不确定的

import java.util.Arrays;
 
public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
 
        Arrays.sort(a);
 
        System.out.println(Arrays.toString(a));
        //使用binarySearch之前，必须先使用sort进行排序
        System.out.println("数字 62出现的位置:"+Arrays.binarySearch(a, 62));
    }
}

---

• 判断是否相同
  • 比较两个数组的内容是否一样
  • 第二个数组的最后一个元素是8，和第一个数组不一样，所以比较结果是false

import java.util.Arrays;
 
public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
        int b[] = new int[] { 18, 62, 68, 82, 65, 8 };
 
        System.out.println(Arrays.equals(a, b));
    }
}

---

• 填充
  • 使用同一个值，填充整个数组

import java.util.Arrays;
  
public class HelloWorld {
    public static void main(String[] args) {
        int a[] = new int[10];
  
        Arrays.fill(a, 5);
  
        System.out.println(Arrays.toString(a));
  
    }
}

 

综合案例

• 案例：
  • 首先定义一个5X8的二维数组，然后使用随机数填充满。
  • 借助Arrays的方法对二维数组进行排序。

import java.util.Arrays;
 
public class HelloWorld {
    public static void main(String[] args) {
        int a[][] = new int[5][8];
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                a[i][j] = (int) (Math.random() * 100);
            }
        }
 
        System.out.println("打印二维数组");
        for (int[] i : a) {
            System.out.println(Arrays.toString(i));
        }
 
        // 把二维数组复制到一维数组
        int b[] = new int[a.length * a[0].length];
        for (int i = 0; i < a.length; i++) {
            System.arraycopy(a[i], 0, b, i * a[i].length, a[i].length);
        }
        // 对一维数组进行排序
        Arrays.sort(b);
        // 把一维数组复制到二维数组
        for (int i = 0; i < a.length; i++) {
            System.arraycopy(b, a[i].length * i, a[i], 0, a[i].length);
        }
        System.out.println("打印排序后的二维数组");
        for (int[] i : a) {
            System.out.println(Arrays.toString(i));
        }
 
    }
}