Java学习---程序设计_面试题[2]

百度2017春招笔试真题编程题集合之买帽子

//    2017-10-09
//     题目描述
//    度度熊想去商场买一顶帽子，商场里有N顶帽子，有些帽子的价格可能相同。度度熊想买一顶价格第三便宜的帽子，问第三便宜的帽子价格是多少？
//    输入描述:
//    首先输入一个正整数N（N <= 50），接下来输入N个数表示每顶帽子的价格（价格均是正整数，且小于等于1000）
//    输出描述:
//    如果存在第三便宜的帽子，请输出这个价格是多少，否则输出-1
//    输入例子:
//    10
//    10 10 10 10 20 20 30 30 40 40
//    输出例子:
//    30

-------------------------------------------------
package com.huawei.test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

/**
 输入描述:
    首先输入一个正整数N（N <= 50），接下来输入N个数表示每顶帽子的价格（价格均是正整数，且小于等于1000）
输出描述:
    如果存在第三便宜的帽子，请输出这个价格是多少，否则输出-1
输入例子:
    10
    10 10 10 10 20 20 30 30 40 40
输出例子:
    30
*/
public class Test {
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        while(scan.hasNext()){
            //输入一个正整数
            int n = scan.nextInt();
            //开辟空间
            int[] prices = new int[n];
            //读取价格
            for(int i = 0; i < prices.length; i++){
                prices[i] = scan.nextInt();
            }
            //价格排序
            Arrays.sort(prices);
            ArrayList<Integer> list = new ArrayList<>();
            //去重复
            for(int i = 0;i < n; i++){
                if(!list.contains(prices[i])){
                    list.add(prices[i]);
                }
            }
            if(list.size()<3){
                System.out.println(-1);
            }else{
                System.out.println(list.get(2));
            }
            
        }
    }
}

寻找三角形

/**
 * 题目描述
 * 
 * 三维空间中有N个点，每个点可能是三种颜色的其中之一，三种颜色分别是红绿蓝，分别用'R', 'G', 'B'表示。
 * 现在要找出三个点，并组成一个三角形，使得这个三角形的面积最大。 
 * 但是三角形必须满足：三个点的颜色要么全部相同，要么全部不同。
 * 输入描述: 首先输入一个正整数N三维坐标系内的点的个数.(N <= 50) 接下来N行 
 * 每一行输入 c x y z，c为'R', 'G', 'B'的其中一个。
 * x，y，z是该点的坐标。(坐标均是0到999之间的整数)
 * 输出描述: 输出一个数表示最大的三角形面积，保留5位小数。 
 * 输入例子:
 *         5 
 *         R 0    0 0
 *         R 0 4 0 
 *         R 0 0 3 
 *        G 92 14 7
 *        G 12 16 8 
 * 输出例子: 6.00000
 */
