快速入门java数组

Java数组

什么是数组？

在内存中是一块连续的空间存放相同的数据类型，且一旦创建长度不可改变。

特点：

1. 是一种引用数据类型。
2. 数组中的多个数据，类型必须统一。
3. 数组的长度在运行期间不能改变。

数组的初始化

数组的初始化有两种方式：

1. 动态初始化
   初始化数组的时候，指定数组的长度，并且赋默认值。
   格式 ：数据类型[] 数组名 = new 数据类型[数组长度];
2. 静态初始化
   初始化数组的同时，给数组赋值。（底层是先指定长度，确定默认值，然后在给数组赋值）
   格式：数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3…}

---

在数组中寻找最大最小值

练习：创建一个10位的数组，在里面随机填入1-100的随机数。寻找最小值
思路：使用打擂台的方式，创建一个变量min，遍历数组中所有元素，跟min进行对比，如果元素比min小，则把这个元素赋值给min。

int[] arr = new int[10];
int min=100;
for(int i = 0; i<arr.length ; i++){
    arr[i] = (int)(Math.random()*100);
    if (min>arr[i]){
        min = arr[i];
    }
}
System.out.println(Demo01Array.showArray(arr));
System.out.println("最小值是："+min);

---

数组的排序：选择排序、冒泡排序。

选择排序（升序）

思路

让第一个元素，和后面的元素分别比较，如果第一个元素的值小于对比的值，那么让对比的两个元素的数值交换，这样就会把最小的一个值放在第一个元素的位置。然后从第二个元素往后比…

public static int[] test01(int[] arr){
    for (int i = 0; i < arr.length; i++) {
        for (int j = i+1; j < arr.length; j++) {
            int a;
                if (arr[i]>arr[j]){
                    a= arr[i];
                    arr[i]=arr[j];
                    arr[j]=a;
                }
        }
    }
    return arr;
}

注意：两个元素的值需要交换位置的时候，不能直接交换，需要用一个变量先保存其中一个元素的值。如上述代码中的int a 。

冒泡排序（降序）

思路

将每个相邻的元素进行对比，如果索引接近0的元素（靠前的）比另一个元素小就把他们俩的数值交换。比完一轮之后最后一个元素就会是最小值，然后下一轮只需要比 arr.length-2次(第一轮是arr.length-1次)，因为最后一个元素的值已经可以确定（最小值），直到最后一轮只有两个元素的值需要对比。

public static int[] test02(int[] arr){
        for (int i = arr.length-1; i >0; i--) {
            for (int y = 0; y < i; y++) {
                int a;
                if (arr[y]<arr[y+1]){
                    a = arr[y];
                    arr[y] = arr[y+1];
                    arr[y+1] = a;
                }

            } 
        }
    return arr;
}

---

数组增强for循环

写法： for (int a : arr){}

• arr：数组名
• a：元素

优点：遍历数组非常简单，结构易懂。
缺点：因为遍历过程中没用indx索引值，所以无法给数组中的元素分别赋值。

---

数组的拷贝（介绍两种方式）

介绍两种数组介绍的方法，他们都是静态方法，不需要创建对象就可以调用。

1. java.lang.System.arraycopy(Object src,int srcPos,Object dest, int destPos,int length)
   • 没有返回值
   • 参数
     1. src 源数组
     2. srcPots 源数组起始位置
     3. dest 被复制的数组
     4. destPots 被复制数组起始位置
     5. length 复制长度

int a [] = new int[]{18,62,68,82,65,9};
int b[] = new int[3];
//将a数组中的前三个元素赋值给数组b
System.arraycopy(a,0,c,0,3);

2. java.util.Arrays.copyOfRange(int[] original, int from, int to);

   • 返回值：int[]

   • 参数

     1. original 数组名
     2. from 起始位置（包含）
     3. to 结束位置（不包含）

public static void testCopyOfRange(int[] a,int[] b){
        //将a数组从0（包含）到4（不包含）赋值给b数组
        b = Arrays.copyOfRange(a, 0, 4);
}

---

二维数组

定义：二维数组就是数组中的数组，二维数组中的每个元素都是一个数组。
写法：

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

练习： 随机打印5*5的二维数组，找出最大数

int[][] arr = new int[5][5];
//填充并打印出二维数组。
for (int i = 0; i < arr.length; i++) {
    for (int j=0;j<arr[i].length;j++){
        //随机将10-99的数填入二维数组
        arr[i][j] = (int)(Math.random()*90+10);
        System.out.print(arr[i][j]+" ");
    }
    System.out.println();
}
//遍历，找出最大值
int max=0;//最大值
int maxJ=0;//用来存放数组中的每一个数组的最大值
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        if (maxJ<arr[i][j]) {
            maxJ = arr[i][j];
        }
    }
        //在这一行最大的是maxJ,如果比mx大，存入max
    if(maxJ>max){
        max = maxJ;
    }
}
System.out.println("这个二维数组中最大值为："+max);

---

数组的工具类Arrays

java.util.Arrays

1. copyOfRange 数组复制 （之前讲过了）
2. toString() 转换为字符串
3. sort 排序
4. binarySearch 搜索
5. equals 判断是否相同
6. fill 填充

直接上代码

/**
 * 测试sort:排序，升序
 */
public static void testSort(){
    int[] a = new int[10];
    for (int i = 0; i < a.length; i++) {
        a[i] = (int) (Math.random() * 100);
    }
    System.out.println(Arrays.toString(a));
    Arrays.sort(a);
    System.out.println(Arrays.toString(a));
}

/**
 * 测试testSearch,查找，
 * @args int[] arr 数组   int value 需要查找的值
 */
public static void testBinarySearch(int[] arr,int value){
    int index = Arrays.binarySearch(arr, value);
    System.out.println("查找出"+value+"的值的下标为"+index);
}

/**
 * 测试equals
 */
public static void testEquals(int[] a ,int[] b){
    boolean equals = Arrays.equals(a, b);
    System.out.println("俩数组的对比结果是"+equals);
}

/**
* 测试fill
*/
public static void testFill(int[] arr){
    Arrays.fill(arr,99);
    System.out.print("填充后的数组为：");
    for (int i : arr) {
        System.out.print(i+" ");
    }
}

---

综合练习：

创建一个5*8的二维数组，对二维数组进行排序

public class Demo08Arrays {
    public static void main(String[] args) {
        int[][] arr = new int[5][8];
        int[] a = new int[40];
        System.out.println("排序前的二维数组");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = (int)(Math.random()*90+10);
            }
            System.arraycopy(arr[i],0,a,i*8,8);
            System.out.println(Arrays.toString(arr[i]));
        }
        //System.out.println(Arrays.toString(a));
        Arrays.sort(a);
        //System.out.println(Arrays.toString(a));
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = a[i*8+j];
            }
        }
        System.out.println("排序后的二维数组");
        showArraysDouble(arr);
    }
    public static void showArraysDouble(int[][] arr){
        for (int[] ints : arr) {
            System.out.println(Arrays.toString(ints)); 
        }
    }
}

end