java面试题大合集（开发者必看三）

前言

本文来自百度网络的一篇文章，由于没有答案，现在整理了一些比较好的回答和好的博客，可以自己扩展思路，如果大家有一下面试题的更好的答案，欢迎在评论区留言。以上全部来自网络！此外，我的微信公众号将每日分享下面面试题相关的知识点总结干货，欢迎关注微信公众号： 好好学java！

文章推荐

---

网络

1、用Java Socket编程，读服务器几个字符，再写入本地显示

反射

1、反射机制提供了什么功能？

得到该对象所属的类：Class ownerClass = owner.getClass()在运行时构造一个类的对象：Class newoneClass = Class.forName(className)：第一步，得到要构造的实例的Class。Constructor cons = newoneClass.getConstructor(argsClass)：得到构造子。cons.newInstance(args)：新建实例。在运行时判断一个类所具有的成员变量和方法：Class ownerClass = owner.getClass()：得到该对象的Class。

Field field = ownerClass.getField(fieldName)：通过Class得到类声明的属性。

Object property = field.get(owner)：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException。在运行时调用一个对象的方法：Method method = ownerClass.getMethod(methodName, argsClass)：通过Method名和参数的Class数组得到要执行的Method。

method.invoke(owner, args)：执行该Method，invoke方法的参数是执行这个方法的对象，和参数数组。返回值是Object，也既是该方法的返回值。

2、反射是如何实现的

所谓反射，是指在运行时状态中，获取类中的属性和方法，以及调用其中的方法的一种机制。这种机制的作用在于获取运行时才知道的类（Class）及其中的属性（Field）、方法（Method）以及调用其中的方法，也可以设置其中的属性值。在Java中实现反射最重要的一步，也是第一步就是获取Class对象，得到Class对象后可以通过该对象调用相应的方法来获取该类中的属性、方法以及调用该类中的方法。Java中反射有如下几种实现方式：1、通过Class.forName()方法加载字符串，就可以得到该字符串做代表的Class对象。例如：Class clazz = Class.forName(“java.lang.String”)就可以得到String类的Class对象。值得注意的是，字符串必须是类的全名，即包名+类名。下边的代码是Struts配置文件struts.xml中的一个action的配置。

/registeResult.jsp   /registe2.jsp

这里的class属性给出了一个类的全名的字符串，服务器是如何通过这个字符串得到类对象的呢？就是通过反射机制RegisteAction对象的。然后再去调用这个类中的默认的execute()方法。2、通过类名调用class属性得到该类的Class对象。例如：Class clazz = String.class也可以得到String类的Class对象。3、调用实例的getClass()方法。例如：Date date = new Date();          Class clazz = date.getClass();通过上边的两句代码就可以得到date实例的Class对象。4、如果是基本类型的包装类，则可以通过调用包装类的Type属性来获得该包装类的Class对象。    例如：Class clazz = Integer.TYPE;

3、哪里用到反射机制

java的反射机制就是增加程序的灵活性，避免将程序写死到代码里，典型应用是Spring例如： 实例化一个 person()对象， 不使用反射， new person(); 如果想变成 实例化 其他类， 那么必须修改源代码，并重新编译。      使用反射： class.forName(“person”).newInstance()； 而且这个类描述可以写到配置文件中，如 **.xml, 这样如果想实例化其他类，只要修改配置文件的”类描述”就可以了，不需要重新修改代码并编译。

4、反射中 Class.forName 和 ClassLoader 区别

参考：http://blog.csdn.net/qq_27093465/article/details/52262340

5、反射创建类实例的三种方式是什么

参考：http://blog.csdn.net/u012110719/article/details/45226937

6、如何通过反射调用对象的方法

参考：blog.csdn.net/handsome_fan/article/details/54862873

7、如何通过反射获取和设置对象私有字段的值

参考：http://blog.csdn.net/u012726702/article/details/72027028

8、反射机制的优缺点

参考：http://blog.csdn.net/u010154380/article/details/78150251

数据库

