Java学习---程序设计_基础题[1]

 180813 补全没有的答案！

0、 数组排序大全[冒泡/选择/快速/插入]

package com.ftl;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

/**
 * 排序算法复习
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 * 【更多参考】 https://blog.csdn.net/snow_5288/article/details/60140265
 */

public class Test2018 {
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        List<Double> l = null;
        System.out.println("[eg.]请输入数据，如:1,12,32,2,3");
        String input = br.readLine();
        //方案一： 多数排序
        check(input);
        //方案二： 冒泡排序
        check2(input);
        //方案三： 快速选择排序
        check3(input);
        //方案四： 插入排序
        check4(input);
        //方案五： 快速排序
        check5(input);
    }
    
    //方案一： list排序：利用Collections工具类实现
    public static void check(String str){
        String[] s = str.split(",");
        int[]  ch = new int[s.length];
        List<Integer> list = new ArrayList<Integer>();
        for(int i = 0; i < s.length; i++){
            ch[i] = Integer.parseInt(s[i]);
            list.add(ch[i]);
        }
        Collections.sort(list);
        System.out.println("【方案一】list排序 ：" + list);
        
    }
    //方案二： 冒泡排序： 相邻2个数字比较，一次排序后最大/最小的数字排列最后
    /**
     *  比较相邻的元素。如果第一个比第二个大，就交换他们两个。
        对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
        针对所有的元素重复以上的步骤，除了最后一个。
        持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
        冒泡排序需要n-1（i）趟冒泡，每趟冒泡需要比较n-1-i(j)次比较，总共的比较次数为(n-1)+(n-2)+……+1,
        所以冒泡排序算法最坏情况和平均复杂度是O(n²)。
        由于占用空间有限，冒泡排序的空间复杂度为O(1)。
     */
    public static void check2(String str){
        String[] s = str.split(",");
        int[]  ch = new int[s.length];
        for(int i = 0; i < s.length; i++){
            ch[i] = Integer.parseInt(s[i]);
        }
        for(int i = 1; i < ch.length; i++){
            for(int j = 0; j < ch.length; j++){
                if(ch[i] < ch[j]){
                    int tmp = ch[i];
                    ch[i] = ch[j];
                    ch[j] = tmp;
                }
            }
        }
        System.out.println("【方案二】冒泡排序后：" + Arrays.toString(ch));
    }
    //方案三： 快速选择排序： 第一个数字依次跟后面的数字比较大小
    /**
     *  是直观的排序，通过确定一个Key最大或最小值，再从带排序的的数中找出最大或最小的交换到对应位置。再选择次之
     *  双重循环时间复杂度为O(n^2)
     */
    public static void check3(String str){
        String[] s = str.split(",");
        int[]  ch = new int[s.length];
        for(int i = 0; i < s.length; i++){
            ch[i] = Integer.parseInt(s[i]);
        }
        for(int i = 0; i < ch.length; i++){
            for(int j = i+1; j < ch.length ; j++){
                if(ch[i] > ch[j]){
                    int tmp = ch[i];
                    ch[i] = ch[j];
                    ch[j] = tmp;
                }
            }
        }
        System.out.println("【方案三】选择排序后：" + Arrays.toString(ch));
    }
    //方案四： 插入排序：往前比较，如果当前数比前一个小则进行第二个循环操作，反之则直接进入下次外层循环
    //比冒泡更优秀一点，冒泡是无论大小都会继续比较，这里是如果当前数字比前面的小，交换位置[降序则反之即可]
        public static void check4(String str){
            String[] s = str.split(",");
            int[]  ch = new int[s.length];
            for(int i = 0; i < s.length; i++){
                ch[i] = Integer.parseInt(s[i]);
            }
            for(int i = 1; i < ch.length; i++){
                int tmp = ch[i];
                // 升序： 如果前面的数字比当前的tmp大，则交换位置
                for(int j = i - 1; j >=0 && tmp < ch[j]; j--){
                    ch[j+1] = ch[j];
                    ch[j] = tmp;
                }
            }
            System.out.println("【方案四】插入排序后：" + Arrays.toString(ch));
        }
        //方案五：快速排序：选择一个基准，大于该值放在右侧，小于则放在左侧
        /**
         *  选择一个关键值作为基准值。比基准值小的都在左边序列（一般是无序的），比基准值大的都在右边（一般是无序的）。一般选择序列的第一个元素。
            一次循环：从后往前比较，用基准值和最后一个值比较，如果比基准值小的交换位置，如果没有继续比较下一个，直到找到第一个比基准值小的值才交换。找到这个值之后，又从前往后开始比较，如果有比基准值大的，交换位置，如果没有继续比较下一个，直到找到第一个比基准值大的值才交换。直到从前往后的比较索引>从后往前比较的索引，结束第一次循环，此时，对于基准值来说，左右两边就是有序的了。
            接着分别比较左右两边的序列，重复上述的循环。
            快速排序是一种快速的分而治之的算法，它是已知的最快的排序算法，其平均运行时间为O(N*1ogN) 。它的速度主要归功于一个非长紧凑的并且高度优化的内部循环。但是他也是一种不稳定的排序，当基准数选择的不合理的时候他的效率又会编程O(N*N)。
            快速排序的最好情况：  快速排序的最好情况是每次都划分后左右子序列的大小都相等，其运行的时间就为O(N*1ogN)。
            快速排序的最坏情况：  快速排序的最坏的情况就是当分组重复生成一个空序列的时候，这时候其运行时间就变为O(N*N)
            快速排序的时间复杂度为O(N*lgN),快速排序的空间复杂度为O(lgN).
         */
        public static void check5(String str){
            String[] s = str.split(",");
            int[]  ch = new int[s.length];
            for(int i = 0; i < s.length; i++){
                ch[i] = Integer.parseInt(s[i]);
            }
            if(ch.length  <=1) return ;
            int start = 0;
            int end = ch.length-1;
            check5sort(ch, start, end);
            System.out.println("【方案五】快速排序后：" + Arrays.toString(ch));
        }
        
        public static void check5sort(int[] a,int low,int high){
             int start = low;
             int end = high;
             int key = a[low];   // 设定基准为第一个数字
             
             
             while(end>start){
                 //从后往前比较
                 while(end>start&&a[end]>=key)  //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
                     end--;
                 if(a[end]<=key){
                     int temp = a[end];
                     a[end] = a[start];
                     a[start] = temp;
                 }
                 //从前往后比较
                 while(end>start&&a[start]<=key)//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
                    start++;
                 if(a[start]>=key){
                     int temp = a[start];
                     a[start] = a[end];
                     a[end] = temp;
                 }
             //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
             }
             //递归
             if(start>low) check5sort(a,low,start-1); //左边序列。第一个索引位置到关键值索引-1
             if(end<high) check5sort(a,end+1,high);   //右边序列。从关键值索引+1到最后一个
         }
}

