【回帖不奖黑马币】今天面试给搞砸了，随便说说仅供参考

本帖最后由水竹于 2014-10-12 21:32 编辑

      如题，今天面试给搞砸了，彻底砸了，黑马没戏了。
      其实虽然好几天前就已经确定了面试的时间，也自以为做了充分的准备，但还是给搞砸了。原因什么的就不分析了，不具有普遍性，只是楼主自己的问题导致的，楼主从来就不擅长面试，曾经有好几个谁都以为可以轻松搞定的面试到了楼主这里就掉了链子，看来楼主确实是个不适合面试的人（莫深究）。
   不过虽然失利的原因没啥可讲的，流程倒是可以说一说，给各位尚未参加面试的同学权作参考。
      呃，前面忘了说，楼主就在北京，所以为了方便，选择的是亲自去黑马进行面对面的面试，所以对于选择参加视频面试的同学可能连参考意义都没有……
      言归正传，楼主约的是今天下午两点进行面试，不过为了不迟到，实际上我上午11点就到了附近，在周围逛了逛后，刚过了一点半就来到了约定的办公室，顺便提一句，那时候很多老师都已经在工作了，而且好多女老师。
      负责给我面试的老师当然也在（不提名字，提名字干什么），首先是发给了我一张试卷，上面有着四道题，让我答（申请面试的时候老师有提醒我带笔，不过我虽然在路上随便买了一支笔，但刚写了两个字就没油了，最后还是用的老师的笔，最最后还忘了还给老师，装在兜里带回家了，我在回家的路上发现了，跟老师发QQ说，要不您给我手机号我给您充10块话费吧，老师说没事不用的。）
      分享一下那四道题：（应该没规定不让说吧？我看到好多人都发了的，而且我面试时候也没有见过的啊，老师早都考虑到了吧）仅凭脑子记忆，可能有偏差，望理解。
      1.写一个延迟加载的单例设计模式。
      2.用缓冲的字符流复制一个文件。
      3.有一个ArrayList<Integer> list=new ArrayList<Integer>();将一个String类型的字符串放进集合中。
      4.创建一个带泛型的Map集合实例，然后添加一堆元素进去，最后遍历输出。
      不得不说一直敲代码突然换笔写确实让我有些不习惯，甚至有的时候为了确定一个单词写没写正确，还要用手照着键盘的样子比划一下才能确定，而且用笔写没有Backspace，写错了我就只能涂了，所以最后版面异常难看，字写得也异常难看，幸好英文字母一共就二十六个，看懂还是没问题的。
      在写题的过程中我也发现了自己的弱点，就是看到一道题有了思路之后不能马上转化成代码，还要想那么一想，这一想的话就拖慢了速度，在键盘上还不觉得，因为键盘上写错了能改，所以根本不在乎写不写错，而且写错了个字改了的同时也会感觉一直在操作着，并不能清晰地察觉出来到底是哪里拖慢了进度、拖慢了多少等等。但在纸上时却不一样，尤其是题目留空挡十分有限的纸上，就不敢随意的写了，手下一停顿立马能察觉到答题速度慢下来了。尤其是我答题的时候还在纠结“要不要写异常处理代码？这点地方根本写不下啊！还是干脆抛了的好”、“果然还是应该把左大括号放在方法名称后面好一点吧，省一点地方是一点”、“这个延迟加载要不要写成毕老师视频里的那种两次判断的”之类的，这样一来就更慢了。结果就是老师过了一会儿来问我答完了没有的时候，我才只答了两道题。
      扯多了，继续言归正传。老师催我之后我加快了答题的速度，第三题**没想出来，没读懂要考的知识点，只写了几句话后放弃了，加上第四题太简单，所以没等老师第二次催，我就交卷了。
      交卷之后算是开始进行第二环节吧。
      老师跟我一起看着试卷，然后随口问出考题里面涉及到的知识点，或涉及到的知识点所涉及到的知识点，让我口头回答。这一步感觉并没有刻意的在问什么，更像是看到哪里想到了什么就让我回答似的，当然问的问题都是基础视频以及高新里面的内容。不过我答的并不好，为了走流程其实我已经宅了好久了，平时也没这么大段大段的说过话（忽然发现，最近这段时间我在论坛打的字都比我说的话多得多），这一问答起来才发现自己竟然都有点变声了……而且语言表达能力也有待提高，明明是再清楚不过的东西，到了关键时候竟然不能有条理的表达出来，东一句西一句的不成系统，有些用词不准确，实在不知道老师听进去了多少……
      最后一个环节，就是自我介绍了，在经历了前面两个环节之后，准备了好久的自我介绍也被我说得乱七八糟的，而且没说几句就说完了，然后就没了，然后就没了，然后老师问我有什么问题，然后我问黑马的宿舍到底是怎么回事，是要自己租房子么，然后老师说是黑马官方对笔试通过的同学会安排宿舍的，住宿费大概在一个月400左右，然后我没再问什么问题，然后老师说先就这样吧，然后我就走了，然后在路上的时候手机收到一条推送消息，大概说面试已审批之类的，然后我打开数据连接上网看了一下，然后果然不出我所料的面试被搞砸了，然后我在网站后台看到老师的QQ，然后加了老师的QQ问我没做出来的那道题到底怎么答，然后老师回复我说其实就是反射，然后获取字节码，然后获得方法，然后用invoke，然后你自己看看，然后我自己一看，可不是嘛，原来是我面试的时候想多了。
      这次面试结束可能就意味着我与黑马彻底无缘了（无奈呦）。其实这段时间总是时不时的有点事（无奈呦），我这次流程其实还是第一次流程，从4月就开始申请了，中间就被其他事情耽搁了下来（无奈呦），最后一直拖了这么久还是没成功（无奈呦），不得不说有点遗憾（无奈呦）。
      不过有遗憾就有遗憾吧，人生哪里能没有遗憾呢（呃……），要怪只能怪自己努力的不够彻底，现在才说这些已经毫无意义，重要的是跌倒之后能否再次爬起，千万不要丧失追寻梦想的勇气。
      最后说一句，黑马，有缘再会！
      无缘的话……那、那就这么着吧……
      （如果有看完了我这段话的肯定会觉得好乱好乱吧，其实我面试的时候说的话比这个还要乱得多！）

