Java重点

0,编程语言的分类

第一种分法:

  • 解释型语言:源代码不是直接翻译成机器语言,而是先翻译成中间代码,再由解释器对中间代码进行解释运行。比如Python/JavaScript / Perl /Shell等都是解释型语言。

  • 编译型语言:程序在执行之前需要一个专门的编译过程,把程序编译成 为机器语言的文件,运行时不需要重新翻译,直接使用编译的结果就行了。程序执行效率高,依赖编译器,跨平台性差些。如C、C++、Delphi等.

第二种分法:

  • 面向对象:Java,C++,C#,Python,PHP,JavaScript
  • 面向过程:C

第三种分法:

  • 强类型:C,C++,Java,C#,python。一种总是强制类型定义的语言,要求变量的使用要严格符合定义,所有变量都必须先定义后使用。java、.NET、C++、python等都是强制类型定义的。也就是说,一旦一个变量被指定了某个数据类型,如果不经过强制转换,那么它就永远是这个数据类型了。
  • 弱类型:数据类型可以被忽略的语言。它与强类型定义语言相反, 一个变量可以赋不同数据类型的值。PHP,JavaScript

1,Java泛型,擦除

不可以把List传递给一个接受List参数的方法。List只接受String。

  • Java的泛型是如何工作的 ? 什么是类型擦除 ?

    • 泛型是通过类型擦除来实现的,编译器在编译时擦除了所有类型相关的信息,所以在运行时不存在任何类型相关的信息。例如List在运行时仅用一个List来表示。这样做的目的,是确保能和Java 5之前的版本开发二进制类库进行兼容。你无法在运行时访问到类型参数,因为编译器已经把泛型类型转换成了原始类型。
  • 什么是泛型中的限定通配符和非限定通配符 ?

    • 限定通配符对类型进行了限制。有两种限定通配符,一种是它通过确保类型必须是T的子类来设定类型的上界,另一种是它通过确保类型必须是T的父类来设定类型的下界。泛型类型必须用限定内的类型来进行初始化,否则会导致编译错误。另一方面表示了非限定通配符,因为可以用任意类型来替代。
  • List和List 之间有什么区别 ?

  • 这和上一个面试题有联系,有时面试官会用这个问题来评估你对泛型的理解,而不是直接问你什么是限定通配符和非限定通配符。这两个List的声明都是限定通配符的例子,List可以接受任何继承自T的类型的List,而List可以接受任何T的父类构成的List。例如List可以接受List或List

2,数组和链表的区别

3, Java线程,栅栏

4, Java内部类,有几种,能不能从外部访问,为什么有内部类?

匿名内部类,静态内部类,成员内部类,局部内部类(定义在代码块中的类)。

内部类最吸引人注意的原因是:每个内部类都能独立的继承自一个(接口的)实现,所以无论外围类是否已经继承了某个就(接口的)实现,对于内部类都没有影响。

�①,内部类提供进入其外围类的绿色通道;

②,一般来说,内部类继承自某个类或实现某个接口,和接口一起实现java中多重继承;如果拥有的是抽象类或具体的类,而不是接口,那就只能使用内部类才能实现多重继承。

③�,private内部类给类的设计者提供了一种途径,通过这种方式可以完全阻止任何依赖于类型的编码,并且完全隐藏了实现的细节;

④,匿名内部类可以使得代码更加地灵活。

5,HashMap,HashTable, LinkedHashMap,TreeMap

* 一般情况下,我们用的最多的是HashMap,在Map 中插入、删除和定位元素,HashMap 是最好的选择。
* 如果要按自然顺序或自定义顺序遍历键,那么TreeMap会更好。
* 如果需要输出的顺序和输入的相同,那么用LinkedHashMap 可以实现,它还可以按读取顺序来排列。
  • HashMap是一个最常用的Map,它根据键的hashCode值存储数据,根据键可以直接获取它的值,具有很快的访问速度。HashMap最多只允许一条记录的键为NULL,允许多条记录的值为NULL。HashMap不支持线程同步,即任一时刻可以有多个线程同时写HashMap,可能会导致数据的不一致性。如果需要同步,可以用Collections的synchronizedMap方法使HashMap具有同步的能力。
    Map m = Collections.synchronizedMap(new HashMap());

  • Hashtable与HashMap类似,不同的是:它不允许记录的键或者值为空;它支持线程的同步,即任一时刻只有一个线程能写Hashtable,因此也导致了Hashtable在写入时会比较慢。

  • LinkedHashMap保存了记录的插入顺序,在用Iterator遍历LinkedHashMap时,先得到的记录肯定是先插入的。在遍历的时候会比HashMap慢TreeMap能够把它保存的记录根据键排序,默认是按升序排序,也可以指定排序的比较器。当用Iterator遍历TreeMap时,得到的记录是排过序的。
    public class LinkedHashMap extends HashMap implements Map