1、写一段 JDBC 连Oracle的程序,并实现数据查询

    package svn;  
    import java.sql.Connection;  
    import java.sql.DriverManager;  
    import java.sql.PreparedStatement;  
    import java.sql.ResultSet;  
    public class Main {  
        public static void main(String[] args) throws Exception {  
            // 1、加载驱动  
            Class.forName("com.mysql.jdbc.Driver");  
            // 2、创建数据库连接对象  
            Connection conn = null;  
            conn = DriverManager  
                    .getConnection(  
                            "jdbc:mysql://localhost:3306/db?useUnicode=true&characterEncoding=UTF-8",  
                            "root", "123456");  
            // 3、创建数据库命令执行对象  
            PreparedStatement psPreparedStatement = conn  
                    .prepareStatement("select * from t_user");  
            // Statement stmtStatement=conn.createStatement();  
            // 4、执行数据库命令  
            ResultSet rSet = psPreparedStatement.executeQuery();  
            //ResultSet rs=stmtStatement.executeQuery("select * from t_user");  
            //5、处理执行结果  
            while(rSet.next()){  
                int id=rSet.getInt("id");  
                String usernameString=rSet.getString("username");  
                String passwordString=rSet.getString("password");  
            }  
            if(rSet!=null)  
                rSet.close();  
            if(psPreparedStatement!=null)  
                psPreparedStatement.close();  
            if(conn!=null)  
                conn.close();  
        }  
    }  

算法

1、50个人围坐一圈，当数到三或者三的倍数出圈，问剩下的人是谁，原来的位置是多少

 /*出圈算法是一类比较典型的算法面试题，它可以很好地考察求职者的编程功底。由于它是一种循环的逻辑，因此它比起一般的基础算法题会更难一些。本例在回答该问题的同时，详细地讲解出圈算法的实现思路。
对于出圈的问题，它有一个比较大的困难点，就是它总是重复循环的，它的头就是它的尾巴，所以，出圈问题的循环语句是比较难写的。
该题目的圈的元素个数是50个，每次数到3或3的倍数的时候，就把当前元素出圈，并且继续数数，直到再遇到3的倍数。这里，如果下标从0开始，一直到一圈完成以后，它就会接到圈的首部，这应该如何处理呢？其实，最好的办法就是使用取余的办法，就可以始终得到3个倍数，无论它的倍数是多少，也不管它的元素个数是多少。
由于每次去掉元素以后，元素的个数会少一个，因此下一个3的倍数其实只需要走两步，在为其下标赋值的时候，需要减一，保持每次去掉的元素都是3的倍数。
说明：如果使用从0开始的下标开始计算，那么初始化的时候应该使用-1，这样就可以模拟元素已经减少一个了。
至于元素的保存，可以使用数组，也可以使用链表。数组的元素去掉以后，它的下一个元素是不会自动往前移动的，不太好使用，但是也可以使用。这里，最好是使用java.util.List链表来表示，它既有下标，又可以很方便地获得元素的当前个数，尽管效率比数组要稍微低一些，不过已经足够了。*/
    import java.util.LinkedList;    
    import java.util.List;    
    //测试类    
    public class Cycle {      
        public static int cycle(int total, int k) {  //功能方法    
            List<Integer> dataList = new LinkedList<Integer>();//创建链表对象    
            for (int i = 0; i < total; i++)  //添加数据元素    
                dataList.add(new Integer(i + 1));      
            int index = -1;  //定义下标，模拟已经去掉一个元素，因此从-1开始  
        while (dataList.size() > 1) { //一直循环去除数据，直到只剩下一个元素   
                index = (index + k) % dataList.size();//得到应该出局的下标    
                dataList.remove(index--);  //去除元素    
            }      
            return ((Integer) dataList.get(0)).intValue();//返回它的值    
        }      
      //主方法    
        public static void main(String[] args) {      
            System.out.println("该数字原来的位置是："+cycle(50, 3));     
        }      
    }  

2、实现一个电梯模拟器用