——注：这帖子是我之前的帖子改的，下面是原帖——

   入学测试，十道题，三十分，限时三天完成，面试之前最后一道环节。

   不知道别人的题目怎么样，我的不算很难，基本上考的都是java基础部分：基本语法、面向对象、算法、IO操作，高新里面只考了两道题，一道枚举、一道反射。
   之前在论坛里见过别人有的在这项上面没有满分的，好多都是扣了零点几或者一点几分，所以我答的比较保守，也很小心，注释也写得很多，基本上一句代码就对应着一句注释，甚至花的时间是写代码的好几倍，所以可能可能看起来会比较臃肿。不过最后确实没扣分，让我很高兴。
   我从没发过主题贴，貌似发帖有字数限制？那分开发好了，一楼贴一道题，要是觉得看起来不方便或者想运行觉得麻烦的话，我把工程打包附件传上来，直接导入eclipse就行了。
   点击下载：

exam.zip (29.2 KB, 下载次数: 1521)
贴出代码旨在交流，大家有什么更好的或是不一样的方法，或者有任何想法和建议，都可以在下面跟帖回复，一起交流、学习、进步。

水竹 · 水竹

第二题：
package com.itheima;

/**2、定义一个交通灯枚举，包含红灯、绿灯、黄灯，需要有获得下一个灯的方法

* ，例如：红灯获取下一个灯是绿灯，绿灯获取下一个灯是黄灯。

*/

// 定义交通灯枚举：TrafficLights

enum TrafficLights {

RED {

/*

定义交通灯枚举的对象红灯，并通过匿名内部类的方式复写TrafficLights枚举

中的抽象方法getNextLight()，并按要求返回获得的下一个灯为绿灯。 */

@Override

public TrafficLights getNextLight() {

// TODO Auto-generated method stub

return GREEN;

}

},GREEN {

/*

定义交通灯枚举的对象绿灯，并通过匿名内部类的方式复写TrafficLights枚举

中的抽象方法getNextLight()，并按要求返回获得的下一个灯为黄灯。 */

public TrafficLights getNextLight() {

// TODO Auto-generated method stub

return YELLOW;

}

},YELLOW {

/*

定义交通灯枚举的对象黄灯，并通过匿名内部类的方式复写TrafficLights枚举

中的抽象方法getNextLight()，并按要求返回获得的下一个灯为红灯。 */

public TrafficLights getNextLight() {

// TODO Auto-generated method stub

return RED;

}

};

// 因为只有一个无参构造方法，所以可以省略

// 交通灯枚举中的抽象方法getNextLight()，作用为返回当前交通灯的下一个灯

public abstract TrafficLights getNextLight();

}

