下角标基础运用

例题1

需求：
输入一个数，判断这个数有哪些情况
若在正常范围内，则直接输出那个数值
也可能小于0或者超出范围，需要进行提示

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int [] arr = new int[] {4,58,69,14,22,-1};
    System.out.println("请输入一个下标：");
    int index = scanner.nextInt();
    if (index < 0) {
        System.out.println("数字太小了，小于0");
    } else if (index < arr.length) {
        System.out.println("数字为: "+arr[index]);
    } else {
        System.out.println("数字太大了，大于数组的长度了");
    }
}

例题2

需求：
定义一个数组，倒叙将值输入进去
最后正序输出这个数组，即for循环内从arr.length-1开始自减
输入: 5 4 3 2 1，输出: 1 2 3 4 5

Scanner scanner = new Scanner(System.in);
int [] arr = new int[5];
for (int i = arr.length-1; i>=0 ; i--) {
    System.out.println("请输入第 "+(arr.length-i)+" 个数: ");
    arr[i] = scanner.nextInt();
}
for (int i : arr) {
    System.out.print(i+" ");
}

例题3

需求：
输入一串数据，添加到arr[]数组中
如果数组长度不够了，要考虑扩容问题
然后倒序存入新数组，最后赋值给原数组
输入: 1 2，输出: 0 0 2 1

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int[] arr = new int[2];
    int i = 0;
    main:while (true) {
        System.out.println("请输入数据：");
        int num = scanner.nextInt();
        arr[arr.length-1-i] = num;
        i++;
        if (i>=arr.length) {
            int [] newArr = new int[arr.length * 2];
            for (int j = 0; j < arr.length; j++) {
                newArr[newArr.length-1-j] = arr[arr.length-j-1];
            }
            arr = newArr;
        }
        System.out.println("是否要继续添加： 1、是    2、否");
        String flag = scanner.next();
        switch (flag) {
            case "1":
                continue;
            case "2":
                System.out.println("当前数组为："+ Arrays.toString(arr));
                break main;
        }
    }
}

例题4

需求：
在一个数组中插入一个值
先输入插入的位置(下角标)，然后输入数据
数组扩容，将index角标后面的数据整体往后移动，包括index位置的数据
用point记录角标，值为原数组的长度arr.length
输入: 1 9 输出: 1 9 2 3 4 5

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int [] arr = new int[]{1,2,3,4,5};
        System.out.print("请输入要插入数据的下标: ");
        int index = scanner.nextInt();
        System.out.print("请输入要插入的数据：");
        int num = scanner.nextInt();

        int [] newArr = new int[arr.length*2]; // 扩容操作
        for (int i = 0; i < arr.length; i++) {
            newArr[i]=arr[i];
        }
        int point = arr.length; // 记录一个角标 从哪里开始移动
        arr=newArr;
        while(point!=index) { // 做循环 把值往后移动
            arr[point]=arr[point-1];
            point--;
        }
        arr[index] = num;
        System.out.println(Arrays.toString(arr));
    }

数组拼接

尾部拼接

需求：
定义两个数组，将第二个数组的所有内容拼接到第一个数组后
最后将第一个数组输出

public static void main(String[] args) {
    int [] arr1 = new int[]{1,2,3,4,5};
    int [] arr2 = new int[]{6,7,8,9,10,11};
    // 定义了一个临时数组，用来存放值
    int [] tempArr = new int[arr1.length+arr2.length];
    // 先将arr1数组放入，从0角标开始即可
    for (int i = 0; i < arr1.length; i++) {
        tempArr[i]=arr1[i];
    }
    // 再将arr2数组放入，从i+arr1.length角标开始
    for (int i = 0; i < arr2.length; i++) {
        tempArr[i+arr1.length]=arr2[i];
    }
    // 最后将tempArr赋值给arr1
    arr1 = tempArr;
    System.out.println(Arrays.toString(arr1));
}

首部拼接

需求：
定义两个数组，将第二个数组的所有内容拼接到第一个数组前
最后将第一个数组输出

public static void main(String[] args) {
    int [] arr1 = new int[]{1,2,3,4,5};
    int [] arr2 = new int[]{6,7,8,9,10,11};
    int [] tempArr = new int[arr1.length+arr2.length];
    for (int i = 0; i < arr2.length; i++) {
        tempArr[i]=arr2[i];
    }
    for (int i = 0; i < arr1.length; i++) {
        tempArr[i+arr2.length]=arr1[i];
    }
    arr1 = tempArr;
    System.out.println(Arrays.toString(arr1));
}

插入拼接

需求：
定义两个数组，然后输入一个pos角标
将第二个数组插入到这个角标开始的位置
然后将第一个数组的剩下内容往后移位
最后将第一个数组输出

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int [] arr1 = new int[]{1,2,3,4,5};
    int [] arr2 = new int[]{6,7,8,9,10,11};
    int [] tempArr = new int[arr1.length+arr2.length];
    System.out.print("请输入你要插入的角标位置: ");
    int pos = scanner.nextInt();

    for (int i = 0; i < pos; i++) {
        tempArr[i]=arr1[i];
    }
    for (int i = pos; i < arr1.length; i++) {
        tempArr[i+arr2.length]=arr1[i];
    }
    for (int i = 0; i < arr2.length; i++) {
        tempArr[i+pos]=arr2[i];
    }
    arr1 = tempArr;
    System.out.println(Arrays.toString(arr1));
}

