java笔试题目及答案（仅供参考哈）-低调大师

java笔试题目及答案（仅供参考哈）

2019-11-04 523

1、运算符优先级问题，下面代码的结果是多少？

public class Test {

public static void main(String[] args) {  
    int k = 0;  
    int ret = ++k + k++ + ++k + k;  
    // ret的值为多少  
    System.err.println(ret);  
}

}
解答：主要考察++i和i++的区别。++在前则先自增再赋值运算，++在后则先赋值再自增运算。因此，结果为8。

2、运算符问题，下面代码分别输出什么？

public class Test {

public static void main(String[] args) {  
    int i1 = 10, i2 = 10;  
    System.err.println("i1 + i2 = " + i1 + i2);  
    System.err.println("i1 - i2 = " + i1 - i2);  
    System.err.println("i1 * i2 = " + i1 * i2);  
    System.err.println("i1 / i2 = " + i1 / i2);  
}

}
解答：主要考察两点，运算符的优先级、字符串与数字中的+为连接符号。第一条中，都是相加，则从前到后的顺序运算，字符串与数字相加，连接为一个字符串，再与后面的数字相加，再次连接为字符串，因此结果为“i1 + i2 = 1010”。第二条是错误的，字符串无法与数字用减号连接。第三条、第四条中乘除的优先级高，会先运算，而后再与字符串连接，因此结果分别为：“i1 i2 = 100”、“i1 i2 = 1”。

3、下面代码的结果是什么？

public class Test {

  
public void myMethod(String str) {  
    System.err.println("string");  
}  
  
public void myMethod(Object obj) {  
    System.err.println("object");  
}  
  
public static void main(String[] args) {  
    Test t = new Test();  
    t.myMethod(null);  
}

}
解答：这道题考察重载方法参数具有继承关系时的调用问题，还有对null的认识。如果是一般具有继承关系的对象分别作为参数，看对象的引用，如：
class A {
}

class B extends A {
}

public class Test {

public static void main(String[] args) {
    A b1 = new B();
    B b2 = new B();
    get(b1);// A
    get(b2);// B
}

public static void get(A a) {
    System.out.println("A");
}

public static void get(B a) {
    System.out.println("B");
}

}
这道题中，Object是一切类的父类，具有继承关系，那null是指向什么呢？null是任何引用类型的初始值，String和Object的初始值都是null，但是null会优先匹配引用类型参数为String的方法，因此这道题答案是string。假设这道题中还有其他同是引用类型的重载方法呢？如：
public void myMethod(Integer obj) {

System.err.println("Integer");

}
如果是这样的话，调用这个方法传入参数null时会报错，他不知道选哪个方法进行匹配调用了。

4、假设今天是9月8日，下面代码输出什么？

public class Test {

public static void main(String[] args) {  
    Date date = new Date();  
    System.err.println(date.getMonth() + " " + date.getDate());  
}

}
解答：这道题考察的是日期中获取的月份是从0开始的，因此会比我们日常的月份少1，这个题答案是8 8。

5、下面代码的输出结果是什么？

public class Test {

public static void main(String[] args) {  
    double val = 11.5;  
    System.err.println(Math.round(val));  
    System.err.println(Math.floor(val));  
    System.err.println(Math.ceil(val));  
}

}
解答：这个是在考Math取整数的三种方法。round()是四舍五入取证，floor()是舍去小数位，ceil()是向上进一位。floor是地板ceil是天花板，一个在下，则舍去，一个在上，则向上进1。那是不是结果应该为12、11、12呢？还要考虑返回值类型，round()返回值类型为long长整型，floor()和ceil()返回值的是double类型，因此正确的答案应该是12、11.0、12.0。

6、编程输出一个目录下的所有目录及文件名称，目录之间用tab。

public class Test {

public static void main(String[] args) {  
    new Test().read("D:/test", "");  
}  
  
public void read(String path, String tab) {  
    File file = new File(path);  
    File[] childFiles = file.listFiles();  
    for (int i = 0; childFiles != null && i < childFiles.length; i++) {  
        System.err.println(tab + childFiles[i].getName());  
        if (childFiles[i].isDirectory()) {  
            read(childFiles[i].getPath(), tab + "\t");  
        }  
    }  
}

}
这个主要是考察IO部分知识点了。

7、从键盘读入10个整数，然后从大到小输出。

public class Test {

public static void main(String[] args) {  
    Scanner in = new Scanner(System.in);  
    // 注意这里的数组，不是int的  
    Integer[] arr = new Integer[10];  
    for (int i = 0; i < 10; i++) {  
        arr[i] = in.nextInt();  
    }  
    Arrays.sort(arr, new Comparator<Integer>() {  
        @Override  
        public int compare(Integer o1, Integer o2) {  
            if (o1 > o2) return -1;  
            if (o1 < o2) return 1;  
            return 0;  
        }  
          
    });  
    System.err.println(Arrays.toString(arr));  
}

}

