10道Java入学测试题目

桃扇骨 2022-12-05 10:27 172阅读 0赞

### 文章目录 ###

*   *  1、写一个ArrayList类的代理，实现和ArrayList中完全相同的功能，并可以计算每个方法运行的时间。
     *  2、编写一个类，在main方法中定义一个Map对象（采用泛型），加入若干个对象， 然后遍历并打印出各元素的key和value。
     *  3、有五个学生，每个学生有3门课（语文、数学、英语）的成绩，写一个程序接收从键盘输入学生的信息，输入格式为：name,30,30,30（姓名，三门课成绩），然后把输入的学生信息按总分从高到低的顺序写入到一个名称"stu.txt"文件中。要求：stu.txt文件的格式要比较直观，打开这个文件，就可以很清楚的看到学生的信息。
     *  4、取出一个字符串中字母出现的次数。如：字符串："abcdekka27qoq" ， 输出格式为：a(2)b(1)k(2)...
     *  5、将字符串中进行反转。abcde ——> edcba
     *  6、已知一个类，定义如下：
     *  7、有一个类为ClassA,有一个类为ClassB，在ClassB中有一个方法b，此方法抛出异常，在ClassA类中有一个方法a，请在这个方法中调用b,然后抛出异常。 在客户端有一个类为TestC,有一个方法为c,请在这个方法中捕捉异常的信息。 完成这个例子，请说出java中针对异常的处理机制。
     *  8、存在一个JavaBean，它包含以下几种可能的属性：
     *  9、使用TCP协议写一个可以上传文件的服务器和客户端。
     *  10、金额转换，阿拉伯数字转换成中国传统形式。

## 1、写一个ArrayList类的代理，实现和ArrayList中完全相同的功能，并可以计算每个方法运行的时间。 ##

package com.itheima;
    public class Test1 { 
        /** 1、 写一个ArrayList类的代理，实现和ArrayList中完全相同的功能，并可以计算每个方法运行的时间。 * * @param args * */
        public static void main(String[] args) { 
            @SuppressWarnings("unchecked")
            List<String> arrayListProxy = (List<String>) Proxy.newProxyInstance(
            /* 定义代理类的加载器，用于创建类的对象 */
            ArrayList.class.getClassLoader(),
            /* 代理类要实现的接口列表 */
            ArrayList.class.getInterfaces(),
            /* 指派方法调用的处理程序，匿名内部类 */
            new InvocationHandler() { 
                // 目标对象
                private ArrayList<String> taret = new ArrayList<String>();
    
                @Override
                public Object invoke(Object proxy, Method method, Object[] args)
                        throws Throwable { 
                    // 开始时间
                    long startTime = System.currentTimeMillis();
                    TimeUnit.MICROSECONDS.sleep(1);
                    // 实际调用的方法，并接受方法的返回值
                    Object obj = method.invoke(taret, args);
                    // 结束时间
                    long endTime = System.currentTimeMillis();
                    System.out.println("[" + method.getName()+ "]需要的时间"
                            + (endTime — startTime) + "毫秒");
                    // 返回实际调用的方法的返回值
                    return obj;
                }
            });
            arrayListProxy.add("abc");
            arrayListProxy.add("abcdf");
            arrayListProxy.add("abcdefg");
            System.out.println("..........................");
            for (String i : arrayListProxy) { 
                System.out.println("i=" + i);
            }       
        }
    }

## 2、编写一个类，在main方法中定义一个Map对象（采用泛型），加入若干个对象， 然后遍历并打印出各元素的key和value。 ##

package com.itheima;
    public class Test2 { 
        /** 2、 编写一个类，在main方法中定义一个Map对象（采用泛型），加入若干个对象， 然后遍历并打印出各元素的key和value。 * * @param args */
        public static void main(String[] args) { 
            
            Map<String,Integer> map = new HashMap<String,Integer>();
            map.put("小赵", 12);
            map.put("小钱", 21);
            map.put("小孙", 25);
            map.put("小李", 9);
            //先获取map集合的所有键的Set集合，keyset();
            Set<String> set = map.keySet();
            //迭代
            Iterator<String> it = set.iterator();
            while(it.hasNext()){ 
                String key = it.next();
                //有了键通过map集合的get方法获取其对应的值
                Integer value = map.get(key);
                System.out.println("key="+key+" "+"value="+value);
            }
        }
    }

