Java基础篇--数据类型

最新推荐文章于 2024-05-19 21:34:53 发布

i18n486

最新推荐文章于 2024-05-19 21:34:53 发布

阅读量284

点赞数 2

文章标签： java 后端面试

本文链接：https://blog.csdn.net/i18n486/article/details/108789559

版权

***：Integer a = 128, int b = 128,Integer c=128, Integer d = 127，Integre e = 127；a == b? a==c? a.equals(c)? d == e？d.equals(e)?

***： == 和 equals（）的区别？int a = 3, long b = 3, float c = 3.0f,double d = 3.0; a == b? c == d?

3.引用类型

***：String s1= "ab",String s2 = new String("ab"); s1 == s2?

***：String a = "a",String s1 = "a"+"b",String s2 = a+"b"; s1 == "ab"? s2 == "ab"?

***：String s = new String("abc")，请问这句执行会创建几个字符串对象？

***：String s = "ni hao", s += " zao an";代码执行后，原始string对象中的内容是否改变？

***：StringBuilder和StringBuffer的区别？

***：什么时候该用String，什么时候该用StringBuilder，什么时候该用StringBuffer？

前言

带着问题学java系列博文之java基础篇。从问题出发，学习java知识。

Java有哪些数据类型？

1.基本数据类型

byte：长度8bit，取值范围【-128，127】（-2^7~2^7-1）；
short：长度16bit（2byte），取值范围【-32768，32767】；
int：长度32bit（4byte），取值范围【-2147483648，2147483647】；
long：长度64bit（8byte），取值范围【-9223372036854774808，9223372036854774807】；
float：长度32bit（4byte），浮点型数据，不能完全精确，最后几位有浮动属于正常现象；
double：长度64bit（8byte）；
boolean：1bit，取值 true/false（1/0）；
char：字符型，16bit（2byte）

2.包装类

Byte、Short、Integer、Long、Float、Double、Boolean、Character

***：有了基本类型，为什么还要包装类？

java是面向对象的语言，而基本数据类型不是对象，不具备对象的特征，在许多场合操作不便，也与设计理念不符。因此java对基本类型做了一次封装，也就是包装类，在包装类中实现一些特有方法，使得可以像操作对象一样操作基本数据类型。另外，java中的容器——集合类型，它能存放的是Object。如果此时我们需要存放基本数据类型，那就必须使用包装类。

***：Integer a = 128, int b = 128,Integer c=128, Integer d = 127，Integre e = 127；a == b? a==c? a.equals(c)? d == e？d.equals(e)?

public class Test {
    public static void main(String[] args) {
        Integer a = 128;
        int b = 128;
        Integer c = 128;
        Integer d =127;
        Integer e = 127;
        System.out.println("a == b ? " + (a==b));
        System.out.println("a == c ? " + (a ==c));
        System.out.println("a.equals(c) ? " + a.equals(c));
        System.out.println("d == e ? " + (d == e));
        System.out.println("d.equals(e) ? " + d.equals(e));
    }
}

如果不确定结果，可以执行一遍上面的代码； a == b true; a == c false; a.equals(c) true;d == e true; d.equlas(e) true.

分析：

1. a == b true：Integer包装类和int基本数据类型作比较运算时，integer包装类会进行自动拆箱，也就是相当于 int a = 128与int b = 128比较，毫无疑问，两者相等。

2. a.equals(c) true; d.equals(e) true：Integer类型，java对equals方法进行了重写。看如下Integer源码：

     /**
     * The value of the {@code Integer}.
     *
     * @serial
     */
    private final int value;

    /**
     * Constructs a newly allocated {@code Integer} object that
     * represents the specified {@code int} value.
     *
     * @param   value   the value to be represented by the
     *                  {@code Integer} object.
     */
    public Integer(int value) {
        this.value = value;
    }

     /**
     * Compares this object to the specified object.  The result is
     * {@code true} if and only if the argument is not
     * {@code null} and is an {@code Integer} object that
     * contains the same {@code int} value as this object.
     *
     * @param   obj   the object to compare with.
     * @return  {@code true} if the objects are the same;
     *          {@code false} otherwise.
     */
    public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

    /**
     * Returns the value of this {@code Integer} as an
     * {@code int}.
     */
    public int intValue() {
        return value;
    }

从Integer源码可以看到，初始化Integer对象的时候，会直接将值赋给int类型的value变量，然后equals方法就是直接将两个Integer对象的成员变量value做对比，很明显int 128 == int 128；

3. a == c false, d == e true：Integer类型有个静态内部类IntegerCache，范围在-128-127之间的都是直接从cache中返回，看一下源码：

private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }

     /**
     * Returns an {@code Integer} instance representing the specified
     * {@code int} value.  If a new {@code Integer} instance is not
     * required, this method should generally be used in preference to
     * the constructor {@link #Integer(int)}, as this method is likely
     * to yield significantly better space and time performance by
     * caching frequently requested values.
     *
     * This method will always cache values in the range -128 to 127,
     * inclusive, and may cache other values outside of this range.
     *
     * @param  i an {@code int} value.
     * @return an {@code Integer} instance representing {@code i}.
     * @since  1.5
     */
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

从源码里可以看到，当值范围在-128-127之间时，是直接从IntegerCache中返回对象（初始化之后，全部存储在常量池中）；因此值为127的d和e是完全相同的Integer对象实例，所以 d == e；而值为128的a和c，都是通过new Integer（128）来创建的，是保存在堆上，它们是不相同的两个对象，所以a != c.关于java内存分区以及数据存储的知识，详见《java基础篇--JVM》。