[排序算法更多参考] https://blog.csdn.net/snow_5288/article/details/60140265

[排序算法更多参考] 值得收藏的十大经典排序算法

0、 实现会员注册，要求用户名长度不小于3，密码长度不小于6，注册时两次输入密码必须相同

package com.ftl;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


// 实现会员注册，要求用户名长度不小于3，密码长度不小于6，注册时两次输入密码必须相同

public class Test2018 {
    public static void main(String[] args) {
        Boolean flag = true ;
        while(flag){
            try {
                System.out.println("请输入姓名:");
                String name = new BufferedReader(new InputStreamReader(System.in)).readLine();
                if(name == null || "".equals(name)){
                    System.out.println("输入为空，请重新输入！");
                    continue;
                }
                if(name.length() < 3){
                    System.out.println("输入用户名长度不得小于3，请重新输入！");
                    continue;
                }
                System.out.println("请输入密码:");
                String passwd = new BufferedReader(new InputStreamReader(System.in)).readLine();
                if(passwd == null || "".equals(passwd)){
                    System.out.println("输入为空，请重新输入！");
                    continue;
                }
                if(passwd.length() < 6){
                    System.out.println("输入密码长度不得小于6，请重新输入！");
                    continue;
                }
                System.out.println("请再次输入密码:");
                String passwd2 = new BufferedReader(new InputStreamReader(System.in)).readLine();
                if(passwd2 == null || "".equals(passwd2)){
                    System.out.println("输入为空，请重新输入！");
                    continue;
                }
                if(passwd.length() == passwd2.length() && passwd.equals(passwd2)){
                    System.out.println("注册成功，欢迎您！");
                    flag = false;
                    break;
                }else{
                    System.out.println("2次输入的密码不一致，请重新注册！");
                    continue;
                }
                
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
    }
}

1、 一个景区根据游人的年龄收取不同价格的门票。请编写游人类，根据年龄段决定能够购买的门票价格并输出，然后写出测试类测试该类

package com.ftl;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

// 实现会员注册，要求用户名长度不小于3，密码长度不小于6，注册时两次输入密码必须相同

public class Test2018 {
    public static void main(String[] args) {
        Boolean flag = true;
        String name = null;
        String info = null;
        List<String> list = new ArrayList<>();
        int price = 120;
        int age = 0;

        while (flag) {
            try {
                System.out.println("请输入游客的姓名:");
                name = new BufferedReader(new InputStreamReader(System.in)).readLine();
                if (name == null || "".equals(name)) {
                    System.out.println("输入为空，请重新输入！");
                    continue;
                }
                System.out.println("请输入游客的年龄:");
                age = Integer.parseInt(new BufferedReader(new InputStreamReader(System.in)).readLine());
                if (age < 0 || age > 100) {
                    System.out.println("输入错误，请从新输入");
                    continue;
                }
            info = "游客信息: 姓名[" + name + "]" + ", age[" + age + "]";
            if(age < 18 ){
                int pri = price / 2;
                info = info + ",门票：" + pri;
            }else if(age < 60){
                int pri = price;
                info = info + ",门票：" + pri;
            }else{
                info = info + ",门票：" + "免费";
            }
            list.add(info);
            System.out.println("是否继续售票[Y/N] ?");
            String con = new BufferedReader(new InputStreamReader(System.in)).readLine();
            if(con.toUpperCase().equals("Y") || con.equals("Y")){
                flag = true;
            }else{
                flag = false;
                for (String string : list) {
                    System.out.println(string);
                    System.out.println("------------------------------");
                }
            }
            } catch (IOException e) {
                e.printStackTrace();
            }
            
        }
        
    }
}

2、 编写一个Java程序，用if-else语句判断某年份是否为闰年

// Programme Name LeapYear.java

public class LeapYear{

public static void main(String args[]){

int year=2010; 

if(args.length!=0)

  year=Integer.parseInt(args[0]);

if((year%4==0 && year%100!=0)||(year%400==0))

 System.out.println(year+" 年是闰年。");

else

 System.out.println(year+" 年不是闰年。");

   }

 }//if-else语句

3、编写一个Java程序在屏幕上输出1！+2！+3！+……+10！的和

public class ForTest { 

public static void main( String args[] ) {

  int  i,j,mul,sum=0;

for(i=1;i<=10;i++) {

mul=1;

for(j=1,j<=i;j++) {

mul=mul*j;

}

      sum=sum+mul;

}

System.out.println(“1！+2！+3！+……+10！= ”+sum);

}

}

5、编写一个Java应用程序，从键盘读取用户输入两个字符串，并重载3个函数分别实现这两个字符串的拼接、整数相加和浮点数相加。要进行异常处理，对输入的不符合要求的字符串提示给用户，不能使程序崩溃

import java.io.*;

public class Strinput

{

  public static void main(String args[]) {

   String s1,s2,ss,si,sf;

       int i1,i2;

       float f1,f2;

       BufferedReader strin=new  BufferedReader(new InputStreamReader(System.in));

       try{System.out.print ("输入第一个字符串：" );

s1= strin.readLine();

           System.out.print ("输入第二个字符串：" );

s2= strin.readLine();}

catch(Exception e){ System.out.println(e.getMessage());}

i1 = Integer.parseInt(s1);

       i2 = Integer.parseInt(s2);

       f1 = Float.parseFloat(s1);

       f2 = Float.parseFloat(s2);

       ss = strAdd(s1,s2);

       si = strAdd(i1,i2);

       sf = strAdd(f1,f2);

       System.out.println ("输入的二个字符串相加结果为："+ss );

       System.out.println ("输入字符串转换为整数相加结果为："+si );

       System.out.println ("输入字符串转换为浮点数相加结果为："+sf );

 }

   String strAdd(String str1,String str2) {

return str1+str2;

}

String strAdd(int int1,int int2) {

return  String.valueOf(int1+int2);

}

String strAdd(float flt1,float flt2) {

return  String.valueOf (flt1+flt2);

}

 }

6. 应用FileInputStream类，编写应用程序，从磁盘上读取一个Java程序，并将源程序代码显示在屏幕上。（被读取的文件路径为：E:/myjava/Hello.java）

import java.io.*;

  public class FISDemo {

  public static void main(String args[]) {

    byte[] buf=new byte[2056];

    try{

     FileInputStream fileIn=new FileInputStream("e:/myjava/Hello.java");

     int bytes=fileIn.read(buf,0,2056);

     String str=new String(buf,0,bytes);

     System.out.println(str);

}catch(Exception e){

 e.printStackTrace( );

}

}

7、编写一个Java程序将当100,101,102,103,104,105个数以数组的形式写入到Dest.txt文件中，并以相反的顺序读出显示在屏幕上

 import java.io.*;

  public class IODemo {

  public static void main( String args[] ) {

    int data[] = {100,101,102,103,104,105};

int t;

try

{ DataOutputStream out = new  DataOutputStream (new  FileOutputStream(“dest.txt”));

  for(int i=0;i<data.length;i++) 

    out.WriteInt(data[i]);

  out.close();

 DataInputStream in = new  DataInputStream (new  FileInputStream(“dest.txt”));

 for(int i= data.length-1;i>= 0;i--) {

    t=in.readInt(data[i]);

System.out.print(“ ”+t);

    }

  System.out.println( );

  in.close();

}catch(IOException e)

{ System.out.println(e.getMessage());}

  }

}

9、编写一个Java程序实现多线程，在线程中输出线程的名字，隔300毫秒输出一次，共输出20次。

 // 声明一个子线程类Threaddemo;

 class ThreadDemo extends Thread {

  public ThreadDemo(String str) {

super(str);

}

  public void run() {

    for(int i=0;i<20;i++){

System.out.print(“ ”+this.getName());

Try {

Sleep(300);

}catch(InterruptedException e){

System.out.println(e.getMessage());

Return;

}

}

System.out.println(“  /end”);

}

}

public class TestThread {

public static void main( String args[] ) {

   ThreadDemo thread1=new ThreadDemo(“T1”);

   ThreadDemo thread2=new ThreadDemo(“T2”);

   ThreadDemo thread3=new ThreadDemo(“T3”);

   thread1.start();

   thread2.start();

   thread3.start();

 }
}

10. 编写程序，在屏幕上显示带标题的窗口，并添加一个按钮。当用户单击按钮时，结束程序。

import javax.swing.*;

import java.awt.event.*;

public class ButtonEventDemo extends JPanel implements ActionListener{

protected JButton b1; //声明一个按钮对象

public ButtonEventDemo() { //构造方法

ImageIcon ButtonIcon = new ImageIcon("images/green.png");  //创建按钮的图标对象

  b1 = new JButton("退出按钮", ButtonIcon);   //生成按钮对象

b1.setMnemonic(KeyEvent.VK_E);   //设置b1的助记符是Alt+E

        b1.setToolTipText("这是退出按钮。"); // 设置按钮提示条

        this.add(b1);   //往面板对象中加载按钮

        b1.addActionListener(this);  //本类对象注册为按钮的事件监听器

     }

public void actionPerformed(ActionEvent e){ //按钮事件响应方法

System.exit(0);   //按b1则退出主程序        

}

    private static void createGUI() { //创建窗体

        JFrame.setDefaultLookAndFeelDecorated(true); //设置java隐含观感

        JFrame frame = new JFrame("按钮测试"); //生成应用程序主窗体

        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //设置关闭时隐含操作

 ButtonEventDemo CPane = new ButtonEventDemo();  //生成主类对象--面板

        CPane.setOpaque(true);    //面板要求不透明

        frame.setContentPane(CPane); //设置主类对象为主窗体的内容面板

        frame.pack(); //主窗体紧缩显示

        frame.setVisible(true);  //设置主窗体可见

    }

    public static void main(String[] args) {  //将createGUI（）列入线程

        javax.swing.SwingUtilities.invokeLater(new Runnable() {

            public void run() {

                createGUI(); 

            }

        });

    }

}

11、定义一个表示学生信息的类Student，要求如下：

（1）类Student的成员变量：

sNO　表示学号；sName表示姓名；sSex表示性别；sAge表示年龄；sJava：表示Java课程成绩。

（2）类Student带参数的构造方法：

在构造方法中通过形参完成对成员变量的赋值操作。

（3）类Student的方法成员：

getNo（）：获得学号；

getName（）：获得姓名；

getSex（）：获得性别；

getAge（）获得年龄；

getJava（）：获得Java 课程成绩

（4）根据类Student的定义，创建五个该类的对象，输出每个学生的信息，计算并输出这五个学生Java语言成绩的平均值，以及计算并输出他们Java语言成绩的最大值和最小值。

public class Student {

String sNO,sName,sSex;

int sAge,sJava;

public Student(String XH,String XM,String XB,int NL,int XF) {

super();

sNO=XH;

sName=XM;

sSex=XB;

sAge=NL;

sJava=XF;

}

public String getNO() {

return sNO;

}

public String getName() {

return sName;

}

public String getSex() {

return sSex;

}

public int getAge() {

return sAge;

}

public int getJava() {

return sJava;

}

public static void main(String[] args) {

Student[] st=new Student[5];

st[0]=new Student("09zc01","张三","男",19,94);

st[1]=new Student("09zc02","李四","男",20,85);

st[2]=new Student("09zc03","王五","女",18,96);

st[3]=new Student("09zc04","赵六","男",17,90);

st[4]=new Student("09zc05","杨七","女",21,88);

int max=0,min=100,sum=0;

    System.out.println("    学生信息：");

for (int i=0;i<st.length;i++) {

if (st[i].sJava < min)

min=st[i].sJava;

if (st[i].sJava > max)

max=st[i].sJava;

sum=sum+st[i].sJava;

System.out.println("学生编号："+st[i].getNO()+"， 姓名："+st[i].getName()+"， 性别："+st[i].getSex()+"， 年龄："+st[i].getAge()+"，  Java课学分："+st[i].getJava());

    }

    System.out.println();

    System.out.println("    共有学生："+st.length+"， 平均成绩："+sum/st.length);

    System.out.println("    最小学分："+min+"， 最大学分："+max);

}

}

 12. 100~200内的素数判断

package com.ftl;

import java.util.ArrayList;
import java.util.List;
/**
    判断101-200之间有多少个素数，并输出所有素数。
 *1.程序分析：判断素数的方法：用一个数分别去除2~sqrt(n)或者2~n/2,常用2~n/2，
 *因为一个数的一半的平方大于其本身是从5开始的，解方程：n/2的平方>n .如果能被整除【取余运算】， 
 *则表明此数不是素数，反之是素数。
 *
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 *
 */
public class Test2018 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>();
        for(int i = 100; i < 200; i++){
            if(isPrimeNumber(i)){
                list.add(i);
            }
        }
        System.out.println("100~200 共有" + list.size() + "个数字");
        System.out.println(list);
    }
    public static boolean isPrimeNumber(int num){
        boolean flag = true;
        if(num == 2) return flag;
        for(int i = 2; i <= num/2; i++){
            if(num % i == 0){
                flag = false;
                return flag;
            }
        }
        return flag;
    }
}

13. 水仙花问题

package com.ftl;

import java.util.ArrayList;
import java.util.List;
/**
  题目：打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如： 
    153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。 
    1.程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。
 *
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 *
 */
public class Test2018 {
    public static void main(String[] args) {
        // 方案一
        List<Integer> list = new ArrayList<Integer>();
        for(int i = 100; i < 999; i++){
            if(i == isPrimeNumber(i)){
                list.add(i);
            }
        }
        System.out.println("【方案一】100~999 共有" + list.size() + "个水仙花");
        System.out.println(list);
        System.out.println("-------------------------------------------");
        // 方案二：
        List<Integer> list2 = new ArrayList<Integer>();
        for(int i = 100; i < 999; i++){
            if(i == isPrimeNumber2(i)){
                list2.add(i);
            }
        }
        System.out.println("【方案二】100~999 共有" + list2.size() + "个水仙花");
        System.out.println(list2);
        System.out.println("-------------------------------------------");
        // 方案三：
                List<Integer> list3 = new ArrayList<Integer>();
                for(int i = 100; i < 999; i++){
                    if(i == isPrimeNumber2(i)){
                        list3.add(i);
                    }
                }
                System.out.println("【方案三】100~999 共有" + list3.size() + "个水仙花");
                System.out.println(list2);
    }
    // 方案一: 直接拆分数字
    public static int isPrimeNumber(int num){
        int sum = 0;
        int bai = num / 100;
        int shi  = num /10 % 10;
        int ge  = num % 10;
        sum = (int) (Math.pow(bai, 3) + Math.pow(shi, 3) + Math.pow(ge, 3));
        return sum;
    }
    // 方案二： 利用String来切割数字
    public static int isPrimeNumber2(int num){
        String sth = String.valueOf(num);
        int sum = 0;
        int bai = Integer.parseInt(String.valueOf(sth.charAt(0)));
        int shi  = Integer.parseInt(String.valueOf(sth.charAt(1)));
        int ge  = Integer.parseInt(String.valueOf(sth.charAt(2)));
        sum = (int) (Math.pow(bai, 3) + Math.pow(shi, 3) + Math.pow(ge, 3));
        //System.out.println("百" + bai + "十" + shi + "个" + ge);
        return sum;
    }
    // 方案三： 数字计算的优化
        public static int isPrimeNumber3(int num){
            String sth = String.valueOf(num);
            int sum = 0;
            for(int i = 0; i < sth.length(); i++){
                sum += Math.pow(Integer.parseInt(String.valueOf(sth.charAt(i))), 3);
            }
            //System.out.println("百" + bai + "十" + shi + "个" + ge);
            return sum;
        }
}

14.分解质因数

package com.ftl;

import java.util.ArrayList;
import java.util.List;
/**
题目：将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。 
程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成： 
(1)运用两层循环。 
(2)外循环得到2~n之间的所有质数，内循环将n循环除以质数，知道不能整除。 
(3)要是内循环n等于1了就说明n被完全整除了。
 *
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 *
 */
public class Test2018 {
    public static void main(String[] args) {
        check(180);
    }
    