复制代码

水竹 · 水竹

第三题：
package com.itheima;

/**3、分析运行结果，说明原理。(没有分析结果不得分)

      import java.util.ArrayList;

      class Data {

         int val;

      }

      public class Test {

               public static void main(String args[]) {

                        Data data = new Data();

                        ArrayList<Data> list = new ArrayList<Data>();

               for (int i = 100; i < 103; i++) {

                        data.val = i;

                        list.add(data);

               }

                  for (Data d : list) {

                        System.out.println(d.val);

               }

         }

   }

   运行结果：程序将打印三行102；

   分析：首先，此程序创建了一个Data类的实例：data，又创建了一个存放Data类型数据的ArrayList；

      接着在第一个for循环中共循环了三次，这三次分别将不同的值赋给了data中的val成员变量，并将data存放到ArrayList中去；

      Data是类，也就是引用类型变量，所以实际上在ArrayList中存入的都是data这一个对象的引用，都指向data这一个对象；

      经过第一个for循环的操作，data中val字段的值已经变为了102，所以最后输出的是102；

      而之所以输出的是三个102，是因为ArrayList集合中允许存在相同元素，所以data的引用总共被存入了三次，也因此程序共输出了三个102。

   注：这道题我在黑马论坛见过，当时不知道这是考题，见到有另外一个人问，我还给他解答了下，附地址：

      http://bbs.itheima.com/forum.php?mod=viewthread&tid=146278&page=1#pid1009664

*/

复制代码

水竹 · 水竹

连续回帖貌似要审核，等等再发

水竹 · 水竹

第三题：
package com.itheima;

/**3、分析运行结果，说明原理。(没有分析结果不得分)

      import java.util.ArrayList;

      class Data {

         int val;

      }

      public class Test {

               public static void main(String args[]) {

                        Data data = new Data();

                        ArrayList<Data> list = new ArrayList<Data>();

               for (int i = 100; i < 103; i++) {

                        data.val = i;

                        list.add(data);

               }

                  for (Data d : list) {

                        System.out.println(d.val);

               }

         }

   }

   运行结果：程序将打印三行102；

   分析：首先，此程序创建了一个Data类的实例：data，又创建了一个存放Data类型数据的ArrayList；

      接着在第一个for循环中共循环了三次，这三次分别将不同的值赋给了data中的val成员变量，并将data存放到ArrayList中去；

      Data是类，也就是引用类型变量，所以实际上在ArrayList中存入的都是data这一个对象的引用，都指向data这一个对象；

      经过第一个for循环的操作，data中val字段的值已经变为了102，所以最后输出的是102；

      而之所以输出的是三个102，是因为ArrayList集合中允许存在相同元素，所以data的引用总共被存入了三次，也因此程序共输出了三个102。

   注：这道题我在黑马论坛见过，当时不知道这是考题，见到有另外一个人问，我还给他解答了下，附地址：

      http://bbs.itheima.com/forum.php?mod=viewthread&tid=146278&page=1#pid1009664

*/

复制代码

水竹 · 水竹

第三题死活发不上来，先发下一个。
第四题：