## 3、有五个学生，每个学生有3门课（语文、数学、英语）的成绩，写一个程序接收从键盘输入学生的信息，输入格式为：name,30,30,30（姓名，三门课成绩），然后把输入的学生信息按总分从高到低的顺序写入到一个名称"stu.txt"文件中。要求：stu.txt文件的格式要比较直观，打开这个文件，就可以很清楚的看到学生的信息。 ##

package com.itheima;
    public class Test3 { 
        /** 3、 有五个学生，每个学生有3门课（语文、数学、英语）的成绩，写一个程序接收从键盘输入学生的信息，输入格式为：name,30,30,30（姓名，三门课成绩），然后把输入的学生信息按总分从高到低的顺序写入到一个名称"stu.txt"文件中。要求：stu.txt文件的格式要比较直观，打开这个文件，就可以很清楚的看到学生的信息。 * @param args */
        public static void main(String[] args)throws IOException{ 
            // 自定义强制反转的比较器
            Comparator<Student> cmp = Collections.reverseOrder();
            // 以下把比较器作为参数传递
            Set<Student> stus = StudentInfoTool.getStudents(cmp);
                StudentInfoTool.writeToFile(stus);
        }
    }
    //定义学生类
    class Student implements Comparable<Student> { 
        private String name;
        private int chinese,english,maths;
        private int sum;
    
        Student(String name, int chinese, int english, int maths) { 
            this.name = name;
            this.chinese = chinese;
            this.english = english;
            this.maths = maths;
            sum = chinese + english + maths;
        }
    
        public String getName() { 
            return name;
        }
    
        public int getSum() { 
            return sum;
        }
        //覆盖hashCode方法
        public int hashCode() { 
            return name.hashCode()+sum * 78;
        }
    
        public boolean equals(Object obj) { 
            if (!(obj instanceof Student))
                throw new ClassCastException("类型不匹配");
            Student s = (Student) obj;
            return this.name.equals(s.name) && this.sum == s.sum;
        }
        // 实现接口中的方法，分数相同再比较姓名。如果总分和姓名都相同，就是同一个人。
        public int compareTo(Student s) { 
            int num = new Integer(this.sum).compareTo(new Integer(s.sum));
            if (num == 0)
                return this.name.compareTo(s.name);
            return num;
        }
    
        public String toString() { 
            return "student["+"姓名："+name+", "+"语文："+chinese+", "+"英语："+english +", "+"数学："+maths+"]";
        }
    }
    //定义学生工具类
    class StudentInfoTool { 
        // 不带比较器的比较
        public static Set<Student> getStudents() { 
            return getStudents(null);
        }
        // 带自定义比较器的比较
        public static Set<Student> getStudents(Comparator<Student> cmp){ 
            //读取键盘
            BufferedReader bufr = new BufferedReader(new InputStreamReader(
                    System.in));
            String line = null;
            Set<Student> stus = null;
            if(cmp==null)
                stus=new TreeSet<Student>();
            else
                stus = new TreeSet<Student>(cmp);
                try { 
                    while ((line = bufr.readLine()) != null) { 
                        // 输入over就结束
                        if ("over".equals(line))
                            break;
                        // 以逗号分隔输入的信息
                        String[] info = line.split(",");
                        // 字符串要转换为整形
                        Student stu = new Student(info[0], Integer.parseInt(info[1]),
                                Integer.parseInt(info[2]), Integer.parseInt(info[3]));
                        stus.add(stu);
                    }
                } catch (NumberFormatException e1) { 
                    System.out.println("输入格式错误，输入格式为：name,30,30,30");
                } catch (IOException e1) { 
                    System.out.println("读取数据失败");
                }
            try { 
                bufr.close();
            } catch (IOException e) { 
                System.out.println("关闭失败");
            }
            return stus;
        }
    
        public static void writeToFile(Set<Student> stus) throws IOException{ 
            BufferedWriter bufw = null;
                bufw = new BufferedWriter(new FileWriter("E:\\stuinfo.txt"));
            for (Student stu : stus) {         
                bufw.write(stu.toString() + "\t");
                bufw.write(stu.getSum() + "");    
                bufw.newLine();    
                bufw.flush();        
            }    
                bufw.close();
            
        }
    }

