526互联

牛客Java题目练习

发布时间 2023-12-13 11:15:06作者: 西芹-小汤圆

  1. Java用监视器机制实现了线程之间的同步执行。

  2. byte b = (byte)129的值是-127，因为byte的存储数字范围为[-128,127]，在计算机中，数值用补码表示，相当于一个环，因此是-127。

  3. 一个Java源程序文件中定义几个类和接口，则编译该文件后生成几个以.class为后缀的字节码文件。错误，因为忽略了在类和接口里面还可以定义内部类和匿名内部类。

  4. String str = "";
System.out.print(str.split(",").length);
//输出结果是1，因为String split这个方法默认返回一个数组，如果没有找到分隔符，会把整个字符串当成一个长度为1的字符串数组返回到结果，所以此处结果就是1。

  5. Java7特性中,abstract class和interface的区别：抽象类可以有构造方法，接口中不能有构造方法；抽象类中可以有普通成员变量，接口中没有普通成员变量；一个类可以实现多个接口，但只能继承一个抽象类。

  6. int i=0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println(j.equals(i));
//在jdk1.5之后，输出结果为true和true，原因是自动装箱机制，equals方法首先判断类型是否一致，再判断值是否相同。

  7. <<<=不是赋值符号，>>>=无符号右移赋值。

  8. protected访问权限大于包(default)访问权限。

  9. public static void main(String args[]) {
    Thread t=new Thread(){
        public void  run(){
            dianping();
        }
    };
    t.start();
    System.out.print("dazhong");
    }
    static void dianping(){
        System.out.print("dianping");
}

    如果线程调用了run()方法，此时仍是只有main一个线程，程序就只能顺序执行；开启线程是调用start()方法，这样才能并发执行。

  10. java命名规则：名称只能由字母、数字、下划线、$符号组成；不能以数字开头；名称不能使用JAVA中的关键字。

  11. Java取余操作，负数间取余先忽略符号。再根据被取余数符号决定结果的符号，

    取余.png

  12. 基本数据类型都是值传递；类，数组，接口是引用传递；由于String对象本身的特殊性，导致它值传递的特征。

  13. public class Test {
    public static void main(String args[]) {
        String s = "祝你考出好成绩！";
        System.out.println(s.length());
    }
}
的输出是8，因为java的String底层是char数组，它的length()返回数组大小，而unicode中一个汉字是可以用一个char表示的

  14. static可以用来修饰内部类，但是不可以用来修饰外部类。static修饰符总的来说有四种作用：修饰字段或方法、修饰代码块、静态导入包、构造静态内部类。

  15. JDK提供的用于并发编程的同步器有：Semaphore、CyclicBarric、CountDownLatch。

  16. intValue()是把Integer对象类型变成int的基础数据类型； parseInt()是把String变成int的基础数据类型；Valueof()是把String转化成Integer对象类型。

  17. 局部内部类是放在代码块或方法中的，不能有访问控制修饰符，且不能用static修饰。

  18. 截图

  19. Integer的范围是-128~127，如果超出范围的话会新建一个对象，否则就是使用内存中的那个对象。

  20. String str="abc"，执行这句话时，会先去“字符数据池”搜索时候有“abc”这个字符串，如果有，则将字符串的首地址赋值给str，如果没有，生成一个新的字符串“abc”并且将首地址赋值给str，且存放与”字符数据池“中。String str=new String("abc")，执行这句话时，不会考虑时候已经存在了“abc”这个字符串，而是直接生成一个新的字符串“abc”并将首地址赋值给str，注意“abc”并不放在“字符数据池”中。java字符串池和字符串堆内存分配

  21. 在异常处理中国：finally代码块在return中间执行。return的值会被放入临时空间，然后执行finally代码块，如果finally中有return，会刷新临时空间的值，方法结束返回临时空间值。

  22. 一个抽象类并不需要其中所有的方法都是抽象的。抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

  23. 子类的构造方法总是先调用父类的构造方法，如果子类的构造方法没有明显地指明使用父类的哪个构造方法，子类就调用父类不带参数的构造方法。而父类没有无参的构造函数，所以子类需要在自己的构造函数中显示的调用父类的构造函数。

  24. 局部变量没有默认值。

  25. String s1 = "coder";     