8、下面代码的结果是什么？
public class Test extends Base {

public static void main(String[] args) {  
    Base b = new Test();  
    b.method();  
      
    Test t = new Test();  
    t.method();  
}  

@Override  
public void method() {  
    System.err.println("test");  
}

}

class Base {

public void method() throws InterruptedException {  
    System.err.println("base");  
}

}
解答：两次调用输出都是test。多态的情况下，尽管是父类的引用，调用方法时，还是调用子类的方法。

9、以下代码的结果是什么？

package test;  
  
public class Test extends Base {  
  
    public static void main(String[] args) {  
        new Test().method();  
    }  
  
    public void method() {  
        System.err.println(super.getClass().getName());  
        System.err.println(this.getClass().getSuperclass().getName());  
    }  
      
}  
  
class Base {  
}

解答：第一个输出test.Test、第二个输出test.Base。super很容易让人以为也是调用了父类，实际上还是本类。具体原因也没太搞懂，有懂的同学欢迎留言。

10、true or false？

public class Test {

public static void main(String[] args) {  
    String str1 = new String("abc");  
    String str2 = new String("abc");  
    System.err.println(str1.equals(str2));  
      
    StringBuffer sb1 = new StringBuffer("abc");  
    StringBuffer sb2 = new StringBuffer("abc");  
    System.err.println(sb1.equals(sb2));  
}

}
解答：第一个true，第二个false。String重写了Object中的equals方法，会将string拆分为字符数组，逐个比较各个字符，代码如下：

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

Object中的equests方法如下：

public boolean equals(Object obj) {
    return (this == obj);
}

11、输出的结果是什么？
public class Test {

public static void main(String[] args) {  
    System.err.println(new Test().method1());  
    System.err.println(new Test().method2());  
}  
  
public int method1() {  
    int x = 1;  
    try {  
        return x;  
    } finally {  
        ++x;  
    }  
}  
  
public int method2() {  
    int x = 1;  
    try {  
        return x;  
    } finally {  
        return ++x;  
    }  
}

}
解答：第一个返回1，第二个返回2。finally中的代码是一定会被执行的且在try中的代码执行完之后，因此若在其中return返回，会覆盖掉try中的返回值。
如果这样呢？

public class Test {

public static void main(String[] args) {  
    System.err.println(method());  
}  
  
public static boolean method() {   
     try {   
        return true;   
    } finally {   
      return false;  
    }   
}

}
很明显返回值应该为false。

12、方法m1和m2有区别吗？

public class Test {

public static void main(String[] args) {  
}  

public synchronized void m1() {  
}  

public static synchronized void m2() {  
}

}
解答：这里考察的是同步方法的问题。synchronized修饰方法时锁定的是调用该方法的对象。它并不能使调用该方法的多个对象在执行顺序上互斥，静态修饰符很有必要。因此当不适用静态时，创建多个对象执行该方法，锁都不一样，还同步什么呢，因此用static修饰后才能实现想要的效果。

13、true or false？

public class Test {

public static void main(String[] args) {  
    Integer i1 = 127;  
    Integer i2 = 127;  
    System.err.println(i1 == i2);  
      
    i1 = 128;  
    i2 = 128;  
    System.err.println(i1 == i2);  
}

}
解答：这个是对Integer包装类型中应用的享元模式的考察。具体可以看一下http://blog.csdn.net/m0_37240709/article/details/78644341

14、true or false？

public class Test {

public static void main(String[] args) {  
    String str1 = "a";  
    String str2 = "a";  
    String str3 = new String("a");  
      
    System.err.println(str1 == str2);  
    System.err.println(str1 == str3);  
    str3 = str3.intern();  
    System.err.println(str1 == str3);  
}

}
解答：这个是对String Pool的考察。参看http://blog.csdn.net/m0_37240709/article/details/78642110

15、true or false？

public class Test {

public static void main(String[] args) {  
    System.err.println(12 - 11.9 == 0.1);  
}

}
解答：结果为false。这个题我只说下我的想法，12-11.9进行运算后会转换成对象，不在是基本数据类型，因此在进行恒等判断时，就会是false。

16、以下代码输出是什么？

public class Test {

public static void main(String[] args) {  
    BigInteger one = new BigInteger("1");  
    BigInteger two = new BigInteger("2");  
    BigInteger three = new BigInteger("3");  
    BigInteger sum = new BigInteger("0");  
    sum.add(one);  
    sum.add(two);  
    sum.add(three);  
    System.out.println(sum.toString());  
}

}
解答：这个是对大整数的考察。结果是不是6呢？看起来好像没毛病，其实不然。sum.add(one)与我们基本类型的sum+=one可不同，前者不会讲结果赋值给sum对象，结果被赋值了这条语句的返回值。因此不管怎么add，sum对象的值是没有变化的，因此结果为0。

17、输出的结果是什么？

public class Test {

public static void main(String[] args) {  
    Set<String> set = new HashSet<String>();  
    set.add("one");  
    set.add("two");  
    set.add("three");  
    set.add("four");  
    set.add("five");  
    for (Iterator<String> it = set.iterator(); it.hasNext();) {  
        System.err.println(it.next());  
    }  
}

}
解答：结果顺序是four one two three five。有懂的同学欢迎留言评论。

