java基础测试

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());
    }
}

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);
        }
    }
}

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();
    }
}

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();
    }
}

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));
    }
}

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;
    }
}

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();
        }
    }
}

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;
    }
}

//学生类实现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("文件写入完成");
    }
}

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);
        }
    }

}

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);
    }
}

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();
    }
}

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();
        }
    }
}

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);
            
        }
    }

}

package cn.himi;
public class DemoClass {
public void run()
{
System.out.println("welcome to himi!");
} 
}

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();
        }
    }
}

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");
    }
}

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());
        }
        
    }
}

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));
    }
}

//定义交通灯枚举：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());
    }
}

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]+")");
                }
            }
        }
    }
}

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    
            }
        }
    }
}

/* 真实开发中，由于所有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();
        }
    }
}

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();
        } 
    }
}