基本思路：
模拟电梯运行（为单一电梯，未考虑达到承载上限，最短等待时间等问题）
基本条件：
1、电梯有三种状态：静止，向上，向下。
2、每层的指示灯有三种状态：向上、向下、到达（只开门）。
3、开门上人1秒，每上或下一层用0.1秒。
/*实现方案:
使用一个队列（可看做时间优先）将所有按钮事件依次入队。
当电梯静止时首先响应队头的按钮事件，并根据按钮楼层和当前楼层的位置确定移动方向； 当向上移动时，将移动到所有亮灯的按钮所在楼层的最高层，当按钮方向和电梯方向一致时或该楼层内部到达按钮亮起时开门；向下移动类似。 当队列中没有按钮事件时，电梯静止。有些类似LOOK算数，但没有按钮事件时不会来回扫描。
使用主线程来控制电梯上下，需要注意同步“设置和获取电梯按钮最高层或按钮最底层数的方法”。*/
while(true){
            if(!ele.getPushedFloor().isEmpty()){
                int nextFloor = ele.getPushedFloor().peek();
                if(nextFloor > 0){//向上的按钮
                    if(ele.getCurFloor() - nextFloor <= 0){
                        ele.liftUp();
                    }else if(ele.getCurFloor() - nextFloor > 0){
                        ele.liftDown();
                    }
                }else{//向下的按钮
                    if(ele.getCurFloor() + nextFloor < 0){
                        ele.liftUp();
                    }else if(ele.getCurFloor() + nextFloor >= 0){
                        ele.liftDown();
                    }
                }
            }else{
                ele.setStat(RunningStat.INIT);
            }
            Thread.sleep(100);
        }

3、写一个冒泡排序

package sort;
public class BubbleSort {
    //第一种方法完全就是按照冒泡排序的定义来写的
    //代码完全没有经过优化
    public void Bubble1(int[]a,int n){
        int i,j;
        for(i=0;i<n-1;i++){
            for(j=1;j<n-i;j++){
                if(a[j-1]>a[j]){
                    swap(a,j-1,j);
                    //int k;
                    //k=a[j-1];
                    //a[j-1]=a[j];
                    //a[j]=k;
            }
        }
    }
   }
   //第二种方法代码优化一下 写一个标志位,如果一趟下来发生交换则标志为true，如果未发生交换，为false
    //则代表排序已完成
    public void Bubble2(int[]a,int n){
        int u,v;
        boolean flag;
        flag=true;
        while(flag){
            flag=false;
            for(u=0;u<n-1;u++){
                for(v=1;v<n-u;v++){
                    if(a[v-1]>a[v])
                        swap(a,v-1,v);
                }
                flag=false;
            }
            }
    }
//第三种方法，如果有一个50个数的数组，仅前面10个数是无序的，后面40个数是有序的，并且大于前面10个数，那么
    //第一次排序后，最后发生交换的位置必小于10，且这个位置之后的数据必定是有序的，记录下这个位置后，
    //以后遍历就从头到这个位置就可以了
    public void Bubble3(int[]a,int n){
        int p,q;
        int flag1=n;
        while(flag1>0){
            q=flag1;
            flag1=0;
            for(p=1;p<q;p++){
                if(a[p-1]>a[p])
                    swap(a,p-1,p);
                flag1=p;
            }
        }
    }
    public void swap(int a[],int p,int q ){
        int k;
        k=a[p];
     a[p]=a[q];
        a[q]=k;
    }  
   }

4、写一个折半查找

    import java.util.Comparator;  
    public class MyUtil {  
       public static <T extends Comparable<T>> int binarySearch(T[] x, T key) {  
          return binarySearch(x, 0, x.length- 1, key);  
       }  
       // 使用循环实现的二分查找  
       public static <T> int binarySearch(T[] x, T key, Comparator<T> comp) {  
          int low = 0;  
          int high = x.length - 1;  
          while (low <= high) {  
              int mid = (low + high) >>> 1;  
              int cmp = comp.compare(x[mid], key);  
              if (cmp < 0) {  
                low= mid + 1;  
              }  
              else if (cmp > 0) {  
                high= mid - 1;  
              }  
              else {  
                return mid;  
              }  
          }  
          return -1;  
       }  
       // 使用递归实现的二分查找  
       private static<T extends Comparable<T>> int binarySearch(T[] x, int low, int high, T key) {  
          if(low <= high) {  
            int mid = low + ((high -low) >> 1);  
            if(key.compareTo(x[mid])== 0) {  
               return mid;  
            }  
            else if(key.compareTo(x[mid])< 0) {  
               return binarySearch(x,low, mid - 1, key);  
            }  
            else {  
               return binarySearch(x,mid + 1, high, key);  
            }  
          }  
          return -1;  
       }  
    }  

5、随机产生20个不能重复的字符并排序

