数组总结_给定数组int[] arr = {1,8,6,5,7,10,9,3,2,0,12};从键盘输入一整数-CSDN博客

本文链接：https://blog.csdn.net/Zhangxindong8/article/details/104309629

1.数组的基本用法

1.1 什么是数组

数组本质上就是让我们能 “批量” 创建相同类型的变量

1.2数组的创建

基本语法

// 动态初始化
数据类型[] 数组名称 = new 数据类型 [长度] { 初始化数据 };
// 静态初始化 
数据类型[] 数组名称 = { 初始化数据 }

示例

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

1.3 数组的使用

获取长度 & 访问元素

int[] arr = {1, 2, 3};

// 获取数组长度 
System.out.println("length: " + arr.length);		 // 执行结果: 3

// 访问数组中的元素 
System.out.println(arr[1]);         // 执行结果: 2 
System.out.println(arr[0]);         // 执行结果: 1 
arr[2] = 100; 
System.out.println(arr[2]);      // 执行结果:100

使用 arr.length 能够获取到数组的长度 . 这个操作为成员访问操作符. 在面向对象中会经常用到.

下标越界

int[] arr = {1, 2, 3}; 
System.out.println(arr[100]);

// 执行结果 
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
        at Test.main(Test.java:4)

抛出了 java.lang.ArrayIndexOutOfBoundsException 异常. 使用数组一定要下标谨防越界，下标访问操作不能超出有效范围 [0, length - 1] , 如果超出有效范围, 会出现下标越界异常

遍历数组

//使用for循环遍历
int[] arr = {1, 2, 3};
for (int i = 0; i < arr.length; i++) { 
    System.out.println(arr[i]);
     }
// 执行结果
 1
 2 
 3

//使用foreach循环遍历
int[] arr = {1, 2, 3};
for (int x : arr) {   
    System.out.println(x);
   }
// 执行结果 
1 
2
3

for循环和foreach都能遍历数组，最大的区别是使用for循环能获得数组的下标，而forerch不能。

2. 数组作为方法的参数

打印数组内容

public static void main(String[] args) { 
    int[] arr = {1, 2, 3};    
    printArray(arr); 
}
public static void printArray(int[] a) {    
    for (int x : a) {
        System.out.println(x);    
	} 
}

// 执行结果 
 1
 2 
 3

在这段代码中int[] a 是函数的形参, int[] arr 是函数实参.

参数为基本类型

public static void main(String[] args) {    
    int num = 0;    
    func(num);    
    System.out.println("num = " + num);
 }
 
public static void func(int x) {   
    x = 10;    
    System.out.println("x = " + x);
}
  
// 执行结果 
x = 10
num = 0

我们会发现, 修改形参 x 的值, 不影响实参的 num 值.

参数为数组（引用）类型

public static void main(String[] args) {     
    int[] arr = {1, 2, 3};     
    func(arr);     
    System.out.println("arr[0] = " + arr[0]); 

public static void func(int[] a) {     
    a[0] = 10;     
    System.out.println("a[0] = " + a[0]); } 
 
// 执行结果 
a[0] = 10 
arr[0] = 10

我们发现, 在函数内部修改数组内容, 函数外部也发生改变. 此时数组名 arr 是一个 “引用” . 当传参的时候, 是按照引用传参.

理解引用

引用相当于一个 “别名”, 也可以理解成一个指针.
创建一个引用只是相当于创建了一个很小的变量, 这个变量保存了一个整数, 这个整数表示内存中的一个地址.
针对 int[] arr = new int[]{1, 2, 3} 这样的代码, 内存布局如图:

a) 当我们创建 new int[]{1, 2, 3} 的时候, 相当于创建了一块内存空间保存三个 int
在这里插入图片描述
b) 接下来执行 int[] arr = new int[]{1, 2, 3} 相当于又创建了一个 int[] 变量, 这个变量是一个引用类型, 里面只保存了一个整数(数组的起始内存地址)

c) 接下来我们进行传参相当于 int[] a = arr , 内存布局如图

d) 接下来我们修改 a[0] , 此时是根据 0x100 这样的地址找到对应的内存位置, 将值改成 100
在这里插入图片描述
此时已经将 0x100 地址的数据改成了 100 . 那么根据实参 arr 来获取数组内容 arr[0] , 本质上也是获取 0x100 地址上的数据, 也是 100.

总结: 所谓的 “引用” 本质上只是存了一个地址. Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大).

3.数组作为方法的返回值

代码示例: 写一个方法, 将数组中的每个元素都 X 2

// 直接修改原数组 
class Test {    
    public static void main(String[] args) {        
        int[] arr = {1, 2, 3};         
        transform(arr);         
        printArray(arr);  
    } 
 
    public static void printArray(int[] arr) {         
        for (int i = 0; i < arr.length; i++) {             
        System.out.println(arr[i]);       
   	    }   
    } 
 
    public static void transform(int[] arr) {         
        for (int i = 0; i < arr.length; i++) {            
            arr[i] = arr[i] * 2;       
        }    
    }
}

这个代码固然可行, 但是破坏了原有数组. 有时候我们不希望破坏原数组, 就需要在方法内部创建一个新的数组, 并由方法返回出来.

// 返回一个新的数组 
class Test {     
    public static void main(String[] args) {         
        int[] arr = {1, 2, 3};         
        int[] output = transform(arr);         
        printArray(output);   
    } 
 
    public static void printArray(int[] arr) {        
        for (int i = 0; i < arr.length; i++) {            
            System.out.println(arr[i]);     
        }   
    } 
 
    public static int[] transform(int[] arr) {       
        int[] ret = new int[arr.length];        
        for (int i = 0; i < arr.length; i++) {            
            ret[i] = arr[i] * 2;
        }         
        return ret;    
    }
}

