编程题（一）

1.九九乘法表

    /**
     * 九九乘法表
     * @param args
     */
    public static void main(String[] args) {
        for (int i = 0; i <= 9; i++){
            for (int j = 1; j <= i; j++){
                System.out.print(j + "*" + i + "=" + (i*j) + "\t");
            }
            System.out.println();
        }
    }

2.输出 100 以内所有的素数

    /**
     * 输出 100 以内所有的素数
     * 素数：又称为质数，它指的是只能被1和自己整除的整数，其中，1不是素数。
     * @param args
     */
    public static void main(String[] args) {
        int count = 0;
        for (int i = 2; i < 100; i++){
            boolean flag = true;
            for (int j = 2; j < i; j++){
                if(i % j == 0){
                    flag = false;
                    break;
                }
            }
            if (flag){
                count++;
                System.out.print(i + "  ");
            }
        }
        System.out.println();
        System.out.println("100 以内的素数个数是："+count);
    }

3.输出1000以内所有的水仙花数

    /**
     *  输出1000以内所有的水仙花数
     *  水仙花数：它是指一个 n 位的数（n>=3），它的每一个位上的数字的 n 次幂的和等于它的本身。
     *  例：153    1³ + 5³ + 3³ = 153
     * @param args
     */
    public static void main(String[] args) {
        int ge,shi,bai;
        int count = 0;
        for (int i = 100; i < 1000; i++){
            ge = i % 10;
            shi = i/10%10;
            bai = i/100;
            int result = (int)(Math.pow(bai,3)+Math.pow(shi,3)+Math.pow(ge,3));
            if(i == result){
                count ++;
                System.out.print(result+"  ");
            }
        }
        System.out.println();
        System.out.println("1000以内所有的水仙花数的个数："+count);
    }

4.统计不同类型字符的个数

    /**
     *  统计不同类型字符的个数
     *  给定一个字符串，分别统计出其中的英文字母、数字、空格以及其他字符的个数
     * @param args
     */
    public static void main(String[] args) {
        String str = "adsf eQW&ER @T12 %3~4 $567 !#890";
        char[] chars = str.toCharArray();

        int englishCount = 0;
        int spaceCount = 0;
        int digitCount = 0;
        int otherCount = 0;

        for (int i = 0; i<str.length(); i++){
            if (Character.isLetter(chars[i])){
                englishCount++;
                continue;
            }
            if (Character.isDigit(chars[i])){
                digitCount++;
                continue;
            }
            if (Character.isSpaceChar(chars[i])){
                spaceCount++;
                continue;
            }
            otherCount++;
        }
        System.out.println("英语字母个数为："+englishCount);
        System.out.println("数字个数为："+digitCount);
        System.out.println("空格个数为："+spaceCount);
        System.out.println("其他字符个数为："+otherCount);
    }

5.计算1-100之间的和

    /**
     *  计算1-100之间的和
     * @param args
     */
    public static void main(String[] args) {
        System.out.println("1-100之间的和为："+sum(1000));
    }
    public static int sum(int value){
        if (value == 1){
            return 1;
        }
        return value+sum(value-1);
    }

6.编程输出只出现过一次的数

    /**
     *  编程输出只出现过一次的数
     *  给定一个整型数组，计算并输出其中只出现一次的数
     * @param args
     */
    public static void main(String[] args) {
        int[] arr = new int[]{1,1,23,23,34,43,43,45,45,65,67,65,67,78};
        for (int i = 0; i < arr.length; i++) {
            int num = 0;
            for (int j = 0; j < arr.length; j++) {
                if (arr[i] == arr[j]) {
                    num++;
                }
            }
            if (num == 1) {
                System.out.println("只出现过一次的数为："+arr[i]);
            }
        }
    }

7.冒泡排序

    /**
     *  冒泡排序
     *  冒泡排序：依次比较两个相邻的数据，若发现逆序则交换，越小的数据经过交换慢慢浮到数组顶端，就如同水底的气泡往上冒一样，最终会上浮的顶端，故名：冒泡排序。
     * @param args
     */
    public static void main(String[] args) {
        int[] arr = {78,56,97,23,57,43,65,3,12,90};
        System.out.print("排序之前的：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }
        int temp;
        for (int i = 0; i < arr.length; 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;
                }
            }
        }
        System.out.println();
        System.out.print("排序之后的：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }
    }