package com.itheima;
/**4、取出一个字符串中字母出现的次数。如：字符串："abcdekka27qoq" ，
* 输出格式为：a(2)b(1)k(2)...
*/
public class Test4 {
public static void main(String[] args) {
// TODO Auto-generated method stub
String s = "abcdekka27qoq"; // 定义一个字符串类型变量，存放欲统计的字符串
count(s);
}
public static void count(String s) {
char[] c = s.toCharArray(); // 将字符串转换为字符数组，以便操作
int[] count = new int[c.length]; // 创建一个int数组，长度等于字符串（字符数组）的长度，用于存放字符出现的次数
/* 循环统计字符出现的次数，将次数存入count数组
i代表char数组中正在统计的字符的角标，j代表被比较字符的角标 */
for(int i = 0; i<c.length;i++) {
if(!Character.isLetter(c[i])) // 如果当前字符不是字母，则跳过，其所对应的count为0
continue;
for(int j = 0; j<i; j++) { // 将当前字符和他前面每一个字符进行比较
if(c[i]==c[j]) { // 如果两个字符相等，则代表是重复元素，角标小的字符(前面的元素)对应的count中相同角标位置处数值加1，
count[j]++; // 角标大的元素对应count中数值设为-1，并进行下个字符的判断；
count[i]=-1;
continue;
}
}
count[i]++; // 如果当前字符与前面每一个字符都不同，则代表它是第一次出现，计数加1
}
// 进行循环输出
for(int i = 0; i<c.length;i++) {
if(count[i]==0) // 如果字符c[i]对应角标为0，则表示它不是字母或者不是第一次出现的字母，不做输出
continue;
System.out.print(c[i]+"("+count[i]+")"); // 按要求格式输出
}
}
}

复制代码

水竹 · 水竹

第五题：
package com.itheima;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.util.HashMap;

import java.util.Map;

/**5、统计一个文本文件中字符出现的次数，结果存入另外的一个文本文件中。例如：

*

* a：21 次

* b：15 次

* c：15 次

* 把：7 次

* 当：9 次

* 前：3 次

* ，：30 次

*/

public class Test5 {

public static void main(String[] args) {

// TODO Auto-generated method stub

File yuan = new File("res\\1.txt"); // 要统计的文本文件

File tongji = new File("res\\tongji.txt"); // 存放统计结果的文本文件

countChar(yuan,tongji); // 调用countChar方法，传入两个文件，统计字符

}

public static void countChar(File yuan,File tongji) {

// 因为操作的是文本文件，所以只用字符流就够了

FileReader fr = null; // 字符文件读取流，因为要逐个字节读取，所以不用缓冲

BufferedWriter fw = null; // 字符缓冲区写入流，提高效率

// 创建一个HashMap的对象hm，用于存放<字符，计数>的关系

HashMap<Character,Integer> hm = new HashMap<Character,Integer>();

char c = 0; // 创建两个临时变量，分别为char和int类型

int i = 0;

try { // 操作IO的方法有可能会引发IO异常，用try进行捕获

fr = new FileReader(yuan);

fw = new BufferedWriter(new FileWriter(tongji));

while((i=fr.read())!=-1) { // 当read方法返回值不为-1时，文件未到结尾，继续读取

c = (char) i; // 将int类型值强转为char类型值

// 如果hm中已经存在键为c的关系，获取对应的值加1后重新存入

if(hm.containsKey(c))

hm.put(c,hm.get(c)+1);

else

hm.put(c, 1); // 否则将键为该字符、值为1的关系存入

}

/* 对hm的Map.Entry中的关系进行遍历，将其中键和值按格式存放进文件中

注：由于'\r'和'\n'字符的特殊性，会在文本文件中无法显示，本来写入

文件时候可以做些处理，但考虑到并不确定此文件是否有被程序读取

的可能，所以保持原样输出，并未做进行处理。 */

for(Map.Entry<Character, Integer> entry : hm.entrySet()) {

fw.write(entry.getKey()+":"+entry.getValue()); // 按格式写入到文件中

fw.newLine(); // 写一句加一个行分隔符

}

}

catch (IOException e) {

// 若发生异常，则抛出RuntimeException，并设置message

throw new RuntimeException("操作失败");

}

finally {

try {

if(fr!=null)

fr.close(); // 关闭读取流

}

catch (IOException e) {

throw new RuntimeException("读取流关闭失败"); // 关闭失败抛出RuntimeException

}

try {

if(fw!=null)

fw.close(); // 关闭写入流

}

catch (IOException e) {

throw new RuntimeException("写入流关闭失败"); // 关闭失败抛出RuntimeException

}

}

}

}

复制代码

水竹 · 水竹

本帖最后由水竹于 2014-10-6 20:57 编辑

第六题：
package com.itheima;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

