首页 > 代码库 > java基础测试
java基础测试
测试一：
第1题：Collection和Collections有什么关系？List和Set有什么异同点？Map有哪些常用类，各有什么特点？
答：Collection是集合操作的接口，Set和List都继承自它；Collections是一个集合工具类，其中方法sort()可以对实现了Comparable
接口的类进行排序。addAll()方法为集合添加内容，binarySearch()方法用于集合检索，reverse()将集合内容翻转等。两者关系:
Collections提供了操作Collection集合内容的方法。
List和Set相同点：都继承自Collection，都是存放单值的集合，都只能存放对象类型的数据,都可以迭代输出；不同点：List集合中允许有
重复的元素，数据是有序排列的；Set集合中不允许有重复的元素，有有序的子类TreeSet，无序的子类HashSet。
Map常用类有HashMap、TreeMap、HashTable。HaspMap是异步的，性能较高，线程不安全；HashTable是同步的，性能较低，线程安全。
TreeMap是可以按照key值排序的。
第2题：为什么需要配置path，什么时候需要classpath?
答：path指定运行路径，搜索可执行文件，如果没配置，在windows cmd中输入java和javac，就会提示找不到命令。
classpath指定一个路径，用于搜索java编译或者运行时需要用到的类，否则提示找不到类。
第3题：从键盘接受一个数字，列出该数字的中文表示格式，例如：键盘输入123，打印出一二三；键盘输入3103，打印出三一零三。
public class Test3 { private static String[] chineses; public static void main(String[] args) { // 初始化String 数组存放中文数字 chineses = new String[] { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九", "十" }; boolean flag = true; System.out.println("请输入数字:"); // 从键盘输入 Scanner scan = new Scanner(System.in); String line = scan.nextLine(); // 循环检测用户输入 while (flag) { if (!line.matches("^\\d+?")) { System.out.println("输入数据格式不正确，请重新输入"); // 读取下一行 line = scan.nextLine(); } else { // 停止循环 flag = false; } } // 调用静态方法 print(line); } /** * 根据传入的阿拉伯数字转化为中文数字 * @param str */ public static void print(String str) { //讲字符串转化为字符数组 char[] chars = str.toCharArray(); //定义一个可变字符串 StringBuffer sb = new StringBuffer(); //遍历字符数组 for (char c : chars) { //将数字字符转化为整型数字 Integer num = Integer.parseInt(c+""); //添加到字符串中 sb.append(chineses[num]); } System.out.println(sb.toString()); }}
第4题：求斐波那契数列第n项，n<30，斐波那契数列前10项为 1,1,2,3,5,8,13,21,34,55
public class Test4 { public static void main(String[] args) { System.out.println("请输入正整数n,n<30"); // 从键盘输入 Scanner scan = new Scanner(System.in); boolean flag = true; String numStr = null; int num = 0; // 循环检测用户输入 while (flag) { // 判断用户输入是否为整型 if (scan.hasNextInt()) { //用户输入了整型 num = scan.nextInt(); if (num >= 30) { System.out.println("请输入小于30的数字"); //用户仍有可能输入一个非数字 numStr = scan.nextLine(); } else { //终止循环 flag = false; } } else { //用户没有输入整型 System.out.println("输入数据格式不正确，请重新输入!"); numStr = scan.nextLine(); } } System.out.println("斐波那契数列第" + num + "项为：" + fibonacci(num)); } /** * 递归调用fibonacci() * @param * @return */ public static int fibonacci(int n) { if (n == 1 || n == 0) { return n; } else { //当n>=2是每一项都等于前面两项的和 return fibonacci(n - 1) + fibonacci(n - 2); } }}
第5题：编程列出一个字符串的全字符组合情况，原始字符串中没有重复字符，例如：
原始字符串是"abc"，打印得到下列所有组合情况：
"a" "b" "c"
"ab" "bc" "ca" "ba" "cb" "ac"
"abc" "acb" "bac" "bca" "cab" "cba"
public class Test5 { static char[] chars="abc".toCharArray(); public static void main(String[] args) { for(int i=0;i<chars.length;i++){ //取得每一个字符 List<Integer> list=new ArrayList<Integer>(); list.add(i); recur(list); } } //使用递归，每次加上列表中不存在的一个字符 private static void recur(List<Integer> list){ print(list); for(int i=0;i<chars.length;i++){ if(!list.contains(i)){ //根据已有的集合构造新的集合 List<Integer> temp=new ArrayList<Integer>(list); temp.add(i); recur(temp); } } } //打印列表内容 private static void print(List<Integer> list){ for(Integer i:list) System.out.print(chars[i]+""); System.out.println(); }}
6、 分析运行结果，说明原理。
class A { void fun1() { System.out.println(fun2()); } int fun2() { return 123; }}public class Test6 extends A { int fun2() { return 456; } public static void main(String args[]) { Test6 b = new Test6(); b.fun1(); A a = b; System.out.println(a instanceof Test6); a.fun1(); }}
答：由于子类B没有覆写父类A的fun1()方法，因此b.fun1()，是调用由父类继承而来的fun1(),在fun1()中调用了fun2()时候由于fun2()
已经被子类覆写，因此调用的是子类的fun2();所以打印第一条结果为456；
A a = b;子类向上转型为父类实例化，a instanceof B 结果为true，此时当前对象为子类的对象，所以在fun1()中调用fun2()是为子类
的fun2()，因此打印第二条结果为456。
第7题： 编写一个可以获取文件扩展名的函数，形参接收一个文件名字符串，返回一个扩展名字符串。
public class Test7 { public static void main(String[] args) { System.out.println("请输入一个包含拓展名的文件名字符串："); Scanner scan = new Scanner(System.in); String str = scan.nextLine(); //从后往前查找.第一次出现的为之 int dot = str.lastIndexOf("."); //从.出现的位置后面 System.out.println("扩展名为："+str.substring(dot+1)); }}
第8题： 编写一个延迟加载的单例设计模式。
public class Test8 { private static Test8 instance ; //讲构造方法私有 private Test8() { } //通过静态方法返回instance对象 public static Test8 getInstance(){ if(instance == null){ //加入同步操作，线程安全 synchronized (Test8.class) { if(instance == null){ //实例化单例对象 instance = new Test8(); } } } return instance; }}
第9题：编写程序，将指定目录下所有.java文件拷贝到另一个目录中，并将扩展名改为.txt
public class Test9 { private static File directory; public static void main(String[] args) { File src = new File("C:\\src"); directory = new File("c:\\directory"); //目录不存在则创建 if(!directory.exists()){ directory.mkdir(); } list(src); System.out.println("文件已拷贝至c:\\directory目录中"); } /** * 递归调用函数 * @param file */ public static void list(File f) { if (f.isDirectory()) { //获得此目录下所有文件名（含绝对路径） File[] files = f.listFiles(); //遍历子文件及目录 if(files!=null){ for (File file : files) { list(file); } } } else { //是文件就直接拷贝，相同文件名拷贝至同一目录会被覆盖 copyFile(f); } } public static void copyFile(File file) { String newName = null; try { //获得文件的原始名字 String name = file.getName(); //只处理java文件 if (name.contains(".java")) { //将.java后缀改成.txt后缀 newName = name.replace(".java", ".txt"); //文件输出流 FileOutputStream fos = new FileOutputStream(new File(directory,newName)); //文件输入流 FileInputStream fis = new FileInputStream(file); int len = 0; //定义数组存储读取到的数据 byte[] b = new byte[1024]; //循环读入源文件 while ((len = fis.read(b)) != -1) { //边读边写 fos.write(b, 0, len); } //关闭输入输出流 fis.close(); fos.close(); } } catch (Exception e) { e.printStackTrace(); } }}
10、 小明的妈妈每天会给他20元零花钱。平日里，小明先花掉一半，再把一半存起来。 每到周日，小明拿到钱后会把所有零花钱花掉一半。 请编程计算，从周一开始，小明需要多少天才能存够100元？
public class Test10 { public static void main(String[] args) { System.out.println("需要"+save()+"天"); } public static int save() { int day = 0, money = 0; //money>=100停止循环 while (money < 100) { //增加天数 day++; //判断是否到达周末 if (day % 7 == 0) { money += 20; money -= money / 2; } else {//平时得20花10相当于得10元 money += 10; } } return day; }}
测试二：
第1题：有五个学生，每个学生有3门课（语文、数学、英语）的成绩，写一个程序接收从键盘输入学生的信息，输入格式为：name,30,30,30（姓名，三门课成绩），然后把输入的学生信息按总分从高到低的顺序写入到一个名称"stu.txt"文件中。 要求：stu.txt文件的格式要比较直观，打开这个文件，就可以很清楚的看到学生的信息。
//学生类实现Comparable接口class Student implements Comparable<Student>{ private String name; private int chinese; private int math; private int english; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getChinese() { return chinese; } public void setChinese(int chinese) { this.chinese = chinese; } public int getMath() { return math; } public void setMath(int math) { this.math = math; } public int getEnglish() { return english; } public void setEnglish(int english) { this.english = english; } @Override public String toString() { return "Student [name=" + name + ", chinese=" + chinese + ", math=" + math + ", english=" + english + "]"; } /** * 计算总分 * @return */ public int getSum(){ return this.chinese+this.english+this.math; } /** * 按照总分比较 */ @Override public int compareTo(Student o) { return o.getSum()-this.getSum(); }}public class Test1 { public static void main(String[] args) { System.out.println("请输入5个学生信息，输入格式为name,30,30,30"); Scanner scan = new Scanner(System.in); List<Student> list = new ArrayList<Student>(); //循环录入学生信息 for(int i=0;i<5;i++){ String line = scan.nextLine(); //按照“，”将字符串拆分成字符串数组 String[] split = line.split(","); //实例化学生类并赋值 Student stu = new Student(); stu.setName(split[0]); stu.setChinese(Integer.parseInt(split[1])); stu.setMath(Integer.parseInt(split[2])); stu.setEnglish(Integer.parseInt(split[3])); //将学生信息加入集合中 list.add(stu); } //使用Collections工具类对集合中的对象排序 Collections.sort(list); //实例化文件对象 File file = new File("c:\\student.txt"); try { //定义文件输出流 FileOutputStream fos = new FileOutputStream(file); //打印标题 fos.write("姓名\t语文\t数学\t英语\r\n".getBytes()); //循环打印学生信息 for (Student stu : list) { String info = stu.getName()+"\t"+stu.getChinese()+"\t"+stu.getMath()+"\t"+stu.getEnglish()+"\r\n"; fos.write(info.getBytes()); } //关闭输出流 fos.close(); } catch (Exception e) { e.printStackTrace(); } System.out.println("文件写入完成"); }}
第2题：分析运行结果，说明原理。
class Data { int val;}public class Test2 { 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); } }}
答：data对象在循环外部实例化分配了堆内存空间，并用data引用指向了这块内存空间，循环中每次修改都是同一个对象的数据，因此data对象val属性
在三次循环后从100修改成了102，因此打印三个102。
3、 假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。 请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。
class Employee{ private int id; private String name; private float salary; public Employee(int id, String name, float salary) { this.id = id; this.name = name; this.salary = salary; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public float getSalary() { return salary; } public void setSalary(float salary) { this.salary = salary; } @Override public String toString() { return "Employee [id=" + id + ", name=" + name + ", salary=" + salary + "]"; }}class Manager extends Employee{ //增加一个奖金属性 private float bonus; public Manager(int id, String name, float salary, float bonus) { //调用父类的构造方法 super(id, name, salary); this.bonus = bonus; } public float getBonus() { return bonus; } public void setBonus(float bonus) { this.bonus = bonus; } }public class Test3 { public static void main(String[] args) { //调用构造方法 Manager m = new Manager(1,"zqt",10000.0f,10000.0f); System.out.println(m); }}
第4题：方法中的内部类能不能访问方法中的局部变量，为什么？
答：必须加上final关键字才能访问，由于内部类的生命周期比局部变量的生命周期要长，当局部变量被系统回收时，内部类就无法访问局部变量。而声明 成final后内部类会得到一份拷贝，即使局部变量消亡，内部类仍能获得这个不变的值。
class Outer{ void out(){ final int a = 5; class Inner{ void in(){ System.out.println(a); } } new Inner().in(); }}public class Test4 { public static void main(String[] args) { new Outer().out(); }}
第5题： 已知文件a.txt文件中的内容为“bcdeadferwplkou”，请编写程序读取该文件内容，并按照自然顺序排序后输出到b.txt文件中。 即b.txt中的文件内容应为“abcd…………..”这样的顺序。
public class Test5 { public static void main(String[] args) { //定义输入，输出文件 File file = new File("c:\\a.txt"); File file2 = new File("c:\\b.txt"); try { //内存操作流 ByteArrayOutputStream baos = new ByteArrayOutputStream(); //文件输入，输出流 FileInputStream fis = new FileInputStream(file); FileOutputStream fos = new FileOutputStream(file2); int len = 0; //byte数组临时存储数据 byte[] b = new byte[1024]; //循环读取数据 while((len=fis.read(b))!=-1){ //写入到内存 baos.write(b,0,len); } String str = baos.toString(); //关闭流 baos.close(); //将字符串转化为字符数组 char[] ch = str.toCharArray(); //调用工具类进行排序 Arrays.sort(ch); //遍历每个字符 for (char c : ch) { //写入文件 fos.write(c); } //关闭流 fos.close(); System.out.println("操作完成！"); } catch (Exception e) { e.printStackTrace(); } }}
第6题：编写程序，循环接收用户从键盘输入多个字符串，直到输入“end”时循环结束，并将所有已输入的字符串按字典顺序倒序打印。
public class Test6 { public static void main(String[] args) { System.out.println("请输入多个字符串，用回车分隔，输入end结束！"); //从键盘读入 Scanner scan = new Scanner(System.in); List<String> list = new ArrayList<String>(); String line = scan.nextLine(); //当输入"end"时结束循环 while(!"end".equals(line)){ //将输入的字符串加入到集合中 list.add(line); line = scan.nextLine(); } //使用工具类对字符串按字典顺序排序 Collections.sort(list); //将字符串序列反转 Collections.reverse(list); for (String string : list) { System.out.println(string); } }}
第7题：已知一个类，定义如下：
package cn.himi;public class DemoClass {public void run(){System.out.println("welcome to himi!");} }
(1) 写一个Properties格式的配置文件，配置类的完整名称。
(2) 写一个程序，读取这个Properties配置文件，获得类的完整名称并加载这个类，用反射 的方式运行run方法。
public class Test7 { public static void main(String[] args) { //定义一个属性配置文件 Properties p = new Properties(); //添加属性 p.setProperty("className","cn.himi.DemoClass"); File file = new File("c:\\himi.properties"); try{ FileOutputStream fos = new FileOutputStream(file); p.store(fos, null); FileInputStream fis = new FileInputStream(file); //读取属性文件 p.load(fis); //根据键得到值 String className = p.getProperty("className"); //实例化Class 对象 Class<?> clazz = Class.forName(className); //获得方法 Method method = clazz.getMethod("run", null); //调用方法 method.invoke(clazz.newInstance(), null); } catch (Exception e) { e.printStackTrace(); } }}
第8题：分析以下程序运行结果，说明原理。
class MyThread extends Thread { public void run() { try { Thread.sleep(3000); } catch (InterruptedException e) { } System.out.println("B"); }}public class Test8 { public static void main(String args[]) { MyThread t = new MyThread(); t.run(); t.start(); System.out.println("A"); }}
答：运行结果为BAB。当实例化MyThread类后，调用run(),此时并没有开启子线程，开启线程必须调用start()方法。进入run()方法后主线程睡眠3秒后打印B，之后调用了start()方法开启了子线程，由于子线程进入run()方法后需要睡眠3秒，而主线直接往下运行，所以打印A, 3秒后子线程再打印B。
第9题：编写一个程序，它先将键盘上输入的一个字符串转换成十进制整数，然后打印出这个十进制整数对应的二进制形式。
这个程序要考虑输入的字符串不能转换成一个十进制整数的情况，并对转换失败的原因要区分出是数字太大，还是其中包含有非数字字符的情况。
提示：十进制数转二进制数的方式是用这个数除以2，余数就是二进制数的最低位，接着再用得到的商作为被除数去除以2，这次得到的余数就是次低位，如此循环，
直到被除数为0为止。其实，只要明白了打印出一个十进制数的每一位的方式（不断除以10，得到的余数就分别是个位，十位，百位），就很容易理解十进制数转
二进制数的这种方式。
public class Test9 { public static void main(String[] args) { System.out.println("请输入十进制整数"); boolean flag = true; Scanner scan = new Scanner(System.in); //循环检测用户输入 while (flag) { //获得用户输入数据 String line = scan.nextLine(); //用户输入为数字 if (line.matches("^\\d+$")) { long num = Long.parseLong(line); //数字超过整型最大值 if (num > Integer.MAX_VALUE) { System.out.println("数字太大，请重新输入!"); } else { decToBin((int) num); //停止循环 flag = false; } } else { System.out.println("请输入数字："); } } } private static void decToBin(int num) { if(num == 0){ System.out.println("二进制为：" + num); }else{ //定义可变字符串 StringBuffer sb = new StringBuffer(); //循环取余 while (num != 0) { int temp = num % 2; num = num / 2; //将取余的结果追加到末尾 sb.append(temp); } //将字符串反转 sb.reverse(); System.out.println("二进制为：" + sb.toString()); } }}
10、 有100个人围成一个圈，从1开始报数，报到14的这个人就要退出。然后其他人重新开始，从1报数，到14退出。问：最后剩下的是100人中的第几个人？
public class Test10 { public static void main(String[] args) { List<Integer> list = new ArrayList<Integer>(); // 将100个人编号添加到集合 for (int i = 1; i <= 100; i++) { list.add(i); } // 存放退出的人的集合 List<Integer> kill = new ArrayList<Integer>(); int count = 0; //当集合中只有一个人时退出循环 while (list.size() > 1) { for (int i = 0; i< list.size(); i++) { // 进入循环一次，计数器+1 count++; // 如果报到的数是14的倍数则将其加入到退出的人的集合 if (count % 14 == 0) { kill.add(list.get(i)); } } // 删除掉退出的人的集合，剩下的就是没退出的人 list.removeAll(kill); } System.out.println("剩下的人的序号是："+list.get(0)); }}
测试三：
1、 定义一个交通灯枚举，包含红灯、绿灯、黄灯，需要有获得下一个灯的方法，例如：红灯获取下一个灯是绿灯，绿灯获取下一个灯是黄灯。
//定义交通灯枚举：TrafficLightsenum TrafficLights { RED { /* 定义交通灯枚举的对象红灯，并通过匿名内部类的方式复写TrafficLights枚举 中的抽象方法getNextLight()*/ @Override public TrafficLights getNextLight() { // TODO Auto-generated method stub return GREEN; } },GREEN { public TrafficLights getNextLight() { // TODO Auto-generated method stub return YELLOW; } },YELLOW { public TrafficLights getNextLight() { // TODO Auto-generated method stub return RED; } }; // 交通灯枚举中的抽象方法getNextLight()，作用为返回当前交通灯的下一个灯 public abstract TrafficLights getNextLight();}public class Traffic{ public static void main(String[] args) { TrafficLights green = TrafficLights.GREEN; System.out.println(green.getNextLight()); }}
2、 取出一个字符串中字母出现的次数。如：字符串："abcdekka27qoq" ，输出格式为：a(2)b(1)k(2)...
public class OtherTest4 { public static void main(String[] args) { String str = "abcdekka27qoqAAABBBDD"; char[] chars = str.toCharArray(); //存储26个小写字母和26个大写字母 int[] count = new int[52]; for (char c : chars) { //小写字母 if(c>=97&&c<=122){ count[c-97]++; }else if(c>=65&&c<=90){ // 大写字母 count[c-65+26]++; } } for (int i = 0; i < count.length; i++) { if(count[i]>0){ if(i<26){ //如果大小写字母分开存就要简单点 System.out.print((char)(97+i)+"("+count[i]+")"); }else if(i<52){ System.out.print((char)(65+i-26)+"("+count[i]+")"); } } } }}
3、 统计一个文本文件中字符出现的次数，结果存入另外的一个文本文件中。例如：
a：21 次
b：15 次
c：15 次
把：7 次
当：9 次
前：3 次
，：30 次
public class Test3 { 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 } } }}
4、 定义一个标准的JavaBean，名叫Person，包含属性name、age。 使用反射的方式创建一个实例、调用构造函数初始化name、age， 使用反射方式调用setName方法对名称进行设置， 不使用setAge方法直接使用反射方式对age赋值。
/* 真实开发中，由于所有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 + "]"; }}
public class OtherTest6 { public static void main(String[] args) { try { // 向Class类的静态方法forName中传入Person类的完整名称，获得Person类的字节码文件对象 @SuppressWarnings("unchecked") Class<Person> clazz = (Class<Person>) Class .forName("cn.cherryhimi.Person"); // 利用person的字节码文件对象得到该类包含字符串和整型参数的构造方法 Constructor<Person> construstor = (Constructor<Person>) clazz .getConstructor(String.class, int.class); // 利用此构造方法初始化name和age属性 Person p1 = construstor.newInstance("person1", 10); System.out.println(p1); // 打印p1，查看结果是否正确 // 利用Class类的成员方法getMethod获得题目要求的setName方法，此方法具有一个String类型的参数 Method method = clazz.getMethod("setName", String.class); method.invoke(p1, "cherryhimi"); System.out.println(p1); // 再次打印p1对象，查看结果 /* * 使用Class中的成员方法getField，得到Person类的age字段； 因为JavaBean中所有成员属性都是私有的， * 所以若使用Field的方法getField则会发生异常 */ Field age = clazz.getDeclaredField("age"); // 对于私有属性的访问，要先设置权限为true，否则会发生异常 age.setAccessible(true); // 调用Field类中的成员方法set，对p1的age字段进行赋值 age.set(p1, 36); // 打印p1，验证结果 System.out.println(p1); } catch (Exception e) { e.printStackTrace(); } }}
5、 把以下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 Test5 { public static void main(String[] args) { File file = new File("c:\\str.txt"); TreeSet<String> set = new TreeSet<String>(new Comparator<String>() { public int compare(String str1, String str2) { String[] split1 = str1.split("\\."); String[] split2 = str2.split("\\."); int sum1 = 0; int sum2 = 0; for(int i=0;i<4;i++){ sum1 += Integer.parseInt(split1[i]); sum2 += Integer.parseInt(split2[i]); } return sum1-sum2; }; }); try { BufferedReader br = new BufferedReader(new FileReader(file)); String line; while((line=br.readLine())!=null){ set.add(line); } for (String string : set) { System.out.println(string); } } catch (Exception e) { e.printStackTrace(); } }}
java基础测试
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。