这样的话就不会破坏原有数组了. 另外由于数组是引用类型, 返回的时候只是将这个数组的首地址返回给函数调用者, 没有拷贝数组内容, 从而比较高效.

4.例子

1.数组转字符串

public static void main(String[] args) {
     int[] arr = {1,2,3,4,5,6};
     System.out.println(toString(arr));
} 
 
public static String toString(int[] arr) {
     String ret = "[";     
     for (int i = 0; i < arr.length; i++) {         
         // 借助 String += 进行拼接字符串         
         ret += arr[i];         
         // 除了后一个元素之外, 其他元素后面都要加上 ", "         
         if (i != arr.length - 1) {             
             ret += ", ";         
         }     
     }     
     ret += "]";     
     return ret; 
}

// 执行结果 [1, 2, 3, 4, 5, 6]

2.找数组中的最大元素

给定一个整型数组, 找到其中的大元素 (找小元素同理)

public static void main(String[] args) {
    int[] arr = {1,2,3,4,5,6};     
    System.out.println(max(arr));
} 
 
public static int max(int[] arr) {
    int max = arr[0];     
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];         
        }     
    }     
    return max;
} 
 
// 执行结果 6

类似于 “打擂台” 这样的过程. 其中 max 变量作为擂台, 比擂台上的元素大, 就替换上去, 否则就下一个对手.

3.求数组中元素的平均值

给定一个整型数组, 求平均值

public static void main(String[] args) { 
    int[] arr = {1,2,3,4,5,6};
    System.out.println(avg(arr));
}
 
public static double avg(int[] arr) { 
    int sum = 0;     
    for (int x : arr) {   
        sum += x;     
    }     
    return (double)sum / (double)arr.length; 
} 
 
// 执行结果 3.5

注意事项: 结果要用 double 来表示.

4.查找数组中指定元素(二分查找)

针对有序数组, 可以使用更高效的二分查找。有序分为 “升序” 和 “降序” 如 1 2 3 4 , 依次递增即为升序. 如 4 3 2 1 , 依次递减即为降序。以升序数组为例, 二分查找的思路是先取中间位置的元素, 看要找的值比中间元素大还是小. 如果小, 就去左边找; 否则就去右边找。

public static void main(String[] args) { 
    int[] arr = {1,2,3,4,5,6};      
    System.out.println(binarySearch(arr, 6)); 
} 
 
public static int binarySearch(int[] arr, int toFind) { 
    int left = 0;      
    int right = arr.length - 1;    
    while (left <= right) {   
        int mid = (left + right) / 2;  
        if (toFind < arr[mid]) {    
            // 去左侧区间找   
            right = mid - 1;      
        } else if (toFind > arr[mid]) {
            // 去右侧区间找             
            left = mid + 1;
        } else {            
            // 相等, 说明找到了
            return mid;         
        }     
    }     
    // 循环结束, 说明没找到     
    return -1; 
} 
 
// 执行结果 5

5.检查数组的有序性

给定一个整型数组, 判断是否该数组是有序的(升序)

public static void main(String[] args) { 
    int[] arr = {1,2,3,10,5,6};     
    System.out.println(isSorted(arr));
} 
 
public static boolean isSorted(int[] arr) { 
    for (int i = 0; i < arr.length - 1; i++) {  
        if (arr[i] > arr[i + 1]) {     
            return false;      
        }     
    }     
    return true; 
}

6.数组排序(冒泡排序)

给定一个数组, 让数组升序 (降序) 排序.
算法思路
每次尝试找到当前待排序区间中小(或大)的元素, 放到数组前面(或后面).

public static void main(String[] args) { 
    int[] arr = {9, 5, 2, 7};     
    bubbleSort(arr);     
    System.out.println(Arrays.toString(arr)); } 
 
public static void bubbleSort(int[] arr) { 
    // [0, bound) 构成了一个前闭后开区间, 表示已排序区间     
    // [bound, length) 构成了一个前闭后开区间, 表示待排序区间     
    // 每循环一次, 就找到一个合适大小的元素, 已排序区间就增大1.     
    for (int bound = 0; bound < arr.length; bound++) {    
        for (int cur = arr.length - 1; cur > bound; cur--) {
            if (arr[cur - 1] > arr[cur]) {       
                int tmp = arr[cur - 1];             
                arr[cur - 1] = arr[cur];                 
                arr[cur] = tmp;  
             }         
         }     
     }  // end for 
}  // end bubbleSort 
 
// 执行结果 [2, 5, 7, 9]

7.数组逆序

给定一个数组, 将里面的元素逆序排列.
思路
设定两个下标, 分别指向第一个元素和后一个元素. 交换两个位置的元素.
然后让前一个下标自增, 后一个下标自减, 循环继续即可.

public static void main(String[] args) { 
    int[] arr = {1, 2, 3, 4};      
    reverse(arr);     
    System.out.println(Arrays.toString(arr)); 
} 
 
public static void reverse(int[] arr) { 
    int left = 0;     
    int right = arr.length - 1;    
    while (left < right) {     
        int tmp = arr[left];         
        arr[left] = arr[right];         
        arr[right] = tmp;         
        left++;         
        right--;     
    }
}

5.二维数组

二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组.
基本语法

数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };

代码示例

int[][] arr = {     
    {1, 2, 3, 4},     
    {5, 6, 7, 8},     
    {9, 10, 11, 12} }; 
 
for (int row = 0; row < arr.length; row++) { 
    for (int col = 0; col < arr[row].length; col++) { 
        System.out.printf("%d\t", arr[row][col]);     
    }     
    System.out.println(""); 
} 
 
// 执行结果
 1       2       3       4 
 5       6       7       8 
 9       10      11      12