/**6、定义一个标准的JavaBean，名叫Person，包含属性name、age。

*                      使用反射的方式创建一个实例、调用构造函数初始化name、age，

*                      使用反射方式调用setName方法对名称进行设置，

*                      不使用setAge方法直接使用反射方式对age赋值。

*/

/* 由于JavaBean要求类名声明为public，所以和本题分开编写，

                     源码为本包下的Person.java文件             */

public class Test6 {

      public static void main(String[] args) {

            // TODO Auto-generated method stub

                     createPerson();             // 调用本类中的静态方法createPerson

      }

      private static void createPerson() {

            try {

                     // 向Class类的静态方法forName中传入Person类的完整名称，获得Person类的字节码文件对象

                     @SuppressWarnings("unchecked")

                     Class<Person> person = (Class<Person>) Class.forName("com.itheima.Person");

                     // 利用person的字节码文件对象得到该类包含字符串和整型参数的构造方法

                     Constructor<Person> construstor = (Constructor<Person>) person.getConstructor(String.class,int.class);

                     // 利用此构造方法初始化name和age属性

                     Person p1 = construstor.newInstance("person1",10);

                     System.out.println(p1);             // 打印p1，查看结果是否正确



                     // 利用Class类的成员方法getMethod获得题目要求的setName方法，此方法具有一个String类型的参数

                     Method setName = person.getMethod("setName", String.class);

                     // 调用p1对象上的该方法，并设置参数为字符串"王晓明"

                     setName.invoke(p1, "王晓明");

                     System.out.println(p1);       // 再次打印p1对象，查看结果

                     /* 使用Class中的成员方法getField，得到Person类的age字段；

                                    因为JavaBean中所有成员属性都是私有的，

                                    所以若使用Field的方法getField则会发生异常             */

                     Field age = person.getDeclaredField("age");

                     // 对于私有属性的访问，要先设置权限为true，否则会发生异常

                     age.setAccessible(true);

                     // 调用Field类中的成员方法set，对p1的age字段进行赋值

                     age.set(p1, 36);

                     // 打印p1，验证结果

                     System.out.println(p1);

            }

            // 以下均为异常处理代码

            catch (ClassNotFoundException e) {

                     // TODO Auto-generated catch block

                     throw new RuntimeException("未找到类文件");

            } catch (NoSuchMethodException e) {

                     // TODO Auto-generated catch block

                     throw new RuntimeException("参数类型错误");

            } catch (NoSuchFieldException e) {

                     // TODO Auto-generated catch block

                     throw new RuntimeException("字段不存在");

            } catch (InstantiationException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

            } catch (IllegalAccessException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

            } catch (IllegalArgumentException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

            } catch (InvocationTargetException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

            } catch (SecurityException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

            }

      }

}

复制代码

Person.java：package com.itheima;

import java.io.Serializable;

/* 真实开发中，由于所有JavaBean都要存放到同一个包中，所以为了能够从其他包访问，

就要将类修饰为公有的，而一个java文件中只能存在一个与文件名相同的公有类，

所以将Person类与Test6的代码分离，单独存放在一个文件中。 */

public class Person implements Serializable {

// Person实现Serializable接口，可以被序列化，设置其序列号为1L

private static final long serialVersionUID = 1L;

/*

   * JavaBean中所有属性都要被私有化，Person中按照题目要求定义了name属性以及 age属性，其中name为字符串类型，age为int类型

   */

private String name;

private int age;

// JavaBean中必须存在一个无参数的构造方法

public Person() {

// TODO Auto-generated constructor stub

this("", 0); // 调用两个参数的构造方法进行初始化

}

// 有name一个参数的构造方法

public Person(String name) {

this(name, 0); // 调用两个参数的构造方法进行初始化

}

// 有name和age两个参数的构造方法

public Person(String name, int age) {

this.setName(name); // 调用setName和()setAge()方法初始化name、age

this.setAge(age);

}

// JavaBean中所有属性都要有对应的set/get方法，可以利用eclipse自动生成

public String getName() { // getName()方法

return name;

}

public void setName(String name) { // setName()方法

this.name = name;

}

public int getAge() { // getAge()方法

return age;

}

public void setAge(int age) { // setAge()方法

this.age = age;

}

@Override

public String toString() { // 覆写Object类中的toString方法

return "Person [name=" + name + ", age=" + age + "]";

}

}

