一图超多实例搞定javaSE数组，你找到队长了吗？

话不多说，直接上一波导图~

 

案例代码

package com.water.javaSE;

import java.util.Arrays;
import java.util.Scanner;
//作业：流程控制的逻辑训练任务(数组+逻辑)
public class Demo515 {
    public static void main(String[] args) {
        //1、查找该数是否在数组中
        //find(12);
        //2、求数组的最大值和最小值
        //inputMaxAndMin(10);
        //3、两数之和
        //twoNum(1,88);
        //4、对数组{1，3，9，5，6，7，15，4，8}进行排序，然后使用二分查找 6
        //int[] arr={1,3,9,5,6,7,15,4,8};
        //sortAndSearch(arr,10);
        //5、移动零
        moveZero(10);
        
    }

    /**
     * 1、查找某个整数
     * 定义一个长度为 10 的整型数组 nums ，循环输入 10 个整数。 然后将输
     * 入一个整数，查找此整数，找到输出下标， 没找到给出提示；
     */
    public static void find(int n){
        //产生数组
        int[] arr = generateArr(n);
        Scanner input = new Scanner(System.in);
        int a;
        System.out.println("请输入一个整数！");
        if (input.hasNextInt()){
            a = input.nextInt();
            //遍历数组，比较用户输入的整数是否在数组中
            for (int i = 0; i < arr.length; i++) {
                if (a==arr[i]){
                    System.out.println("此整数的下标为："+i);
                    return;
                }
            }
            System.out.println("数组中没有该整数");
        }else {
            System.out.println("你输入了个锤子！不是整数！拜拜！"); //非整数输入，结束程序！
        }
    }

    /**
     * 2、找出数组的最值
     * 定义一个长度为 10 的整型数组 nums ，循环输入 10 个整数。输出数组的最大值、最小值。
     */
    public static void inputMaxAndMin(int n){
        int[] ints = generateArr(n);
        int max = ints[0];
        int min = ints[0];
        //max、min都初始化为数组的第一个数，因此从索引1开始比较
        for (int i = 1; i < ints.length; i++) {
            if (ints[i]>max)
                max=ints[i];
            if (ints[i]<min)
                min=ints[i];
        }
        System.out.println("该数组的最大值为："+max+"; 最小值为："+min);
    }

    /**
     * 3、两数之和
     * 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为
     * 目标值的那两个整数，并输出他们的数组下标
     * 假设每种输入只会对应一个答案，不能重复利用这个数组中同样的元素。
     * 示例:
     * 给定 nums = [2, 7, 11, 15], target = 9
     * 因为 nums[0] + nums[1] = 2 + 7 = 9
     * 所以输出 0，1
     */
    public static void twoNum(int n, int target){
        System.out.println("目标数为："+target);
        if (n<2){
            System.out.println("数组长度为"+n+",该数组不符合要求！");
        }else {
            int[] ints = generateArr(n);
            int a,b;
            //遍历两数之和，比较目标数
            for (int i = 0; i < ints.length; i++) {
                for (int j = i+1; j < ints.length; j++) {
                     a=ints[i];
                     b=ints[j];
                    if (a+b==target){
                        System.out.println("该数组中存在两数之后为目标数，下标分别："+i+"和"+j);
                        return;
                    }
                }
            }
            System.out.println("该数组没有符合要求的两个数！");
        }


    }

    /**
     * 4、排序并查找
     * 对数组{1，3，9，5，6，7，15，4，8}进行排序，然后使用二分查找 6 并
     * 输出排序后的下标。
     */
    public static void sortAndSearch(int[] arr,int n){
        //调用冒泡排序，从小到大
        paoSort(arr);
        int a;
        System.out.println("排序后数组为："+Arrays.toString(arr));
        //二分查找法，时间复杂度O（logN），比较中间下标的元素，左右边界按条件移动，逐步缩小查找范围
        a=0;    //最小下标（左）
        int b=arr.length-1; //最大下标（右）
        int c = (a+b)/2;    //中间下标（中）
        while(true){
            if (arr[c]==n){
                System.out.println(n+"的下标为："+c);
                break;
            }else if (arr[c]<n){
                a=c+1;
            }else {
                b=c-1;
            }
            //最小下标大于最大下标，表示查找到头了
            if (a>b){
                System.out.println("该数组没有要找的数！");
                break;
            }
            //更新中间下标，虽然c依赖a、b,但赋值的动作不会自动发生，需要手动更新
            c = (a+b)/2;
        }

    }