关于拼接，不管是怎么拼接，都要考虑是从哪个位置 即pos
逻辑思路要清晰，是要先把它拿出来，再塞进去，还是直接塞进去
向后移位最简单的方式就是先移位再插入
如果直接插入还需要使用额外的变量temp，即拿出来一个再塞进去一个
就会显得很麻烦

利用下角标判断数组

作业1

判断两个数组是否完全一致
运用for循环，index控制角标遍历两个数组
只要arr1[index]和arr2[index]不一样，则返回false

public class Test6 {
    public static void main(String[] args) {
        int arr1[] = new int[]{1,2,3,4,3,2,1};
        int arr2[] = new int[]{1,2,3,4,3,2,1};
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr2));
        System.out.println(" 是否一致："+eqauls(arr1,arr2));
    }
    public static boolean eqauls(int[] numArr1,int[] numArr2) {
        if (numArr1.length != numArr2.length){
            return false;
        }
        for (int i = 0; i < numArr1.length; i++) {
            if (numArr1[i] != numArr2[i]) {
                return false;
            }
        }
        return true;
    }
}

作业2

判断数组是否中间对称
即[1,2,3,4,5,4,3,2,1]为true
[1,2,3,4,4,3,2,1]为true
[1,2,3,4,5,6,7,8]为false

思路：
定义一个preIndex与lastIndex分别代指前角标和后角标
当preIndex > lastIndex则退出循环，不再进行判断
只要arr[preIndex] != arr[lastIndex]直接返回false

public class Test5 {
    public static void main(String[] args) {
        int arr1[] = new int[]{1,2,3,4,3,2,1};
        int arr2[] = new int[]{1,2,3,4,5,2,1};
        System.out.println(Arrays.toString(arr1) +"是否对称："+sym(arr1));
        System.out.println(Arrays.toString(arr2) +"是否对称："+sym(arr2));
    }
    public static boolean sym(int[] arr) {
        int preIndex=0,lastIndex=arr.length-1;
        while (preIndex < lastIndex) {
            if (arr[preIndex] != arr[lastIndex]) {
                return false;
            }
            preIndex++;
            lastIndex--;
        }
        return true;
    }
}

作业3

将一个数组中，奇数元素放在左侧，偶数元素放在右侧
若preIndex为偶数且lastIndex为奇数则开始调换
否则，将不满足条件的index移位

public class Other1 {
    public static void main(String[] args) {
        // {26,67,49,38,52,66,7,71,56,87}
        // 87,67,49,71,7,66,52,38,56,26
        int [] arr = new int[]{26,67,49,38,52,66,7,71,56,87};
        System.out.println("原数组：");
        System.out.println(Arrays.toString(arr));
        int preIndex=0,lastIndex=arr.length-1;
        while (preIndex < lastIndex) {
            if (arr[preIndex]%2!=0) {
                preIndex++;
                continue;
            }
            if (arr[lastIndex]%2==0) {
                lastIndex--;
                continue;
            }
            int temp=arr[preIndex];
            arr[preIndex]=arr[lastIndex];
            arr[lastIndex]=temp;
            preIndex++;
            lastIndex--;
        }
        System.out.println("排列后：");
        System.out.println(Arrays.toString(arr));
    }
}

作业4

查重一个数组，将出现重复的数在数组中删掉
即[2,1,3,3,1]变为[2,1,3]

思路：
建立一个新数组newArr，判断原数组numArr
若newArr内遍历查找没有numArr的内容，则添加到newArr当中

public class Other2 {
    public static void main(String[] args) {
        // {9,10,6,6,1,9,3,5,6,4}
        // 9 10 6 1 3 5 4
        int [] numArr = new int[]{9,10,6,6,1,9,3,5,6,4};
        int [] newArr = new int[1];
        for (int i = 0; i < numArr.length; i++) {
            if (i==0) {
                newArr[i] = numArr[i];
            }
            for (int j = 0; j < newArr.length; j++) {
                if (newArr[j]==numArr[i]) {
                    break;
                }
                if (j==newArr.length-1) {
                    int [] tempArr = new int[newArr.length+1];
                    for (int k = 0; k < newArr.length; k++) {
                        tempArr[k]=newArr[k];
                    }
                    newArr=tempArr;
                    newArr[newArr.length-1]=numArr[i];
                }
            }
        }
        System.out.println(Arrays.toString(newArr));
    }
}

作业5

字符数组：{'a','l','f','m','f','o','b','b','s','n'}
将数字强制转换，根据ASCII码表转换为字符
统计每个字符出现的次数并打印到控制台

思路：
建立一个新数组charNum，存入出现字符出现的次数
出现则自增，最后输出的时候判断，若为0则跳过

public class Last {
    public static void main(String[] args) {
        char[] charArr = new char[]{'a','l','f','m','f','o','b','b','s','n'};
        int [] charNum = new int[26];
        for (int i = 0; i < charArr.length; i++) {
            charNum[(int)charArr[i]-97]++;
        }
        for (int i = 0; i < charNum.length; i++) {
            if (charNum[i] != 0) {
                System.out.println((char)(i+97)+"--"+charNum[i]);
            }
        }
    }
}

总结