复制代码

水竹 · 水竹

第七题：
package com.itheima;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.ArrayList;

import java.util.Collections;

/**7、编写程序，循环接收用户从键盘输入多个字符串，直到输入“end”时循环结束，

* 并将所有已输入的字符串按字典顺序倒序打印。

*/

public class Test7 {

public static void main(String[] args) {

// TODO Auto-generated method stub

sort(); // 调用方法

}

public static void sort() {

BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // 创建读取流对象br，源为键盘

/* 考虑到用户可能输入重复字符串，所以建立ArrayList的对象al，

存储用户输入的字符串 */

ArrayList<String> al = new ArrayList<String>();

String s = null; // 定义字符串变量s，用于接收键盘输入

try { // 对可能发生的异常进行处理

while((s=br.readLine())!=null) { // 读取流获取一行输入，并赋值给字符串s，若不为空则继续循环

if("end".equals(s)) // 判断用户如果输入"end"，则结束输入跳出循环

break;

al.add(s); // 将获取到的字符串存入集合al中

}

} catch (IOException e) {

// TODO Auto-generated catch block

throw new RuntimeException("键盘操作读取失败"); // 若发生异常，抛出新的运行时异常RuntimeException，并设置message

}

finally {

try {

if(br!=null)

br.close(); // 关闭读取流资源

} catch (IOException e) {

// TODO Auto-generated catch block

throw new RuntimeException("读取流未正常关闭"); // 若读取流关闭异常，抛出新的运行时异常，并设置message

}

}

/*

对ArrayList的对象al进行排序，同时传入一个强行逆转元素自然顺序的比较器。

由于String实现了Comparable接口，其自然顺序即为字典顺序，所以强行逆转之后

的顺序即为字典顺序的倒序。 */

Collections.sort(al,Collections.reverseOrder());

// 遍历al集合进行打印

for(String s1:al) {

System.out.println(s1);

}

}

}

复制代码

水竹 · 水竹

第八题：

package com.itheima;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Comparator;
import java.util.TreeSet;
/**8、把以下IP存入一个txt文件，编写程序把这些IP按数值大小，从小到大排序并打印出来。
* 61.54.231.245
* 61.54.231.9
* 61.54.231.246
* 61.54.231.48
* 61.53.231.249
*/
public class Test8 {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
File res = new File("res\\2.txt"); // 欲操作的文件
show(res); // 调用方法，操作文件
}
public static void show(File res) {
BufferedReader br = null; // 声明一个读取流的引用，用于操作目标文件
String s = null; // 准备一个空字符串，用于存放读取流读到的数据
// 准备一个TreeSet集合tree，并用匿名内部类的方式传入一个自定义比较器，用于存放读取到的数据
TreeSet<String> tree = new TreeSet<String>(new Comparator<String>() {
// 实现Comparator中的抽象方法compare，自定义比较规则
public int compare(String s1,String s2) {
int i = 0; // 定义整形变量i，存储返回值
/* 将要进行比较的IP按照英文句号切割，切成四个String类型的整数
注：本来打算判断IP地址是否合法，所以为了方便用的切割后判断的方法，
不过发现题目只要求针对给定的IP进行操作，就没有判断了。如果不判断
IP地址的合法性，用毕老师视频中的正则表达式方法会更方便一些。 */
String[] sp1 = s1.split("\\.");
String[] sp2 = s2.split("\\.");
// 循环判断IP地址切成的四段
for(int x=0; x<4; x++) {
// 用两个整形变量将String类型整数强转后存储起来
int j = Integer.parseInt(sp1[x]);
int k = Integer.parseInt(sp2[x]);
// 如果两个整数不相等，则设置返回值为它们的差，并跳出循环
if(j!=k) {
i = j-k; // 这里不直接返回，是为了给方法只留一个出口，更规范一些
break;
}
}
return i; // 返回比较的结果
}
});
if (!res.exists()) // 如果文件不存在，则抛出新的运行时异常，并设置message
throw new RuntimeException("文件不存在");
try { // 用try捕获可能发生的异常
br = new BufferedReader(new FileReader(res)); // 关联流对象
while((s=br.readLine())!=null) // 如果存在下一行，则循环将读到的字符串添加到tree集合中
tree.add(s);
} catch (FileNotFoundException e) { // 如果发生FileNotFoundException异常，则抛出新的RuntimeException，并设置message
// TODO Auto-generated catch block
throw new RuntimeException("文件未找到");
} catch (IOException e) { // 如果发生其他异常，抛出新的RuntimeException异常，并设置message
// TODO Auto-generated catch block
throw new RuntimeException("读取流操作失败");
} finally { // finally语句块用来关闭用到的流资源
try {
if (br!=null) // 如果读取流不等于空，则进行关闭
br.close();
} catch (IOException e) {
// TODO Auto-generated catch block
throw new RuntimeException("读取流关闭失败"); // 如果关闭流资源时发生异常，则抛出新的RuntimeException，并设置message
}
}
// 遍历tree集合，按要求打印已经排好序的字符串
for(String s1 :tree)
System.out.println(s1);
}
}