String s2 = "coder";     
String s3 = "coder" + s2;     
String s4 = "coder" + "coder";     
String s5 = s1 + s2;            
System.out.println(s3 == s4); 
System.out.println(s3 == s5);    
System.out.println(s4 == "codercoder");
输出结果是false;false;true

截图

  1. jre判断程序是否执行结束的标准是所有的前台线程执行完毕。
  2. interface中的方法默认为public abstract 的 ，变量默认为public static final。
  3. 泛型只在编译的时候保证数据类型的正确性，和运行期间的性能无关。
  4. java运行时内存分为“线程共享”和“线程私有”两部分，私有:java虚拟机栈，程序计数器，本地方法栈；共享:java堆，方法区。
  5. Switch判断支持byte、short、int、char和String。
  6. class Car extends Vehicle
{
    public static void main (String[] args)
    {
        new  Car(). run();
    }
    private final void run()
    {
        System. out. println ("Car");
    }
}
class Vehicle
{
    private final void run()
    {
        System. out. println("Vehicle");
    }
}

final声明的方法是不能被覆盖的，但是这里并不错误，因为方法是private的，也就是子类没有继承父类的run方法，因此子类的run方法跟父类的run方法无关，并不是覆盖。new Car().run()也是调用子类的run方法。

  1. public void test() {
    int a = 10;
    System.out.println(a++ + a--);
}
//a++ + a--等价于下面的代码
int b = a++;//b=10,a=11
int c = a--;//c=11,a=10
System.out.println(b+c);//10+11=21

  2. Integer i01=59;