package com.ftl.test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // 输入一个正整数Ｎ
        System.out.println("Please input the Num:");
        int n = sc.nextInt();
        // N行 N 个数组
        String[] nums = new String[n];
        // 初始化
        double temp = 0.0;
        double area = Double.MAX_VALUE;
        // 输入N行，用数组保存
        for (int i = 0; i < n; i++) {
            nums[i] = sc.nextLine();
        }
        // 获取颜色
        char[] colors = new char[n];
        for (int i = 0; i < n; i++) {
            colors[i] = nums[i].split(" ")[0].charAt(0);
        }
        // 获取X轴
        int[] x = new int[n];
        for (int i = 0; i < n; i++) {
            x[i] = Integer.parseInt(nums[i].split(" ")[1]);
        }
        // 获取Y轴
        int[] y = new int[n];
        for (int i = 0; i < n; i++) {
            x[i] = Integer.parseInt(nums[i].split(" ")[2]);
        }
        // 获取Z轴
        int[] z = new int[n];
        for (int i = 0; i < n; i++) {
            x[i] = Integer.parseInt(nums[i].split(" ")[3]);
        }
        // 进行判断 三个点的颜色要么全部相同，要么全部不同
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                for (int k = j + 1; k < n; k++) {
                    if (colors[i] == colors[j] && colors[j] == colors[k]
                            || colors[i] != colors[j] && colors[j] != colors[k]
                            && colors[k] != colors[i]) {
                        if (colors[i] == colors[j] && colors[j] == colors[k]
                                || colors[i] != colors[j]
                                && colors[j] != colors[k]
                                && colors[i] != colors[k]) {
                            double a = Math
                                    .pow(Math.pow(Math.abs(x[i] - x[j]), 2)
                                            + Math.pow(Math.abs(y[i] - y[j]), 2)
                                            + Math.pow(Math.abs(z[i] - z[j]), 2),
                                            0.5);
                            double b = Math
                                    .pow(Math.pow(Math.abs(x[i] - x[k]), 2)
                                            + Math.pow(Math.abs(y[i] - y[k]), 2)
                                            + Math.pow(Math.abs(z[i] - z[k]), 2),
                                            0.5);
                            double c = Math
                                    .pow(Math.pow(Math.abs(x[k] - x[j]), 2)
                                            + Math.pow(Math.abs(y[k] - y[j]), 2)
                                            + Math.pow(Math.abs(z[k] - z[j]), 2),
                                            0.5);

                            double p = (a + b + c) / 2;
                            // 海伦公式求空间三角形面积
                            temp = Math.pow(p * (p - a) * (p - b) * (p - c),
                                    0.5);
                            if (area < temp) {
                                area = temp;
                            }
                        }
                    }
                }
            }
        }
        System.out.printf("%.2f",area);
    }
}

输出不同的元素的个数

package com.ftl;
/** 
 *  输入字符串长度len1，字符串s1，字符串长度len2，字符串s2。
 *  从后向前比较，以最短字符串为标准，输出不同的元素的个数。 
 *  例如:  输入：s1="1,3,5"   len1=3        s2="2,4,1,7,5"   len2=5   
           输出：2   
       函数原型 public int getDiffNum(int len1, String s1, int len2, String s2) 
 * 
 * @author ftl 
 */ 

public class HWText {
    public static void main(String[] args){
         String s1="1,3,5";  
         int len1=3;  
         String s2="2,4,2,7,6";  
         int len2=5;  
         int diffNum= getDiffNum(s1,len1,s2,len2);  
         System.out.println("不同的数目："+diffNum); 
    }
    
    public static int getDiffNum(String s1,int len1, String s2, int len2){
        int num = 0;
        //字符串转换为字符数组
        String[] str1 = s1.split(",");
        String[] str2 = s2.split(",");
        //以最端的字符串为标准(换言之，就是确定循环的次数)
        int len = len1<len2?len1:len2;
        for (int i = 0; i < len; i++) {
            //判断是否相等
            if(!str1[len1-1-i].equals(str2[len2-1-i])){
                num++;
            }
        }
        return num;
    }
}

混合运算

package com.ftl;

import java.util.ArrayList;
import java.util.List;

/** 
 输入一个表达式，没有括号，数字小于0-9之间，输出计算结果，所有的中间结果化为整形。
            例如:  输入：3+8×2/9-2  
            输出：2 
 * @author ftl 
 */ 

public class HWText {
    public static void main(String[] args){
        String s="3+8×2/9-2 ";  
        int result=getMyRet(s);  
        System.out.println("最后结果："+result); 
    }
    
