Java基础知识之数组及相关面试题

以你之姓@ 2023-07-18 06:29 10阅读 0赞

**一.数组的定义:**  
所谓数组，是在程序设计中，为了处理方便，把具有相同类型的若干变量按有序的形式组织起来的一种数据形式。这些按一定顺序排列的同类型数据的集合称为数组。而数组中的每一个数据称之为数组元素，数组中的元素以索引来表示其存放的位置，索引从0开始，步长是1.  
方式1: 数组元素的类型\[\] 数组名; int\[\] ages;推荐的. 可以吧int\[\]看成是一种数据类型,int类型的数组类型.  
方式2:数组元素的类型 数组名\[\]; int ages\[\];  
**二.数组的初始化:**  
1.静态初始化:  
语法:  
数组元素类型\[\] 数组名 = new 数组元素类型\[\]\{元素1,元素2,元素3,…\};  
举例:  
int\[\] nums = new int\[\]\{1,3,5,7,9\};  
简单写法,必须声明之后,立刻初始化,不能先声明后初始化:  
int\[\] nums = \{1,3,5,7,9\};  
2.动态初始化:  
由我们来设置数组的元素个数(数组长度),而每一个数组元素的初始值有系统决定.  
语法:  
数组元素类型\[\] 数组名 = new 数组元素类型\[ length \];  
比如:  
int\[\] ages = new int\[100\];  
注意:静态初始化和动态初始化不能同时使用 int\[\] nums = new int\[5\]\{1,3,5,7,9\};错误写法  
三. 面试题(笔试)  
1.手写找出一个数组的最大值

//手写找出做大值
        static int getMax(int[] arr){ 
            if(arr!=null && arr.length>0){ 
                int max=arr[0];
                for (int i =0;i<arr.length;i++){ 
                    if(max<arr[i]){ 
                        max=arr[i];
                    }
                }
                return max;
            }
            return -1;
        }

2.冒泡排序法  
这是最简单的排序法，基本思路：  
对未排序的各元素从头到尾依次比较相邻的两个元素大小关系，若大于则交换位置，经过第一轮比较排序后可得出最大值，然后使用同样的方法把剩下的元素逐个比较即可。  
可以看出若有N个元素，那么一共要进行N-1轮比较，第M轮要进行N-M次比较。（若6个元素，要进行6-1轮比较，第一轮比较6-1次，第三轮比较6-3次）。

//冒泡排序法
        static  void  sort(int[] arr){ 
            int temp = 0;
            for (int i =0;i<arr.length-1;i++){ 
                for(int j = 0;j<arr.length-1-i;j++){ 
                    if(arr[j]>arr[j+1]){ 
                        temp=arr[j];
                        arr[j]=arr[j+1];
                        arr[j+1]=temp;
                    }
                }
            }
        }

3.选择排序  
基本思路：选择某个索引位置的元素，然后和后面元素依次比较，若大于则交换位置，经过第一轮比较排序后可得出最小值，然后使用同样的方法把剩下的元素逐个比较即可。  
可以看出选择排序，第一轮会选出最小值，第二轮会选出第二小的值，直到最后。  
第一轮从arr\[0\]和后面元素相比较，第二轮从arr\[1\]和后面的元素相比较，依次类推。N个数要进行N-1轮。选择排序每一轮只进行一次交换，相对于冒泡排序效率高一些。

//选择排序
        static void selectSort(int[] arr) { 
            int temp = 0;
            if (arr != null && arr.length > 0) { 
                for (int i = 0; i < arr.length - 1; i++) { 
                    for (int j = i + 1; j < arr.length; j++) { 
                        if (arr[i] > arr[j]) { 
                            temp = arr[j];
                            arr[j] = arr[i];
                            arr[i] = temp;
                        }
                    }
                }
            }
        }

4.二分法查找元素索引( 数组元素必须有顺序.)

//二分法查找
        static int binarySearch(int[] arr, int key) { 
            int low = 0;
            int high = arr.length - 1;
            if (arr != null && arr.length > 0) { 
                while (low <= high) { 
                    int mid = (low + high) >> 1;
                    int midVal = arr[mid];
                    if (midVal < key) { 
                        low = mid + 1;
                    } else if (midVal > key) { 
                        high = mid - 1;
                    } else { 
                        return mid;
                    }
                }
            }
            return -1;
        }

4.如何增加数组的长度:  
答: Java中的数组是定长的，无法动态增加长度。如果要扩充数组，只能通过重新定义数组，把旧数组内容拷贝到新数组中。

copyOf
    public static int[] copyOf(int[] original,
                               int newLength)复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引，副本将包含 0。当且仅当指定长度大于原数组的长度时，这些索引存在。 
    参数：
    original - 要复制的数组
    newLength - 要返回的副本的长度 
    返回：
    原数组的副本，截取或用 0 填充以获得指定的长度 
            int[] arr = { 2, 1, 4, 3, 6, 5};
            int[] arr1= Arrays.copyOf(arr,10);
            System.out.println(Arrays.toString(arr1));

5.Arrays工具类  
常用方法

asList(T... a) 
              返回一个受指定数组支持的固定大小的列表。
    binarySearch(int[] a, int key) 
              使用二分搜索法来搜索指定的 int 型数组，以获得指定的值 
    copyOf(int[] original, int newLength) 
              复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。 
    copyOfRange(int[] original, int from, int to) 
              将指定数组的指定范围复制到一个新数组。 
    equals(int[] a, int[] a2) 
              如果两个指定的 int 型数组彼此相等，则返回 true。 
    fill(int[] a, int val) 
              将指定的 int 值分配给指定 int 型数组的每个元素。 
    fill(int[] a, int fromIndex, int toIndex, int val) 
              将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。 
    hashCode(int[] a) 
              基于指定数组的内容返回哈希码 
    sort(int[] a) 
              对指定的 int 型数组按数字升序进行排序。 
    sort(int[] a, int fromIndex, int toIndex) 
              对指定 int 型数组的指定范围按数字升序进行排序。 
    toString(int[] a) 
              返回指定数组内容的字符串表示形式。