 public static boolean isPrimeNumber(int n){
        if(n == 2) return true;
        for(int i=2; i<=n/2; i++){
            if(n % i == 0) return false;
        }
        return true;
    }    
    public static void check(int num){
        StringBuffer sb = new StringBuffer();
        sb.append(num+"=");
        // 这里一定是小于等于，耗时30mins+
        for(int i = 2; i <= num; i++){
//            System.out.print("质数：" + i+"	");
            if(isPrimeNumber(i)){
                while(num%i==0){
                    sb.append(i);
                    num = num / i;
                    if(num == 1) break;
                    sb.append("*");
                }
            }else{
                continue;
            }
        }
        System.out.println("
" + sb);
    }
}

 15. 求s=a+aa+aaa+aaaa+aa...a的值,其中a是一个数字

package com.ftl;

import java.util.Scanner;
/**
 * 求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加有键盘控制。 
 * 2  = 2 * 10^0
 * 22 = 2 * 10^1 + 2
 * 222= 2 * 10^2 + 22
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 *
 */

public class Test2018 {
    public static void main(String[] args) {
        int n = 0;      // 中间
        int num = 0;      // 键盘输入的数字
        int sum = 0;      // 求和
        int fac = 0;      // 中间值
        int roate = 0;    // 循环次数
        boolean flag = true; 
        while(flag){
            Scanner scan = new Scanner(System.in);
            System.out.println("请输入一个数组[0-9]:");
            num = scan.nextInt();
            if(num < 0 || num > 9){
                System.out.println("输入错误，请重新输入");
                continue;
            }
            System.out.println("请输入循环次数[10以内]:");
            roate = scan.nextInt();
            if(roate >= 10 || roate <=0 ){
                System.out.println("输入错误，请重新输入");
                continue;
            }
            flag = false;
        }
        StringBuffer sb = new StringBuffer();
            for(int j = 0; j < roate; j++){
                n = (int)Math.pow(10, j) * num;
                fac += n; 
                sb.append(fac).append("+");
                sum += fac;
            }
        System.out.println(sum + "=" + sb.substring(0, sb.length()-1));
    }
}

16. 求完数，数字=因子之和

package com.ftl;

import java.util.Scanner;
/**
    题目：一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3.编程 找出1000以内的所有完数。
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 *
 */

public class Test2018 {
    public static void main(String[] args) {
        for(int i=1; i<1000; i++){
            if(isWanShu(i)){
                System.out.print(i + ",");
            }
        }
    }

