面试题总结

最新推荐文章于 2021-07-27 23:55:08 发布

BigFishAndBegonia

最新推荐文章于 2021-07-27 23:55:08 发布

阅读量894

点赞数 1

分类专栏： JAVA JAVASE基础面试

本文链接：https://blog.csdn.net/qq_38962004/article/details/79854440

版权

JAVA 同时被 3 个专栏收录

54 篇文章 0 订阅

订阅专栏

JAVASE基础

9 篇文章 0 订阅

订阅专栏

面试

3 篇文章 0 订阅

订阅专栏

int和Integer的区别

1、Integer是int的包装类，int则是java的一种基本数据类型
2、Integer变量必须实例化后才能使用，而int变量不需要
3、Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值
4、Integer的默认值是null，int的默认值是0

延伸：
关于Integer和int的比较
1、由于Integer变量实际上是对一个Integer对象的引用，所以两个通过new生成的Integer变量永远是不相等的（因为new生成的是两个对象，其内存地址不同）。

Integer i = new Integer(100);
Integer j = new Integer(100); System.out.print(i == j); //false

2、Integer变量和int变量比较时，只要两个变量的值是向等的，则结果为true（因为包装类Integer和基本数据类型int比较时，java会自动拆包装为int，然后进行比较，实际上就变为两个int变量的比较）

Integer i = new Integer(100);
int j = 100； System.out.print(i == j); //true

3、非new生成的Integer变量和new Integer()生成的变量比较时，结果为false。（因为非new生成的Integer变量指向的是java常量池中的对象，而new Integer()生成的变量指向堆中新建的对象，两者在内存中的地址不同）

Integer i = new Integer(100);
Integer j = 100; System.out.print(i == j); //false

4、对于两个非new生成的Integer对象，进行比较时，如果两个变量的值在区间-128到127之间，则比较结果为true，如果两个变量的值不在此区间，则比较结果为false

Integer i = 100;
Integer j = 100;
System.out.print(i == j); //true

Integer i = 128;
Integer j = 128;
System.out.print(i == j); //false

对于第4条的原因：
java在编译Integer i = 100 ;时，会翻译成为Integer i = Integer.valueOf(100)；，而java API中对Integer类型的valueOf的定义如下：

public static Integer valueOf(int i){ assert IntegerCache.high >= 127; if (i >= IntegerCache.low && i <= IntegerCache.high){ return IntegerCache.cache[i + (-IntegerCache.low)]; } return new Integer(i); }

java对于-128到127之间的数，会进行缓存，Integer i = 127时，会将127进行缓存，下次再写Integer j = 127时，就会直接从缓存中取，就不会new了

String / new String的区别比较

今天看到这样的面试题，如下：

var yiifaa = 'yiifaa',
    str1 = new String(yiifaa),
    str2 = String(yiifaa)

声明与赋值了3个变量，然后考题如下：

//  请确认以下的判断是否准确
str1 === yiifaa
//
str2 === yiifaa
//
typeof str1 === typeof str2

根据JS的语法，要满足===的条件如下：
1. 如果是引用类型，则两个变量必须指向同一个对象（同一个地址）；
2. 如果是基本类型，则两个变量除了类型必须相同外，值还必须相等。

再把话题切换到String对象上来，String的声明方式有三种（请参见第一段代码），但产生的类型却不尽相同，结果如下：

//  类型为string，为基本类型
typeof yiifaa
//  类型为object，为引用类型
typeof str1
//  类型为string，为基本类型
typeof str2

那现在答案很清楚了，如下：

//  false， 因为str1为引用类型
str1 === yiifaa
//  true， 因为都是基本类型，并且值相等
str2 === yiifaa
// false， 虽然都是字符串，但分别为object与string
typeof str1 === typeof str2

总结

很神奇的String对象，一方面可以作为基本类型，另一方面还可以作为引用类型，更神奇的是，为String.prototype添加方法，基本类型还可以引用到，怎么做到的？

对比JAVA的Integer对象的实现，利用int声明的变量可不能调用Integer的方法，所以还不是装箱操作。

最后关于一个函数既可以作为普通函数调用，也可以作为构造函数调用，实现方法如下：

function User(username) {
    this.username = username
    //  这肯定是作为函数调用，但在服务端判断需要改进
    //  必须要进行判断，否则死循环
    if(this === window) {
        return new User(username)
    }
}

改进的方法如下：

function User(username) {
    //  一定是调用了构造函数
    if(this.inst === "User") {
        this.username = username
    } else {
        return new User(username)
    }
}
//  为User的上下文添加标记
User.prototype.inst = "User"

连续子数组求最大值的问题

/*
输入一个整型数组，数组里面有正数也有负数，数组中连续的一个或多个整数组
成子数组，每个子数组都有一个和。求所有子数组的和的最大值。例如，输入的
数字为：1，-2,3,10，-4,7,2，-5，则和最大的子数组为 3,10，-4,7,2 和为 18。

 */
public class TestArrays {
    public static void main(String[] args) {
        //目标数组
        int[] arr = {8,-9,2,-8,5,4,-2,1,15};

        MaxSum(arr);
    }

    private static void MaxSum(int[] arr) {
        //子数组和和
        int cursum = 0;
        int i ;
        //最大子数组的和
        int sum = 0;
        for ( i = 0 ; i < arr.length; i++) {
            cursum +=arr[i];
           if(cursum < 0){
               //当前子数组的和小于0，表示此指针k之前的数应该被抛弃,则子数组的和应该重新为0
               cursum = 0;
           }if(cursum > sum){
               //当前子数组的和大于最大子数组的和，则替换
                sum = cursum;
            }if(sum == 0){
               //表示当前的数组中全是负数，则找到数组中的最小负数，就是最大值
                sum = findMax(arr);
            }
        }
        System.out.println(sum);
    }
    private static int findMax(int[] arr) {
        int max = arr[0];
        for (int i = 0; i < arr.length - 1;i++ ) {
            if(arr[i] < arr[ i+1]){
                max = arr[i+1];
            }
        }
        return max;
    }
}