    public static int getMyRet(String s){
        int len = s.length();
        List<String> list = new ArrayList<>();
        //字符串变成集合
        for(int i = 0; i < len; i++){
            list.add(s.charAt(i)+"");
        }
        System.out.println("list--->"+ list);//list--->[3, +, 8, ×, 2, /, 9, -, 2,  
        for(int i = 0; i<list.size(); i++){
            if(list.get(i).equals("x")){
                //计算乘法
                int ji = Integer.parseInt(list.get(i-1))*Integer.parseInt(list.get(i+1));
                //将积放在集合中，整个位置都后移一位，8现在是i的位置
                list.add(i-1,ji+"");
                //删除原来的位置
                list.remove(i);  //删除8
                list.remove(i);  //删除*
                list.remove(i);  //删除2
                System.out.println("list--x后->"+ list);//list--x后->[3, +, 16, /, 9, -, 2,  ]
                //回到积的位置，再次参与运算
                i--;  
            }else if(list.get(i).equals("/")){
                int shang = Integer.parseInt(list.get(i-1))/Integer.parseInt(list.get(i+1));
                list.add(i-1,shang+"");
                list.remove(i); //删除16
                list.remove(i); //删除/
                list.remove(i); //删除9
                System.out.println("list--/后->"+ list);//list--/后->[3, +, 1, -, 2,  ] 
                i--;              //回到商的位置
            }
        }
        //新的list，只有+-,注意用新的变量k，否则会编译报错            
         for(int k=0;k<list.size();k++){//这个时候是新的size  
             if(list.get(k).equals("+")){  
                 int he=Integer.parseInt(list.get(k-1))+Integer.parseInt(list.get(k+1));  
                 list.add(k-1,he+"");   
                 list.remove(k);   
                 list.remove(k);   
                 list.remove(k);   
                 System.out.println("list--+后->"+ list); //list--+后->[4, -, 2,  ]  
                k--;   
             }  
             if(list.get(k).equals("-")){  
                 int cha=Integer.parseInt(list.get(k-1))-Integer.parseInt(list.get(k+1));  
                 list.add(k-1,cha+"");   
                 list.remove(k);   
                 list.remove(k);   
                 list.remove(k);   
                 System.out.println("list--  -后->"+ list); //list--  -后->[2,  ]  
                k--;  
             }  
        }
        return Integer.parseInt(list.get(0));
    }
}

二叉树算法描述

二叉树的遍历是指按照某条搜索路径访问树中的每个节点，使得每个节点的均只被访问一次。由二叉树的递归定义，遍历一棵二叉树便要决定对根节点、左子树和右子树的访问顺序。
常见的遍历次序有先序遍历、中序遍历和后序遍历。其中序指的是根节点在何时被访问。
先序遍历(PreOrder)：若二叉树非空，则先访问根节点，再访问左子树，最后访问右子树。
中序遍历(InOrder)：若二叉树非空，则先访问左子树，再访问根节点，最后访问右子树。
后序遍历(PostOder)：若二叉树非空，则先访问左子树，再访问右子树，最后访问根节点。

 统计字符串中某个字符出现的次数

package com.ftl;

public class HelloFtl {
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        System.out.println("----------------------------------------");
        String str = "want you know one thing";
        int count = 0;
        int count1 = 0;
        char[] c = str.toCharArray();
        for ( int i = 0; i < c.length; i++)
        {
            if (c[i] == 'o')
            {
                count++;
            }
            if (c[i] == 'n')
            {
                count1++;
            }
        }
        System.out.println("O出现的次数为：" + count);
        System.out.println("n出现的次数为：" + count1);
        System.out.println("----------------------------------------");
        int c1 = 0;
        while ( str.indexOf("n") != -1) //indexOf存在则返回所处位置，否则返回-1 
        {
            
            c1++;
            //改变字符串数量
            str = str.substring(str.indexOf("n") + 1);
            System.out.println("Str "
                    + "为：" + str);
            
        }
        System.out.println("n出现的次数为：" + c1);
    }

}

输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数

package com.ftl;

import java.util.HashMap;
import java.util.Map;
/**
 *题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。 
 *1.程序分析：利用循环,使用Map存储数据.其实完全可以使用4个变量来解决,这边舍近求远复习下Map啦
 *
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 *
 */