## 4、取出一个字符串中字母出现的次数。如：字符串：“abcdekka27qoq” ， 输出格式为：a(2)b(1)k(2)… ##

package com.itheima;
    public class Test4 { 
        /** 4、 取出一个字符串中字母出现的次数。如：字符串："abcdekka27qoq" ， 输出格式为：a(2)b(1)k(2)... * * @param args */
        public static void main(String[] args) { 
            String str = "abcdekka27qoq";
            System.out.println(charCount(str));
            
        }
        public static String charCount(String str){ 
            //将字符串转成字符数组
            char[] chs = str.toCharArray();
            //定义集合（打印有顺序使用TreeMap集合）
            TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
            int count =0;
            //遍历字符数组
            for(int x=0;x<chs.length;x++){ 
                //判断是不是字母
                if(!(chs[x]>='a' && chs[x]<='z' || chs[x]>='A' && chs[x]<='Z'))
                    continue;
                //chs[x]作为键找集合
                Integer value = tm.get(chs[x]);
                
                if(value!=null)
                    count=value;
                count++;
                tm.put(chs[x], count);
                count=0;
    
            }
            //定义缓冲区
            StringBuilder sb = new StringBuilder();
            Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();
            //迭代
            Iterator<Map.Entry<Character,Integer>> it = entrySet.iterator();
            while(it.hasNext()){ 
                Map.Entry<Character,Integer> me = it.next();
                Character ch = me.getKey();
                Integer value = me.getValue();
                sb.append(ch+"("+value+")");
            }
            return sb.toString();
        }
    }

## 5、将字符串中进行反转。abcde ——> edcba ##

package com.itheima;
    public class Test5 { 
        /** 5、 将字符串中进行反转。abcde ——> edcba * @param args */
        public static void main(String[] args) { 
            String str = "abcde";
            System.out.println(reverseString(str));
        }
        public static String reverseString(String str){ 
            //将字符串转成字符数组
            char[] chs = str.toCharArray();
            reverse(chs);
            //将字符数组转成字符串
            return new String(chs);
        }
        //反转数组
        private static void reverse(char[] chs) { 
            for(int start=0,end=chs.length—1;start<end;start++,end——){ 
                swap(chs,start,end);
            }
        }
        //换位置
        private static void swap(char[] chs, int start, int end) { 
            char temp = chs[start];
            chs[start] = chs[end];
            chs[end] = temp;
        }
    }

## 6、已知一个类，定义如下： ##

package cn.itcast.heima; 
    public class DemoClass { 
    	publicvoid run() {  
    		System.out.println("welcome to heima!"); 
    	}
    }

(1)写一个Properties格式的配置文件，配置类的完整名称。  
(2)写一个程序，读取这个Properties配置文件，获得类的完整名称并加载这个类，用反射的方式运行run方法。

package com.itheima;
    public class Test6 { 
        /** 6、 已知一个类，定义如下： 　　 package cn.itcast.heima; 　　 public class DemoClass { 　　 　　 publicvoid run() { 　　　　　　　　　　System.out.println("welcome to heima!"); } } 　　 (1)写一个Properties格式的配置文件，配置类的完整名称。 　　 (2)写一个程序，读取这个Properties配置文件，获得类的完整名称并加载这个类，用反射 的方式运行run方法。 * * @param args */
        @SuppressWarnings({  "rawtypes", "unchecked" })
        public static void main(String[] args) throws Exception { 
            // 用Properties类加载配置文件
            Properties props = new Properties();
            InputStream fis = Test6.class.getClassLoader().getResourceAsStream(
                    "com/itheima/Test6.Properties");
            props.load(fis);
            fis.close();
            // 取出类的完整名称
            String className = props.getProperty("className");
            System.out.println(className);
            DemoClass dc = new DemoClass();
            //加载类
            Class clazz = Class.forName(className);
            Method method = clazz.getMethod("run");
            method.invoke(dc);
        }
    }
    当前目录建一个Test6.Properties 内存入：className=cn.itcast.heima.DemoClass
    package cn.itcast.heima;
    public class DemoClass { 
        public void run() { 
            System.out.println("welcome to heima!");
        }
    }