int i02=59;
Integer i03=Integer.valueOf(59);
Integer i04=new Integer(59);
以下输出结果是：
(i01==i02);//True,当包装类与基本数据类型对比时，包装类会自动拆箱变为基本类型再进行比较
(i01==i03);//True,包装数据类直接赋值，默认调用其对用的valueOf()方法，在-128~127范围内会查找是否已存在
(i03==i04);//false,包装类是基础数据类型的引用类型，i04的定义使用了new关键字，这会开辟出一块新内存来放置值为59的Integer对象。
(i02==i04);//True,当包装类与基本数据类型对比时，包装类会自动拆箱变为基本类型再进行比较

  3. 接口的抽象方法默认是public的，因此实现该接口的类的实现方法也需要是public的。

  4. 强引用不回收，软引用内存不足时回收，弱引用JVMGC时回收，虚引用随时会被回收。

  5. 导包只可以导到当前层，不可以再导入包里面的包中的类。

  6. final类型的变量一定要初始化，因为final的变量不可更改。

  7. 一旦垃圾回收器准备好释放对象占用的存储空间，将首先调用其finalize()方法， 并且在下一次垃圾回收动作发生时，才会真正的回收对象占用的内存。

  8. 在接口里面的变量默认都是public static final的，它们是公共的，静态的，最终的常量。相当于全局常量，可以直接省略修饰符。 实现类可以直接访问接口中的变量。

  9. 属于JVM规范的内存区域：方法区、程序计数器、虚拟机栈。

  10. JDK8之前，HashMap的数据结构是数组+链表，JDK8及之后是数组+链表/红黑树。

  11. JDK5之后提供的自动拆箱和自动装箱实现了将基本数据类型存入collection类型的集合。

  12. JAVA的赋值运算是有返回值的，赋了什么值，就返回什么值。

  13. 可以把任何一种数据类型的变量赋给Object类型的变量。

  14. Java数据库连接库JDBC用到的设计模式是桥接模式。

  15. boolean类型不能和任何类型进行转换，会报出类型异常错误。

  16. JDK8中，接口中的方法可以被default和static修饰，但是数据被修饰的方法必须有方法体。

  17. public static void main(String args[]) {
  System.out.println(14^3);
}
的输出是13，^在java中是异或的意思，14是1110，3是0011，所以14^3=1101，即13

  18. System是java.lang中的类，out为System中的一个静态成员，out是java.io.PrintStream类的对象，而println()是java.io.PrintStream类的方法，所有可以调用类.静态方法.println()方法。

  19. public class MyClass {
    long var;
    public void MyClass(long param) { var = param; }//(1)
    public static void main(String[] args) {
        MyClass a, b;
        a =new MyClass();//(2)
        b =new MyClass(5);//(3)
    }
}
编译错误将在（3）处发生，因为该类没有接受一个int类型的参数的构造函数。
这个MyClass()方法并不是构造方法，因为它有void返回值类型。

  20. static修饰的成员属于类成员，父类字段或方法只能被子类同名字段或方法遮蔽，不能被继承覆盖。

  21. ResultSet中记录行的第一列索引为1。

  22. public class Demo{
  public static void main(String args[]){
    int count = 0;
    int num = 0;
    for(int i = 0;i <= 100;i++){
      num = num + i;
      count = count++;
    }
    System.out.println("num*count="+(num*count));
  }
}
的输出结果是0，因为count = count ++;这个先将count这个值0暂存起来，然后count自加1变成1，最后将暂存的值赋值给count，count最终的值为0。

  23. JAVA反射机制主要提供的功能有：在运行时判断一个对象所属的类；在运行时构造一个类的对象；在运行时判断一个类所具有的成员变量和方法；在运行时调用一个对象的方法。

  24. public class Test {
    static String x="1";
    static int y=1;
    public static void main(String args[]) {
        static int z=2;//(1)
        System.out.println(x+y+z);
    }
}
程序会在(1)处出现编译错误，因为被static修饰的变量称为静态变量，静态变量属于整个类，而局部变量属于方法，只在该方法内有效，所以static不能修饰局部变量

  25. 数组复制方法中，复制的效率System.arraycopy>clone>Arrays.copyOf>for循环。

  26. byte b1=1,b2=2,b3,b6,b8;
final byte b4=4,b5=6,b7;
b3=(b1+b2);  /*语句1*/（b1 + b2） 被转换为int类型 但是 b3仍为 byte ，所以出错要么将b3转化为int 要么将（b1 + b2） 强制转换为byte类型。所以语句1错误。
b6=b4+b5;    /*语句2*/ b4 、b5被声明final 所以类型是不会转换， 计算结果仍然是byte  ，所以 语句2正确。
b8=(b1+b4);  /*语句3*/ (b1 + b4)  结果仍然转换成int  所以语句 3 错误。
b7=(b2+b5);  /*语句4*/ (b2 + b5)  结果仍然转换为int ， 所以语句4错误。
System.out.println(b3+b6);
存在编译错误的语句是语句1、3、4，操作数为时byte、short、int 、char，两个数都会被转换成int类型，并且结果也是int类型。

  27. threadlocalmap使用开放定址法解决haah冲突，hashmap使用链地址法解决hash冲突。

  28. Object类拥有的方法：Object()、registerNatives()、getClass()、hashCode()、equals()、clone()、toString()、notify()、notifyAll()、wait()、finalize()。

  29. +=会自动强转（自动装箱功能），但是+必须要手动强转b=(byte)(a+b)。

  30. 构造函数不能被继承，只能被显式或隐式的调用。

  31. package NowCoder;