8.快速排序

    /**
     *  快速排序
     *  快速排序：是对冒泡排序的一种改进，它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有的数据都比别一部分的所有的数据都要小，
     *            然后在按此方法对这两部分述句分别进行快速排序，整个排序过程是以递归进行，以此达到整个数据变成有序序列。
     * @param args
     */
    public static void main(String[] args) {
        int[] arr = {78,56,97,23,57,43,65,3,12,90};
        System.out.print("排序之前的：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }

        正在排序
        System.out.println();
        System.out.println("正在排序。。。");
        quickSort(arr,0,arr.length-1);

        System.out.println();
        System.out.print("排序之后的：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }

    }
    public static void quickSort(int[] arr, int low, int high) {
        int pivot,pos,t;
        if (low < high) {
            pos = low;
            pivot = arr[pos];
            for (int i = low+1; i <= high; i++) {
                if (arr[i]<pivot){
                    pos++;
                    t = arr[pos];
                    arr[pos] = arr[i];
                    arr[i] = t;
                }
            }
            t = arr[low];
            arr[low] = arr[pos];
            arr[pos] = t;

            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i]+"\t");
            }
            System.out.println();
            排序左半部分
            quickSort(arr,low,pos-1);
            排序右半部分
            quickSort(arr,pos+1,high);
        }
    }

9.选择排序

    /**
     *  选择排序
     *  选择排序：第一次从待排序的数据中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。
     *            以此类推，直到全部待排序的数据元素的个数为零。注：选择排序是不稳定的排序方法。
     * @param args
     */
    public static void main(String[] args) {
        int[] arr = {78,56,97,23,57,43,65,3,12,90};
        System.out.print("排序之前的：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }

        正在排序
        System.out.println();
        System.out.println("正在排序。。。");
        selectSort(arr);

        System.out.println();
        System.out.print("排序之后的：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }
    }

    public static void selectSort(int[] arr) {
        int temp;
        for (int j = 0; j < arr.length; j++) {
            int min = arr[j];
            int minIndex = j;
            for (int k = j; k < arr.length; k++) {
                if (min > arr[k]){
                    min = arr[k];
                    minIndex = k;
                }
            }
            temp = arr[j];
            arr[j] = arr[minIndex];
            arr[minIndex] = temp;

            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i]+"\t");
            }
            System.out.println();
        }
    }

