Java面试题代码篇

1.统计字符串中的各种字符的个数并对其排序

package JavaMianSiTest;

public class TongJIZiFu {

    public static void main(String[] args)
    {
        String str = "a12中国3@b&4语*$#@^&言3c";  

        String E1 = "[\u4e00-\u9fa5]";// 中文
        String E2 = "[a-zA-Z]";// 英文
        String E3 = "[0-9]";// 数字  

        int chineseCount = 0;
        int englishCount = 0;
        int numberCount = 0;  

        String temp;
        for (int i = 0; i < str.length(); i++)
        {
            temp = String.valueOf(str.charAt(i));
            if (temp.matches(E1))
            {
                chineseCount++;
            }
            if (temp.matches(E2))
            {
                englishCount++;
            }
            if (temp.matches(E3))
            {
                numberCount++;
            }
        }
        System.out.println("汉字数:" + chineseCount);
        System.out.println("英文数:" + englishCount);
        System.out.println("数字数:" + numberCount);
        System.out.println("特殊字符:" + (str.length() - (chineseCount + englishCount + numberCount)));
    }
}

2.文件合并

package JavaMianSiTest;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

/**
 * 1、编写一个程序，将a.txt文件中的单词与b.txt文件中的单词交替合并到c.txt文件中，a.txt文件中的单词用回车符分隔，b.txt文件中用回车或空格进行分隔
 *
 */
public class WenjianHebing {

public static void main(String[] args) throws IOException {

File fileA= new File("D:/eclipse项目/a.txt");
Reader readerA = new FileReader(fileA); 

//创建可以一次读取一行的输入流
BufferedReader a = new BufferedReader(readerA);   //一次读取一行，结束符为null

File fileB= new File("D:/eclipse项目/b.txt");
Reader readerB = new FileReader(fileB);
BufferedReader b = new BufferedReader(readerB);   //一次读取一行，结束符为null

String str1=a.readLine();

//用于单词的计数
int wordsA=0;
//缓冲区，可以把读取的单词存进去
StringBuffer bufA= new StringBuffer();
while(str1!=null){
System.out.println("***********"+str1);
str1=a.readLine();
wordsA++;
if(str1!=null)
bufA.append(str1);
bufA.append(" ");

}
System.out.println("a.txt单词数："+wordsA);
System.out.println("-------------------------");

String str2=b.readLine();
int wordsB=0;
StringBuffer bufB= new StringBuffer();
while(str2!=null){
String[] st = str2.split(" ");  //例如读取的一行为：house home desk
        wordsB+=st.length;
        for(String i :st){
        bufB.append(i);     //把切割后的字符放到b的缓冲区
        bufB.append(" ");

        }
System.out.println(str2);
str2=b.readLine();
}
System.out.println("b.txt单词数："+wordsB);

System.out.println("A文件："+bufA);
System.out.println("B文件："+bufB);

String strA=bufA.toString();  //转为字符串
String strB=bufB.toString();

String []A=strA.split(" ");
String []B=strB.split(" ");
int total=wordsA+wordsB;
String [] result=new String [total-1];  //创建一个字符串数组，可以容纳a.txt以及b.txt的单词的总数
if(wordsA<wordsB)//只做了a文件的单词数比b的少的，后面加个else就可以了
{
int j=0;
for(int i=0;i<wordsB;i++)
{
result[j]=B[i];
j++;
if(i<A.length)
{
result[j]=A[i];
j++;
}

}
}
String content ="";
     for(String x:result){
    content+=x+" "; //把字符数组的内容转为字符串
     }
    System.out.println("content:"+content);

  File fileC = new File("D:/eclipse项目/c.txt");
    Writer w = new FileWriter(fileC);
    w.write(content);  //把字符串写到c.txt里去

  w.close();     //一定要关闭，不然无法成功的

 }

}

3.金额转换

package JavaMianSiTest;
/*
 * 金额转换，阿拉伯数字的金额转换成中国传统的形式
 */