## 7、有一个类为ClassA,有一个类为ClassB，在ClassB中有一个方法b，此方法抛出异常，在ClassA类中有一个方法a，请在这个方法中调用b,然后抛出异常。 在客户端有一个类为TestC,有一个方法为c,请在这个方法中捕捉异常的信息。 完成这个例子，请说出java中针对异常的处理机制。 ##

package com.itheima;
    public class Test7 { 
        /** 7、 有一个类为ClassA,有一个类为ClassB，在ClassB中有一个方法b，此方法抛出异常，在ClassA类中有一个方法a，请在这个方法中调用b,然后抛出异常。 在客户端有一个类为TestC,有一个方法为c,请在这个方法中捕捉异常的信息。 完成这个例子，请说出java中针对异常的处理机制。 * * @param args */
        /* 1，处理方式有两种：try 或者 throws。 　　　　 try { 需要被检测的代码；} 　　　　 catch ( 异常类 变量 ) { 处理异常的代码；(处理方式) } 　　　　 finally { 一定会执行的语句； } 2，调用到抛出异常的功能时，抛出几个，就处理几个。一个try对应多个catch。 3，多个catch，父类的catch放到最下面。 4，catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。也不要不写。 当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。 */
        public static void main(String[] args) { 
            TestC.c();
        }
    }
    
    class ClassA { 
        public static void a() throws Exception { 
            ClassB.b();
        }
    }
    
    class ClassB { 
        public static void b() throws Exception { 
            throw new Exception("方法b异常");
        }
    }
    
    class TestC { 
        public static void c() { 
            try { 
                ClassA.a();
            } catch (Exception e) { 
                System.out.println(e.getMessage()+"..."+e.toString());
            }
        }
    }

## 8、存在一个JavaBean，它包含以下几种可能的属性： ##

1:boolean/Boolean 
         2:int/Integer 
         3:String
         4:double/Double 
     属性名未知，现在要给这些属性设置默认值，以下是要求的默认值：
         String类型的默认值为字符串"itheima.com" 
         int/Integer类型的默认值为100
         boolean/Boolean类型的默认值为true 
         double/Double的默认值为0.01D.
     只需要设置带有getXxx/isXxx/setXxx方法的属性，非JavaBean属性不设置，请用代码实现

package com.itheima;
    public class Test8 { 
        /** 8、 存在一个JavaBean，它包含以下几种可能的属性： 1:boolean/Boolean 2:int/Integer 3:String 4:double/Double 属性名未知，现在要给这些属性设置默认值，以下是要求的默认值： String类型的默认值为字符串"itheima.com" int/Integer类型的默认值为100 boolean/Boolean类型的默认值为true double/Double的默认值为0.01D. 只需要设置带有getXxx/isXxx/setXxx方法的属性，非JavaBean属性不设置，请用代码实现 * * @param args */
        public static void main(String[] args) { 
            JavaBean jb = new JavaBean();
            jb.setString("itheima.com");
            jb.setInteger(100);
            jb.setBooleam(true);
            jb.setDoublo(0.01D);
            System.out.println("String类型的值="+jb.getString()+"\t\n"
                                +"int/Integer类型的值="+jb.getInteger()+"\t\n"
                                +"boolean/Boolean类型的值="+jb.isBooleam()+"\t\n"
                                +"double/Double的值="+jb.getDoublo());
        }
    }
    
    package com.itheima;
    public class JavaBean { 
        private String string ;
        private Integer integer;
        private Boolean booleam ;
        private Double doublo ;
    
        public String getString() { 
            return string;
        }
        public void setString(String string) { 
            this.string = string;
        }
        public Integer getInteger() { 
            return integer;
        }
        public void setInteger(Integer integer) { 
            this.integer = integer;
        }
        public Boolean isBooleam() { 
            return booleam;
        }
        public void setBooleam(Boolean booleam) { 
            this.booleam = booleam;
        }
        public Double getDoublo() { 
            return doublo;
        }
        public void setDoublo(Double doublo) { 
            this.doublo = doublo;
        }
    }

