码迷,mamicode.com
首页 > 编程语言 > 详细

java基础测试

时间:2014-11-07 16:44:47      阅读:444      评论:0      收藏:0      [点我收藏+]

标签:style   blog   io   color   ar   os   使用   java   sp   

测试一:

第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、 定义一个交通灯枚举,包含红灯、绿灯、黄灯,需要有获得下一个灯的方法,例如:红灯获取下一个灯是绿灯,绿灯获取下一个灯是黄灯。

//定义交通灯枚举:TrafficLights
enum 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基础测试

标签:style   blog   io   color   ar   os   使用   java   sp   

原文地址:http://www.cnblogs.com/cherryhimi/p/4081524.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!