import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;
public class bb {
    public static void main(String[] args) {
        Set noreapeat  =new TreeSet();
         Random rdm = new Random();  
        while (noreapeat.size()<20){
            int  bb =Math.abs(rdm.nextInt())%26+97;
             char cc =(char)bb;
            noreapeat.add(cc);
        }
        System.out.println(noreapeat);
    }
}

6、写一个函数，传入 2 个有序的整数数组，返回一个有序的整数数组
7、写一段代码在遍历 ArrayList 时移除一个元素
8、古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第四个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少
9、约瑟芬环游戏

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class No10 {
//约瑟芬环 游戏：有n个人站成一个圈，标上号1-n：从第一个开始报数，数到m,就拖出去杀掉，下一位从一开始数，数到m杀掉，问最后一个人的标号是多少，
//下面有两个方法
//方法2是正确的，方法只能满足小数据，大一点的就异常了。求大神帮我改一下，看我的打印信息就知道我的思路了。
public static void main(String[] args) {
// TODO Auto-generated method stub
//经测试，输入： 6 3
//12 4都成功，输入大了就不行了，比如54 12就报错了，求帮我修改一下
Scanner scanner = new Scanner(System.in);
System.out.print("请输入总人数：");
int totalNum = scanner.nextInt();
System.out.print("请输入报数的大小：");
int cycleNum = scanner.nextInt();
yuesefu1(totalNum, cycleNum);
System.out.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
yuesefu2(totalNum, cycleNum);
}
public static void yuesefu1(int t ,int p)
{
    //首先我把这些人给放到数组里面，方便操作
    List l = new ArrayList();
    for(int i=1;i<=t;i++)
    { 
        l.add(i);
    }
    System.out.println(l.size());
    int wei =p;
    while(l.size()>1)
    {
        if(l.size()==p)
        {
            System.out.println("等于p");
            System.out.println("删掉"+l.get(p-1));
            l.remove(p-1);
        }if(l.size()<p)
        {
            System.out.println("小于p");
            System.out.println("删掉"+l.get(p-l.size()-1));
            l.remove(l.get(p-l.size()-1));
            System.out.println("---------------------------------");
            for(int k = 0;k<l.size();k++)
            {
                System.out.print(l.get(k)+".");
            }
            System.out.println("---------------------------------");
        }
        else{
        //先删除一个p位置的
        l.remove(p-1);
        //---------------------------------
        System.out.println("---------------------------------");
        for(int k = 0;k<l.size();k++)
        {
            System.out.print(l.get(k)+".");
        }
        System.out.println("---------------------------------");
        //---------------------------------
        for(int j=0;j<p-1;j++)
        {
            l.add(l.get(j));
        }
        //---------------------------------
        System.out.println("---------------------------------");
        for(int k = 0;k<l.size();k++)
        {
            System.out.print(l.get(k)+".");
        }
        System.out.println();
        System.out.println("---------------------------------");
        //---------------------------------
        for(int j=0;j<p-1;j++)
        {
            l.remove(0);
        }
        //---------------------------------
        System.out.println("---------------------------------");
        for(int k = 0;k<l.size();k++)
        {
            System.out.print(l.get(k)+".");
        }System.out.println();
        System.out.println("---------------------------------");
        }
    }
    System.out.println("最后的："+l.get(0));
}
public static void yuesefu2(int t,int p)
{
    List list = new ArrayList();
    for(int i=1;i<=t;i++)
    {
        list.add(i);
    }
    int k=0;
    while(list.size()>0)
    {
        k = k+p; 
        k= k%(list.size())-1;
         System.out.print("k="+k+"值为：");
        if(k<0)
        {
            System.out.println(list.get(list.size()-1));
            list.remove(list.size()-1);
            k=0;
        }else
        {
            System.out.println(list.get(k));
            list.remove(k);
        }
    }
}
}

正则

1、请编写一段匹配IP地址的正则表达式

