java-数组

原文地址：https://www.cnblogs.com/lyang-a/p/11434528.html

一维数组定义：

// 1数据类型[] 数组名 = new 数组类型[数组长度];    
String[] str = new String[10];

//2数据类型[] 对象数组名 = new 类名称[] {对象，对象......};
  
String[] str = new String[]{“a”,"b"}

//数据类型[] 对象数组名 = {对象，对象......};

String[] str = {“a”,"b"}

二维数组定义：

//元素类型[][]  数组名 = new 元素类型[数组长度1][数组长度2];

String[][] str2 = new String[2][3]; // 可以认为创建一个两行三列的数组

//数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
String[][] str = {{"a","1"},{"b","2"}};

//数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
String[][] str2 = new String[][]{{"a","1"},{"b","2"}};

一维数组遍历

使用for循环遍历获取数组元素

int[] arr = {11, 22, 33, 44, 55, 66, 77};
// for循环遍历数组
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

或者用增强for循环：

for (int s ： arr) {
    System.out.println(s);
}

二维数组遍历

/ 使用嵌套循环（两层for循环）遍历
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++){
        sum +=arr[i][j];
        System.out.print(arr[i][j] + "	");
    }
}

　　

数组的操作：

插入：
    a)插入元素之前，先判断数组是否还能存得下插入的元素，如果存不下那么需要执行扩容操作。
    原因：数组一旦创建完毕，那么数组的空间长度就不能发生变化了！
    b)插入元素时，为了保证数组是一块连续的内容空间，那么我们需要对插入位置之后的元素做位移操作。
  位移操作：向后移动一位

  删除：
    a)删除元素时，为了保证数组是一块连续的内容空间，那么我们需要对删除位置之后的元素做位移操作。
    位移操作：向前移动一位

/*
 * 增删改查
 * 
 */

/**
 * 根据下标查询元素
 * 
 * @param arr
 * @param index
 * @return 整型元素
 * @author ZZY
 * @time 2018-12-07 14:35
 */
public static int queryElementByIndex(int[] arr, int index) {

    return arr[index];
}

/**
 * 根据元素查找下标
 * 
 * @param arr
 * @param ele
 * @return 元素下标
 */
public static int queryIndexByElement(int[] arr, int ele) {

    int index = -1; // 用来记录下标的变量
    // 1：遍历所有的元素
    for (int i = 0; i < arr.length; i++) {
        // 2 用你要查找的元素和所有的元素做==比较
        if (arr[i] == ele) {
            // 3 相等判断成立，记录当前元素的下标
            index = i;// 记录当前元素的下标
            break; // 后面元素就不用判断了
        }
    }
    return index;
}

/**
 * 求数组的最大值
 * 
 * @param arr
 * @return 最大值
 */
public static int maxValue(int[] arr) {
    // 1 假设第一个元素是最大值
    int max = arr[0];
    // 2:遍历数组
    for (int i = 1; i < arr.length; i++) {
        // 3 用这个个最大值和后面的元素做大于比较
        if (arr[i] > max) {
            // 4如果后面的元素比这个最大值还大，那么后面的元素就是最大值
            max = arr[i];
        }
    }
    return max;
}

/**
 * 求数组的最小值
 * 
 * @param arr
 * @return 最小值
 */
public static int minValue(int[] arr) {
    // 1 假设第一个元素是最小值
    int min = arr[0];
    // 2:遍历数组
    for (int i = 1; i < arr.length; i++) {
        // 3 用后面的元素这个最小值和做小于比较
        if (arr[i] < min) {
            // 4如果后面的元素比这个最小值还小，那么后面的元素就是最小值
            min = arr[i];
        }
    }
    return min;
}

/**
 *  给数组添加元素
 * @param arr
 * @param ele
 * @param index
 * @return  返回新的数组
 */
public static int[] addElement(int[] arr, int ele, int index) {
    

    // 1：新建一个数组，长度是原数组长度+1 数组扩容
    int[] newArr = new int[arr.length + 1];
    if(index>=0 && index<newArr.length){

        // 2 拿到下标为3的前面的元素，放到新数组按照0 1 2 顺序依次存放
        for (int i = 0; i < index; i++) {
            newArr[i] = arr[i];
        }

        // 3 把要添加的元素100放入新数组下标为3的位置
        newArr[index] = 100;

        // 4 拿到下标为3的后面的元素，放到新数组按照 4 5 顺序依次存放

        for (int i = index; i < arr.length; i++) {
            newArr[i + 1] = arr[i];
        }
    }else{
        System.out.println("索引超出范围");
        //超出范围，返回旧数组
        return arr;
    }        
    
    // 5:返回新数组
    return newArr;

}

