Java知识--零碎

低配张家辉

于 2019-05-02 23:19:10 发布

阅读量158

点赞数

本文链接：https://blog.csdn.net/zxc_jkl/article/details/89715573

版权

1.&和&&的区别。
&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。
&&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式，例如，对于if(str != null && !str.equals(“”))表达式，当str为null时，后面的表达式不会执行，所以不会出现NullPointerException如果将&&改为&，则会抛出NullPointerException异常。If(x==33 & ++y>0) y会增长，If(x==33 && ++y>0)不会增长
&还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们通常使用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位，例如，0x31 & 0x0f的结果为0x01。

2.==和equals的区别。
"=="判断是否指向同一个对象或者同一个内存空间
equals判断指向的两个对象的内容是否相同

3.int和Integer的自动拆箱/装箱相关问题。
在这里插入图片描述
自动拆箱： 将对象类型转化成基本数据类型

Integer a1 = 96;
Integer a2 = 96;
System.out.println(a1==a2)//输出true

享元模式： 在自动装箱时对于值从–128到127之间的值，它们被装箱为Integer对象后，会存在内存中被重用，始终只存在一个对象；而如果超过了从–128到127之间的值，被装箱后的Integer对象并不会被重用，即相当于每次装箱时都新建一个 Integer对象；

Integer a1 = 196;
Integer a2 = 196;
System.out.println(a1==a2)//输出false

4.IO和NIO的区别。
NIO即New IO，这个库是在JDK1.4中才引入的。NIO和IO有相同的作用和目的，但实现方式不同，NIO主要用到的是块，所以NIO的效率要比IO高很多。在Java API中提供了两套NIO，一套是针对标准输入输出NIO，另一套就是网络编程NIO。

IO	NIO
面向流	面向缓冲
阻塞IO	非阻塞IO
无	选择器

Java IO和NIO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。
Java IO的各种流是阻塞的，Java NIO的非阻塞模式。
Java NIO的选择器允许一个单独的线程来监视多个输入通道。

5.final、finally、finalize的区别。
final
在java中，final可以用来修饰类，方法和变量（成员变量或局部变量）
修饰类
当用final修饰类的时，表明该类不能被其他类所继承。但要注意：

final类中所有的成员方法都会隐式的定义为final方法。

修饰方法
使用final方法的原因主要有两个：
(1) 把方法锁定，以防止继承类对其进行更改。
(2) 效率，在早期的java版本中，会将final方法转为内嵌调用。但若方法过于庞大，可能在性能上不会有多大提升。因此在最近版本中，不需要final方法进行这些优化了。

final方法意味着此方法不能被重写。

 注意：若父类中final方法的访问权限为private，将导致子类中不能直接继承该方法，因此，此时可以在子类中定义相同方法名的函数，此时不会与重写final的矛盾，而是在子类中重新地定义了新方法。
子类继承了父类的所有属性和方法或子类拥有父类的所有属性和方法是对的，只不过父类的私有属性和方法，子类是无法直接访问到的。即只是拥有，但是无法使用。

修饰变量
final成员变量表示常量，只能被赋值一次，赋值后其值不再改变。类似于C++中的const。

finally
finally作为异常处理的一部分，它只能用在try/catch语句中，并且附带一个语句块，表示这段语句最终一定会被执行（不管有没有抛出异常），经常被用在需要释放资源的情况下。

finalize　　
finalize()是在java.lang.Object里定义的，也就是说每一个对象都有这么个方法。这个方法在gc启动，该对象被回收的时候被调用。其实gc可以回收大部分的对象（凡是new出来的对象，gc都能搞定，一般情况下我们又不会用new以外的方式去创建对象），所以一般是不需要程序员去实现finalize的。

特殊情况下，需要程序员实现finalize，当对象被回收的时候释放一些资源，比如：一个socket链接，在对象初始化时创建，整个生命周期内有效，那么就需要实现finalize，关闭这个链接。

使用finalize还需要注意一个事，调用super.finalize();
一个对象的finalize()方法只会被调用一次，而且finalize()被调用不意味着gc会立即回收该对象，所以有可能调用finalize()后，该对象又不需要被回收了，然后到了真正要被回收的时候，因为前面调用过一次，所以不会调用finalize()，产生问题。所以，推荐不要使用finalize()方法，它跟析构函数不一样。

