不如大家一起来把你们面试时被提的问题写出来，供我们这些即将面试考试的人参考。

有木有人呀，求题目，我正等着题目练手呢，已经申请面试了，正在等面试时间，想在面试前多练练

1、有一个字符串"woaiheimahahaheimaaiwo"求该字符串中"heima"出现的次数
2、有一个Map集合里面存储的是学生的姓名和年龄，内容如下{赵四=21, 王二=17, 张三=18, 小丫=25, 李四=26, 王五=38}（14分）
   a.将里面的元素用两种遍历方式打印到控制台上（4分）
   b.将小丫的年龄改成18(2分)
   c.将里面的元素存入到D:\\student.txt中（8分）
3、有100个限量版的包包，但是只能通过实体店和官网才能进行购买，并且分别统计卖了多少。请用线程进行模拟并设置线程名称代表售出途径再将信息打印出来
比如（实体店卖出第1个总共剩余n个..）（10分）

今天上午的面试题

谢谢分享

加油加油加油加油加油

1.计算指定路径下所有.txt文件包括子文件夹里的.txt文件的个数然后将所有的.txt文件复制到D盘下任意目录

2.编写一个类，其中包含两个排序的方法sort（）,参数不同，当键盘录入的是一串整数，就按照从小到大的顺序输出，如果键盘录入的是一个字符串，就将字符串反序输出

3.在treeset集合中  存入多个学生对象，学生有姓名和成绩两个属性，再存入集合时已经学生的成绩为依据判断

我的面试题

楼上这位兄弟，你第三题，TreeSet这题，看不懂这个题目什么意思啊，是以学生成绩排序吗

lll456123l 发表于 2016-4-30 18:11
楼上这位兄弟，你第三题，TreeSet这题，看不懂这个题目什么意思啊，是以学生成绩排序吗 ...

嗯  
思路就是创建一个TreeSet集合,然后创建的时候传入一个比较器,重写ComparaTo方法.以学生的成绩为主要条件进行排序.

九天玄妖 发表于 2016-4-29 13:59
1、有一个字符串"woaiheimahahaheimaaiwo"求该字符串中"heima"出现的次数
2、有一个Map集合里面存储的是学 ...

就这三道题目？好简单。。

1、有一个字符串"woaiheimahahaheimaaiwo"求该字符串中"heima"出现的次数
思路懒得写：
方法应该挺多的，我再看看API，看看还有没有其他的方法
解题步骤：
public static void main(String[] args) {
                String str = "woaiheimahahaheimaaiwo";
                int num = 0;
                while(str.contains("heima")){
                        num++;
                        str = str.replaceFirst("heima", "");
                }
                System.out.println(num);
        }

方式二：        解题的思路其实是一样的，只是用不同的方法来实现而已
public static void main(String[] args) throws Exception {
                String str = "woaiheimahahaheimaaiwoheima";
                String substr = "heima";
                int num = 0;
                int x = 0;
                while((x = str.indexOf(substr)) != -1){
                        num++;
                        str = str.substring(x + substr.length());
                }
                System.out.println(num);
        }

/**
         * 2、有一个Map集合里面存储的是学生的姓名和年龄，内容如下{赵四=21, 王二=17, 张三=18, 小丫=25, 李四=26, 王五=38}（14分）
                   a.将里面的元素用两种遍历方式打印到控制台上（4分）
                   b.将小丫的年龄改成18(2分)
                   c.将里面的元素存入到D:\\student.txt中（8分）
         * @throws IOException
         */
        public static void main(String[] args) throws IOException {
                HashMap<String, Integer> map = new HashMap<String, Integer>();
                map.put("赵四", 21);
                map.put("王二", 17);
                map.put("张三", 18);
                map.put("小丫", 25);
                map.put("李四", 26);
                map.put("王五", 38);
//                printMap1(map);
//                printMap2(map);
                storeMap(map);
//                map.put("小丫", 18);        这是修改值
        }


        /*
         * 存储的方法
         */
        private static void storeMap(HashMap<String, Integer> map) throws IOException {
                PrintStream ps = new PrintStream(new FileOutputStream(new File("D:\\Student.txt")),true);
                Set<Map.Entry<String, Integer>> set = map.entrySet();
                for (Map.Entry<String, Integer> entry : set) {
                        String key = entry.getKey();
                        ps.println(entry.toString());
                }
                ps.close();
        }


        /*
         * 遍历方式1
         */
        private static void printMap2(HashMap<String, Integer> map) {
                Set<Map.Entry<String, Integer>> set = map.entrySet();
                for (Map.Entry<String, Integer> entry : set) {
                        String key = entry.getKey();
                        int value = entry.getValue();
                        System.out.println(key + "=" + value);
                }
        }
       
        /*
         * 遍历方式2
         */
        private static void printMap1(HashMap<String, Integer> map) {
                Set<String> set = map.keySet();
                for (String string : set) {
                        int value = map.get(string);
                        System.out.println(string + "=" + value);
                }
        }

大神真多!!!!!!!!!