之前一直不太会写正则表达式，很多要用到正则表达式的都直接百度，像上次要用正则表达式验证是否是合法的ip地址，然后就上网找，结果就是没找到一个对的，今天就为大家贡献一下，写个对的，并做一下解析。（建议大家还是去看书去规范的学一下，不要直接百度，不然都是坑）。
iPv4的ip地址都是（1~255）.（0~255）.（0~255）.（0~255）的格式
下面给出相对应的正则表达式：
"^(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|[1-9])\\."
+"(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."
+"(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."
+"(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)$"
上面的一个不漏就是正确的验证ip的正则表达式，简单的讲解一下
\\d表示0~9的任何一个数字
{2}表示正好出现两次
[0-4]表示0~4的任何一个数字
| 的意思是或者
( )上面的括号不能少，是为了提取匹配的字符串，表达式中有几个()就表示有几个相应的匹配字符串
1\\d{2}的意思就是100~199之间的任意一个数字
2[0-4]\\d的意思是200~249之间的任意一个数字
25[0-5]的意思是250~255之间的任意一个数字
[1-9]\\d的意思是10~99之间的任意一个数字
[1-9])的意思是1~9之间的任意一个数字
\\.的意思是.点要转义（特殊字符类似，@都要加\\转义）
说到这里应该已经很清楚的知道了上面的正则表达式的意思。

2、写出一个正则表达式来判断一个字符串是否是一个数字

public boolean isNumeric(String str){   
   Pattern pattern = Pattern.compile("[0-9]*");   
   Matcher isNum = pattern.matcher(str);  
   if( !isNum.matches() ){  
       return false;   
   }   
   return true;   
}  

字符串

1、写一个方法，入一个文件名和一个字符串，统计这个字符串在这个文件中出现的次数。

/**
     * 写入一个方法，输入一个文件名和一个字符串，统计这个字符串在这个文件中出现的次数。
     * @param fileName 文件名
     * @param str 查找的字符串
     * @return
     * @throws Exception
     */
    //方法一
    public static int funCount1(String fileName,String str) throws Exception {
        int count = 0;
        BufferedReader bf = new BufferedReader(new InputStreamReader(new FileInputStream(fileName)));
        String line ;
        StringBuilder sb = new StringBuilder();
        while((line = bf.readLine() )!= null) {
            sb = sb.append(line);
        }
        int a = 0;
        while((a = sb.indexOf(str)) != -1) {
            sb = sb.delete(a, a + str.length());
            count++;
        }
        return count;
    }
    //方法二：正则表达式
    public static int funCount2(String fileName,String str) throws Exception {
        int count =0 ;
        BufferedReader bf = new BufferedReader(new InputStreamReader(new FileInputStream(fileName)));
        String line ;
        StringBuilder sb = new StringBuilder();
        while((line = bf.readLine() )!= null) {
            sb = sb.append(line);
        }
        String pattern = ".*" + str + ".*";
        while(Pattern.matches(pattern, sb.toString())) {
            count ++;
            int a = sb.indexOf(str);
            sb.delete(a, a + str.length());
        }
        return count;
    }

2、写一个程序找出所有字符串的组合，并检查它们是否是回文串

public static void main(String[] args) {
  String text = "abccb";
  System.out.println(isHuiwen(text));
 }
 public static boolean isHuiwen(String text){
  int length = text.length();
  for(int i=0;i<length/2;i++){
   if(text.charAt(i)!=text.charAt(length-i-1)){
    return false;
   }
  }
  return true;
 }

3、写一个字符串反转函数，输入abcde转换成edcba代码

import java.util.Scanner;
public class Test6 {
    /**
     * 6、将字符串中进行反转。abcde --> edcba
     * 分析：
     *      字符串String 有索引  有最大长度
     *      通过for循环从最大长度lengrh-1  开始到0为止倒序遍历
     */
    public static void main(String[] args) {
        //键盘录入任意字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一串字符串：");
        String line = sc.nextLine();
        //将字符串倒序打印
        System.out.println("字符串反转后为：");
        //循环条件int i = line.length()-1;i >= 0;i--
        for(int i = line.length()-1;i >= 0;i--){
         //字符串转换成字符输出
            System.out.print(line.charAt(i));
        }
    }
}

4、小游戏，倒转句子中的单词

public static void reverseWord( char[ ] s,int start,int end  ){
      char temp;
      while(start < end){ 
          temp = s[start];
          s[start] = s[end];
           s[end] = temp;
     }    
}
 public static void reverseSentense(char[] s){
              int len = s.length;
               int start = 0,end = 0;
              reverseWord(s,0,len-1);
           while(start < len){
                    if(s[start] == '  ' ){
                                  start++;
                                  end++;
                                 continue;
                      }else if(s[end] == '  ' || end == len ]){
                                       reverseWord(s,start,end-1);
                                       strat = end;
                       }else{
                                end++;}
                    }
}