复制代码

用到的2.txt文件：61.54.231.245

61.54.231.9

61.54.231.246

61.54.231.48

61.53.231.249

复制代码

水竹 · 水竹

第九题：
package com.itheima;

/**

* 9、在一个类中编写一个方法，这个方法搜索一个字符数组中是否存在某个字符，如果存在，

* 则返回这个字符在字符数组中第一次出现的位置（序号从0开始计算），否则，返回-1。

* 要搜索的字符数组和字符都以参数形式传递传递给该方法，如果传入的数组为null，

* 应抛出IllegalArgumentException异常。在类的main方法中以各种可能出现的情况测

* 试验证该方法编写得是否正确，例如，字符不存在，字符存在，传入的数组为null等。

*/

public class Test9 {

public static void main(String[] args) {

// TODO Auto-generated method stub

char[] ch = { 'a', 'b', 'c', 'd', 'e', 'c', 'a', 'q', '2', '9', '3' }; // 定义字符数组

int i = isContainChar(ch, 'c'); // 测试字符存在

int j = isContainChar(ch, 'C'); // 测试字符不存在

System.out.println("字符存在测试：" + i + "\n字符不存在测试：" + j); // 打印结果

isContainChar(null, 'c'); // 测试传入数组为null

}

public static int isContainChar(char[] ch, char c) {

if (ch == null) // 如果传入的字符数组为空，则按要求抛出参数不合法异常

throw new IllegalArgumentException("参数不合法");

int count = -1; // 设置一个变量记录字符位置

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

// 遍历数组，寻找字符

if (ch[i] == c) { // 如果找到了，则记录角标，并跳出循环；没找到则不会设置count，count依旧为-1

count = i;

break;

}

return count; // 按要求返回

}

}

复制代码

水竹 · 水竹

第十题：
package com.itheima;

/**10、有100个人围成一个圈，从1开始报数，报到14的这个人就要退出。然后其他人重新

* 开始，从1报数，到14退出。问：最后剩下的是100人中的第几个人？

*/

public class Test10 {

public static void main(String[] args) {

// TODO Auto-generated method stub

int all = 100; // 共有100个人

int number = 14; // 报到14则退出

int count = countGame(all,number); // 开始游戏，设置变量count接收返回的剩下人的编号

System.out.println("剩下的人是第"+count+"个。");

}

public static int countGame(int all,int number) {

int count = all-1; // 初始化人员编号，第一人编号为零，因为进入循环要先加一再判断，所以初始化为最后一人编号

boolean[] flag = new boolean[all]; // 创建boolean数组存储所有人的状态，用默认状态false表示未退出，ture表示已经退出

for(int i=0; i<all-1; i++){ // 外循环循环一次有一人退出，所以可得循环次数为all-1

for(int j=0; j<number; j++){ // j为每次报的数字

count++; // 检查下一个人，到达最后一人则循环

count%=all;

if(flag[count]) // 如果下一个人已经退出，则报数未成功，不算数

j--;

}

flag[count]=true; // 报到指定数字后内循环退出，则count为要退出人的编号，b[count]设为true表示此人已退出

}

for(int i=0;i<all;i++) { // 获取剩下人的编号

if(!flag[i]){ // 【注】：若将17行处for循环判断条件改为"i<all"，则26~31行代码可以删除，但是程序运行效率会降低

count=i;

break;

}

}

return count+1; // 返回，因为返回的“第几个人”是从1开始计数，所以要加1

}

}

