java基础编程一

1. 斐波那契算法

   斐波那契数列，又被称为兔子繁殖问题的解法，黄金分割比例。

/*
 * 斐波那契数列算法，n表示第n个月份，假定n是大于0的*/
    public int fibonacci(int n){
        if(n == 1||n == 2){
            return 1;
        }else{
            return fibonacci(n-2)+fibonacci(n-1);
        }
    }

2. 判断一个数是否为质数

/*
    * 判断一个数是否是质数,若返回值为-1则说明输入值既不是质数也不是偶数；
    * 若返回值为1则说明输入值为质数；
    * 若返回值为0则说明输入值为合数*/
    public int prime(int n){
        int flag = 1;
        if(n == 1){
            return -1;
        }else{
            for (int i = 2; i <=n ; i++) {
                if(n%i==0&&i!=n){
                    flag = 0;
                    break;
                }
            }
        }
        return flag;
    }

3. 输出100-1000之间的所有水仙花数

/*
    * 水仙花数是指一个 n 位正整数 ( n≥3 )，
    * 它的每个位上的数字的 n 次幂之和等于它本身。*/
    public void daffodil(){
        for (int i = 100; i <1000 ; i++) {
            int a = i/100;
            int b = i/10%10;
            int c = i%10;
            if(i==(a*a*a+b*b*b+c*c*c)){
                System.out.println(i);
            }
        }
    }

4. 输出一个数的所有质因数

public void pnum(int n){
        int temp = 2;//将最小的质数赋值给temp
        System.out.print("数字"+n+"=");
        if (n <= 2) {
            System.out.println("该数为无效数字！");
        }else{
            while(temp<=n){
                if((n%temp)==0){
                    System.out.print(temp+"*");
                    n=n/temp;
                }else{
                    temp++;
                }
            }
        }
    }

 5. 数组题

    有两个数组，以数组s1的顺序为准，输出数组s1和数组s2共有的元素。　

public static String[] inArray(String[] array1, String[] array2) {
        String[] newString = new String[10];
        int m = 0;
        for (int i = 0;i<array1.length;i++) {
            for(int j = 0;j<array2.length;j++){
                if(array2[j].contains(array1[i])){
                    newString[m] = array1[i];
                    m++;
                    break;
                }
            }
        }
        return newString;
    }

 6. 求两个数的最大公约数

    常见的求法有短除法，分解质因数法，辗转相除法和更相减损术。而在这几个里面中适合我们编写程序的有辗转相除法和更相减损术。

   a. 辗转相除法，又叫欧几里德算法，是解决求最大公约数最常用的方法。 

public static void gcd(int m,int n){
        int r = m%n;
        if(r == 0){
            System.out.println("两数的的最大公约数是："+n);
        }else{
            m = n;
            n = r;
            gcd(m,n);
        }
    }

   b. 更相减损术，是九章算术中给我们提供的一种算法，其实现原理是：可半者半之，不可半者，副置分母、子之数，以少减多，更相减损，求其等也。以等数约之。解释来说就是：如果两个数都是偶数，就折半分之（ 用2来约分），两个数都不是偶数的话，以大数减小数，直至减数与差相等为止。  

public static void gcd2(int m,int n){
        while(m!=n){
            if(m>n){
                m = m-n;
            }else{
                n = n-m;
            }
        }
        System.out.println("最大公约数是："+m);
    }

 7. 求两个数的最小公倍数

public static void lcm(int m,int n){
        int i = 2;
        if(m<n){    //判断m，n的大小是为了
                    // 减少while循环的次数，去掉判断也能出结果
            m = m^n;
            n = m^n;
            m = m^n;
        }
        int temp = m;
        while(temp%n!=0){
            temp = m*i;
            i++;
        }
        System.out.println("两个数的最小公倍数为："+temp);
    }

 8. 判断一个字符串包含多少个数字，包含多少个字母，包含多少个空格，除此之外还剩多少字符。

public static void count(){
        int numCount = 0;
        int letterCount = 0;
        int spaceCount = 0;
        int other = 0;
        Scanner console = new Scanner(System.in);
        String str = console.nextLine();
        for(int i = 0;i<str.length();i++){
            char t = str.charAt(i);
            if(Character.isDigit(t)){
                numCount++;
            }else if(Character.isLetter(t)){
                letterCount++;
            }else if(Character.isSpaceChar(t)){
                spaceCount++;
            }else{
                other++;
            }
        }
        System.out.println("该字符串中包含数字"+numCount+
                "个，包含字母(包含大小写字母)"+
                letterCount+"个，包含空格"+
                spaceCount+"个，其他字符"+other+"个。");
    }

说明：从控制台获取输入的字符串时，要注意使用nextLine()方法，不要使用next()方法，否则会出现当字符串中包含空格时，它获取到的字符串与输入的不一致。(原因：next()方法匹配的原则是以空格为一个标记)。