5、将GB2312编码的字符串转换为ISO-8859-1编码的字符串

String s2 = new String(s1.getBytes("GB2312"), "ISO-8859-1");  

6、请写一段代码来计算给定文本内字符“A”的个数。分别用迭代和递归两种方式

public class RecursiveCall {
    public int countA(String input) {
        // exit condition – recursive calls must have an exit condition
        if (input == null || input.length( ) == 0) {
            return 0;
        }
        int count = 0;
        //check first character of the input
        if (input.substring(0, 1).equals("A")) {
            count = 1;
        }
        //recursive call to evaluate rest of the input
        //(i.e.  2nd character onwards)
        return count + countA(input.substring(1));
    }
    public static void main(String[ ] args) {
        System.out.println(new RecursiveCall( ).countA("AAA rating"));  // Ans. 3
    }
}

7、编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。 但是要保证汉字不被截半个，如“我ABC”，应该截为“我AB”，输入“我ABC汉DEF”，应该输出为“我ABC”，而不是“我ABC+汉的半个”

一、需要分析
1、输入为一个字符串和字节数，输出为按字节截取的字符串--------------》按照字节[byte]截取操作字符串，先将String转换成byte类型
2、汉字不可以截半----------------------------------------------------------------------------------------------------------》汉字截半的话对应字节的ASC码为小于0的数值
二、技术难点
1、知道汉字截半的话对应字节的ASC码为小于0的数值
2、对字符串操作应该都要面对的一个问题，字符串是否有效null, 字符串的长度0,1这种边界处理
代码实现
package com.itheima;
/**
 * 10、 编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。
 * 但是要保证汉字不被截半个，如“我ABC”4，应该截为“我AB”，输入“我ABC汉DEF”，6，应该输出为“我ABC”而不是“我ABC+汉的半个”。
 * 
 * @author 281167413@qq.com
 */
public class Test10 {
    public static void main(String[] args) {
        String srcStr1 = "我ABC";
        String srcStr2 = "我ABC汉DEF";
        splitString(srcStr1, 4);
        splitString(srcStr2, 6);
    }
    public static void splitString(String src, int len) {
        int byteNum = 0;
        if (null == src) {
            System.out.println("The source String is null!");
            return;
        }
        byteNum = src.length();
        byte bt[] = src.getBytes(); // 将String转换成byte字节数组
        if (len > byteNum) {
            len = byteNum;
        }
        // 判断是否出现了截半，截半的话字节对于的ASC码是小于0的值
        if (bt[len] < 0) {
            String subStrx = new String(bt, 0, --len);
            System.out.println("subStrx==" + subStrx);
        } else {
            String subStrx = new String(bt, 0, len);
            System.out.println("subStrx==" + subStrx);
        }
    }
}

8、给定 2 个包含单词列表（每行一个）的文件，编程列出交集
9、打印出一个字符串的所有排列

import java.util.Scanner;
public class Demo001 {
    public static void main(String[] args) {
        String str = "";
        Scanner scan = new Scanner(System.in);
        str = scan.nextLine();
        permutation(str.toCharArray(), 0);
    }
    public static void permutation(char[] str, int i) {
        if (i >= str.length)
            return;
        if (i == str.length - 1) {
            System.out.println(String.valueOf(str));
        } else {
            for (int j = i; j < str.length; j++) {
                char temp = str[j];
                str[j] = str[i];
                str[i] = temp;
                permutation(str, i + 1);
                temp = str[j];
                str[j] = str[i];
                str[i] = temp;
            }
        }
    }
}