复制代码

水竹 · 水竹

现在正在做板块活动上的那些题目，从第一期开始做的，也贴个：第一期：
/**

写一段代码，分别验证静态代码块、代码块、构造函数在：

1、初始化对象的时候的执行顺序

2、直接用类名调用该类的静态变量时的执行的顺序

*/

class Demo1

{

public static void main(String[] args)

{

A.b();

//new A(); //这两句话要分别进行测试，测试这一句的时候请将上面那句注释掉，因为static代码块只会在类加载的时候执行一次

}

}

class A

{

static

{

System.out.println("静态代码块执行");

}

{

System.out.println("构造代码块执行");

}

public A()

{

System.out.println("构造函数执行");

}

static void b()

{

System.out.println("A类的静态方法");

}

}
复制代码

水竹 · 水竹

第二期：
import java.util.*;

/*

通过编码分别测试ArrayList 和 LinkedList 添加、删除对象时的耗时情况

（精确到纳秒），并总结出以上两种集合的数据结构的不同之处。

不同之处：

1. 在内存里面，一个连续存放，一个不连续存放

2. LinkedList比ArrayList多存了个地址

*/

class Demo2

{

public static void main(String[] args) throws Exception

{

int count = 100000;

long[] l0 = countTime(new ArrayList<Demo2>(),new Demo2(),count);

long[] l1 = countTime(new LinkedList<Demo2>(),new Demo2(),count);

System.out.println("ArrayList添加和删除"+count+"个Demo2对象。\t添加"+l0[0]+"纳秒\t删除"+l0[1]+"纳秒");

System.out.println("LinkedList添加和删除"+count+"个Demo2对象。\t添加"+l1[0]+"纳秒\t删除"+l1[1]+"纳秒");

}

// list:欲操作的集合；t:要存入类型的一个实例；count:存入的对象个数

public static <T>long[] countTime(List<T> list,T t,int count) throws Exception

{

long startTime = getTime();

for (int x=0; x<count; x++)

{

list.add((T)t.getClass().newInstance()); // 这里有个警告，未经检测的类型转换，看下高新的泛型再处理

}

long midTime = getTime();

for (int x=0; x<count; x++)

{

list.remove(0);

}

return new long[]{midTime - startTime,getTime() - midTime};

}

public static long getTime()

{

return System.nanoTime();

}

}
复制代码

clevergump · clevergump

感谢分享！

管晓博 · 管晓博

:handshake,谢谢分享！自己完了做做

dhgcy · dhgcy

恭喜恭喜，谢谢分享。

九零零 · 九零零

感谢楼主分享，已收藏

水竹 · 水竹

第三期：
/*

打印如下图案：要求，通过输入不同的参数

（比如1、2、3、4...N）该图案可以90°*N的倍数

进行顺时针旋转。不需要图形化界面，在控制台中

输出即可。注意：图中的“I”为占位符，真实的图形

不应该有此符号。

   *

***

   *****

   *******

I*********

***********

I*********

   *******

   *****

***

   *

注：这题不大明白，这图形根本不可能转90°啊，因为行间距本来就很大

怎么可能变得那么紧凑呢？难不成要按照等比例放大？

试着做了一下，不知道符不符合题目标准，困惑……

   */

class Demo3

{

public static void main(String[] args)

{

int n = 9;

show(n);

}

public static void show(int n)

{

String s1 = " ";

String s2 = "*";

if(n%2==1)

{

s1=" ";

s2="* ";

}

for (int x=0; x<12; x++)

{

for (int y=0; y<Math.abs(x-6); y++)

{

System.out.print(s1);

}

for (int y=0; y<2*(6-Math.abs(x-6))-1; y++)

{

System.out.print(s2);

}

System.out.println();

}

}

}

复制代码

MR.Sun · MR.Sun

好吧目前我还没有到做入学测试题的地步。。。看看吧。。

帐号		自动登录	找回密码
密码			加入黑马

【回帖不奖黑马币】今天面试给搞砸了，随便说说仅供参考

158 个回复

回帖奖励 +1

回帖奖励 +1

回帖奖励 +1

回帖奖励 +1