    /**
     * 5、移动零
     * 给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保
     * 持非零元素的相对顺序。
     * 示例:
     * 输入: [0,1,0,3,12] 输出: [1,3,12,0,0]
     */
    public static void moveZero(int n){
        //产生长度为n的整数数组
        int[] ints = generateArr(n);
        //遍历数组，找到元素0的数量
        int a=0;
        for (int anInt : ints) {
            if (anInt == 0) {
                a++;
            }
        }
        //新数组arr[],装非零元素
        int[] arr = new int[ints.length-a];
        int b=0;
        for (int anInt : ints) {
            if (anInt != 0) {
                arr[b] = anInt;
                b++;
            }
        }
        //排序数组arr[]，从小到大
        paoSort(arr);
        for (int k = 0; k < ints.length; k++) {
            //组装
            ints[k]=k<arr.length?arr[k]:0;
        }
        System.out.println("该数组为："+Arrays.toString(ints));

    }


    /**
     * 冒泡排序，从小到大
     * @param arr
     */
    private static void paoSort(int[] arr) {
        int a;
        //冒泡排序，外层循环控制比较轮数，排序n个数，需要n-1轮，时间复杂度为O（NlogN），外层N，里层logN
        //举例：10*10=N*N，10+9+……1=55，约一半，1/2N约等于logN
        for (int i = 0; i < arr.length - 1; i++) {
            //内层控制每轮比较，得出一个最大值，往右移，同时每轮比较的次数减i，i表示已经排好序的元素个数
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    a = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = a;
                }
            }
        }
    }

    /**
     * 产生长度为n的整数数组
     */
    private static int[] generateArr(int n){
        int[] arr = new int[n];    //定义了长度为n的整数数组
        Scanner input = new Scanner(System.in); //接收用户输入
        System.out.println("请逐一输入"+n+"个整数,组成长度为"+n+"的整数数组");
        int a = 0;  //数组下标
        String str ;    //接收非整数的输入
        while(true){
            if (input.hasNextInt()){
                arr[a] = input.nextInt();   //死循环，接收用户输入的n个整数
                a++;
            }else {
                str = input.next();
                System.out.println(str+"该输入无效，请重新输入！"); //无效输入，则提示重新输入
                continue;
            }
            if (a==n){
                System.out.println("已输入"+n+"个整数！----->"+ Arrays.toString(arr));
                break;
            }
        }
        return arr;
    }
}

找队长游戏，来大家过来围圈。

package com.water.javaSE;

import java.util.Arrays;
import java.util.Scanner;

/**
 * 今天同学们相约一起爬山游玩，为了更好的进行这场活动，大家准备推举
 * 一个人作为出游的临时队长。为了体现合理公平，大家提出了一个比较有趣的
 * 规则。所有人围成一圈，顺序排号。从第一个人开始报数（从 1 到 3 报数），
 * 凡报到 3 的人退出圈子，剩下的人继续报数，最后留下的当选为队长。
 * 请你通过编写程序，求出一组人中的队长是原来第几位同学。
 */
public class Demo516 {
    public static void main(String[] args) {
       position(3);
    }
    /**
     * 求队长是原来的第几位同学
     * @param n 报数1-n
     */
    public static void position(int n){
        Scanner input = new Scanner(System.in);
        System.out.println("请输入同学们的人数！");
        int a;
        while(true){
            if (input.hasNextInt()) {
                a = input.nextInt();
                if (a > 0) break;
            }
             System.out.println("输入无效，重新输入！");

        }
        System.out.println("同学们的人数为："+a+"人，马上围成一圈，报数顺序为1-"+n+"，凡是喊到"+n+"的，退圈！最后一名同学为队长！");
        int[] arr = new int[a];
        int b=1;    //1，报数
        int c=0;    //出局人数
        //给每个同学标记上序号
        for (int i = 0; i < arr.length; i++) {
            arr[i]=i+1;
        }
        //喊到3的设为0，表示出局
        aa:while(true){
            for (int i = 0; i < arr.length; i++) {
                //喊到3（或者n），并且该元素不为0，则设置为0，表示已出局
                if (b==n && arr[i]!=0){
                    arr[i]=0;   //表示出局
                    b=1;    //重置b
                    c++;    //累计有多少人出局
                }
                if (arr[i]!=0){
                    b++;    //累加器
                }
            }
            if (arr.length-c==1){   //仅剩1人，则为队长
                for (int i : arr) {
                    if (i!=0){
                        System.out.println("队长的原来序号为："+i);
                        //break循环名，直接跳出多重循环
                        break aa;
                    }
                }
            }

        }

    }
}

将生活的场景，用代码实现，是一件很棒的事！编程实战要多多练习，多多思考。

有反馈的事，就是比没反馈的要让人开心，这或许就是编程的魅力之一。

有态度的结尾：

“谁是编程之光？你大爷还是你大爷……”

“且看下回请教~”