10、将一个键盘输入的数字转化成中文输出(例如：输入1234567，输出:一百二拾三万四千五百六拾七)

 public class Reader {
    private String strNum;
    private String strNumChFormat;
    private String strNumTemp;
    private int intNumLen;
    private String strBegin;
    public Reader(String strNum) {
        this.strNum = strNum;
    }
    public boolean check(String strNum) {
        boolean valid = false;
        if (strNum.substring(0,1).equals("0")){
            this.strNum = strNum.substring(1);
        }
        try {
            new Double(strNum);
            valid = true;
        }
        catch (NumberFormatException ex) {
            System.out.println("Bad number format!");
        }
        return valid;
    }
    public void init() {
        strNumChFormat = "";
        intNumLen = strNum.length();
        strNumTemp = strNum;
        strNumTemp = strNumTemp.replace('1', '一');
        strNumTemp = strNumTemp.replace('2', '二');
        strNumTemp = strNumTemp.replace('3', '三');
        strNumTemp = strNumTemp.replace('4', '四');
        strNumTemp = strNumTemp.replace('5', '五');
        strNumTemp = strNumTemp.replace('6', '六');
        strNumTemp = strNumTemp.replace('7', '七');
        strNumTemp = strNumTemp.replace('8', '八');
        strNumTemp = strNumTemp.replace('9', '九');
        strNumTemp = strNumTemp.replace('0', '零');
        strNumTemp = strNumTemp.replace('.', '点');
        strBegin = strNumTemp.substring(0, 1);
    }
    public String readNum() {
        if (check(strNum)) {
            init();
            try {
                for (int i = 1, j = 1, k = 1; i < intNumLen; i++) {
                    if (strNumTemp.charAt(intNumLen - 1) == '零' && i == 1) {
                        strNumChFormat = "位";
                    }
                    else if (strNumTemp.charAt(intNumLen - i) == '零' && j == 1) {
                        strNumChFormat = "位" + strNumChFormat;
                    }
                    else if (strNumTemp.charAt(intNumLen - i) == '点') {
                        j = 1;
                        k = 1;
                        strNumChFormat = strNumTemp.charAt(intNumLen - i) + strNumChFormat;
                        continue;
                   }
                   else {
                       strNumChFormat = strNumTemp.charAt(intNumLen - i) + strNumChFormat;
                    }
          if (strNumTemp.charAt(intNumLen - i - 1) != '位' &&
              strNumTemp.charAt(intNumLen - i - 1) != '零') {
            if (j == 1 && i < intNumLen) {
              strNumChFormat = '拾' + strNumChFormat;
            }
            else if (j == 2 && i < intNumLen) {
              strNumChFormat = '百' + strNumChFormat;
            }
            else if (j == 3 && i < intNumLen) {
              strNumChFormat = '千' + strNumChFormat;
            }
          }
          if (j == 4 && i < intNumLen) {
            j = 0;
          }
          if (k == 4 && i < intNumLen) {
            strNumChFormat = '万' + strNumChFormat;
          }
          else if (k == 8 && i < intNumLen) {
            k = 0;
            strNumChFormat = '亿' + strNumChFormat;
          }
          j++;
          k++;
        }
        while (strNumChFormat.indexOf("位") != -1) {
          strNumChFormat = strNumChFormat.replaceAll("位", " ");
        }
        if (strNumChFormat.substring(0, 2) == "一拾") {
          strNumChFormat = strNumChFormat.substring(1, strNumChFormat.length());
        }
        if (strNumChFormat.indexOf("点") >= 0) {
          String rebegin = strNumChFormat.substring(0,
              strNumChFormat.indexOf("点"));
          String relast = strNumChFormat.substring(strNumChFormat.indexOf("点"),
              strNumChFormat.length());
          for (int i = 1; i <= relast.length(); i++) {
            relast = relast.replaceAll("拾", "");
            relast = relast.replaceAll("百", "");
            relast = relast.replaceAll("千", "");
            relast = relast.replaceAll("万", "");
            relast = relast.replaceAll("亿", "");
          }
          strNumChFormat = rebegin + relast;
        }
      }
      catch (ArrayIndexOutOfBoundsException ex) {
        ex.printStackTrace();
      }
      catch (Exception ex) {
        ex.printStackTrace();
      }
      int off = strNumChFormat.indexOf("点");
      strNumChFormat = strBegin + strNumChFormat.substring(0);
    }
    else {
      strNumChFormat = "";
    }
    return strNumChFormat;
  }
  public static void main(String args[]) {
    try {
      String number = args[0].toString();
      System.out.println("The number is: " + number);
      Reader reader = new Reader(number);
      System.out.println("Output String: " + reader.readNum());
    }
    catch (Exception ex) {
      System.out.println("Please input like that: javac Reader <number>");
    }
  }
} 

