1. 输出1-100以内的质数

代码:

    //输出1-100之间的质数
    class Test12 {
        public static void main(String[] args) {
            //因为1既不是质数也不是合数,所以直接从2开始
            for (int i = 2; i < 100; i++) {
                //假定i是质数,进入循环判断
                boolean b = true;
                for (int j = 2; j < i; j++) {
                    //如果i能被某个j整除,说明不是质数
                    if (i % j == 0) {
                        b = false;
                        break;
                    }
                }
                //标记没被修改为false的就是质数
                if (b) {
                    System.out.println(i + "是质数");
                }
            }
        }
    }

结果:

(单纯截结果太长了报看,截出来我的宝儿姐给各位看看)

2. 用递归求1-100的和

代码:

public class Recursion {
     static int sum(int n) {
         if (n == 1) {
             return 1;
         }
         return sum(n - 1) + n;
     }
     public static void main(String[] args) {
         System.out.println("sum:" + sum(100));
     }
 }

结果:

3.有条件最小值(索引法)

代码:

//练习：创建一个数组，产生8个50以内的随机整数保存其中，找能被13整除的数的最小值的索引
class Test9 {

    public static void main(String[] args) {

        int[] arr = new int[8];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 50);
        }
        for (int c : arr) {
            System.out.print(c + " ");
        }
        System.out.println();

        int minIndex = -1; //minIndex初始值用-1标记
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] % 13 == 0) { //判断遍历的数能否被13整除
                if (minIndex == -1) { //第一个能被13整除的数的下标刷给minIndex
                    minIndex = i;
                } else {
                    if (arr[i] < arr[minIndex]) {   //其余的数进行比较找到最小值，如果有更小的数，再次把下标刷新
                        minIndex = i;
                    }
                }
            }
        }
        if (minIndex != -1) {       //如果minIndex为-1，说明没有符合条件的数，此处进行保护
            System.out.println("minIndex = " + minIndex);
        } else {
            System.out.println("没有能被13整除的数");
        }
    }
}

结果:

4.数组反转

代码:

class Test10 {

    public static void main(String[] args) {
        
        int[] arr = new int[8];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 20);
        }
        //遍历打印原数组的值
        for (int c : arr) {
            System.out.print(c + " ");
        }
        System.out.println();
        //对原数组进行反转处理
        for (int i = 0; i < arr.length / 2; i++) {
            //交换i位置下标和length-1-i下标位置的值
            int tmp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = tmp;
        }
        //遍历打印反转后数组的值
        for (int c : arr) {
            System.out.print(c + " ");
        }
    }
}

结果:

5.冒泡排序(必会)

代码:

//练习：冒泡排序
class Test11 {

    public static void main(String[] args) {

        int[] arr = new int[8];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 20);
        }
        //遍历打印原数组的值
        for (int c : arr) {
            System.out.print(c + " ");
        }
        System.out.println();
        //冒泡排序
        int tmp;
        for (int i = 0; i < arr.length - 1; i++) { //交换arr.length-1次即可
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                }
            }
        }
        //遍历打印冒泡排序后数组的值
        for (int c : arr) {
            System.out.print(c + " ");
        }
        System.out.println();
    }
}

结果:

6,7,8,9前置代码

  		Student[] stuArr = new Student[10];
        //创建一个拥有10个元素的Student引用数组,保存10个学生对象
        //学号1-10,姓名:小明,年级随机1-6,分数随机0-100

        //随机姓名
        String[] name1 = {"赵", "钱", "孙", "李", "周", "吴", "郑", "王", "张"};
        String[] name2 = {"二虎", "铁蛋", "铁柱", "建国", "二妞", "翠花", "狗蛋", "富贵", "刚子"};

        for (int i = 0; i < stuArr.length; i++) {
            int id = i + 1;
            int index1 = (int) (Math.random() * 10000 % name1.length);
            int index2 = (int) (Math.random() * 10000 % name2.length);
            String name = name1[index1] + name2[index2];
            int grade = (int) (Math.random() * 6 + 1);
            double score = (int) (Math.random() * 101);
            stuArr[i] = new Student(id, name, grade, score);
        }
        //遍历
        for (Student student : stuArr) {
            System.out.println(student.say());
        }
        System.out.println("--------------------------------");

6.有条件最值(引用数组标记值)

代码:

//找三年级最高分,最牛人(标记值改为null,比较通用的写法)
        //找三年级最牛的人
        Student maxStudent = null; //引用类型的标记用null
        for (Student student : stuArr) {
            if (student.getGrade() == 3) {
                if (maxStudent == null) {
                    maxStudent = student;
                } else {
                    if (student.getScore() > maxStudent.getScore()) {
                        maxStudent = student;
                    }
                }
            }
        }
        if (maxStudent != null) {
            System.out.println("三年级最高分 : " + maxStudent.getScore());
            System.out.println("三年级最牛人的信息 : " + maxStudent.say());
        } else {
            System.out.println("没有三年级的同学");
        }

结果:

7.取子数组(必会)

代码:

   		 //取出所有4年级同学的信息
        Student[] newArr = new Student[stuArr.length];
        int count = 0;
        for (Student student : stuArr) {
            if (student.getGrade() == 4) {
                newArr[count++] = student;
            }
        }
        // 缩减数组
        Student[] resultArr = new Student[count];
        for (int i = 0; i < count; i++) {
            resultArr[i] = newArr[i];
        }
        //遍历新数组,打印结果
        for (Student student : resultArr) {
            System.out.println(student.say());
        }

结果:

只有两个四年级的

8.删除数组元素

代码:

 //有效元素个数
        int size = 10;
        //要删除的下标
        int index = 5;
        //从index处开始,右边的值向左边复制,直到最后一个结束
        for (int i = index; i < size - 1; i++) {
            stuArr[i] = stuArr[i + 1];
        }
        //因为多了一个重复值,将最后一个元素置空
        stuArr[--size] = null;
        //遍历
        for (Student student : stuArr) {
            if (student != null) {
                System.out.println(student.say());
            } else {
                System.out.println(student);
            }
        }

结果:

可以看到6号学生信息没了

9.改进版选择排序(必会)

代码:

  //让固定的位置保存单次循环中最小值
        //改进版选择排序
        for (int i = 0; i < stuArr.length - 1; i++) {
        //以i位置,为基准位置,让它取保存最小值(包括基准位置在内到右面的所有数中的最小值)
            int minIndex = i;//假定基准位置就是i最小值
            //从基准位置右侧到后面所有数中找更小值的
            for (int j = i + 1; j < stuArr.length; j++) { 
                if (stuArr[j].getScore() < stuArr[minIndex].getScore()) {
                    minIndex = j;//记录更小的值的位置j
                }
            } 
            if (minIndex != i) { //如果基准位置就是最小值，就不交换
         	   Student tmp = stuArr[i];
         	   stuArr[i] = stuArr[minIndex];
         	   stuArr[minIndex] = tmp;
        	}
        }
        //遍历
        System.out.println("选择排序-->成绩排名 : " + "\n");
        for (Student student : stuArr) {
            System.out.println(student.say());
        }

结果:

10.快速排序(想会)

代码:

public class ArrayTest {
     //快速排序递归部分
     public static void quick(int[] arr, int begin, int end) {
         if (begin >= end - 1) {
             return;
         }
         int key = arr[begin];
         int keyIndex = begin;
         for (int i = begin + 1; i < end; i++) {
             if (arr[i] < key) {
                 keyIndex++;
                 int tmp = arr[keyIndex];
                 arr[keyIndex] = arr[i];
                 arr[i] = tmp;
             }
         }
         arr[begin] = arr[keyIndex];
         arr[keyIndex] = key;
         quick(arr, begin, keyIndex);
         quick(arr, keyIndex + 1, end);
     }
 
     //快速排序
     public static void main(String[] args) {
         int[] arr = new int[8];
         //随机数的数组
         for (int i = 0; i < arr.length; i++) {
             arr[i] = (int) (Math.random() * 20);
         }
         //遍历
         for (int i : arr) {
             System.out.print(i + " ");
         }
         System.out.println();
         //递归
         quick(arr, 0, arr.length);
         //遍历
         for (int i : arr) {
             System.out.print(i + " ");
         }
     }
 }

结果:

11.杨辉三角(了解)

代码:

 public class YangHui {
        public static void main(String...args) {
            //声明一个10行的二维数组
            int[][] arr = new int[10][];
            //外循环,给每行的数组声明长度
            for (int i = 0; i < arr.length; i++) {
                //i行i个元素
                arr[i] = new int[i + 1];
                //内循环,给每行的数组刷值
                for (int j = 0; j < arr[i].length; j++) {
                    //第一列和最后一列都是1
                    if (j == 0 || j == arr[i].length - 1) {
                        arr[i][j] = 1;
                    } else { //第三行开始,杨辉三角算法
                        if (i > 1) {
                            arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
                        }
                    }
                }
            }
            //遍历
            for (int[] ints : arr) {
                for (int anInt : ints) {
                    System.out.print(anInt + " ");
                }
                System.out.println();
            }
        }
    }

结果:

Q.E.D.