/**
 * 根据下标删除元素
 * @param arr
 * @param index
 * @return  原数组
 */
public static int[] delEleByIndex(int[] arr,int index){
    
    if(index>=0 && index<arr.length){
        //1：找到下标为2的元素，后面的元素依次覆盖前面的元素
        for(int i = index;i<arr.length-1;i++){
            arr[i] = arr[i+1];
        }
        
        //2：把最后一位赋值为0
        arr[arr.length-1] = 0;
        
    }else{
        System.out.println("没有此下标");
    }
    //3 返回删除后的数组
    return arr;
    
}

/**
 * 根据元素删除元素
 * @param arr
 * @param ele
 * @return  下标
 */
public static int delEleByEle(int[] arr,int ele){
       //1 :定义删除元素的下标
        int index = -1;
        
        //2：用你要删除的元素和数组里面的每一个元素做==比较
        for(int i = 0;i<arr.length;i++){
            if(ele==arr[i]){
              //3：找到要删除的元素后，记录下当前元素的下标
                index = i;
                break; //后面就不要比较了
            }
        }
        //如果index是-1，直接返回，不需要移位
        if(index==-1){
            return index;
        }
         //4：然后后面的下标依次向前移位
        for(int i = index;i<arr.length-1;i++){
            arr[i] = arr[i+1];
        }

        //5：把最后一位置为0
        arr[arr.length-1] = 0;
        //6  返回数组的下标即可
        return index;
}