## 9、使用TCP协议写一个可以上传文件的服务器和客户端。 ##

package com.itheima;
    public class Test9 { 
        /** 9、 使用TCP协议写一个可以上传文件的服务器和客户端。 * * @param args */
        public static void main(String[] args) {     
        }
    }
    class  Client{ 
        public static void main(String[] args) throws Exception{ 
            Socket s = new Socket("192.168.1.102",10001);
            BufferedReader bufr =
                new BufferedReader(new FileReader("F:\\1.mp3"));
    
            //定义目的，将数据写入到socket输出流。发给服务端。
            PrintWriter out = new PrintWriter(s.getOutputStream(),true);
            String line = null;
            while((line=bufr.readLine())!=null){ 
                out.println(line);
            }
            s.shutdownOutput();//关闭客户端的输出流。相当于给流中加入一个结束标记—1. 
    
            //定义一个socket读取流，读取服务端返回的信息。 
            BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
            String str = bufIn.readLine();
            System.out.println(str);
            bufr.close();
            s.close();
        }
    }
    class  Server{ 
        public static void main(String[] args) throws Exception{ 
            ServerSocket ss = new ServerSocket(10001);
            Socket s = ss.accept();
            String ip = s.getInetAddress().getHostAddress();
            System.out.println(ip+"....connected");
    
            //读取socket读取流中的数据。
            BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
            //目的。socket输出流。将大写数据写入到socket输出流，并发送给客户端。
            PrintWriter out  = new PrintWriter(new FileWriter("F:\\server.mp3"),true);
            String line = null;
            while((line=bufIn.readLine())!=null){ 
                out.println(line);
            }
            PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
            pw.println("上传成功");
            out.close();
            s.close();
            ss.close();
        }
    }

## 10、金额转换，阿拉伯数字转换成中国传统形式。 ##

*  例如：101000001010 转换为 壹仟零壹拾亿零壹仟零壹拾圆整

package com.itheima;
    public class Test10 { 
        /** 10、 金额转换，阿拉伯数字转换成中国传统形式。 * * 例如：101000001010 转换为 壹仟零壹拾亿零壹仟零壹拾圆整 * * @param args */
        public static void main(String[] args) { 
            // 测试
            long L = 101000001010L;
            System.out.println(convert(L));
        }
    
        public static String convert(long number) { 
            // 定义字符数组存储中国数字写法格式
            final char[] chinese = new char[] {  '零', '壹', '贰', '叁', '肆', '伍',
                    '陆', '柒', '捌', '玖' };
            // 定义字符数组存储中国数字的单位
            final char[] units = new char[] {  '圆', '拾', '佰', '仟', '万', '拾', '佰',
                    '仟', '亿', '拾', '佰', '仟' };
            // 定义一个字符串缓冲区对字符进行存储
            StringBuilder sb = new StringBuilder();
            int index = 0;
            long lastNumber = 0;
            while (number != 0) { 
                lastNumber = number % 10;
                sb.insert(0, units[index++]);
                sb.insert(0, chinese[(int) lastNumber]);
                number = number / 10;
            }
            // 去零操作，通过正则表达式
            return sb.toString().replaceAll("零[拾佰仟]", "零").replaceAll("零+亿", "亿")
                    .replaceAll("零{4}万", "零").replaceAll("零+万", "万")
                    .replaceAll("零+圆", "圆").replaceAll("零+", "零")
                    + "整";
        }
    }