18、如何迭代Map容器？

Map<String, String> map = new HashMap<>();
Set<Map.Entry<String, String>> entrySet = map.entrySet();
for(Map.Entry<String, String> entry : entrySet){
    String key = entry.getKey();
    String value = entry.getValue();
}

Set<String> keySet = map.keySet();
Iterator<String> it1 = keySet.iterator();
if(it1.hasNext())
    System.out.println(it1.next());

Collection<String> values = map.values();
Iterator<String> it2 = values.iterator();
if(it2.hasNext())
    System.out.println(it2.next());

19、以下代码输出的结果

public class Test {  
  
    public static void main(String[] args) {  
        System.err.println(args.length);  
    }  
      
}  
/* 
A. null     B. 0        C. Test 
D. Exception in thread "main" java.lang.NullPointerException 
*/

解答：0.

20、下面为一个单例的实现代码，请指出代码中有几个错误或不合理之处，并改正。

public class Test {  
      
    public Test instance = null;  
      
    public static Test getInstance() {  
        if (instance == null) {  
            instance = new Test();  
            return instance;  
        }  
    }  
}

解答：单例模式要满足三点：1、私有化构造方法；2、创建私有静态对象；3、提供公有静态方法获取唯一实例。因此错误包含，1构造函数没有私有化，2对象非私有静态，3获取实例的方法中return不应包含在条件中。
————————————————
对于十七题的答案我感觉是随机的吧，我打印的结果和你的不一样，Hashset集合是无序且元素不重复的，所以插入数据的时候本身就是随机的，因此结果肯定不会按照one two there four five 顺序打印。
1@Test
2 public void test2() {
3 Set set = new HashSet();
4 set.add("one");
5 set.add("two");
6 set.add("three");
7 set.add("four");
8 set.add("five");
9 for (Iterator it = set.iterator(); it.hasNext();) {
10 System.err.print(it.next()+" ");
11 //two five one three four
12 }
13 }
2019年阿里云双11活动热门型号价格表只要是新用户，就可以直接购买，无需拼团，没有任何门槛。
(https://www.aliyun.com/1111/2019/group-buying-share?spm=a2c4e.11153940.0.0.59e85d407TbQ62&ptCode=4F3EAAA24826E82EB0B79C1A87FF53FE647C88CF896EF535&userCode=btodw2md&share_source=copy_link)（价格确实很低86/年学习的话可以考虑来一个||）

微信关注我们

原文链接：https://yq.aliyun.com/articles/725880

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

物联网干货：C++const的使用

C++const使用： const 是C++中常用的类型修饰符，但我在工作中发现，许多人使用它仅仅是想当然尔，这样,有时也会用对，但在某些微妙的场合，可就没那么幸运了，究其实质原由，大多因为没有搞清本源。故在本篇文章中我将对const进行辨析。溯其本源，究其实质，希望能对大家理解const有所帮助，根据思维的承接关系，分为如下几个部分进行阐述。 C++中为什么会引入const C++的提出者当初是基于什么样的目的引入（或者说保留）const关键字呢？，这是一个有趣又有益的话题，对理解const很有帮助。 1．大家知道，C++有一个类型严格的编译系统，这使得C++程序的错误在编译阶段即可发现许多，从而使得出错率大为减少，因此，也成为了C++与C相比，有着突出优点的一个方面。 2． C中很常见的预处理指令 #define VariableName VariableValue 可以很方便地进行值替代，这种值替代至少在三个方面优点突出：一是避免了意义模糊的数字出现，使得程序语义流畅清晰，如下例： define USER_NUM_MAX 107 这样就避免了直接使用107带来的...

2019-11-04

513

一、数据库管理系统的基本功能数据库管理系统主要是实现对共享数据有效的组织、存储、管理和存取。围绕数据，数据库管理系统的功能为： 1、数据库定义和创建创建数据库主要是用数据定义语言定义和创建数据库模式、外模式、内模式等数据库对象。在关系数据库中就是建立数据库（或模式）、表、视图、索引等，还有创建用户、安全保密定义（如用户口令、级别、角色、存取权限）、数据库的完整性定义。这些定义存储在数据字典（亦称为系统目录）中，是数据库管理系统运行的基本依据。 2、数据组织、存储和管理数据库管理系统要分类组织、存储和管理各种数据，包括数据字典、用户数据、存取路径等。要确定以何种文件结构和存取方式在存储器上组织这些数据，以及如何实现数据之间的联系。数据组织和存储的基本目标是提高存储空间利用率和方式存取，提高多种存取方法（如索引查找、hash查找、顺序查找等）以提高存取效率。 3、数据库管理系统提供用户对数据的操作功能，实现对数据库数据的索引、插入、修改和删除。一个友好的关系数据库管理系统应该提供功能强且易学易用的数据操纵语言、方便的操作方式和较高的数据存取效率。数据操纵语言有两类：宿主型语言和自立（独立）...

2019-11-05

2004

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。