public static void main(String[] args) {
    int[] arr = { 10, 20, 300, 40, 50 };
    
    int index = delEleByEle(arr,300);
    if(index!=-1){
        for (int i : arr) {
            System.out.println(i);
        }
    }else{
        System.out.println("没有此元素");
    }
    
    /*arr = delEleByIndex(arr,2);
    for (int i : arr) {
        System.out.println(i);
    }
    */
    
    
    
    
/*    int[] newArr = addElement(arr,100,-12);
    
    for (int i : newArr) {
        System.out.println(i);
    }*/
    
    /*int max = maxValue(arr);
    int min = minValue(arr);
    System.out.println("最大值是:" + max);
    System.out.println("最小值是:" + min);

import java.util.Arrays;

public class ArraysUtil {
    public static void main(String[] args) {
        int[] arr = { 5, 12, 90, 18, 77, 76, 45, 28, 59, 72 };
        
        // 字符串输出
        //toString(arr);
        
        // 升序排序
        //sort(arr);
        
        // 判断数组是否相等
        //equals();

        // 二分法查找
        //binarySearch();
        
        // 数组复制
        //copyOf(arr);
        //copyOfRange(arr);
        
        /* System类中的arraycopy方法
         public static native void arraycopy(Object src,  int  srcPos,
                                                Object dest, int destPos,
                                                int length);
         作用：就是用于实现数组元素的拷贝工作。
         建议：如果需要实现对数组元素的拷贝工作，建议使用System类中的arraycopy方法，而不要去用Arrays工具类中的copyOf()和copyOfRange()方法
         方法参数分析：
                 src：需要被拷贝的数组(源数组)
                 srcPos：从源数组中的那个位置开始拷贝，传递是一个索引值
                 dest：目标数组，也就是把拷贝的元素放入目标数组中
                  destPos：把拷贝的元素放在目标数组中的哪个位置，传递是一个索引值
                  length：拷贝数组的元素个数*/
        // 复制数组建议使用这种
        int[] dest = new int[5];
        System.arraycopy(arr, 2, dest, 0, 5);
        System.out.println(Arrays.toString(dest));
                  
         /*native关键字介绍：
                 使用关键字“native”修饰的方法，我们称之为本地方法。
                   本地方法特点：只有方法的声明，没有方法的实现(没有方法体)。
                   为什么会有本地方法的出现呢？？？
                       java虽然很强大，但是也有局限性。java不能直接操作硬件！
                       java中提供的本地方法，本质上就是通过本地方法来调用别的语言（例如：C语言）来操作硬件。*/
        
        
    }

    /**
     * 范围复制数组
     * @param arr 传入的数组
     */
    public static void copyOfRange(int[] arr) {
        /*int[] copyOfRange = Arrays.copyOfRange(arr, 2, 8);
        for (int i : copyOfRange) {
            System.out.print(i + "  ");
        }*/
        
        int[] copyOfRangeArrays = copyOfRangeArrays(arr, 2, 8);
        for (int i : copyOfRangeArrays) {
            System.out.print(i + "  ");
        }
    }

    /**
     * 手写实现范围复制数组
     * @param arr 传入的数组
     * @param from  取值的初始索引
     * @param to  取值的结束索引
     * @return 返回的新数组
     */
    public static int[] copyOfRangeArrays(int[] arr,int from,int to) {
        // 0.判断form和to是否合法
        if (to < from || to < 0 || from < 0 || to >= arr.length) {
            System.out.println("传入的to或from不合法！");
            throw new RuntimeException();
        }
        int length = to - from;
        int[] arr2 = new int[length];
        // 方案一：
        for (int i = 0; i < arr2.length; i++) {
            arr2[i] = arr[from + i];
        }
        /*// 方案二：
          for(int i = from; i < to; i++) { 
            arr2[i - from] = arr[i];
        }*/
        /*// 方法三：
         for(int i = from, j = 0; i < to; i++, j++) {
            arr2[j] = arr[i];
        }*/
        arr = arr2;
        return arr;
    }
    
    /**
     * 赋值数组
     * @param arr 传入的数组
     */
    public static void copyOf(int[] arr) {
        /*int[] arr2 = new int[4];
        int[] copyOf = Arrays.copyOf(arr, 4);
        arr2 = copyOf;
        for (int i : arr2) {
            System.out.print(i + "  ");
        }*/
        
        int[] copyOfArrays = copyOfArrays(arr,4);
        for (int i : copyOfArrays) {
            System.out.print(i + "  ");
        }
    }
    
    /**
     * 手写实现copy数组方法
     * @param arr 传入的数组
     * @param length 截取的长度
     * @return 返回截取的数组
     */
    public static int[] copyOfArrays(int[] arr,int length) {
        int[] arr2 = new int[length];
        for (int i = 0; i < arr2.length; i++) {
            arr2[i] = arr[i];
        }
        arr = arr2;
        return arr;
    }

    /**
     * 二分法查找 （数组必须有序）
     * @param arr 传入的数组
     */
    public static void binarySearch() {
        int[] arr = {1,2,3,4,5,6,7,8,9};
        
        /*int binarySearch = Arrays.binarySearch(arr, 6);
        System.out.println(binarySearch);*/
        
        int binarySearch = binarySearch(arr, 6);
        System.out.println(binarySearch);
        
    }
    
    /**
     * 手写实现二分法查找
     * @param arr 传入的数组
     * @param value 传入的值
     * @return 返回数组中查找值的索引
     */
    public static int binarySearch(int[] arr,int value){
        int min = 0,max = arr.length - 1,mid = 0;
        for (int i = 0; i < arr.length; i++) {
            mid = (min + max) / 2;
            if (value > arr[mid]) {
                min = mid + 1;
            }else if(value < arr[mid]){
                max = mid - 1;
            }else {
                return mid;
            }
            if (max < min) {
                return -1;
            }
        }
        return mid;
    }

    /**
     * sort方法
     * @param arr 传入的数组
     */
    private static void sort(int[] arr) {
        // Arrays.sort(arr);
        int[] sortArrays = sortArrays(arr);
        for (int i : sortArrays) {
            System.out.print(i + "  ");
        }
    }
    
    /**
     * 手写实现sort方法（冒泡法）
     * @param arr 传入的数组
     * @return 返回排序后（升序）的数组
     */
    public static int[] sortArrays(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            // 假设数组是有序的
            boolean flag= true;
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = false; // 推翻假设
                }
            }
            if (flag) { // 如果有序直接跳出循环
                break;
            }
        }
        return arr;
    }

    /**
     * toString方法
     * @param arr 传入的数组
     */
    public static void toString(int[] arr) {
        // System.out.println(Arrays.toString(arr));

        System.out.println(toStringArrys(arr));
    }

    /**
     * 手写实现tostring方法
     * @param arr 传入的数组
     * @return 返回的字符串
     */
    private static String toStringArrys(int[] arr) {
        String str = "";
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i != arr.length - 1) {
                str += arr[i] + ",";
            } else {
                str += arr[i] + "]";
            }
        }
        return str;
    }
    
    /**
     * rquals方法
     */
    public static void equals() {
        int[] arr1 = {1,2,3,4};
        int[] arr2 = {1,2,3,4};
        /*boolean equals = Arrays.equals(arr1, arr2);
        System.out.println(equals);*/
        
        boolean equals = equalsArrays(arr1, arr2);
        System.out.println(equals);
    }

    /**
     * 手写实现rquals方法
     * @param arr1 传入的第一个数组
     * @param arr2 传入的第二个数组
     * @return 如果相同则为true，不同则为false
     */
    public static boolean equalsArrays(int[] arr1, int[] arr2) {
        if (arr1 == arr2) 
            return true;
        if (arr1 == null || arr2 == null) 
            return false;
        if (arr1.length != arr2.length) 
            return false;
        for (int i = 0; i < arr2.length; i++) {
            if (arr1[i] != arr1[i]) {
                return false;
            }
        }
        return true;
    }
    
}