    private static boolean isWanShu(int a) {
        int cup = 0;
        for(int i=1; i<a; i++){
            if(a%i == 0)
                cup = cup + i;
        }
        return (cup == a);
    }
}

 17. 弹球高度计算

package com.ftl;

import java.util.Scanner;
/**
    一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？
    1 100  
    2 50
    3 25
    4 12.5
    5 6.25
    6 3.125
     
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 *
 */

public class Test2018 {
    public static void main(String[] args) {
        // 方案一： 直接计算
        int sum = 0;
        double height= 100;
        for(int i = 2; i < 11 ; i++){
            // 因为第一次是100米，第二次50米，
            sum += height;
            height = height/2;
        }
        System.out.println("第十次：" + height);
        System.out.println("总路程：" + sum);
        
        // 方案二： 递归解决
        System.out.println(height(100, 10));

    }
    
        public static double height(double h, int n){
            if(n==2)  return h/2;
            else return height(h/2,n-1);
        }
}

18. 排列组合[互不相同且无重复数字的三位数]

package com.ftl;

import java.util.List;
import java.util.Vector;
/**
    题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？ 
     
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 *
 */

public class Test2018 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4};
        int tmp = 0;
        List<Integer> list = new Vector<>();
        for(int i = 0; i < 4; i++){
            for(int j = 0; j < 4; j++){
                if(arr[i] != arr[j]){
                    for(int k = 0; k < 4; k++){
                        if(arr[i] != arr[k] && arr[j] != arr[k]){
                            tmp = 100 * arr[i] + 10 * arr[j] + arr[k];
                            list.add(tmp);
                        }
                    }
                }
            }
        }
        System.out.println("共有：" + list.size());
        for(int i = 0; i < list.size(); i++){
            if(i % 7 != 0){
                System.out.print(list.get(i) + "	");
            }else{
                System.out.println();
            }
        }
    }
}

