10道java测试题

布满荆棘的人生 2023-05-21 07:18 4阅读 0赞

### 10道java测试题 ###

package com.mtons.mblog.leetcode;
    
    
    import com.mtons.mblog.BootApplication;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.io.IOException;
    import java.util.HashMap;
    import java.util.Map;
    
    
    @RunWith(SpringRunner.class)
    @SpringBootTest(classes = BootApplication.class)
    /** * 这 10 道 Java 测试题，据 * 说阿里 P7 的正确率只有 50% * 0.8d-0.6d 运算存在精度损失问题 * 0.82d-0.62d /0.825d-0.625d 增加小数点位数做运算就不存在精度损失问题 */
    public class JavaTest { 
    
        /** * 题目一： float a = 0.125f; double b = 0.125d; * System.out.println((a - b) == 0.0); 代码的输出结果是什么？ * 0.125f、0.125d均可以精确的表示出来，不存在精度丢失 * 输出： * 0.0 * true * 0.0 0.0000 也是相等的 */
        @Test
        public void testOne() { 
            float a = 0.125f;
            double b = 0.125d;
            System.out.println((a - b));
            System.out.println((a - b) == 0.000);
        }
    
        /** * 题目二： double c = 0.8; double d = 0.7; * double e = 0.6; 那么c-d与d-e是否相等？ * 0.10000000000000009 * 0.09999999999999998 * false */
        @Test
        public void testTwo() { 
            double c = 0.8;
            double d = 0.7;
            double e = 0.6;
            System.out.println((c - d));
            System.out.println((d - e));
            System.out.println(((c - d) == (d - e)));
        }
    
        /** * 题目三： System.out.println(1.0 / 0); 的结果是什么？ * Infinity * 在整型运算中，除数是不能为0的，否则直接运行异常。但是在浮点数运算中， * 引入了无限这个概念。可以看一下源码Double的定义, * public static final double POSITIVE_INFINITY = 1.0 / 0.0; * public static final double NEGATIVE_INFINITY = -1.0 / 0.0; * public static final double NaN = 0.0d / 0.0; */
        @Test
        public void testThree() { 
            //Infinity
            System.out.println(7.0 / 0);
            //NaN
            System.out.println(0.0 / 0.0);
        }
    
        /** * 题目五： >>和>>>的区别是？ * 正整数一定没有区别 * >>:右移运算符，num >> 1,相当于num除以2 * >>>表示不带符号向右移动二进制数，移动后前 * 面统统补0；两个箭头表示带符号移动，正整数 * 的符号位是0，因而两者没有区别 */
        @Test
        public void testFour() { 
            //Infinity
            System.out.println(100 >> 2);
            //NaN
            System.out.println(100 >>> 2);
        }
        /** * HashMap 初始容量 10000 即 new HashMap(10000)， * 当往里 put 10000 个元素时，需要 resize 几次（初始化的那次不算）？ * * 比10000大，且最接近的2的n次方数是16384，默认负载因子是0.75，1 * 6384*0.75 = 12288>10000，因而不需要扩容。 */
        @Test
        public void testFive() { 
            Map<Integer,Integer> map = new HashMap<>(10000);
            for(int i=0;i<10000;i++){ 
                map.put(i,i);
            }
        }
    
        /** * 查找 * 比10000大，且最接近的2的n次方数是16384 * https://blog.csdn.net/for_cxc/article/details/85229922 */
        @Test
        public void testSix() { 
            //"C:\\Program Files\\Internet Explorer\\iexplore.exe"
    // ProcessBuilder proc = new ProcessBuilder(
    // "C:\\Program Files (x86)\\ChromeCore\\ChromeCoreLauncher.exe",
    // "https://www.99cankao.com/algebra/exponent2.php");
    // try { 
    // proc.start();
    // } catch (IOException e) { 
    // e.printStackTrace();
    // }
    
            //这个方案靠谱 java打开浏览器
            try { 
                Runtime.getRuntime().exec(
                        "cmd /c start https://www.99cankao.com/algebra/exponent2.php ");
            } catch (IOException e) { 
                e.printStackTrace();
            }
            System.out.println("https://www.99cankao.com/algebra/exponent2.php");
        }
    }

package com.mtons.mblog.modules.service.impl;
    
    /** * 某个类有两个重载方法：void f(String s) * 和 void f(Integer i)，那么f(null)的会调用哪个方法？ */
    public class HeavyLoad { 
        static void f(String s) { 
            System.out.println("one");
        }
    
        static void f(Integer i) { 
            System.out.println("two");
        }
    
        static void g(double d) { 
            System.out.println("three");
        }
    
        static void g(Integer i) { 
            System.out.println("four");
        }
    
        public static void main(String[] args) { 
    
            //编译出错
            //f(null);
    
    
            //1）精确匹配->2）基本数据类型（自动转换成更大范围）->
            // 3）封装类（自动拆箱与装箱）->4）子类向上转型依次匹配
            // ->5）可变参数匹配，本题是进行到第二步匹配上了。
            g(1);
    
        }
    }