public class RenMingBi {
    public static String convert(double inputMonney) {
        int decimalDigit = 2;//人名币保留2位小数到分
        //汉语中数字大写
        char[] data = {'零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'};
        //汉语中货币单位大写，这样的设计类似于占位符
        char[] units = {'分', '角', '元', '拾', '佰', '仟', '万', '拾', '佰', '仟', '亿', '拾', '佰', '仟','兆', '拾', '佰', '仟'};
        int uint = 0;
        //在这里我不使用系统函数，自己实现四舍五入，原理：如102.345,保留2位并四舍五入,102.3456->102.3456*10^(2+1)=102345.6->去掉小数部分102345->102345%10=5取到保留小数位数的下一位数字，判断舍入
        long money = (long)(inputMonney * Math.pow(10, decimalDigit + 1));
        if (money % 10 > 4) {
            money = (money / 10) + 1;
        } else {
            money = money / 10;
        }
        StringBuffer sbf = new StringBuffer();
        while (money != 0) {
            sbf.insert(0, units[uint++]);//插入人名币单位
            sbf.insert(0, data[(int) (money % 10)]);//插入单位所对应的值
            money = money / 10;
        }
        //使用replaceAll替换掉“零+'人民币单位'”,replaceAll里面的old字符串可以是正则表达式
        return sbf.toString().replaceAll("零[仟佰拾]", "零").replaceAll("零+万", "万").replaceAll("零+亿", "亿").replaceAll("亿万", "亿零").replaceAll("零+", "零").replaceAll("零元", "元").replaceAll("零[角分]", "");
    }  

    public static void main(String[] args) {
        System.out.println(convert(25936.36));

    }
}

4.二叉树

package JavaMianSiTest;

/**
 * 说明生活中遇到的二叉树，用 java 实现二叉树 。
    这是组合设计模式。
    我有很多个(假设 10 万个)数据要保存起来，以后还需要从保存的这些数据中检索是否存在
    某个数据， （我想说出二叉树的好处， 该怎么说呢？那就是说别人的缺点） ， 假如存在数组中，
    那么，碰巧要找的数字位于 99999那个地方，那查找的速度将很慢，因为要从第 1 个依次往 67
    后取，取出来后进行比较。平衡二叉树（构建平衡二叉树需要先排序，我们这里就不作考虑
    了）可以很好地解决这个问题，但二叉树的遍历（前序，中序，后序）效率要比数组低很多， 

 * store(int value)可以选择二叉树中是否可以存在相同的值
 */  

//Node，准确的说，是树（包括子树）的根节点
public class ErChashuTest{
    public int value;
    public ErChashuTest left;
    public ErChashuTest right;
    //这种存储方式，是：往已经存在的节点的左右子节点上寻找插入点，而不是考虑作为已经存在的节点的父节点，会造成二叉树的不平衡
    public void store(int value){
        if(value<this.value){
            if(left==null){
                left = new ErChashuTest();
                left.value=value;
            }else{
                left.store(value);
            }
        }else if(value>this.value){
            if(right==null){
                right = new ErChashuTest();
                right.value=value;
            }else{
                right.store(value);
            }
        }//已经存在的值，不插入
    }
    //先序遍历
    public void preList(){
        System.out.print(this.value+",");
        if(left!=null)left.preList();
        if(right!=null)right.preList();
    }
    //中序遍历
    public void middleList(){  

        if(left!=null)left.middleList();
        System.out.print(this.value+",");
        if(right!=null)right.middleList();
    }
    //后序遍历
    public void afterList(){  

        if(left!=null)left.afterList();
        if(right!=null)right.afterList();
        System.out.print(this.value+",");
    }  

    public static void main(String [] args){
        int[] data = new int[20];
        for(int i=0; i<data.length; i++){
            data[i] = (int)(Math.random()*100)+1;//0+1<<x*100+1<<1*100+1
            System.out.print(data[i]+",");
        }
        System.out.println();
        ErChashuTest root = new ErChashuTest();
        root.value = data[0];
        for(int i=1; i<data.length; i++){
            root.store(data[i]);
        }
        root.preList();
        System.out.println();
        root.middleList();
        System.out.println();
        root.afterList();  

    }  

}  

5.对文件中的姓名的重复次数进行排序

package JavaMianSiTest;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeSet;

/*
 * 从类试如下文本文件中读取所有的姓名，并打印出重复的姓名和重复的次数
 * 并按重复次数排序
 *
 */

public class ChongFuSort {

      /**
     * ①读取文件到字符串
     * ②按照换行分割成字符串数组
     * ③遍历字符串数组，取出姓名
     * ④将姓名和出现的次数存入map中；
     * ⑤利用 treeset整理结果；为此需要封装User,其中包含了name，以及count；需要在User 中实现comparable接口或者构造 treesetmap时传入comparator;
     *
     * @throws Exception
     */  