6.重载（Overload）和重写（Override）的区别。
重载（Overload）:首先是位于一个类之中或者其子类中，具有相同的方法名，但是方法的参数不同，返回值类型可以相同也可以不同。
重写（override）：一般都是表示子类和父类之间的关系，其主要的特征是：方法名相同，参数相同，但是具体的实现不同。

7.String、StringBuffer和StringBuilder的区别。
String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，是可以更改的。

运行速度快慢为：StringBuilder > StringBuffer （线程安全）> String
在线程安全上，StringBuilder是线程不安全的，而StringBuffer是线程安全的

String：适用于少量的字符串操作的情况
StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

8.如何实现浅克隆和深克隆。
浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。

深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。
在这里插入图片描述
9.单例模式的实现以及最优。
饿汉式（静态常量）[可用]

public class Singleton {

    private final static Singleton INSTANCE = new Singleton();

    private Singleton(){}

    public static Singleton getInstance(){
        return INSTANCE;
    }
}

优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

静态内部类[推荐用]

public class Singleton {

    private Singleton() {}

    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

这种方式跟饿汉式方式采用的机制类似，但又有不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同的地方在饿汉式方式是只要Singleton类被装载就会实例化，没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。

类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

优点：避免了线程不安全，延迟加载，效率高。

10.排序的实现（冒泡、选择、快速等）。
https://www.cnblogs.com/guoyaohua/p/8600214.html

/**
     * 冒泡排序
     *
     * @param array
     * @return
     */
    public static int[] bubbleSort(int[] array) {
        if (array.length == 0)
            return array;
        for (int i = 0; i < array.length; i++)
            for (int j = 0; j < array.length - 1 - i; j++)
                if (array[j + 1] < array[j]) {
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
        return array;
    }
____________________________________________________________
/**
     * 选择排序
     * @param array
     * @return
     */
    public static int[] selectionSort(int[] array) {
        if (array.length == 0)
            return array;
        for (int i = 0; i < array.length; i++) {
            int minIndex = i;
            for (int j = i; j < array.length; j++) {
                if (array[j] < array[minIndex]) //找到最小的数
                    minIndex = j; //将最小数的索引保存
            }
            int temp = array[minIndex];
            array[minIndex] = array[i];
            array[i] = temp;
        }
        return array;
    }

11.去除重复的元素(实际是重写equals和hashcode)。

12.Servlet的生命周期。

13.String为什么要设计成final。
主要是为了“效率” 和 “安全性” 的缘故。String字符串对象不可变让它们可以被共享，final不可变，线程安全。

14.Java中，异常和错误的区别

在这里插入图片描述
Throwable类有两个子类，Error与 Exception。
Exception是java中所有异常的基类。在java中异常被分为两大类，编译时异常和运行时异常。
Error是java中所有错误的基类。错误通常是我们无法处理的，绝大多数情况下，我们不应该试图捕获错误。

注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。
错误与异常都是在程序编译和运行时出现的错误。不同的是，异常可以被开发人员捕捉和处理；而错误一般是
系统错误，一般不需要开发人员处理（也无法处理），比如内存溢出。

15.Thread 和 Runnable 的区别
Thread实现了Runnable接口，Thread的start（）才会开启一个线程，它调用了Runnable的run（），而直接调用Runnable的run（）不会开启一个线程。

16.IOC 和 AOP解决了什么问题
IOC即控制反转，一种将控制权转移的设计模式，由传统的程序控制转移到容器控制；通俗的说就是我们不用自己创建实例对象，这些都交给Spring的bean工厂帮我们创建管理。这也是Spring的核心思想，通过面向接口编程的方式来是实现对业务组件的动态依赖。这就意味着IOC是Spring针对解决程序耦合而存在的。

DI即依赖注入，意思自身对象中的内置对象是通过注入的方式进行创建。

IOC就是一种软件设计思想，DI是这种软件设计思想的一个实现。而Spring中的核心机制就是DI。

AOP即面向切面，一种编程思想，OOP的延续。将系统中非核心的业务提取出来，进行单独处理。
将程序功能中的频繁出现或者与主业务逻辑代码相关度不高的代码抽离出来，通过切面编程的方式在想要调用的时候引入调用的思想。而这种思想并不是只限于Spring和java，AOP（面向切面）和OOP（面向对象）一样都是一种编程思想，这种思想的实现机制在Spring中便是应用了java的动态代理和java的反射。

Spring的AOP和IOC都是为了解决代码的耦合度的实际应用，使得代码的重用度变高，便于维护。

17.当try、catch中有return时，finally中的代码会执行么？
在执行try、catch中的return之前一定会执行finally中的代码（如果finally存在），如果finally中有return语句，就会直接执行finally中的return方法，所以finally中的return语句一定会被执行的。编译器把finally中的return语句标识为一个warning.

18.wait方法和sleep方法的区别
1、sleep()睡眠时，保持对象锁，仍然占有该锁
2、 wait()睡眠时，释放对象锁。
3、wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException（但不建议使用该方法）。

对于sleep()方法，我们首先要知道该方法是属于Thread类中的。而wait()方法，则是属于Object类中的。

sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。在调用sleep()方法的过程中，线程不会释放对象锁。

而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备，获取对象锁进入运行状态。

19.equals()和hashCode()区别
两个obj，如果equals()相等，hashCode()一定相等。
两个obj，如果hashCode()相等，equals()不一定相等（Hash散列值有冲突的情况，虽然概率很低）。

为什么选择hashcode方法

hashCode()返回值为int
在 Java 中，Object 对象的 hashCode()方法会根据不同的对象生成不同的哈希值，默认情况下为了确保这个哈希值的唯一性，是通过~~将该对象的内部地址转换成一个整数来实现的~~ ，JDK8 的默认hashCode的计算方法是通过和当前线程有关的一个随机数+三个确定值，运用Marsaglia’s xorshift scheme随机数算法得到的一个随机数。

以java.lang.Object来理解,JVM每new一个Object,它都会将这个Object丢到一个Hash哈希表中去,这样的话,下次做Object的比较或者取这个对象的时候,它会根据对象的hashcode再从Hash表中取这个对象。这样做的目的是提高取对象的效率。

new Object(),JVM根据这个对象的Hashcode值,放入到对应的Hash表对应的Key上,如果不同的对象确产生了相同的hash值,也就是发生了Hash key相同导致冲突的情况,那么就在这个Hash key的地方产生一个链表,将所有产生相同hashcode的对象放到这个单链表上去,串在一起。
比较两个对象的时候,首先根据他们的hashcode去hash表中找他的对象,当两个对象的hashcode相同,那么就是说他们这两个对象放在Hash表中的同一个key上,那么他们一定在这个key上的链表上。那么此时就只能根据Object的equal方法来比较这个对象是否equal。当两个对象的hashcode不同的话，肯定他们不能equal.

可能经过上面理论的讲一下大家都迷糊了，我也看了之后也是似懂非懂的。下面我举个例子详细说明下。

list是可以重复的，set是不可以重复的。那么set存储数据的时候是怎样判断存进的数据是否已经存在。使用equals()方法呢，还是hashcode()方法。

假如用equals()，那么存储一个元素就要跟已存在的所有元素比较一遍，比如已存入100个元素，那么存101个元素的时候，就要调用equals方法100次。

但如果用hashcode()方法的话，他就利用了hash算法来存储数据的。

这样的话每存一个数据就调用一次hashcode()方法，得到一个hashcode值及存入的位置。如果该位置不存在数据那么就直接存入，否则调用一次equals()方法，不相同则存，相同不存。这样下来整个存储下来不需要调用几次equals方法，虽然多了几次hashcode方法，但相对于前面来讲效率高了不少。

低配张家辉

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java知识--零碎

1.&和&&的区别。2.==和equals的区别。3.int和Integer的自动拆箱/装箱相关问题。4.IO和NIO的区别。5.final、finally、finalize的区别。6.重载（Overload）和重写（Override）的区别。7.String、StringBuffer和StringBuilder的区别。8.如何实现浅克隆和深克隆。9.单例模...
复制链接

扫一扫