精华内容
下载资源
问答
  • String面试

    千次阅读 2020-10-30 19:48:03
    String s1 = "123"; String s2 = "123"; System.out.println(s1 == s2); // true System.out.println(s1.equals(s2)); // true String字符串属于常量,常量需要进入内存中的方法区的常量池(进入常量池规则:...

    1、判断s1和s2是否相等

    	String s1 = "123";
    	String s2 = "123";
    	System.out.println(s1 == s2);       // true
    	System.out.println(s1.equals(s2));  // true
    

    String字符串属于常量,常量需要进入内存中的字符串常量池进入常量池规则:如果常量池中没有这个常量,就创建一个,如果有就不再创建了),所以s2的引用也指向内存区中已经存在的“123”,所以地址一样,==对于引用类型比较的是地址,String类和其他基本类型的封装类中重写了equals方法,比较的是值。




    2、以下代码创建了几个对象

    	String s = new String("abc");
    

    2个对象(常量池中没“abc”对象),如果常量池中有abc,则是创建1个对象。s首先会在方法区的常量池创建“abc”字符串对象,当new的时候就会在堆内存中创建一个对象,此时会把常量池中的字符串常量拷贝一份副本给堆内存中的对象,堆内存中的对象会把地址赋值给s。
    常量池中的对象的地址和堆内存中对象的地址是不一样的,故创建2个对象。




    3、判断new String是否相等

    		String s1 = new String("abc");
    		String s2 = "abc";
            System.out.println(s1 == s2);            // false
            System.out.println(s1.equals(s2));       // true
    

    根据上一题得出,执行完s1后,内存中会有两个对象,一个在方法区中的常量池,一个在堆内存,地址值是不一样的,s1指向的是堆内存中的对象,当执行到s2时,s2指向的是方法区常量池中的对象。地址值不一样,==比较为false,String类重写equals方法,比较的值,故true




    4、string被final修饰,值是不可变的,解释?

    		 String s = "Java";
    		 s = "HTML";
    

    第一条语句创建了一个内容为"Java"的String对象,并将其引用赋值给s。
    第二条语句创建了一个内容为"HTML"的新String对象,并将其引用赋值给s。
    赋值后第一个String对象仍然存在,但是不能再访问它,因为变量s现在指向了新的对象。




    5、拼接字符串是否相等

    		String s1 = "a"+"b"+"c";
            String s2 = "abc";
            System.out.println(s1 == s2);    // true
    

    Java中有常量优化机制,“a”、“b”、“c”本身就是字符串常量,所以在编译时,“a”+“b”+"c"就是“abc”字符串,所以就在常量池创建了“abc”字符串,当执行s2的时候,此时常量池中已经存在了“abc”,所以==号比较返回true。equals方法比较毫无疑问是true。




    6、变量拼接字符串相等吗?

    		String s1 = "ab";
            String s2 = "abc";
            String s3 = s1 + "c";
            System.out.println(s3 == s2);        // false
            System.out.println(s3.equals(s2));   // true
    

    s1+"c"中s1不是常量,涉及到变量相加,所以会生成新的对象,其内部实现是先new一个StringBuilder/StringBuffer,然后 append(s1);append(“c”);然后让s3引用toString()返回的这个对象。
    s3指向堆内存中的对象,s2是方法区常量池中的对象,故为false;

    展开全文
  • Java String 面试题以及答案

    千次阅读 多人点赞 2017-12-08 15:25:23
    String是最常使用的Java类之一,整理的了一些重要的String知识分享给大家。 作为一个Java新手程序员,对String进行更深入的了解很有必要。如果你是有几年Java开发经验,可以根据目录选择性的阅读以下内容。

    String是最常使用的Java类之一,整理的了一些重要的String知识分享给大家。

    作为一个Java新手程序员,对String进行更深入的了解很有必要。如果你是有几年Java开发经验,可以根据目录选择性的阅读以下内容。

    1、什么是String,它是什么数据类型?

    String是定义在 java.lang 包下的一个类。它不是基本数据类型。
    String是不可变的,JVM使用字符串池来存储所有的字符串对象。

    2、创建String对象的不同方式有哪些?

    • 和使用其他类一样通过new关键字来创建。

      使用这种方式时,JVM创建字符串对象但不存储于字符串池。我们可以调用intern()方法将该字符串对象存储在字符串池,如果字符串池已经有了同样值的字符串,则返回引用。

    • 使用双引号直接创建。

      使用这种方式时,JVM去字符串池找有没有值相等字符串,如果有,则返回找到的字符串引用。否则创建一个新的字符串对象并存储在字符串池。

    String str = new String("abc");
    String str1 = "abc";
    

    3、写一个方法来判断一个String是否是回文(顺读和倒读都一样的词)?

    回文就是正反都一样的词,如果需要判断是否是回文,只需要比较正反是否相等即可。String类并没有提供反转方法供我们使用,但StringBuffer和StringBuilder有reverse方法。

    private static boolean isPalindrome(String str) {
            if (str == null)
                return false;
            StringBuilder strBuilder = new StringBuilder(str);
            strBuilder.reverse();
            return strBuilder.toString().equals(str);
        }

    假设面试官让你不使用任何其他类来实现的话,我们只需要首尾一一对比就知道是不是回文了。

    private static boolean isPalindromeString(String str) {
            if (str == null)
                return false;
            int length = str.length();
            System.out.println(length / 2);
            for (int i = 0; i < length / 2; i++) {
    
                if (str.charAt(i) != str.charAt(length - i - 1))
                    return false;
            }
            return true;
        }

    4、如何让一个字符串变成小写或大写形式?

    使用toUpperCase 和 toLowerCase 方法让一个字符串变为 大写或小写。

    5、如何比较两个字符串?

    String内部实现了Comparable接口,有两个比较方法:compareTo(String anotherString) 和compareToIgnoreCase(String str)。

    • compareTo(String anotherString)

      与传入的anotherString字符串进行比较,如果小于传入的字符串返回负数,如果大于则返回证书。当两个字符串值相等时,返回0.此时eqauls方法会返回true。

    • equalsIgnoreCase(String str)

      该方法与compareTo方法类似,区别只是内部利用了Character.toUpperCase等方法进行了大小写转换后进行比较。

    6、如何将String转换为char,反过来呢?

    这是一个误导题,String是一系列字符,所有我们没法转换成一个单一的char,但可以调用toCharArray() 方法将字符串转成字符数组。

        String str = "Java interview";
    
        //string to char array
        char[] chars = str.toCharArray();
        System.out.println(chars.length);
    

    7、如何将String转换为byte array,反过来呢?

    使用String的getBytes()方法将String转成byte数组,使用String的构造方法 new String(byte[] arr) 将byte数据转为String。

    
    public class StringToByteArray {
    
        public static void main(String[] args) {
            String str = "PANKAJ";
            byte[] byteArr = str.getBytes();
            // print the byte[] elements
            System.out.println("String to byte array: " + Arrays.toString(byteArr));
        }
    }
    
    
    public class ByteArrayToString {
    
        public static void main(String[] args) {
            byte[] byteArray = { 'P', 'A', 'N', 'K', 'A', 'J' };
            byte[] byteArray1 = { 80, 65, 78, 75, 65, 74 };
    
            String str = new String(byteArray);
            String str1 = new String(byteArray1);
    
            System.out.println(str);
            System.out.println(str1);
        }
    }
    

    8、浅谈一下String, StringBuffer,StringBuilder的区别?

    String是不可变类,每当我们对String进行操作的时候,总是会创建新的字符串。操作String很耗资源,所以Java提供了两个工具类来操作String - StringBuffer和StringBuilder。

    StringBuffer和StringBuilder是可变类,StringBuffer是线程安全的,StringBuilder则不是线程安全的。所以在多线程对同一个字符串操作的时候,我们应该选择用StringBuffer。由于不需要处理多线程的情况,StringBuilder的效率比StringBuffer高。

    9、String是不可变的有什么好处?!

    String是不可变类有以下几个优点

    • 由于String是不可变类,所以在多线程中使用是安全的,我们不需要做任何其他同步操作。
    • String是不可变的,它的值也不能被改变,所以用来存储数据密码很安全。
    • 因为java字符串是不可变的,可以在java运行时节省大量java堆空间。因为不同的字符串变量可以引用池中的相同的字符串。如果字符串是可变得话,任何一个变量的值改变,就会反射到其他变量,那字符串池也就没有任何意义了。

    10、如何分割一个String?

    • public String[] split(String regex):

      根据传入的正则字符串进行分割,注意,如果最后一位刚好有传入的字符,返回数组最后一位不会有空字符串。

    String s = "abcaada";
    System.out.println(Arrays.toString(s.split("a")));
    
    //以上代码输出为  [, bc, , d].
    
    • public String[] split(String regex, int limit):

      限制分割结果数组中有几个字符串。传入2,则结果分割后数组长度为2。

    String s = "Y,Kunming,Yunnan";
    String[] data = s.split(",", 2);
    System.out.println("Name = "+data[0]); //Y
    System.out.println("Address = "+data[1]); //Kunming,Yunnan
    

    实际上第一个方法调用了第二个方法,只不过不限制返回的数组长度了。

    public String[] split(String regex) {
        return split(regex, 0);
    }

    11、如何判断两个String是否相等?

    有两种方式判断字符串是否相等,使用”==”或者使用equals方法。当使用”==”操作符时,不仅比较字符串的值,还会比较引用的内存地址。大多数情况下,我们只需要判断值是否相等,此时用equals方法比较即可。
    还有一个equalsIgnoreCase可以用来忽略大小写进行比较。

            String s1 = "abc";
            String s2 = "abc";
            String s3= new String("abc");
            System.out.println("s1 == s2 ? "+(s1==s2)); //true
            System.out.println("s1 == s3 ? "+(s1==s3)); //false
            System.out.println("s1 equals s3 ? "+(s1.equals(s3))); //true

    12、什么是字符串池?

    顾名思义,字符串常量池就是用来存储字符串的。它存在于Java 堆内存。

    下图解释了字符串池在java堆空间如何存在以及当我们使用不同方式创建字符串时的情况。

    这里写图片描述

    以下是上图的一个编程例子

    public class StringPool {
    
    
        public static void main(String[] args) {
            String s1 = "Cat";
            String s2 = "Cat";
            String s3 = new String("Cat");
    
            System.out.println("s1 == s2 :"+(s1==s2));
            System.out.println("s1 == s3 :"+(s1==s3));
        }
    
    }
    

    运行以上代码,输出如下:

    s1 == s2 :true
    s1 == s3 :false

    一些java题中,可能会问一段代码中有几个字符串被创建,例如:

    String str = new String("Cat");

    上面一行代码将会创建1或2个字符串。如果在字符串常量池中已经有一个字符串“Cat”,那么就智慧创建一个“Cat”字符串。如果字符串常量池中没有“Cat”,那么首先会在字符串池中创建,然后才在堆内存中创建,这种情况就会创建2个对象了。

    13、String的intern()方法

    当intern()方法被调用,如果字符串池中含有一个字符串和当前调用方法的字符串eqauls相等,那么就会返回池中的字符串。如果池中没有的话,则首先将当前字符串加入到池中,然后返回引用。

    14、String是线程安全的吗?

    String是不可变类,一旦创建了String对象,我们就无法改变它的值。因此,它是线程安全的,可以安全地用于多线程环境中。

    15、为什么我们在使用HashMap的时候总是用String做key?

    因为字符串是不可变的,当创建字符串时,它的它的hashcode被缓存下来,不需要再次计算。因为HashMap内部实现是通过key的hashcode来确定value的存储位置,所以相比于其他对象更快。这也是为什么我们平时都使用String作为HashMap对象。

    16、String编程题

    1、下面的代码输入什么

    String s1 = new String("abc");
    String s2 = new String("abc");
    System.out.println(s1 == s2);

    输入false

    2、下面的代码输入什么

    String s1 = "abc";
    StringBuffer s2 = new StringBuffer(s1);
    System.out.println(s1.equals(s2));
    

    输入false,因为s2不是String类型,String的equals方法进行了类型判断。

    3、下面的代码输入什么

    String s1 = "abc";
    String s2 = new String("abc");
    s2.intern();
    System.out.println(s1 ==s2);

    输出false,intern()方法将返回从字符串池中的字符串对象的引用,但因为我们没有分配到S2,S2没有变化,如果该第三行代码为s2 =
    s2.intern(),则输入true。

    4、下面的代码将创建几个字符串对象。

    String s1 = new String("Hello");  
    String s2 = new String("Hello");

    答案是3个对象.

    第一,行1 字符串池中的“hello”对象。

    第二,行1,在堆内存中带有值“hello”的新字符串。

    第三,行2,在堆内存中带有“hello”的新字符串。这里“hello”字符串池中的字符串被重用。

    题外话

    希望上面的这些知识能够帮助到你,如果有哪些不足请留言告知!

    喜欢我的分享,请关注右下角公众号,有新博文会第一时间推送。

    展开全文
  • 10个Java经典的String面试题!.zip
  • 10个Java经典的String面试题!.pdf
  • 主要介绍了Java常用类String面试题汇总,非常不错,具有参考借鉴价值,需要的朋友可以参考下
  • Java 几道常见String面试

    万次阅读 多人点赞 2017-05-26 11:36:42
    本篇谈谈几个常见的java关于 String面试题。 (1)String s1="abc"; String s2="abc"; System.out.println(s1==s2); System.out.println(s1.equals(s2)); /*output: true true */本题主要考察对于java常量池的...

    本篇谈谈几个常见的java关于 String的面试题。
    (1)

    String s1="abc";
    String s2="abc";
    System.out.println(s1==s2);
    System.out.println(s1.equals(s2));
    /*output:
    true
    true
    */

    本题主要考察对于java常量池的理解。java中的常量池技术,是为了方便快捷地创建某些对象而出现的,当需要一个对象时,就可以从池中取一个出来(如果池中没有则创建一个),则在需要重复创建相等变量时节省了很多时间。常量池其实也就是一个内存空间,常量池存在于方法区中。根据代码顺序,先在常量池中创建”abc“,并指向s1,而后在创建s2时,由于常量池中已经存在”abc“,只需指向s2就可以,而不需要再创建。”==”在这里比较的是对象引用,故结果为”true”,String 中的equals方法经过重写后操作为“比较此字符串与指定的对象。当且仅当该参数不为 null,并且是表示与此对象相同的字符序列的 String 对象时,结果才为 true”。很明显,s1和s2的字符序列相同,故而结果为true。
    (2)“ String s1=new String(“abc”)”语句创建了几个对象?
    该语句首先String s1是声明,new String(“abc”)先在常量池中查找,若没有则创建“abc”,而后通过new在堆内存中创建对象,把“abc”拷贝赋值。String 定义为初始化一个新创建的 String 对象,表示一个与该参数相同的字符序列;换句话说,新创建的字符串是该参数字符串的一个副本。故创建常量池和堆内存中两个对象,两个对象的地址值不一样。
    (3)

    String s1=new String("abc");
    String s2="abc";
    System.out.println(s1==s2); 
    System.out.println(s1.equals(s2));
    /*output:
    false
    true
    */

    由(2)分析可知s1在堆内存中,s2在常量池中,故结果为false,true
    (4)

    String s1="a"+"b"+"c";
    String s2="abc";
    System.out.println(s1==s2);
    System.out.println(s1.equals(s2));
    /*output:
    true
    true
    */

    本题主要考察java中常量优化机制,编译时s1已经成为“abc”在常量池中查找创建,s2不需要再创建。
    (5)

    String s1="ab";
    String s2="abc";
    String s3=s1+"c";
    System.out.println(s3==s2);
    System.out.println(s3.equals(s2));
    /*output:
    false
    true
    */

    Java 语言提供对字符串串联符号(”+”)和其他对象到字符串的转换的特殊支持。字符串串联是通过 StringBuilder(或 StringBuffer)类及其 append 方法实现的,字符串转换是通过 toString 方法实现的。在本题中,先在常量池中创建”ab“,地址指向s1,再创建”abc”,指向s2。对于s3,先创建StringBuilder(或 StringBuffer)对象,通过append连接得到“abc”,再调用toString()转换得到的地址指向s3。故(s3==s2)为false.

    展开全文
  • java String类常见面试

    千次阅读 多人点赞 2018-07-26 10:07:09
    基础知识: 1、==:既可以比较基本数据类型,又可以比较引用数据类型。基本数据类型比较的是值,引用数据类型比较的是地址。...2.字符串常量存储在常量池,而new String 创建对象,在编译期间不能确定具体的...

     基础知识:

    1、==:既可以比较基本数据类型,又可以比较引用数据类型。基本数据类型比较的是值,引用数据类型比较的是地址。

    equals只能比较引用数据类型,如果没有重写Object类中的equals方法,equals方法和==号比较引用数据类型无区别   ,重写后的equals方法比较的是对象中的属性。

    2.字符串常量存储在常量池,而new String 创建对象,在编译期间不能确定具体的值,所以会在 在在内存中创建的一个地址。 所以下面的第三题用等号比较的两个地址不同,但是属性是相同的,所以用equals比较的是属性值,所以相同。

     

     

     

    1.判断定义为String类型的s1s2是否相等

    * String s1 = "abc";

    * String s2 = "abc";

    * System.out.println(s1 == s2);                 //true ,比较地址值,都在常量池,相等

    * System.out.println(s1.equals(s2));             //true,equals中,先判断两个对象的地址值,地址值相同,默认就是同一个对象,不会继续equalse中的具体值是否相等的判断了,直接会返回true。

     2.下面这句话在内存中创建了几个对象?

    * String s1 = new String("abc");                      //两个对象 :abc在常量池,有自己的地址。 new String 创建                                           对象,在编译期间不能确定具体的值,所以会在 在在内存中创建的一个地址。

     

    3.判断定义为String类型的s1和s2是否相等

    * String s1 = new String("abc");

    * String s2 = "abc";

    * System.out.println(s1 == s2); //false

    * System.out.println(s1.equals(s2));    //true

     

    4.判断定义为String类型的s1s2是否相等

    * String s1 = "a" + "b" + "c";

    * String s2 = "abc";

    * System.out.println(s1 == s2);          //true         地址值相同,都是常量,在常量池里面        

    * System.out.println(s1.equals(s2));                //true         地址值相同,默认同一个对象,值当然也是相等的。

     

    5.判断定义为String类型的s1s2是否相等

    * String s1 = "ab";

    * String s2 = "abc";

    * String s3 = s1 + "c";

    * System.out.println(s3 == s2);               //false   不相等,s1是变量,编译的时候确定不了值,在内存中会创建值,s3在堆内存中,。s2在常量池,所以不相等。

    * System.out.println(s3.equals(s2));      //true   比较两个对象的值相等。

     

    解释:这就关系到底层的运行图了

    * String s1 = "abc";

    String s2 = "abc";

    s1会在常量池中创建,s2先查看常量池中有没有,如果有的话就指向它,如果没有就在常量池中创建一个然后指向它。所以s1和s2的两种比较是相同的。

    * String s2 = "abc";

     

    展开全文
  • 结论是jdk1.8及以前String使用的是char数组,jdk1.9及以后使用的是byte数组。因为开发人员发现人们大多数使用的String还是拉丁字符而之前使用的char数组每一个char占用两个字节而拉丁字符只需要一个字节就可以存储,...
  • 关于String面试

    千次阅读 2019-01-26 16:43:04
    String str2 = new String(“123”):; 我们先来看下面这张图 我们先说常量池,常量池分为 1;编译常量池:当字节码加载进jvm的时候,存储字节码相关的信息 2;运行常量池:存储常量数据 String str1 = "123"...
  • String类常见面试

    千次阅读 多人点赞 2019-05-01 13:44:47
    1.判断定义为String类型的s1和s2是否相等? 答案解释:String类代表字符串,字符串是常量,常量需要进入到内存中的方法区的常量池(进入常量池规则:如果常量池中没有这个常量,就创建一个,如果有就不再创建了)。...
  • JAVA中String介绍以及常见面试

    千次阅读 2020-02-25 21:44:46
    深刻认识String 1)String为字符串常量:即String对象一旦创建之后该对象是不可更改的。(源码如下) String str1 = "abc"; String str2 = "abc"; String str3 = new String("abc"); System.out.println(str1 ...
  • C++ 的一个常见面试题是让你实现一个 String 类,限于时间,不可能要求具备 std::string 的功能,但至少要求能正确管理资源
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    String为什么是不可变的 Date相关 包装类相关 自动装箱与拆箱 int 和 Integer 有什么区别 Integer a= 127 与 Integer b = 127相等吗 常用工具类库 单元测试 日志 Java面试总结汇总,整理了包括Java基础知识,集合...
  • 主要介绍了JAVA面试String s = new String("xyz");产生了几个对象?,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了JAVA中String介绍及常见面试题,在java面试中经常会被面试官问到,小编通过实例代码相结合给大家详细介绍,需要的朋友可以参考下
  • String创建对象的问题(java面试题)

    千次阅读 2018-03-19 11:43:06
    String s1 = "a"; String s2 = s1 + "b"; String s3 = "a" + "b"; System.out.println(s2 == "ab");//false System.out.println(s3 == "ab");//true 至于为什么s2 == "ab" 为false,s3 == "ab";为true 在这里先讲...
  • String面试题--字符串的拼接

    千次阅读 2015-06-02 22:15:16
    我们先看看下面的程序: String s1="hello"; String s2="world"; String s3="helloworld"; System.out.println(s3==s1+s2); System.out.println(s3.equals(s1+s2)); System.out.println(s3=="hello"+"world

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 298,643
精华内容 119,457
关键字:

string面试