    static class User /*implements Comparable<User>*/ {
         String name;
          int count ;
          public User(String name, int count) {
              super();
              this.name = name;
              this.count = count;
         }
          @Override
          public String toString() {
              return "User [name=" + name + ", count=" + count + "]" ;
         }  

          /**
          * 方法一。使用comparable接口来进行排序；
          */
//       @Override
//       public int compareTo(User o) {
//           if(this.count>o.count)return -1;
//           if(this.count<o.count)return 1;
//
//           return this.name.compareTo(o.name);
//
//            return this.count>o.count?1:(this.count<o.count?-1:this.name.compareTo(o.name));
//
//       }  

    }  

    public static void main(String[] args) throws Exception {
          //读取文件；
         File file= new File("D:/eclipse项目/a.txt" );
         FileReader fr=new FileReader(file);
          int fileSize=(int) file.length();
          char[] buff=new char[fileSize];  

          //用来存放名字和对应的次数；
         Map<String, Integer> map= new HashMap<String, Integer>();  

          //安装次数由小到大排序后的结果；传入比较器，使用comparator来比较；这样元素再加入的时候就会调用比较方法，按照默认升序排列
         Set<User> sortedResult= new TreeSet<User>(new Comparator<User>() {  

              public int compare(User o1, User o2) {
//                if(o1.count>o2.count)return -1;//默认是从小到大排列
//                if(o1.count<o2.count)return 1;
//                return o1.name.compareTo(o2.name);
                   //更简洁的写法
                   return o1.count >o2.count ? 1:(o1.count<o2.count ?-1:o1.name .compareTo(o2.name));
             }
         });  

          int len=fr.read(buff);//得到读取的字符个数；
         String result= new String(buff,0,len);  

         String[] strings = result.split( "\\s+");
          //将姓名提取出来；并将姓名和出现的次数放入到集合中；
          for (String string : strings) {
             string= new String(string.getBytes(),"gbk" );//1,张三,28(解决乱码)
             System. out.println(string);  

             String[] strings2 = string.split( ",");
             String name=strings2[0];
            //存入姓名以及对应的次数
             Integer count=map.get(name);
              if(count==null ){
                  map.put(name, 1);
             } else{
                  map.put(name, count+1);
             }
         }
          //遍历map，得到所有的entry集合,封装成user，加入到set集合中；
         Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
         Iterator<Entry<String, Integer>> iterator = entrySet.iterator();  

          while(iterator.hasNext()){
             Entry<String, Integer> entry = iterator.next();
              System. out.println(entry.getKey()+":" +entry.getValue()+"次");
             User user= new User(entry.getKey(), entry.getValue());
             sortedResult.add(user); //在加入数据时，自动安装 compareto定义的进行排序；  

         }
          //遍历整理好的set，从小到大升序排列
         Iterator<User> it = sortedResult.iterator();
          while(it.hasNext()){
             User user=it.next();
             System. out.println(user);
         }
    }  

}

6.递归排序

package org.sbj.sort;

import java.util.Arrays;

public class SortTest {
    /*
     * 快速排序（递归排序）
     * @param strDate
     * @param  left
     * @param  right
     */

public void quickSort(String []strDate,int left,int right ) {
    String middle,tempDate;
    int i,j;
    i=left;
    j=right;
    middle=strDate[(i+j)/2];
    do {
        while (strDate[i].compareTo(middle)<0&&i<right)
            i++;//找出左边比中间值大的数
        while(strDate[j].compareTo(middle)>0&&j>left)
            j--;//找出右边比中间值小的数
        if(i<=j) {//将左边大的数和右边晓得数进行替黄
            tempDate=strDate[i];
            strDate[i]=strDate[j];
            strDate[j]=tempDate;
            i++;
            j--;
        }

    }while(i<=j);//当两者交错时停止
    if(i<right) {
        quickSort(strDate,i,right);

    }
    if(j>left) {
    quickSort(strDate,left,j);
    }
}

public static void main(String[] args) {
    String [] strVoid= {"12","52","36","89","47","12","4","23","68"};

    SortTest  sort= new SortTest();
    sort.quickSort(strVoid, 0, strVoid.length-1);
    for(int i=0;i<strVoid.length;i++) {
        System.out.print(strVoid[i]+" ");
    }
}
}