数组与字符串操作-高效率的数组方法

高效率的数组方法包括以下几种常见的操作：

1. 遍历数组：使用for循环或者增强型for循环可以高效地遍历数组中的每个元素。

2. 查找元素：使用线性搜索或者二分搜索算法可以在有序数组中高效地查找指定元素。

3. 插入元素：在数组中插入元素时，如果不需要保持有序性，可以直接将元素插入到数组的末尾，时间复杂度为O(1)。如果需要保持有序性，可以使用二分搜索找到插入位置，然后将元素插入到相应位置，时间复杂度为O(log n)。

4. 删除元素：删除数组中的元素时，可以将指定位置后面的元素向前移动一位，然后将数组的长度减一，时间复杂度为O(n)。

5. 排序数组：使用高效的排序算法（如快速排序、归并排序、堆排序等）可以对数组进行排序，时间复杂度为O(nlog n)。

6. 合并数组：将两个有序数组合并成一个有序数组时，可以使用双指针法，逐个比较两个数组的元素，然后按顺序插入到新的数组中，时间复杂度为O(n)。

7. 数组的拷贝：对于大数组的拷贝操作，使用System.arraycopy()方法可以高效地完成，时间复杂度为O(n)。

8. 数组的扩容：当数组的长度不足以存放新增的元素时，可以使用Arrays.copyOf()方法或者ArrayList的动态扩容机制来扩容数组，时间复杂度为O(n)。

注意：以上操作的效率都是基于平均情况下的时间复杂度，实际效率可能还受到其他因素的影响，如硬件性能、操作系统等。在实际应用中，根据具体的场景和需求选择合适的数组方法能够提高代码的效率。

以下是一个使用高效率数组方法的示例代码，包括遍历数组、查找元素、插入元素和删除元素的操作：

import java.util.Arrays;

public class ArrayDemo {
    public static void main(String[] args) {
        int[] array = {4, 2, 7, 1, 9, 5};
        
        // 遍历数组
        System.out.println("遍历数组：");
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        
        // 查找元素
        int target = 7;
        int index = binarySearch(array, target);
        if (index != -1) {
            System.out.println("元素 " + target + " 的索引位置为 " + index);
        } else {
            System.out.println("元素 " + target + " 不存在");
        }
        
        // 插入元素
        int element = 3;
        int insertIndex = findInsertIndex(array, element);
        array = insertElement(array, element, insertIndex);
        System.out.println("插入元素 " + element + " 后的数组：");
        System.out.println(Arrays.toString(array));
        
        // 删除元素
        int deleteIndex = 2;
        array = deleteElement(array, deleteIndex);
        System.out.println("删除索引为 " + deleteIndex + " 的元素后的数组：");
        System.out.println(Arrays.toString(array));
    }
    
    // 二分查找元素
    public static int binarySearch(int[] array, int target) {
        int left = 0;
        int right = array.length - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            
            if (array[mid] == target) {
                return mid;
            } else if (array[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        
        return -1;
    }
    
    // 查找插入位置
    public static int findInsertIndex(int[] array, int element) {
        int index = 0;
        
        while (index < array.length && array[index] < element) {
            index++;
        }
        
        return index;
    }
    
    // 插入元素
    public static int[] insertElement(int[] array, int element, int index) {
        int[] newArray = new int[array.length + 1];
        
        System.arraycopy(array, 0, newArray, 0, index);
        newArray[index] = element;
        System.arraycopy(array, index, newArray, index + 1, array.length - index);
        
        return newArray;
    }
    
    // 删除元素
    public static int[] deleteElement(int[] array, int index) {
        int[] newArray = new int[array.length - 1];
        
        System.arraycopy(array, 0, newArray, 0, index);
        System.arraycopy(array, index + 1, newArray, index, array.length - index - 1);
        
        return newArray;
    }
}

通过运行以上示例代码，可以看到数组的遍历、查找、插入和删除操作的效果。