/*
* 实体类
*/
public class Bag implements Runnable{
        static int num = 100;
        @Override
        public void run() {
                while(num > 0){       
                        synchronized(this){
                                num--;
                                System.out.println(Thread.currentThread().getName() + "卖出第 " +  (100 - num)
                                                + "个包包\t还剩" + num + "包包");
                                try {
                                        Thread.sleep(100);
                                } catch (InterruptedException e) {
                                        e.printStackTrace();
                                }
                        }
                }
        }

}

/*
* 测试类
*/
public class Demo4 {

        /**
         *         3、有100个限量版的包包，但是只能通过实体店和官网才能进行购买，并且分别统计卖了多少。
         *         请用线程进行模拟并设置线程名称代表售出途径再将信息打印出来
         */
        public static void main(String[] args) {
                Bag b = new Bag();
                Thread t1 = new Thread(b);
                Thread t2 = new Thread(b);
                t1.setName("实体店");
                t2.setName("官网");
                t1.start();
                t2.start();
        }

}

/**
         * 1.计算指定路径下所有.txt文件包括子文件夹里的.txt文件的个数然后将所有的.txt文件复制到D盘下任意目录
         */
        public static void main(String[] args) throws IOException{
                File srcfile = new File("F:\\javase");
                File destfile = new File("F:\\新建文件夹");
                getTxt(srcfile, destfile);
        }
        public static void getTxt(File srcfile,File destfile) throws IOException{
                File[] files = srcfile.listFiles();
                for (File file : files) {
                        if(file.isFile()){
                                if(file.getName().endsWith(".txt")){
                                        copyTxt(file, new File(destfile,file.getName()));
                                }
                        }else{
                                getTxt(file, destfile);
                        }
                }
        }
        public static void copyTxt(File srcfile,File destfile) throws IOException{
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcfile));
                BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destfile));
                byte[] arr = new byte[1024 * 8];
                int len = 0;
                while((len = bis.read(arr)) != -1){
                        bos.write(arr, 0, len);
                }
                bis.close();
                bos.close();
        }

/**
         * 2.编写一个类，其中包含两个排序的方法sort（）,
         * 参数不同，当键盘录入的是一串整数，就按照从小到大的顺序输出，如果键盘录入的是一个字符串，就将字符串反序输出
         */
        public static void main(String[] args) {
                Scanner sc = new Scanner(System.in);
                String str = sc.nextLine();
                sort(str);
               

        }

        private static void sort(String s) {
                try {
                        int x = Integer.parseInt(s);
                        char[] arr = s.toCharArray();
                        int[] intarr = new int[arr.length];
                        String str = null;
                        for (int i = 0; i < arr.length; i++) {
                                intarr[i] = new Integer(str.valueOf(arr[i]));
                        }
                        //冒泡排序
//                        bubbleSort(intarr);
                        //选择排序
                        selete(intarr);
                        printArr(intarr);
                } catch (NumberFormatException e) {
                        char[] arr = s.toCharArray();
                        for (int i = 0; i < arr.length / 2; i++) {
                                char c = arr[i];
                                arr[i] = arr[arr.length - i - 1];
                                arr[arr.length - i - 1] = c;
                        }
                        System.out.println(new String(arr));
                }
               
        }
/*
* 选择排序法
*/
        private static void selete(int[] intarr) {
                for (int i = 0; i < intarr.length - 1; i++) {
                        for (int j = i + 1; j < intarr.length; j++) {
                                if(intarr[i] > intarr[j]){
                                        swap(intarr, i, j);
                                }
                        }
                }
        }
/*
* 遍历int数组
*/
        private static void printArr(int[] intarr) {
                for (int i = 0; i < intarr.length; i++) {
                        System.out.print(intarr[i] + " ");
                }
        }
/*
* 冒泡排序
*/
        private static void bubbleSort(int[] intarr) {
                for (int i = 0; i < intarr.length - 1; i++) {
                        for (int j = 0; j < intarr.length - 1 - i; j++) {
                                if(intarr[j] > intarr[j + 1]){
                                        swap(intarr, j, j + 1);                                       
                                }
                        }
                }
        }
/*
* 数组元素替换
*/
        private static void swap(int[] arr, int i, int j) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
        }

/**
         * 3.在treeset集合中  存入多个学生对象，学生有姓名和成绩两个属性，再存入集合时已经学生的成绩为依据判断
         */
        public static void main(String[] args) {
                TreeSet<Student> tree = new TreeSet<>();
                tree.add(new Student("张三", 13));
                tree.add(new Student("李四", 11));
                tree.add(new Student("王五", 3));
                tree.add(new Student("赵六", 3));
                System.out.println(tree);
        }

}
class Student implements Comparable<Student>{
        private String name;
        private int grade;
        public Student() {
                super();
               
        }
        public Student(String name, int age) {
                super();
                this.name = name;
                this.grade = age;
        }
        public String getName() {
                return name;
        }
        public void setName(String name) {
                this.name = name;
        }
        public int getAge() {
                return grade;
        }
        public void setAge(int age) {
                this.grade = age;
        }
        @Override
        public String toString() {
                return "Student [name=" + name + ", age=" + grade + "]";
        }
        @Override
        public int compareTo(Student o) {
                int num = this.grade - o.grade;
                return num == 0 ? this.name.compareTo(o.name) : num;
        }

好厉害

好腻害...

这贴好，收藏啦，等学完自己练一把