class Test {
    public static void hello() {
        System.out.println("hello");
    }
}
public class MyApplication {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Test test=null;
        test.hello();
    }
}
能编译通过并正确运行，因为静态方法属于静态绑定，编译器根据引用类型所属的静态类型为它绑定其对应的方法。此语句会翻译成invokestatic，该指令的调用中不会涉及this,所以不会依赖对象

  32. 内部类（也叫成员内部类）可以有4种访问权限。

  33. Collection是java.util下的接口，它是各种集合结构的父接口；Collections是java.util下的类，它包含有各种有关集合操作的静态方法。

  34. 子类能继承父类的所有成员，只是私有部用来访问父类被隐藏的非私有成员变量分不能调用。

  35. 关键字super的作用是：用来访问父类被隐藏的非私有成员变量；用来调用父类中被重写的方法；用来调用父类的构造函数。

  36. volatile关键字不保证对变量操作的原子性。

  37. float f=1.1是错误的写法，在JAVA中，小数默认是double类型的，如果想表达是float类型的，需要在数字末尾加上f标识。

  38. 动态类型语言是指在运行期间才去做数据类型检查的语言，也就是说，在用动态类型的语言编程时，永远也不用给任何变量指定数据类型，该语言会在你第一次赋值给变量时，在内部将数据类型记录下来。静态类型语言与动态类型语言刚好相反，它的数据类型是在编译其间检查的，也就是说在写程序时要声明所有变量的数据类型，C/C++是静态类型语言的典型代表，其他的静态类型语言还有C#、JAVA等。

  39. this不能在static的方法中使用。

  40. 2.public class NameList
{
    private List names = new ArrayList();
    public synchronized void add(String name)
    {
        names.add(name);
    }
    public synchronized void printAll() {
        for (int i = 0; i < names.size(); i++)
        {
            System.out.print(names.get(i) + "");
        }
    }
 
    public static void main(String[]args)
    {
        final NameList sl = new NameList();
        for (int i = 0; i < 2; i++)
        {
            new Thread()
            {
                public void run()
                {
                    sl.add("A");
                    sl.add("B");
                    sl.add("C");
                    sl.printAll();
                }
            } .start();
        }
    }
}
在每个线程中都是顺序执行的，所以sl.printAll();必须在前三句执行之后执行，也就是输出的内容必有（连续或非连续的）ABC。
而线程之间是穿插执行的，所以一个线程执行 sl.printAll();之前可能有另一个线程执行了前三句的前几句。  
E答案相当于线程1顺序执行完然后线程2顺序执行完。输出"A B C A B C A B C "
G答案则是线程1执行完前三句add之后线程2插一脚执行了一句add然后线程1再执行 sl.printAll();输出ABCA。接着线程2顺序执行完输出ABCABC，输出加起来即为ABCAABCABC。

  41. 堆区：只存放类对象，线程共享；方法区：又叫静态存储区，存放class文件和静态数据，线程共享；栈区：存放方法局部变量，基本类型变量区、执行环境上下文、操作指令区，线程不共享。

  42. public class ZeroTest {
    public static void main(String[] args) {
     try{
       int i = 100 / 0;
       System.out.print(i);
      }catch(Exception e){
       System.out.print(1);
       throw new RuntimeException();
      }finally{
       System.out.print(2);
      }
      System.out.print(3);
     }
 }
 输出为12，即使在catch语句中抛出RuntimeException，但仍会执行finally块中的语句

  43.  public static void main (String[] args) { 
    String classFile = "com.jd.". replaceAll(".", "/") + "MyClass.class";
    System.out.println(classFile);
}的输出结果不是com/jd/MyClass.class，而是///////MyClass.class，因为replaceAll()函数的第一个参数是一个正则表达式，而"."在正则表达式中代表了全部的字符，因此"com.jd."会全部被替换成"/"。
之后字符串正常拼接，输出"///////MyClass.class"，答案选择C。如想仅仅替换"."，就需要使用转义字符"\\."

  44. Object是引用数据类型，只声明而不创建实例，只会在栈内存中开辟空间，默认为空，空占1bit。

  45. 如果希望监听TCP端口9000，服务器端应该使用new ServerSocket(9000);创建socket。

  46. 虚拟机是运行在操作系统之上的，不与硬件交互。

  47. 通过HttpServletRequest. getParameter获取的参数由服务器所在的操作系统决定编码。

  48. String s = new String("xyz");可能会创建一个或两个StringObject，因为 用new关键字创建字符串对象时，JVM会先检查字符串常量池中时候有存在的对应字符串，如果已经存在，则不会在字符串常量池中创建，如果没有存在，那么就会在字符串常量池中创建一个字符串对象，然后还会去堆内存中创建一份字符串对象，把常量池中的对象内容拷贝到内存中的字符串对象，然后返回堆内存中的字符串对象内存地址。

  49. run()方法的执行结束会导致线程销毁。

    截图

  50. public class Test{
  static{
     int x=5;
  }
  static int x,y;
  public static void main(String args[]){
     x--;
     myMethod( );
     System.out.println(x+y+ ++x);
  }
  public static void myMethod( ){
    y=x++ + ++x;
   }
}
输出结果是3。其中静态代码块中的x为局部变量，不影响静态变量x的值。

  51. JAVA的基本编程单元是类，基本存储单元是变量。

  52. public class Test { 
    public int aMethod(){
        static int i = 0;
        i++; 
        return i;
    } 
    public static void main(String args[]){
        Test test = new Test(); 
        test.aMethod(); 
        int j = test.aMethod();
        System.out.println(j);
    } 
}
这段代码将会编译失败，JAVA中静态变量只能在类主体定义，不能在方法中定义。

  53. final 定义的变量，可以在不是必须要在定义的同时完成初始化，也可以在构造方法中完成初始化。

  54. 子类不可以继承父类的构造方法，只可以调用父类的构造方法。

  55. 类中静态语句块仅在类加载时被执行一次。

  56. 不会初始化子类的几种类型：调用的是父类的static方法或者字段、调用的是父类的final方法或字段、通过数组来引用：Person[] person = new Person[]。

  57. 关于抽象类：JDK 1.8以前，抽象类的方法默认访问权限为protected；JDK 1.8时，抽象类的方法默认访问权限变为default。关于接口：JDK 1.8以前，接口中的方法必须是public的；JDK 1.8时，接口中的方法可以是public的，也可以是default的；JDK 1.9时，接口中的方法可以是private的。

  58. 静态内部类不可以直接访问外围类的非静态数据，而非静态内部类可以直接访问外围类的数据，包括私有数据。

  59. long型转float型无须强制转换，浮点数在内存中的32位不是简单地转换为十进制，而是通过公式来计算而来，通过这个公式虽然，只有4个字节，但浮点数最大值要比长整型的范围要大。

  60. 编译看左边，运行看右边。意思编译时候，看左边有没有该方法，运行的时候结果看 new 的对象是谁，就调用的谁。

  61. instanceof运算符能够用来判断一个对象是否为：一个类的实例、一个实现指定接口的类的实例、一个子类的实例。

  62. join()底层就是调用wait()方法的，wait()释放锁资源，故join也释放锁资源。

  63. join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。

  64. 针对循环优化的方法：强度削弱、删除归纳变量和代码外提。

  65. 抽象类和接口都不能被实例化。接口没有构造方法，所以不能实例化，抽象类有构造方法，但是不是用来实例化的，是用来初始化的。

  66. 抽象类可以定义普通成员变量而接口不可以，但是抽象类和接口都可以定义静态成员变量，只是接口的静态成员变量要用static final public 来修饰。

  67. public class Arraytest{
    int a[] = new int[6];
    public static void main ( String arg[] ) {
        System.out.println ( a[0] );
    }
}
这段代码将会编译出错，因为main是Static方法， 在static方法中是不能访问非静态变量 a 的，需要将 a 声明为static，答案才会是 0 ，否则是编译出错

  68. Math.cos为计算弧度的余弦值，Math.toRadians函数讲角度转换为弧度。

  69. 类之间存在这些常见的关系：“USES-A”关系、“HAS-A"关系和”IS-A“关系。