11、在Web应用开发过程中经常遇到输出某种编码的字符，如从 GBK 到 ISO8859-1等，如何输出一个某种编码的字符串

public String translate (String str) {
        String tempStr = "";
        try {
            tempStr = new String(str.getBytes("ISO-8859-1"), "GBK");
            tempStr = tempStr.trim();
        }catch (Exception e) {
            System.err.println(e.getMessage());
        }
        return tempStr;
        }

日期

1、计算两个日期之间的差距

    import java.text.DateFormat;  
    import java.text.ParseException;  
    import java.text.SimpleDateFormat;  
    import java.util.Date;  
    /** 
    * 时间相距 
    * @author Ben 
    * @version 1.0 
    * @date 2009-10-21 16:38:51 
    */  
    public class DateDistance {  
        /** 
         * 两个时间之间相差距离多少天 
         * @param one 时间参数 1： 
         * @param two 时间参数 2： 
         * @return 相差天数 
         */  
        public static long getDistanceDays(String str1, String str2) throws Exception{  
            DateFormat df = new SimpleDateFormat("yyyy-MM-dd");  
            Date one;  
            Date two;  
            long days=0;  
            try {  
                one = df.parse(str1);  
                two = df.parse(str2);  
                long time1 = one.getTime();  
                long time2 = two.getTime();  
                long diff ;  
                if(time1<time2) {  
                    diff = time2 - time1;  
                } else {  
                    diff = time1 - time2;  
                }  
                days = diff / (1000 * 60 * 60 * 24);  
            } catch (ParseException e) {  
                e.printStackTrace();  
            }  
            return days;  
        }  
        /** 
         * 两个时间相差距离多少天多少小时多少分多少秒 
         * @param str1 时间参数 1 格式：1990-01-01 12:00:00 
         * @param str2 时间参数 2 格式：2009-01-01 12:00:00 
         * @return long[] 返回值为：{天, 时, 分, 秒} 
         */  
        public static long[] getDistanceTimes(String str1, String str2) {  
            DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
            Date one;  
            Date two;  
            long day = 0;  
            long hour = 0;  
            long min = 0;  
            long sec = 0;  
            try {  
                one = df.parse(str1);  
                two = df.parse(str2);  
                long time1 = one.getTime();  
                long time2 = two.getTime();  
                long diff ;  
                if(time1<time2) {  
                    diff = time2 - time1;  
                } else {  
                    diff = time1 - time2;  
                }  
                day = diff / (24 * 60 * 60 * 1000);  
                hour = (diff / (60 * 60 * 1000) - day * 24);  
                min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);  
                sec = (diff/1000-day*24*60*60-hour*60*60-min*60);  
            } catch (ParseException e) {  
                e.printStackTrace();  
            }  
            long[] times = {day, hour, min, sec};  
            return times;  
        }  
        /** 
         * 两个时间相差距离多少天多少小时多少分多少秒 
         * @param str1 时间参数 1 格式：1990-01-01 12:00:00 
         * @param str2 时间参数 2 格式：2009-01-01 12:00:00 
         * @return String 返回值为：xx天xx小时xx分xx秒 
         */  
        public static String getDistanceTime(String str1, String str2) {  
            DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
            Date one;  
            Date two;  
            long day = 0;  
            long hour = 0;  
            long min = 0;  
            long sec = 0;  
            try {  
                one = df.parse(str1);  
                two = df.parse(str2);  
                long time1 = one.getTime();  
                long time2 = two.getTime();  
                long diff ;  
                if(time1<time2) {  
                    diff = time2 - time1;  
                } else {  
                    diff = time1 - time2;  
                }  
                day = diff / (24 * 60 * 60 * 1000);  
                hour = (diff / (60 * 60 * 1000) - day * 24);  
                min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);  
                sec = (diff/1000-day*24*60*60-hour*60*60-min*60);  
            } catch (ParseException e) {  
                e.printStackTrace();  
            }  
            return day + "天" + hour + "小时" + min + "分" + sec + "秒";  
        }  
    }  

文章有不当之处，欢迎指正，同时也欢迎在评论区给你的漂亮的答案，你也可以关注我的微信公众号： 好好学java，每日更新知识点总结干货。

好好学java

原文地址：https://sihai.blog.csdn.net/article/details/109464687