练习项目

一些小的练习

斐波那契数列：

package com.rongyu.day01;

/**
 * 斐波那契数列
 */
public class Work03 {
    public static void main(String[] args) {
        int a = 1;
        int b = 1;
        for (int i = 0; i < 10; i++) {
            int c = a;
            if (i>=2){
                c = a + b;
                a = b;
                b = c;
            }
            System.out.println(c);
        }
    }
}

总结：
利用了交换的思想，在求出和之后进行交换处理，利用了程序执行的顺序思想，对于什么时候倒值的顺序很重要。

循环打出等腰三角形：

package com.rongyu.day01;

/**
 * 等腰三角形
 */
public class Work05 {
    public static void main(String[] args) {
        for (int i = 1; i < 8; i++) {
            for (int k = 7*i-8*(i-1); k >1 ; k--) {
                System.out.print(" ");
            }
            for (int j = 0; j < 2*i-1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

总结：
还是要一步一步寻找规律，由于打出来的是一个平面图形，肯定最多需要2层循环，内层循环用来打出列，外层循环用来打出行，计算出行和星星个数的关系为2*i+1打出星星，这里的关键是打出空格的个数，这里的算法还有待提高。

求出数字最大数：

package com.rongyu.day02;
/**
 * 求出最大数
 */

import java.util.Scanner;
public class Dame01 {
    public static void main(String[] args) {
        System.out.println("请输入两个数字：");
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        int b = scanner.nextInt();
        int max = b;
        if (a>b){
            max = a;
        }
        System.out.println("两个数字的最大值是："+max);
    }
}

总结：
这里用的思想就是，先把一个值当成最大值，当还有比他大的值的时候进行替换，否则不改变。

十进制转二进制：

package com.rongyu.day02;
import java.util.Scanner;
/**
 * 求一个数的二进制数字
 */

public class Dome02 {
    public static void main(String[] args) {
        System.out.print("请输入一个不超过16的数字：");
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        if (num>16){
            System.out.println("你输入的数字超过16！！！");
            return;
        }
        String s = "";
        int a;
        while (num!=0){
            a = num % 2;
            num /= 2;
            s += a;
        }
        if (s.length()==3){
            s+="0";
        }
        System.out.print("你输入的数字的二进制数是：");
        char[] chars = s.toCharArray();
        for (int i = chars.length-1;i >= 0;i--) {
            System.out.print(chars[i]);
        }
    }
}

总结：
这里的核心思想就是要透彻理解十进制转换为二进制的具体的算法步骤，第一步求出余数，然后算出除数，当除数为0的时候停止计算，把所有的余数拼接成字符串，把字符串转换为字符数组，并且按照倒叙进行显示。这里需要注意的是循环的判断条件，实在除数不等于0的时候，还有就是一定要先算余数，因为余数不会改变条件的值并且可以继续进行计算。还有就是数组长度-1为数组的最大下标，数组的最小下标为0。

计算100以内所有偶数的和：

package com.rongyu.day02;

/**
 * 计算100以内所有的偶数的和
 */
public class Dome03 {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i < 101; i++) {
            if (i % 2 != 0){
                continue;
            }
            sum += i;
        }
        System.out.println("100以内所有的偶数的和为："+sum);
    }
}

总结：
这里用到了continue 他只是终止本次循环并不是跳出循环和break有很大区别。

循环练习之打出图形：

package com.rongyu.day02;

public class Dome05 {
    public static void main(String[] args) {
       // juxing(4);
        //pingxing(4);
        dengyao(4);
    }

    //打印矩形
    public static void juxing(int a){
        for (int i = 1; i <= a; i++){
            for (int j = 1; j <= a; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }

    //打印平行四边形
    public static void pingxing(int a){
        for (int i = 1; i <=a  ; i++) {
            for (int j = a; j >i ; j--) {
                System.out.print(" ");
            }
            for (int j = 1; j <=a ; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }

    //打印等腰三角形
    public static void dengyao(int a){
        for (int i = 1; i <= a ; i++) {
            for (int k = a; k >i ; k--) {
                System.out.print(" ");
            }
            for (int j = 1; j <= 2*i-1 ; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

总结：
当循环嵌套式，要理解内层循环循环一遍外层循环循环一次，然后找出各个图形之间的规律，就能打出自己想要的图形。

判断一个数是不是质数：

package com.rongyu.day02;

import java.util.Scanner;

/**
 * 判断一个数是不是质数
 */
public class Dome06 {
    public static void main(String[] args) {
        System.out.print("请输入一个数字：");
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        int count = -1;
        for (int i = 2; i < 10; i++) {
            if (num % i ==0 && i != num){
                count++;
            }
        }
        if (count!=-1){
            System.out.println("改数字不是质数!!!");
        }else {
            System.out.println("该数字是质数");
        }
    }
}

总结：
这里要理解，质数也称素数，指的的一个数字只能被1和他本身除尽，所以判断条件语句中写出就可以了。

求出100以内所有质数：

package com.rongyu.day02;

/**
 * 求出100以内所有的质数
 */
public class Dome07 {
    public static void main(String[] args) {
        int count = -1;
        System.out.println("100以内所有的素数为：");
        for (int i = 2; i <101 ; i++) {
            for (int j = 2; j < 9 ; j++) {
                if (i % j == 0 && i != j){
                   count++;
                }
            }
            if (count==-1){
                System.out.print(i+",");
            }
            count = -1;
        }
    }
}

总结：
也是用循环嵌套的思想，外层循环用来打出100以内所有的数字，内层循环用来循环进行除，设置一个外部变量进行存储能除过的数字的个数，但是这里要注意得是每次内层循环循环完之后进行内层循环的时候一定要回复外不变量的值。

打印99乘法表：

package com.rongyu.day02;

/**
 * 打印99乘法表
 */
public class Dome08 {
    public static void main(String[] args) {
        for (int i = 1; i < 10; i++) {
            for (int j = 1; j <= i ; j++) {
                System.out.print(i+"*"+j+"="+j*i+"  ");
            }
            System.out.println();
        }
    }
}

总结：
还是利用嵌套循环，就是要注意内层循环的循环条件一定要是小于等于外部循环循环的数字，然后进行字符串得拼接就可以了。

递归求阶乘求和：

package com.rongyu.day04;

/**
 * 方法的重载
 * //1.方法名相同
 * 2.参数个数或者类型不相同
 */
public class Dome02 {
    public static void main(String[] args) {
        System.out.println(digui(100));
        System.out.println(jiecheng(3));
    }
    //使用递归实现累加
    public static int digui(int a){
        if (a==1){
            return 1;
        }else {
            return a + digui(a-1);
        }
    }

    //使用递归求阶乘
    public  static int jiecheng(int a){
        if (a==1){
            return 1;
        }else {
            return a*jiecheng(a-1);
        }
    }
}

总结：
递归总有递归头和递归体组成，写之前一定要想好递归头和递归体。

声明数组的3种方式：

package com.rongyu.day05;

import java.util.Arrays;

public class Dome01 {
    public static void main(String[] args) {
        //声明数组的三种形式
        //方式一：
        int[] arr1 = new int[3];
        //方式二：
        int[] arr2 = new int[]{1,2,3,4,5};
        //方式三：
        int[] arr3 = {1,2,3,4,5};
        System.out.println(arr1.length);
        for (int i : arr2) {
            System.out.print(i+",");
        }
        System.out.println();
        for (int i = 0; i < 5; i++) {
            System.out.print(arr3[i]+",");
        }
        System.out.println();
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = i;
        }
        System.out.println(Arrays.toString(arr1));

    }
}

数组中获得最大值：

package com.rongyu.day05;

/**
 * 数组中获取最大元素
 */
public class Dome02 {
    public static void main(String[] args) {
        int[] arr = {12,23,1,2,5,3,1,1};
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]>max){
              max = arr[i];
            }
        }
        System.out.println(max);
    }
}

总结：
跟之前的思想是一样的都是先给第个值当成最大的值然后进行替换。

实现数组的反转：

package com.rongyu.day05;

import java.util.Arrays;

/**
 * 实现数组反转
 */
public class Dome03 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        for (int min = 0,max = arr.length-1; min<=max; min++,max--){
            int temp = arr[min];
            arr[min] = arr[max];
            arr[max] = temp;
        }
        System.out.println(Arrays.toString(arr));
    }
}

总结：
这里要注意的是判断条件的不同把对称的2各元素进行交换，注意判断条件是大于等于。

冒泡排序法：

package com.rongyu.day05;

import java.util.Arrays;

/**
 * 冒泡排序法
 */
public class Dome04 {
    public static void main(String[] args) {
        int[] arr = {8,7,6,4,5};
        for (int i = 0; i < arr.length-1; i++) {
            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;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

选择排序法：

package com.rongyu.day05;

import java.util.Arrays;

/**
 * 选择排序法
 */
public class Dome05 {
    public static void main(String[] args) {
        int[] arr = {8,7,6,4,5};
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i+1; j < arr.length ; j++) {
                if (arr[i]>arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

二维数组：

package com.rongyu.day05;

/**
 * 二位数组
 */
public class Dome07 {
    public static void main(String[] args) {
        int[][] arr1 = new int[3][2];
        int[][] arr = {{1,2,3,4},{1,2,3},{2,3,4}};

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

总结：
二维数组其实就是数组里面套了个数组，所以二维数组的长度是含有数组的个数，每个元素的长度才是数组的长度。

二维数组小项目，求班级成绩：

package com.rongyu.day05;

import java.util.Scanner;

/**
 * 练习二维数组
 */
public class Dome08 {
    public static void main(String[] args) {
        int[][] arr = new int[3][5];
        int[] score = new int[3];
        Scanner scanner = new Scanner(System.in);
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            System.out.println("***********第"+(i+1)+"个班***************");
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print("请输入第"+(j+1)+"个学生的成绩：");
                arr[i][j] = scanner.nextInt();
                sum+=arr[i][j];
            }
            score[i] = sum;
            sum = 0;
        }
        System.out.println("**********成绩统计**********");
        for (int i = 0; i < score.length; i++) {
            System.out.println((i+1)+"班总成绩："+score[i]);
        }
    }
}

总结：
还是理解二维数组的概念是数组里面套数组，这就能理解数组相当于班级，数组里面的元素就相当于学生。