***： == 和 equals（）的区别？int a = 3, long b = 3, float c = 3.0f,double d = 3.0; a == b? c == d?

public class Test {
    public static void main(String[] args) {
        int a = 3;
        long b = 3;
        float c = 3.0f;
        double d = 3.0;
        System.out.println("a == b ? "+(a == b));
        System.out.println("c == d ? "+(c == d));
        System.out.println("a == c ? "+(a == c));
    }
}

== 是关系运算符，当操作数是两个基本类型时，该运算就是值比较，所以 a == b == c == d（注意这里有一个默认类型转换，小类型向大类型转换）。当操作数是引用类型时，则必须两个操作数的类型相同或者具有父子关系，并且此时比较的是两个引用的地址是否一致，仅当地址一致时，返回true。

equals()是Object对象的方法，Object默认的equals方法我们看下源码：

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

从源码我们可以看到Object默认的就是 “==”运算符，因此如果子类不对equals方法进行重写的话，那“==” 和 equals()是完全一样的。不过java已经在常用类型中对equals方法进行了重写，常用的主要有包装类和String；对这几个类型的equals()方法进行源码跟踪：

Integer：重写equals，不再是默认的地址比较，改为值比较。

    public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

Long：重写equals，不再是默认的地址比较，改为值比较。

    public boolean equals(Object obj) {
        if (obj instanceof Long) {
            return value == ((Long)obj).longValue();
        }
        return false;
    }

String：重写了equals方法

 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;
    }

3.引用类型

类：典型String
接口：
数组：

java保存对象是在内存中开辟一块空间来保存，而引用就是指向该空间的地址。

***：String s1= "ab",String s2 = new String("ab"); s1 == s2?

首先我们要知道，string是引用类型，所以这里的“==”运算符是比较的地址。string类型被设计成不可变类，对于直接赋值方式创建的字符串对象，会先从常量池中查找是否有对应字串，如果常量池中已经有了，则将地址引用返回给字符串变量；如果常量池中没有对应字串，则先在常量池中生成一个字串对象，然后返回地址引用。而通过new关键字方式创建的字符串对象，是直接在堆内存初始化一个字符串对象，然后返回地址引用。所以这里s1 != s2.

***：String a = "a",String s1 = "a"+"b",String s2 = a+"b"; s1 == "ab"? s2 == "ab"?

javac编译时会对字符串常量相加的表达式进行优化，直接将拼接后的字串存入常量池，而不需要等到执行时才做加法运算。所以这里s1 == "ab"；s2是由字符串对象a与字符串常量“b”相加，只有运行时才会实际执行加法运算，生成一个新的字串对象（临时变量在方法区，成员变量在堆内存），所以这里s2 != "ab"（“ab”字串常量在常量池中，s2在栈区或者堆区）。

***：String s = new String("abc")，请问这句执行会创建几个字符串对象？

会有两种情况：

1.创建一个：“abc”字串前面已经定义并使用过，在常量池中已经存在；这句执行后，由new关键字创建了一个新的字符串对象，保存在堆区。

2.创建两个：“abc”字串前面没有出现过，常量池中不存在。这句执行后，首先“abc”字串常量会在常量池中创建并保存，之后无论使用多少次，都是直接返回这个地址，而不新建对象；然后由new关键字创建一个新的字符串对象，保存在堆区。

***：String s = "ni hao", s += " zao an";代码执行后，原始string对象中的内容是否改变？

我们知道string被设计成不可变类，它的值不支持反复修改。因此这句执行后，其实有两个字符串对象，一开始的字符串对象是“ni hao”，保存在常量池中；后面的是经过加法运算后新生成的一个字符串对象“ni hao zao an”，保存在栈区或者堆区。而s只是指向对象的引用，一开始指向常量池中的“ni hao”，后面指向栈区/堆区的“ni hao zao an”。如此分析，我们可以看到，如果使用String类型定义的变量，并且频繁对其进行拼接等字符串操作，就会频繁的生成字符串对象，然后不停的修改指向对象的引用，显然这对内存的消耗更大，并且效率更低下。因此如果涉及频繁操作字符串，建议使用StringBuilder或者StringBuffer代替String。

***：StringBuilder和StringBuffer的区别？

StringBuilder是非线程安全的，效率高；

StringBuffer是线程安全的，效率低；

***：什么时候该用String，什么时候该用StringBuilder，什么时候该用StringBuffer？

如果是简单的string字串拼接，并且是字串常量拼接，比如 String s = "a"+"b"+"c",使用String效率最高。javac编译期之间优化为s = “abc”.

如果是频繁的不可预期的字串拼接（不是字串常量），且不需要保证线程安全，使用StringBuilder效率最高，不会创建额外对象；

如果是频繁的不可预期的字串拼接，且需要保证线程安全，则建议使用StringBuffer。

以上系个人理解，如果存在错误，欢迎大家指正。原创不易，转载请注明出处！

i18n486

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java基础篇--数据类型

Java有哪些数据类型？1.基本数据类型2.包装类***：有了基本类型，为什么还要包装类？***：Integer a = 128, int b = 128；a == b?***： == 和 equals（）的区别？3.引用类型***：String s1= "ab",String s2 = new String("ab"); s1 == s2?***：String a = "a",String s1 = "a"+"b",String s2 = a+"b"; s1 == "
复制链接

扫一扫