19. 完全平方数

package com.ftl;

/**
    一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？ 
    1. 任何数对1取余数都是0
     
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 *
 */

public class Test2018 {
    public static void main(String[] args) {
        
        for(int i = 0; i < 1000; i++){
             if(Math.sqrt(i + 100) % 1 == 0 && Math.sqrt(i + 268) % 1 == 0){
                System.out.println(i);
            }
        }
    }
}

20. 输出9*9口诀

package com.ftl;

/**
 * 输出9*9口诀
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 */

public class Test2018 {
    
    public static void main(String[] args)  {
        for(int i = 1; i <=9; i++){
            for(int j = 1; j <=i; j++){
                System.out.print(i + "*" + j + "=" + (i * j)+"	");
            }
            System.out.println();
        }
    }
}

21. 猴子偷桃

package com.ftl;

/**
 *猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个 第二天早上又将剩下的桃子吃掉一半，又多吃了一个。
 *以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。 
 1.程序分析：采取逆向思维的方法，从后往前推断(递归)
     day1: 1
     day2: (1+1)*2 = 4
     day3: (4+1)*2 = 10
     day4: (10+1)*2 = 22
     day5: (22+1)*2 = 46
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 */

public class Test2018 {
    
    public static void main(String[] args)  {
        // 方案一： 循环解决
        int n = 1;
        int sum = 1;
        for(int i = 2; i <= 5; i++){
            n = ( n + 1 ) * 2;
        }
        System.out.println("方案一：" + n);
        //方案二： 递归
        System.out.println("方案二：" + getNum(5));
    }
    