5,HashMap线程不安全,CocurrentHashMap线程安全,以及HashMap的结构。

HashMap实际上是一个“链表散列”的数据结构,即数组和链表的结合体。


Java重点_第1张图片
Paste_Image.png

从上图中可以看出,HashMap底层就是一个数组结构,数组中的每一项又是一个链表。当新建一个HashMap的时候,就会初始化一个数组。

    • 在HashMap中添加值步骤
      第一步,对key的hashcode进行hash计算,获取应该保存到数组中的index。
      第二步,判断index所指向的数组元素是否为空,如果为空则直接插入。
      第三步,如果不为空,则依次查找entry中next所指定的元素,判读key是否相等,如果相等,则替换久的值,返回。
      第四步,如果都不相等,则将此链表头元素赋值给待插入entry的next变量,让后将待插入元素插入到entry数组中去。

6, java wait()和sleep()区别

  • 1,原理不同。 sleep()是Thread的静态方法,会使线程暂停执行一段时间,直到计时时间到。而wait()是Objet类的方法,用于线程间通信。该方法会使当前拥有该对象锁的线程等待,直到其他线程调用notify()方法时才醒来,当然也可以定义一段时间自动醒来。
  • 2,对锁的处理机制不同。sleep方法不涉及线程间通信,不会释放锁当调用wait方法后,线程会释放掉它所占用的锁,从而使线程所在对象中的其他synchronized数据可以被别的线程使用。
  • 3,使用区域不同。sleep可以在任意位置使用。而由于wait方法对资源的处理,wait方法必须放在同步控制方法或者同步语句块中使用。
  • 4,wait方法推荐使用,sleep方法由于不会释放锁,会引起死锁的问题。

其他相关知识,

  • java yield()和sleep()区别
  • sleep方法一定会让进程休眠,他不考虑其他进程的优先级,可能会给低优先级的进程运行的机会。而yield仅仅会给相同或者更高优先级的进程运行机会。
  • 线程执行sleep方法后会进入阻塞状态。而yield后会进入可执行状态。
  • sleep方法会抛出InterruptedException中断异常,而yield方法没有声明任何异常。
  • sleep方法比yield方法具有更好的移植性。

7, 如何不用构造函数就能获得对象。

Class.forName,反射

假设Sub类继承自Base类。他们都有一个f()方法。

try{
  Class c = Class.forName("Sub");
  Base b = (Base)c.newInstance();
  b.f();
}catch(Exception e){
  e.printStackTrace();
}

这样就会调用Base类的子类Sub类的f方法(多态)。

8, 对线程的中断的理解。

9,如何实现4个线程,让前三个并发执行完后,才继续执行第四个

第一种方法,使用join(),确保子线程运行完毕才运行主线程。

public class Test{
    private Runnable task1 = new Runnable() {
        @Override
        public void run() {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("task1");
        }
    };

    private Runnable task2 = new Runnable() {
        @Override
        public void run() {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("task2");
        }
    };
    
    private Runnable task3 = new Runnable() {
        @Override
        public void run() {
            System.out.println("task3");
        }
    };
    
    private Runnable task4 = new Runnable() {
        @Override
        public void run() {
            System.out.println("task4");
        }
    };

    public static void main(String...args){
          Test test = new Test();
          test.go123();
          test.go4();      
    }
    
    public void go123(){
          Thread myThread1 = new Thread(task1);
           myThread1.start();
           
           Thread myThread2 = new Thread(task2);
           myThread2.start();
           
           Thread myThread3 = new Thread(task3);
           myThread3.start();
           
           try {
            myThread1.join();
            myThread2.join();
            myThread3.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
           
    }
    
    public void go4(){
        Thread myThread4 = new Thread(task4);
        myThread4.start();
    }
}

第二种方法,使用栅栏CyclicBarrier

你可能感兴趣的:(Java重点)