10.插入排序

    /**
     *  插入排序
     *  插入排序：指的是再待排序的元素中，假设前面n-1（其中n>=2）个数已经排好顺序的，先将第n个数插到前面已经拍好的序列中，然后找到合适自己的位置，
     *            使得插入第n个数的这个序列也是排好顺序的。按照此方法所有元素进行插入，直到整个序列排为有序的过程，称为插入排序。
     * @param args
     */
    public static void main(String[] args) {
        int[] arr = {78,56,97,23,57,43,65,3,12,90};
        System.out.print("排序之前的：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }

        正在排序
        System.out.println();
        System.out.println("正在排序。。。");
        insertSort(arr);

        System.out.println();
        System.out.print("排序之后的：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }
    }
    private static void insertSort(int[] arr) {
        int i,j,t;
        for (i = 1; i < arr.length; i++) {
            if (arr[i] < arr[i-1]) {
                t = arr[i];
                for (j = i-1; j >= 0 && t < arr[j]; j--) {
                    arr[j+1] = arr[j];
                }
                arr[j+1] = t;

                for (int k = 0; k < arr.length; k++) {
                    System.out.print(arr[k]+"\t");
                }
                System.out.println();
            }
        }
    }

11.希尔排序

    /**
     * 希尔排序
     * 希尔排序：是插入排序的一种缩小增量排序，是插入排序的一种更高效的改进版本，希尔排序是非稳定排序算法。
     * 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
     * @param args
     */
    public static void main(String[] args) {
        int[] arr = {78,56,97,23,57,43,65,3,12,90};
        System.out.print("排序之前的：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }

        正在排序
        System.out.println();
        System.out.println("正在排序。。。");
        shellSort(arr);

        System.out.println();
        System.out.print("排序之后的：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }
    }
    private static void shellSort(int[] arr) {
        int j, temp;
        for (int incr = arr.length/2; incr > 0; incr/=2) {
            for (int i = incr; i < arr.length; i++) {
                temp = arr[i];
                for (j = i; j >= incr; j -= incr) {
                    if (temp < arr[j - incr]){
                        arr[j] = arr[j - incr];
                    }else{
                        break;
                    }
                }
                arr[j] = temp;
                for (int k = 0; k < arr.length; k++) {
                    System.out.print(arr[k]+"\t");
                }
                System.out.println();
            }
        }
    }

12.二分排序

    /**
     *  二分排序
     *  二分排序：是指利用二分法的思想对插入进行改进的一种插入排序算法，不同于二叉排序，可以利用数组的特点快速定位指定索引的元素。
     *  二分法插入排序是插入第 i 个元素时，对前面的 0到i-1 元素进行折半，先跟他们中间的那个元素比，如果小，则对前半再进行折半，否则对后半进行折半，
     *  直到 left > right ，然后再把第 i 个元素前1 位与目标位置之间的所有元素后移，再把第 i 个元素放在目标位置上。
     * @param args
     */
    public static void main(String[] args) {
        int[] arr = {78,56,97,23,57,43,65,3,12,90};
        System.out.print("排序之前的：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }

        正在排序
        System.out.println();
        System.out.println("正在排序。。。");
        binarySort(arr);

        System.out.println();
        System.out.print("排序之后的：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }
    }
    private static void binarySort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int temp = arr[i];  要插入的第i个元素
            int low = 0;
            int high = i - 1; 插入目标元素的前 i-1 个元素
            int mid = -1;
            while (low <= high) {
                mid = low + (high - low) / 2;
                if (arr[mid] > temp) {
                    high = mid - 1;
                } else {  元素相同时，也插入在后面的位置
                    low = mid + 1;
                }
            }
             目标位置 之后的元素 整体移动一位
            for(int j = i - 1; j >= low; j--) {
                arr[j + 1] = arr[j];
            }
            arr[low] = temp;

            for (int k = 0; k < arr.length ; k++) {
                System.out.print(arr[k]+" ");
            }
            System.out.println();
        }

    }

13.归并排序

    /**
     * 归并排序
     * 归并排序：是建立再归并操作的一种有效，稳定的排序算法，该算法是采用分治法的一个非常典型的应用。
     * @param args
     */
    public static void main(String[] args) {
        int[] arr = {78,56,97,23,57,43,65,3,12,90};
        System.out.print("排序之前的：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }

        正在排序
        System.out.println();
        System.out.println("正在排序。。。");
        mergeSort(arr, 0, arr.length-1);

        System.out.println();
        System.out.print("排序之后的：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }
    }
    private static void mergeSort(int[] arr, int start, int end) {
        if (start < end){
            int m = (start + end) / 2;
            mergeSort(arr, start, m);
            mergeSort(arr, m+1, end);

            merge(arr, start, m, end);

            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + "\t");
            }
            System.out.println();
        }
    }

    private static void merge(int[] arr, int start, int m, int end) {
        int length = end -start + 1;
        int temp[] = new int [length];

        int i = start;
        int j = m + 1;
        int k = 0;

        while (i <= m && j <= end){
            if (arr[i] < arr[j]){
                temp[k++] = arr[i++];
            }else{
                temp[k++] = arr[j++];
            }
        }

        while (i <= m){
            temp[k++] = arr[i++];
        }

        while (j <= end){
            temp[k++] = arr[j++];
        }

        k = 0;
        for (int t = start; t <= end; t++){
            arr[t] = temp[k++];
        }
    }

14.实现让 3 个线程按顺序执行

    /**
     *  实现让 3 个线程按顺序执行
     * @param args
     */
    public static void main(String[] args) throws Exception{
        Thread t1 = new Thread(() ->{
            try {
                Thread.sleep(2000);
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println("线程1执行完成。。。");
        });

        Thread t2 = new Thread(() ->{
            try {
                Thread.sleep(1000);
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println("线程2执行完成。。。");
        });

        Thread t3 = new Thread(() ->{
            System.out.println("线程3执行完成。。。");
        });

        t1.start();
        t1.join();
        t2.start();
        t2.join();
        t3.start();
    }

15.实现一个多线程死锁

    /**
     *  实现一个多线程死锁
     * @param args
     */
    private static Object lock1 = new Object();
    private static Object lock2 = new Object();
    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println("thread1 get lock1");
            synchronized (lock1){
                try{
                    Thread.sleep(1000);
                }catch (Exception e){
                    e.printStackTrace();
                }
                synchronized (lock2){
                    System.out.println("thread1 get lock2");
                }
                System.out.println("thread1 end");
            }
        }).start();

        new Thread(() -> {
            System.out.println("thread2 get lock2");
            synchronized (lock2){
                try{
                    Thread.sleep(1000);
                }catch (Exception e){
                    e.printStackTrace();
                }
                synchronized (lock1){
                    System.out.println("thread2 get lock1");
                }
                System.out.println("thread2 end");
            }
        }).start();
    }

16.实现删除 list 集合的元素

    /**
     *  实现删除 list 集合的元素
     * @param args
     */
    public static void main(String[] args) {
        List<String> list = new ArrayList();
        list.add("sdfs");
        list.add("adff");
        list.add("werwer");
        list.add("adeww");
        list.add("rgdfg");
        System.out.println(list);

        for (Iterator<String> ite = list.iterator(); ((Iterator) ite).hasNext();){
            String str = ite.next();
            if (str.contains("sdfs")){
                ite.remove();
            }
        }
        System.out.println(list);
    }