    public static int getNum(int d){
        int sum = 0;
        if(d==1) return 1;
        // 这里实际上就是题目说的，前一天的量吃完一半后还余一个的算法
        else return (getNum(d-1) + 1) * 2;
                
    }
    
    
}

22. 乒乓球比赛名单

package com.ftl;

/**
    两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。
    已抽签决定比赛名单。有人向队员打听比赛的名单。a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 */

public class Test2018 {
    
    public static void main(String[] args)  {
        char[] a = {'a', 'b', 'c'};
        char[] b = {'x', 'y', 'z'};
        // 方案一：
        for(int i = 0; i < 3; i++){
            for(int j = 0; j < 3; j++){
                if(a[i] == 'a' && b[j] != 'x'){
                    System.out.println(a[i] + "--->" + b[j]);
                }else if(a[i] == 'c' && b[j] != 'x' && b[j] != 'z'){
                    System.out.println(a[i] + "--->" + b[j]);
                }else if(a[i] == 'b' ){
                    System.out.println(a[i] + "--->" + b[j]);
                }
            }
        }
        System.out.println("==============");
        // 方案二：
        for(int i = 0; i < 3; i++){
            for(int j = 0; j < 3; j++){
                if(a[i] == 'a' && b[j] == 'x'){
                    continue;
                }else if(a[i] == 'c' &&( b[j] == 'x' || b[j] == 'z')){
                    continue;
                }else{
                    System.out.println(a[i] + "--->" + b[j]);
                }
            }
        }
        
        System.out.println("==============");
        // 方案三：
        for(int i=0; i<3; i++){
            for(int j=0; j<3; j++){
                if(i == 0 && j == 0)//a说他不和x比
                    continue;
                else if(i == 2 && (j == 0 || j == 2))
                    continue;//c说他不和x,z比
                else{
                    System.out.println(a[i] + "<-->" + a[j]);
                }
            }
        }
    }
}