public class Test2018 {
    public static void main(String[] args) {
        String str = "abcd 1234 ef *";
        check(str);
        check2(str);
        check3(str);
    }
    // 方案一： 设定变量，根据数组ch[i]实现
    private static void check(String str) {
        int shuzi = 0;
        int zifu = 0;
        int kongge = 0;
        int qita = 0;
        char[] ch = str.toCharArray();
        for(int i = 0; i < ch.length; i++){
            if(String.valueOf(ch[i]).matches("\d+")){
                shuzi++;
            }else if(String.valueOf(ch[i]).matches("\w+")){
                zifu++;
            }else if(String.valueOf(ch[i]).matches("\s+")){
                kongge++;
            }else{
                qita++;
            }
        }
        System.out.println("【方案一】" + "数字：" + shuzi + "、字符：" + zifu + "、空格：" + kongge + "、其他：" + qita);
    }
    // 方案二： 设定变量，根据charAt(i)实现
    private static void check2(String str) {
        int shuzi = 0;
        int zifu = 0;
        int kongge = 0;
        int qita = 0;
        for(int i = 0; i < str.length(); i++){
            if(String.valueOf(str.charAt(i)).matches("\d+")){
                shuzi++;
            }else if(String.valueOf(str.charAt(i)).matches("\w+")){
                zifu++;
            }else if(String.valueOf(str.charAt(i)).matches("\s+")){
                kongge++;
            }else{
                qita++;
            }
        }
        System.out.println("【方案二】" +"数字：" + shuzi + "、字符：" + zifu + "、空格：" + kongge + "、其他：" + qita);
    }
    // 方案三： 设定变量，根据map实现
    private static void check3(String str) {
        Map<String,Integer> map = new HashMap<>();
        map.put("数字",0);
        map.put("字符",0);
        map.put("空格",0);
        map.put("其他",0);
        for(int i = 0; i < str.length(); i++){
            if(String.valueOf(str.charAt(i)).matches("\d+")){
                map.put("数字", map.get("数字")+1);
            }else if(String.valueOf(str.charAt(i)).matches("\w+")){
                map.put("字符", map.get("字符")+1);
            }else if(String.valueOf(str.charAt(i)).matches("\s+")){
                map.put("空格", map.get("空格")+1);
            }else{
                map.put("其他", map.get("其他")+1);
            }
        }
        System.out.println("【方案三】" +map);
    }
}

简单的登录验证系统

package com.ftl;

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

class Check
{
    private int age = 11;

    // 内部类
     public boolean validate(String name, String password)
    {
         if (name.equals("ftl") && 
                 password.equals("1012"))
         {
             return true;
         }
         else 
         {
             return false;
         }
             
    }
}

class Operate
{   
    private String info[];
    
    public Operate(String info[])
    {
        this.info = info;
    }
    public String login()
    {
        Check check = new Check();
        String name = this.info[0];
        String password = this.info[1];
        String str = null; 
        if (check.validate(name, password))
        {
            str = "Welcome " + name.toUpperCase() +" comingg   "; 
        }
        else
        {
            str = "No Welcome " + name.toUpperCase() +" comingg   ";
        }
     return str;   
    }
}