23. 打印菱形

package com.ftl;

/**
    打印出如下图案（菱形） 
         * 
        *** 
       ***** 
      ******* 
       ***** 
        *** 
         * 
         程序分析：先把图形分成两部分来看待，前四行一个规律，后三行一个规律，利用双重 for循环，第一层控制行，第二层控制列。
         n=4
                0    1    2    3    4    5    6         
       0       空        空    空      *   空      空    空         
       1       空        空    *   *   *   空    空                
       2       空         *    *   *   *   *    空                                    
       3   *    *    *   *   *   *   *                
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 */

public class Test2018 {
    
    public static void print(int n){
        int i = 0;
        int j = 0;
        for(i=0; i<n; i++){//前四行
            for(j=0; j<n+i;j++){
                if(j < n-i-1)
                    System.out.print(" ");
                else
                    System.out.print("*");
            }
            System.out.println();
        }
        
        for(i=1; i<n; i++){//后三行
            for(j=0; j<(2*n-i-1); j++){
                if(j < i)
                    System.out.print(" ");
                else
                    System.out.print("*");
            }
            System.out.println();
        }
    }
    
    public static void main(String[] args) {
        print(4);
    }
}

 23. 分数计算

package com.ftl;

/**有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。
    1.程序分析：请抓住分子与分母的变化规律。
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 */

public class Test2018 {
    
    public static void main(String[] args) {
        double fenmu = 2;
        double fenzi = 1;
        double num = 0;
        double sum = 0;
        for(int i = 0; i < 20; i++){
            num = fenmu / fenzi;
            double tmp = fenmu;
            fenmu = fenzi + tmp;
            fenzi = tmp;
//            System.out.println(fenmu + "	" + fenzi + "	" + num);
            sum += num;
        }
        System.out.println(sum);
    }
}

24. 阶乘计算

package com.ftl;

import org.omg.Messaging.SyncScopeHelper;

/**
    题目：求1+2!+3!+...+20!的和
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 */

public class Test2018 {
    
    public static void main(String[] args) {
        // 方案一：循环
        long sum = 0;
        for(int i = 1; i <=20; i++){
            long fac = 1;
            for(int j = 1; j <=i; j++){
                fac *= j;
            }
            sum += fac;
        }
        System.out.println(sum);
        
        // 方案二： 阶乘
        long ans = 0;
        for(int i=1; i<=20; i++){
            ans = ans + jieCheng(i);
        }
        System.out.println(ans);
    
    }
    
    public static long jieCheng(int num){
        if(num == 1) return 1;
        else return jieCheng(num-1) * num;
        
    }
}

25. 年龄递归计算

package com.ftl;

/**
        有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。
        问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 */

public class Test2018 {
    
    public static void main(String[] args) {
        int num = 5;
        System.out.println(jieCheng(num));
    }
    
    public static int jieCheng(int num){
        if(num == 1) return 10;
        else return jieCheng(num-1) + 2;
    }
}

26. 分解数字和数字反转

package com.ftl;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

/**
        有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。
        问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 */

public class Test2018 {
    
    public static void main(String[] args) {
        String str = "1234567";
        // 方案一： 直接反转计算
        System.out.println("反转前：" + str);
        List<String> list = new ArrayList<String>();
        for(int i = 0; i < str.length(); i++){
            list.add(String.valueOf(str.charAt(i)));
        }
        Collections.reverse(list);
        System.out.println("【方案一】反转后：" + list + "，共有" + list.size() + "个数字");
        
        // 方案二： 分解数字
        Iterator<Integer> iter = explodeNumber(Integer.parseInt(str)).iterator();
        
        while(iter.hasNext()){
            System.out.print(iter.next());
        }
    }
    
    public static  List<Integer> explodeNumber(int n){
        List<Integer> li = new ArrayList<Integer>();
        int count = 0;
        while(n != 0){
            li.add((int)n%10);
            count++;
            n = n / 10;
        }
        System.out.print("【方案二】：");
        System.out.println("共有" + count + "个数字");
        return li;
    }
}

27. 数列： 1,1,2,3,5,8,13,21...

package com.ftl;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
 *  数列： 1,1,2,3,5,8,13,21...
 *    ==> 0,1,1,2,3,5,8,13,21...
 *
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 *
 */
public class Test2018 {
    public static void main(String[] args) {
        int first = 0;
        int second = 1;
        int sum = 0;
        int month = 0;
        try {
            BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入月份：");
            month = Integer.parseInt(buf.readLine());
        } catch (NumberFormatException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        for(int i = 1; i < month; i++){
            sum = first + second;
            first = second;
            second = sum;
        }
        System.out.println("5个月后：" + sum);
    }
}

 28. 输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。

package com.ftl;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

/**
       输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 */

public class Test2018 {
    public static void sort(int[] a){//类似冒泡排序
        int cup = 0;
        int l = a.length-1;
        for(int i=1; i<a.length-1; i++){
            if(a[i] > a[0]){
                cup = a[i];
                a[i] = a[0];
                a[0] = cup;
            }
            if(a[i] < a[l]){
                cup = a[i];
                a[i] = a[l];
                a[l] = cup;
            }
        }
    }
    
    public static void printArray(int[] a){
        for(int i=0; i<a.length; i++){
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        int[] a = new int[]{2,3,5,1,2,34,1,0,24};
        printArray(a);
        sort(a);
        printArray(a);
    }
}

【更多学习参考】

链接：https://pan.baidu.com/s/1Xm4Qt6eWD5cE2t_ZpKk-ow    密码：z6qh