public class HelloFtl
{
    public static void main(String args[])
    {
        String[] arg = new String[2];
        BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Input the name and password[换行表示结束]: ") ;
        for(int i = 0; i < arg.length; i++ ){
             try
            {
                arg[i] = buf.readLine() ;
            } catch (IOException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        boolean flag = new Check().validate(arg[0], arg[1]);
        System.out.println("-------------------------------------------");
        if(flag){
            Operate oper = new Operate(arg);
            System.out.println(oper.login());
            System.out.println("黄沙百战穿金甲，不破楼兰终不还");
        }
       
    }   
}

 加减乘除计算

package com.ftl;

import java.util.ArrayList;
import java.util.List;

/** 
 输入一个表达式，没有括号，数字小于0-9之间，输出计算结果，所有的中间结果化为整形。
            例如:  输入：3+8×2/9-2  
            输出：2 
 * @author ftl 
 */ 

public class HWText {
    public static void main(String[] args){
        String s="3+8×2/9-2 ";  
        int result=getMyRet(s);  
        System.out.println("最后结果："+result); 
    }
    
    public static int getMyRet(String s){
        int len = s.length();
        List<String> list = new ArrayList<>();
        //字符串变成集合
        for(int i = 0; i < len; i++){
            list.add(s.charAt(i)+"");
        }
        System.out.println("list--->"+ list);//list--->[3, +, 8, ×, 2, /, 9, -, 2,  
        for(int i = 0; i<list.size(); i++){
            if(list.get(i).equals("x")){
                //计算乘法
                int ji = Integer.parseInt(list.get(i-1))*Integer.parseInt(list.get(i+1));
                //将积放在集合中，整个位置都后移一位，8现在是i的位置
                list.add(i-1,ji+"");
                //删除原来的位置
                list.remove(i);  //删除8
                list.remove(i);  //删除*
                list.remove(i);  //删除2
                System.out.println("list--x后->"+ list);//list--x后->[3, +, 16, /, 9, -, 2,  ]
                //回到积的位置，再次参与运算
                i--;  
            }else if(list.get(i).equals("/")){
                int shang = Integer.parseInt(list.get(i-1))/Integer.parseInt(list.get(i+1));
                list.add(i-1,shang+"");
                list.remove(i); //删除16
                list.remove(i); //删除/
                list.remove(i); //删除9
                System.out.println("list--/后->"+ list);//list--/后->[3, +, 1, -, 2,  ] 
                i--;              //回到商的位置
            }
        }
        //新的list，只有+-
         for(int k=0;k<list.size();k++){//这个时候是新的size  
             if(list.get(k).equals("+")){  
                 int he=Integer.parseInt(list.get(k-1))+Integer.parseInt(list.get(k+1));  
                 list.add(k-1,he+"");   
                 list.remove(k);   
                 list.remove(k);   
                 list.remove(k);   
                 System.out.println("list--+后->"+ list); //list--+后->[4, -, 2,  ]  
                k--;   
             }  
             if(list.get(k).equals("-")){  
                 int cha=Integer.parseInt(list.get(k-1))-Integer.parseInt(list.get(k+1));  
                 list.add(k-1,cha+"");   
                 list.remove(k);   
                 list.remove(k);   
                 list.remove(k);   
                 System.out.println("list--  -后->"+ list); //list--  -后->[2,  ]  
                k--;  
             }  
        }
        return Integer.parseInt(list.get(0));
    }
}

 生成随记不重复ID

import java.util.Random;
 
/**
 * 各种id生成策略
 * <p>Title: IDUtils</p>
 * <p>Description: </p>
 * @version 1.0
 */
public class IDUtils {
 
    /**
     * 图片名生成
     */
    public static String genImageName() {
        //取当前时间的长整形值包含毫秒
        long millis = System.currentTimeMillis();
        //long millis = System.nanoTime();
        //加上三位随机数
        Random random = new Random();
        int end3 = random.nextInt(999);
        //如果不足三位前面补0
        String str = millis + String.format("%03d", end3);
         
        return str;
    }
     
    /**
     * 商品id生成
     */
    public static long genItemId() {
        //取当前时间的长整形值包含毫秒
        long millis = System.currentTimeMillis();
        //long millis = System.nanoTime();
        //加上两位随机数
        Random random = new Random();
        int end2 = random.nextInt(99);
        //如果不足两位前面补0
        String str = millis + String.format("%02d", end2);
        long id = new Long(str);
        return id;
    }
     
    public static void main(String[] args) {
        for(int i=0;i< 100;i++)
        System.out.println(genItemId());
    }
}

 就餐问题抽查情况

/** 
问题描述：  某公司由于人多，午餐分为多批次就餐，严格要求每批次就餐时间。并定期抽查就餐情况。请编写程序实现就餐抽查情况。
 • 要求实现函数：  void check_lunch(int num, int time,int input[], int output[]) 
【输入】  int num，就餐总人数           int time，就餐分批数           char input[]，就餐情况 
【输出】  char output[]， 违规就餐情况 
【返回】  无 注：对就餐分3批的情况，12人就餐，正确的就餐情况应如下分布[1,2,3,1,2,3,1,2,3,1,2,3]，不符合该分布的即是违规，输出时对相应位置0。
 • 示例  
1） 输入：num = 12，time = 3，input =[1,2,3,3,1,3,1,1,1,1,2,3] 输出：output = [1,2,3,0,0,3,1,0,0,1,2,3] 
2） 输入：num = 11，time = 4，input =[1,2,3,4,2,3,3,4,1,2,3] 输出：output = [1,2,3,4,0,0,3,4,1,2,3]
• 算法思路：
    比较简单，对数组中的元素进行取余运算判断与输入的关系
•算法代码：
 * @author ftl 
 */ 

public class FTL2018 {
    public static void main(String[] args){
        int[] num = {1,2,3,3,1,3,1,1,1,1,2,3};
        int[] output = sort(num, num.length);
    }
    public static int[] sort(int[] num, int len){
        int count = 0;
        int output[] = new int[len];
        System.out.println("输入数据：" + Arrays.toString(num));
        for (int i = 1; i <= len; i++) {
            // 位置上的数字准确
            if(i % 3 == num[i-1]){
                output[i-1] = num[i-1];
            }else if(i % 3 == 0 && num[i-1] == 3) {
                output[i-1] = num[i-1];
            }else{
                output[i-1] = 0;
            }
            if(output[i-1] == 0){
                count++;
            }
        }
        System.out.println("输出数据：" + Arrays.toString(output));
        System.out.println("共有" + count + "个人违规");
        
        return output;
        
        
    }
}

输入联想【正则匹配】

package com.ftl;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/** 
 问题描述：  输入联想功能是非常实用的一个功能，请编程实现类似功能。 
• 要求实现函数：  void auto_complete(char *str, char *tmp,char *output) 
【输入】  char *str，候选字符串           char *tmp，输入字符串 
【输出】  int *output，联想匹配的字符串 
【返回】  无 注：候选字符串以空格隔开，输入字符串仅从字符串开始处匹配。将匹配的子字符串输出，同样以空格隔开。如无匹配成功的子字符串，则输出空字符串。
 • 示例  
1） 输入：str = chengdu chongqing，tmp = c 输出：output = chengdu Chongqing  
2） 输入：str = chengdu chongqing，tmp = che 输出：end = Chengdu  
3） 输入：str = beijing nanjing，tmp = jing 输出：end =   
 •算法思路：字符串匹配，充分利用容器string的优势，给出两种代码：一种利用string，一种利用字符串数组。

•算法代码：
 * @author ftl 
 */ 

public class FTL2018 {
    public static void main(String[] args){
        String str = "chengdu,chongqing,changan";
        String tmp = "che";
        auto_complete(str, tmp);
        auto_complete1(str, tmp);
    }
    //方案一： 利用正则进行查找
    public static void auto_complete(String str, String tmp){
        List<String> list = new ArrayList<>();
        String[] s = str.split(",");
        for(int i = 0; i < s.length; i++){
            String regex = tmp + "[a-zA-Z]";
            Matcher p = Pattern.compile(regex).matcher(s[i]);
            if(p.find()){
                list.add(s[i]);
            }
        }
        System.out.println("匹配成功["+ list.size() +"]
" + list);
    }
    //方案二： 利用String类的startWith()方法
    public static void auto_complete1(String str, String tmp){
        List<String> list = new ArrayList<>();
        String[] s = str.split(",");
        for(int i = 0; i < s.length; i++){
            if(s[i].startsWith(tmp)){
                list.add(s[i]);
            }
        }
        System.out.println("匹配成功["+ list.size() +"]
" + list);
    }
}

 正则学习

package com.ftl;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test2018 {
    public static void main(String[] args) {
        //需要进行爬虫的字符串
        String s = "shshska13966668888hdjd13966668888iaj";
        //写正则
        String regex = "s\w";
        //把正则表达式编译成一个正则对象
        Pattern p = Pattern.compile(regex);
        //获取匹配器
        Matcher m = p.matcher(s);
        while(m.find()){
            System.out.println(m.group());
        }
    }
}

 有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中

package com.ftl;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Vector;

/**
 * 题目：有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 */

public class Test2018 {
    
    public static void main(String[] args) {
        int[] ch = new int[]{1,2,3,5,6,7,9,12,16};  //已经排好序的数组
        int num = 15;
        // 方案一： 排序判断,有小问题，针对此案例，问题不大
        addNumber(ch, num );
        
        // 方案二： 利用Collections工具类
        List<Integer> list = new Vector<>();
        for(int i = 0; i < ch.length; i++){
            list.add(ch[i]);
        }
        list.add(num);
        Collections.sort(list);
        System.out.println("【方案二】:" + list);
        
        // 方案三： 利用System类
        String str = "1,2,3,5,6,7,9,12,16";
        String[] arr = str.split(",");
        String[] abc = new String[arr.length + 1];
        int flag = 0;
        for(int i = 0; i < arr.length; i++){
            if(Integer.valueOf(arr[i]) > num){
                flag = i;  
                break;
            }
        }
        System.arraycopy(arr, 0, abc, 0, flag);
        abc[flag] = String.valueOf(num);
        System.arraycopy(arr, flag, abc, flag+1, 1);
        System.out.println("【方案三】:" + Arrays.toString(abc));
    }
    
    public static int[] addNumber(int[] ch, int num){

        int[] arr = new int[ch.length + 1];
        int tmp = 0;
        for(int i = 0; i < ch.length; i++){
            // 如果小，则不动
            if(ch[i] < num){
                arr[i] = ch[i];
            }else{
                arr[i] = num;
                tmp = i;
                break;
            }
        }
        for(int i = tmp ; i < ch.length; i++){
            arr[i+1] = ch[i];
        }
        System.out.println("【方案一】:" + Arrays.toString(arr));
        return arr;
    }
}

 有200个小朋友拉成一个圆圈，从其中某一个小朋友开始依次编号1－200，从1号小朋友开始循环1－3报数，数到3的小朋友就退出。编写一个Java应用程序，计算出最后一个小朋友的号码是多少。

package com.ftl;

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

/**
 * 有200个小朋友拉成一个圆圈，从其中一个小朋友开始依次编号1－200，
 * 从1号小朋友开始循环1－3报数，数到3的小朋友就退出。
 * 编写一个Java应用程序，计算出最后一个小朋友的号码是多少。
 * 
 * 1 2 3 1 2 3 1 2 3 
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 */

public class Test2018 {
    
    public static void main(String[] args) {
        System.out.println("输入有多少个小朋友:");
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        
        List<Integer> l = new ArrayList<Integer>();
        for(int i=1; i<=n; i++){
            l.add(i);
        }
        System.out.println(play(l, 0, 3));
    }

    /**
     * @param l 剩下小朋友List
     * @param n 第n个开始报数
     * @param m 数到m的人退出
     * @return 最后一个小朋友的号码
     */
    public static int play(List<Integer> list, int n, int m){
        int num = list.size();
        // 仅剩余一个学生, 返回最后一个学生的信息
        if(num <= 1 ){
            return list.get(0);
        }else{
            n = n + m - 1;
            while(n >= num)
                n = n - num;
            list.remove(n);
            return play(list, n, m);
        }
    }
}

取一个整数a从右端开始的4～7位

package com.ftl;

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

/**
       取一个整数a从右端开始的4～7位。
 * @author 小a玖拾柒
 * Date:   2018年8月18日  
 */

public class Test2018 {
    
    public static void main(String[] args) {
        int a = 123456789;
        // 方案一： 利用数组进行数组反转输出
        String str = String.valueOf(a);
        char[] arr = new char[str.length()];
        for(int i = 0; i < arr.length; i++){
            arr[arr.length-i-1] = str.charAt(i);
        } 
        System.out.println("【方案一】：");
        for(int i = 3; i < 7; i++){
            System.out.print(arr[i] + "	");
        }
        
        // 方案二： 利用list进行数组反转输出
        List<Character> list = new ArrayList<>();
        for(int i = 0; i < arr.length; i++){
            list.add(str.charAt(i));
        }
        Collections.reverse(list);
        System.out.println("
【方案二】：");
        for(int i = 3; i < 7; i++){
            System.out.print(list.get(i) + "	");
        }
        // 方法三：  
        System.out.println("
【方案三】：");
        getNum(a, 4, 7);
    }
    public static void getNum(int a, int m, int n){
        int[] ans = new int[n-m+1];
        for(int i=1,j=0; j<ans.length && a>0;i++){
            if(i>=m && i<=n){
                ans[j] = a%10;
                j++;
            }
            a = a / 10;
        }
        
        for(int i=ans.length-1; i>=0; i--){
            System.out.print(ans[i]+"	");
        }
        System.out.println();
    }
}