JAVA面试题解惑系列(二)——到底创建了几个String对象-JAVA程序员JAVA工程师面试必看
JAVA程序员面试题
JAVA程序员面试题(2)2008-06-12 10:411.String是最基本的数据类型吗?基本数据类型包括byte、int、char、long、float、double、boolean和short。
ng.String类是final类型的，因此不可以继承这个类、不能修改这个类。
为了提高效率节省空间，我们应该用StringBuffer类2.String 和StringBuffer的区别。
JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。
这个String类提供了数值不可改变的字符串。
而这个StringBuffer类提供的字符串进行修改。
当你知道字符数据要改变的时候你就可以使用StringBuffer。
典型地，你可以使用StringBuffers来动态构造字符数据。
3.运行时异常与一般异常有何异同？异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。
java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。
4.说出Servlet的生命周期，并说出Servlet和CGI的区别。
Servlet被服务器实例化后，容器运行其init方法，请求到达时运行其service方法，service方法自动派遣运行与请求对应的doXXX方法（doGet，doPost）等，当服务器决定将实例销毁的时候调用其destroy方法.与cgi的区别在于servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。
5.Overload和Override的区别。
Overloaded的方法是否可以改变返回值的类型?方法的重写Overriding和重载Overloading是Java多态性的不同表现。
JAVA创建String对象的问题
JAVA创建String对象的问题最近在论坛上看到关于String s = new String("XYZ") + new String("XYZ");到底创建几个对象的讨论，觉得比较有意思，在此总结一下。
在JAVA中除了8种基本类型之外，其他的都是类对象及其引用。
所以"XYZ"在JAV A中是一个String对象，对于String类对象来说它的对象值是不能修改的，也就是具有不变性。
但是在下面一段程序中：1.public class TestString {2. public static void main(String args[]) {3. String s = "Hello";4. s = "Java";5. String s1 = "Java";6. String s2 = new String("Java");7. System.out.println(s);8. System.out.println(s == s1);9. System.out.println(s == s2);10. }11.}12./*output:13. *Java14. *true15. *false16. */打印出s的结果是"Java"，看起来s所引用的String变量好像是被修改了，但是如果你了解JVM(Java虚拟机)处理String变量时的机制，你就会知道事实并非如此。
在JVM的工作过程中，会创建一片的内存空间专门存入String对象，我们把这片内存空间叫做String池。
对于语句String s= "Hello";，当JVM看到"Hello"时，会在String池创建String对象存储它，并将它的引用返回给String变量s。
《Java面试题及答案》
《Java面试题及答案》Java面试题及答案Java编程语言是一门非常流行的编程语言，随着互联网的飞速发展，Java 也成为了最重要的编程语言之一。
因此，Java面试题也成为了许多Java 开发者所关注的问题。
在这篇文章中，我们将会提供一些关于Java面试题的问题和答案。
1. Java是什么？Java是一种面向对象的编程语言，最初是由Sun Microsystems的James Gosling和他的团队所开发出来的。
Java具有强大的跨平台能力，能够在各种操作系统上运行。
Java也是一种静态类型的语言，它要求程序员在编写代码时指定变量的类型和方法的返回值类型。
2. 请解释什么是面向对象编程？面向对象编程（Object-Oriented Programming，OOP）是一种编程风格，它将对象作为程序的基本构建块，通过封装、继承和多态等机制来组织代码。
封装是将数据和功能绑定在一起的机制，继承是在已有类的基础上创建新类的机制，多态则是指具有相同名字但不同实现的方法。
3. 请问什么是Java虚拟机（JVM）？Java虚拟机（Java Virtual Machine，JVM）是一个Java程序的运行环境。
它能够在各种操作系统上运行Java程序，并且具有垃圾回收和内存管理等特性。
JVM有一个字节码解释器，它能够将Java源代码编译成字节码。
JVM还有一个类加载器，它能够将字节码加载到内存中。
4. Java中有哪些数据类型？Java中有两种数据类型，一种是基本数据类型，一种是引用数据类型。
基本数据类型包括：byte、short、int、long、float、double、char、boolean。
引用数据类型包括：类、接口、数组等。
5. 什么是Java中的包（Package）？在Java中，包（Package）是一种将类和接口组织在一起的机制。
一个包可以包含多个类和接口，可以将类和接口按照功能或用途分组。
包提供了一种将类和接口进行逻辑分组的方法，同时也避免了命名空间的冲突问题。
java面试题库java面试题目及答案(3篇)
第1篇一、基础知识1. Java简介题目：请简述Java的基本特点。
答案：- 简单易学：Java设计之初就考虑了易学性，使用面向对象编程。
- 原生跨平台：Java通过JVM（Java虚拟机）实现跨平台运行。
- 安全性：Java提供了强大的安全机制，如沙箱安全模型。
- 体系结构中立：Java不依赖于特定的硬件或操作系统。
- 高效：Java的运行速度接近C/C++。
- 多线程：Java内置多线程支持，便于实现并发处理。
- 动态性：Java在运行时可以进行扩展和修改。
2. Java虚拟机题目：请解释Java虚拟机（JVM）的作用。
答案：JVM是Java程序的运行环境，其主要作用包括：- 将Java字节码转换为本地机器码。
- 管理内存，包括堆、栈、方法区等。
- 提供垃圾回收机制。
- 管理线程和同步。
3. Java内存模型题目：请简述Java内存模型的组成。
答案：Java内存模型主要由以下部分组成：- 堆（Heap）：存储对象实例和数组。
- 栈（Stack）：存储局部变量和方法调用。
- 方法区（Method Area）：存储类信息、常量、静态变量等。
- 本地方法栈（Native Method Stack）：存储本地方法调用的相关数据。
- 程序计数器（Program Counter Register）：存储线程的当前指令地址。
4. Java关键字题目：请列举并解释Java中的几个关键字。
答案：- `public`：表示访问权限为公开。
- `private`：表示访问权限为私有。
- `protected`：表示访问权限为受保护。
- `static`：表示属于类本身，而非对象实例。
- `final`：表示常量或方法不能被修改。
- `synchronized`：表示线程同步。
- `transient`：表示数据在序列化时不会被持久化。
二、面向对象编程5. 类和对象题目：请解释类和对象之间的关系。
答案：类是对象的模板，对象是类的实例。
java模拟面试题目(3篇)
第1篇一、Java基础知识1. 请简述Java语言的特点。
2. 什么是Java虚拟机（JVM）？它有什么作用？3. 什么是Java的内存模型？请解释Java内存模型中的几个关键概念：堆、栈、方法区、程序计数器、本地方法栈。
4. 什么是Java中的反射机制？请举例说明反射在Java中的应用。
5. 什么是Java中的泛型？请解释泛型的原理和作用。
6. 请简述Java中的四种访问控制符：public、protected、default、private。
7. 什么是Java中的继承和多态？请举例说明继承和多态在实际开发中的应用。
8. 什么是Java中的封装？请举例说明封装在实际开发中的应用。
9. 什么是Java中的接口和抽象类？它们之间有什么区别？10. 什么是Java中的异常处理？请解释try-catch-finally语句的执行顺序。
二、Java集合框架1. 请列举Java集合框架中的常用集合类及其特点。
2. 请简述ArrayList、LinkedList、HashMap、HashSet的区别。
3. 什么是Java中的泛型集合？请举例说明泛型集合的应用。
4. 什么是Java中的迭代器（Iterator）和枚举器（Enum）？请比较它们的区别。
5. 什么是Java中的List、Set、Map的遍历方法？6. 请解释Java中的ArrayList和LinkedList的内部实现原理。
7. 什么是Java中的HashMap的扩容机制？8. 什么是Java中的HashSet的内部实现原理？9. 请解释Java中的线程安全集合类，如CopyOnWriteArrayList、ConcurrentHashMap。
三、Java多线程与并发1. 什么是Java中的线程？请解释线程的创建、调度和同步。
2. 请简述Java中的线程状态，如新建、就绪、运行、阻塞、等待、超时等待、终止。
3. 什么是Java中的同步机制？请解释synchronized关键字的作用。
[VIP专享]JAVA面试题解惑系列(二)——到底创建了几个String对象？
![[VIP专享]JAVA面试题解惑系列(二)——到底创建了几个String对象？](https://img.taocdn.com/s3/m/be9a1599bb68a98271fefaff.png)
JAVA面试题解惑系列（二）——到底创建了几个String对象？我们首先来看一段代码：Java代码1.String str=new String("abc");紧接着这段代码之后的往往是这个问题，那就是这行代码究竟创建了几个String对象呢？相信大家对这道题并不陌生，答案也是众所周知的，2个。
接下来我们就从这道题展开，一起回顾一下与创建String对象相关的一些JAVA 知识。
我们可以把上面这行代码分成String str、=、"abc"和new String()四部分来看待。
String str只是定义了一个名为str的String类型的变量，因此它并没有创建对象；=是对变量str进行初始化，将某个对象的引用（或者叫句柄）赋值给它，显然也没有创建对象；现在只剩下new String("abc")了。
那么，new String("abc")为什么又能被看成"abc"和new String()呢？我们来看一下被我们调用了的String的构造器：Java代码1.public String(String original) {2. //other code ...3.}大家都知道，我们常用的创建一个类的实例（对象）的方法有以下两种：1.使用new创建对象。
2.调用Class类的newInstance方法，利用反射机制创建对象。
我们正是使用new调用了String类的上面那个构造器方法创建了一个对象，并将它的引用赋值给了str变量。
同时我们注意到，被调用的构造器方法接受的参数也是一个String对象，这个对象正是"abc"。
由此我们又要引入另外一种创建String对象的方式的讨论——引号内包含文本。
这种方式是String特有的，并且它与new的方式存在很大区别。
Java代码1.String str="abc";毫无疑问，这行代码创建了一个String对象。
java面试问题及答案
java面试问题及答案java面试问题及答案「篇一」1)Java 中能创建 volatile 数组吗?能，Java 中可以创建 volatile 类型数组，不过只是一个指向数组的引用，而不是整个数组。
我的意思是，如果改变引用指向的数组，将会受到 volatile 的保护，但是如果多个线程同时改变数组的元素，volatile 标示符就不能起到之前的保护作用了。
2)volatile 能使得一个非原子操作变成原子操作吗?一个典型的例子是在类中有一个 long 类型的成员变量。
如果你知道该成员变量会被多个线程访问，如计数器、价格等，你最好是将其设置为 volatile。
为什么?因为 Java 中读取 long 类型变量不是原子的，需要分成两步，如果一个线程正在修改该 long 变量的值，另一个线程可能只能看到该值的一半(前 32 位)。
但是对一个 volatile 型的 long 或 double 变量的读写是原子。
3)volatile 修饰符的有过什么实践?一种实践是用 volatile 修饰 long 和 double 变量，使其能按原子类型来读写。
double 和 long 都是64位宽，因此对这两种类型的读是分为两部分的，第一次读取第一个 32 位，然后再读剩下的 32 位，这个过程不是原子的，但 Java 中volatile 型的 long 或 double 变量的读写是原子的。
volatile 修复符的另一个作用是提供内存屏障(memory barrier)，例如在分布式框架中的'应用。
简单的说，就是当你写一个 volatile 变量之前，Java 内存模型会插入一个写屏障(write barrier)，读一个 volatile 变量之前，会插入一个读屏障(read barrier)。
意思就是说，在你写一个 volatile 域时，能保证任何线程都能看到你写的值，同时，在写之前，也能保证任何数值的更新对所有线程是可见的，因为内存屏障会将其他所有写的值更新到缓存。
职场_java面试会问什么问题
java面试会问什么问题java面试问题(一)1、问题：程序中可以允许多个类同时拥有都有main方法吗?答案：可以。
当程序运行的时候，我们会指定运行的类名。
JVM只会在你指定的类中查找main方法。
因此多个类拥有main方法并不存在命名冲突的问题。
2、问题：静态变量在什么时候加载?编译期还是运行期?静态代码块加载的时机呢?答案：当类加载器将类加载到JVM中的时候就会创建静态变量，这跟对象是否创建无关。
静态变量加载的时候就会分配内存空间。
静态代码块的代码只会在类第一次初始化的时候执行一次。
一个类可以有多个静态代码块，它并不是类的成员，也没有返回值，并且不能直接调用。
静态代码块不能包含this或者super,它们通常被用初始化静态变量。
3、问题：一个类能拥有多个main方法吗?答案：可以，但只能有一个main方法拥有以下签名： public static void main(String[] args) {}否则程序将无法通过编译。
编译器会警告你main方法已经存在。
4、问题：简单的介绍下JVM是如何工作的?答案：JVM是一台抽象的计算机，就像真实的计算机那样，它们会先将.java 文件编译成.class文件(.class文件就是字节码文件),然后用它的解释器来加载字节码。
5、问题：如果原地交换两个变量的值?答案：先把两个值相加赋值给第一个变量，然后用得到的结果减去第二个变量，赋值给第二个变量。
再用第一个变量减去第二个变量，同时赋值给第一个变量。
代码如下： int a=5,b=10;a=a+b; b=a-b; a=a-b;使用异或操作也可以交换。
第一个方法还可能会引起溢出。
异或的方法如下： int a=5,b=10;a=a+b; b=a-b; a=a-b; int a = 5; int b = 10;a = a ^ b;b = a ^ b;a = a ^ b;6、问题：什么是数据的封装?答案：数据封装的一种方式是在类中创建set和get方法来访问对象的数据变量。
java必背面试题
.011# 面试题11.为什么要使用static?使用方式: 通过类名调用创建多个对象时，共享一个静态属性和方法，当有一个对象修改了，其他对象使用时，也会改变一个类只能有一个同名的静态属性和静态方法，这样每个对象创建时，就不会再分配额外空间了，存储在方法区（静态区）节省空间。
2. jvm 内存模型有哪些，分别介绍一下？包括: 堆虚拟机栈本地方法栈程序计数器方法区堆:存储对象数组集合存储new出来的东西方法区: 存储类的信息常量（常量池中）静态变量编译器编译后的数据程序计数器: 相当于当前程序制定的字节码行号，指向下一行代码（因为多线程并发，如何实现轮流切换的，是因为每一个线程都会独立有一个程序计数器，可以保证每个线程切换之后，可以回到原来的位置）虚拟机栈: 存放的是每一个栈帧，每一个栈帧对应的一个被调用的方法栈帧包括: 局部变量表操作数栈常量池引用返回地址 .....局部变量表 : 存储局部变量操作数栈 : 程序中所有的计算过程都是它来完成常量池引用: 在方法运行时，用于引用类中的常量返回地址: 当方法被调用时，方法执行结束，还要回到调用的位置所以要保存一个方法返回地址。
本地方法栈:类似于虚拟机栈，只不过虚拟机栈运行是 java 方法，而它是运行native修饰的方法（本地方法）本地方法是操作系统帮你实现的，java只负责调用即可。
3.创建对象的方式有哪些？1.new2. 克隆3.反射4.反序列化调用构造的: 1. new 2. 反射 newInstance() 调用底层无参构造不用构造: 1. 克隆 : 在堆内存直接将已经存在的对象拷贝一份。
2.反序列化: 表示将本地文件生成一个java对象。
克隆:实现一个接口Cloneable 重写clone()User u = new User();User u2 = u.clone();深克隆:如果对象属性中也有引用类型，这些引用类型也需要实现Cloneable接口，重写clone(), 如果不重写克隆出来的对象基本类型可以克隆，引用类型不会克隆，是指向同一个对象4.什么是自动装箱和拆箱?装箱:就是自动将基本类型转换成封装类型拆箱:就是自动将封装类型转成基本类型。
java面试问题及回答
java面试问题及回答java面试问题及回答一1.Java中的方法覆盖(Overriding)和方法重载(Overloading)是什么意思？Java中的方法重载发生在同一个类里面两个或者是多个方法的方法名相同但是参数不同的情况。
与此相对，方法覆盖是说子类重新定义了父类的方法。
方法覆盖必须有相同的方法名，参数列表和返回类型。
覆盖者可能不会限制它所覆盖的方法的访问。
2.Java中，什么是构造函数?什么是构造函数重载?什么是复制构造函数?当新对象被创建的时候，构造函数会被调用。
每一个类都有构造函数。
在程序员没有给类提供构造函数的情况下，Java编译器会为这个类创建一个默认的构造函数。
Java中构造函数重载和方法重载很相似。
可以为一个类创建多个构造函数。
每一个构造函数必须有它自己唯一的参数列表。
Java不支持像C++中那样的复制构造函数，这个不同点是因为如果你不自己写构造函数的情况下，Java不会创建默认的复制构造函数。
3.Java支持多继承么？不支持，Java不支持多继承。
每个类都只能继承一个类，但是可以实现多个接口。
4.接口和抽象类的区别是什么?Java提供和支持创建抽象类和接口。
它们的实现有共同点，不同点在于：接口中所有的方法隐含的都是抽象的。
而抽象类则可以同时包含抽象和非抽象的方法。
类可以实现很多个接口，但是只能继承一个抽象类类如果要实现一个接口，它必须要实现接口声明的所有方法。
但是，类可以不实现抽象类声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。
抽象类可以在不提供接口方法实现的情况下实现接口。
Java接口中声明的变量默认都是final的。
抽象类可以包含非final的变量。
Java接口中的成员函数默认是public的。
抽象类的成员函数可以是private，protected或者是public。
接口是绝对抽象的，不可以被实例化。
抽象类也不可以被实例化，但是，如果它包含main方法的话是可以被调用的。
华为java面试题及答案
华为java面试题及答案（实用版）编制人：__________________审核人：__________________审批人：__________________编制单位：__________________编制时间：____年____月____日序言下载提示：该文档是本店铺精心编制而成的，希望大家下载后，能够帮助大家解决实际问题。
文档下载后可定制修改，请根据实际需要进行调整和使用，谢谢!并且，本店铺为大家提供各种类型的实用范文，如自我介绍、自我总结、自我鉴定、职场资料、工作报告、策划方案、演讲致辞、合同协议、条据文书、其他范文等等，想了解不同范文格式和写法，敬请关注!Download tips: This document is carefully compiled by this editor. I hope that after you download it, it can help you solve practical problems. The document can be customized and modified after downloading, please adjust and use it according to actual needs, thank you!In addition, this shop provides various types of practical sample essays, such as self-introduction, self-summary, self-assessment, workplace information, work report, planning plan, speeches, contracts, agreements, documents, other sample essays, etc. Please pay attention to the different formats and writing methods of the model essay!华为java面试题及答案华为java面试题及答案Java技术员在面试中，参加华为企业的面试中，做好准备很重要，你了解面试题目了吗?下面本店铺已经为你们整理了华为java面试题及答案,希望可以帮到你。
字符串
时间：2009-09-23 14:22 来源：未知作者：fangzhusterCSDN IE QQ百度我挖Google POCO Yahoo新浪365Key天极和讯博拉Live奇客鲜果收客饭否叽歪挖客核心提示：java 字符串对象的创建个数提一个问题，s = new String(xyz);创建了几个String Object? 答：两个对象。
String s=你好;int i=3; s=i+s; 这个表达式对吗?在java中会提示数据类型不匹配。
因为string是类!正确做法: s+=3 或者 s+='3'或者 s+=(char)i; 我们要引java 字符串对象的创建个数提一个问题，s = new String("xyz");创建了几个String Object?答：两个对象。
String s="你好";int i=3; s=i+s; 这个表达式对吗?在java中会提示数据类型不匹配。
因为string是类!正确做法: s+="3" 或者 s+='3'或者 s+=(char)i;我们要引入另外一种创建String对象的方式的讨论——引号内包含文本。
这种方式是String特有的，并且它与new的方式存在很大区别。
在JAVA虚拟机（JVM）中存在着一个字符串池，其中保存着很多String对象，并且可以被共享使用，因此它提高了效率。
String a="abc";，这行代码被执行的时候，JAVA虚拟机首先在字符串池中查找是否已经存在了值为"abc"的这么一个对象，判断依据是String类equals(Object obj)方法的返回值。
如果有，则不再创建新的对象，直接返回已存在对象的引用；如果没有，则先创建这个对象，然后把它加入到字符串池中，再将它的引用返回。
字符串对象的创建:由于字符串对象的大量使用[它是一个对象，一般而言对象总是在heap分配内存]，Java中为了节省内存空间和运行时间[如比较字符串时，==比equals()快]，在编译阶段就把所有的字符串文字放到一个文字池中，而运行时文字池成为常量池的一部分。
JavaString对象的问题Strings=a+b+c+d
JavaString对象的问题Strings=a+b+c+d 12 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 181, String s="a"+"b"+"c"+"d"创建了⼏个对象（假设之前串池是空的）2,StringBuilder sb = new StringBuilder();String a = "a";String b = "b";String c = "c";String d = "d";String s = a+b+c+d; 这句话创建了⼏个对象StringBuilder sb = new StringBuilder();sb.append("a").append("b").append("c").append("d");这句话创建了⼏个对象-------------------------------------------------------------------------------------------答案是 7 3 0第⼀题：“a”“b”“c”“d” “ab”“abc”“abcd”第⼆题： “ab”“abc”“abcd”第三题：因为a”“b”“c”“d”在串池中已经存在，不会创建对象，并且StringBuilder添加字符串的时候跟String是不⼀样的，StringBuilder是不会创建对象的（所以说我们在增加字符串长度的时候尽量⽤StringBuilder，这样会少创建对象，节省资源，提⾼效率）所以是0个对象在JVM中有⼀个字符串池，它⽤来保存很多可以被共享的String对象，这样如果我们在使⽤同样字⾯字符串时，它就使⽤字符串池中同字⾯的字符串。
【java】【String】new字符串到底创建了几个对象
【java】【String】new字符串到底创建了⼏个对象别再问我 new 字符串创建了⼏个对象了！我来证明给你看！我想所有 Java 程序员都曾被这个 new String 的问题困扰过，这是⼀道⾼频的 Java ⾯试题，但可惜的是⽹上众说纷纭，竟然找不到标准的答案。
有⼈说创建了 1 个对象，也有⼈说创建了 2 个对象，还有⼈说可能创建了 1 个或 2 个对象，但谁都没有拿出⼲掉对⽅的证据，这就让我们这帮吃⽠群众们陷⼊了两难之中，不知道到底该信谁得。
但是今天就⽃胆和⼤家聊聊这个话题，顺便再拿出点证据。
以⽬前的情况来看，关于 new String("xxx") 创建对象个数的答案有 3 种：有⼈说创建了 1 个对象；有⼈说创建了 2 个对象；有⼈说创建了 1 个或 2 个对象。
⽽出现多个答案的关键争议点在「字符串常量池」上，有的说 new 字符串的⽅式会在常量池创建⼀个字符串对象，有⼈说 new 字符串的时候并不会去字符串常量池创建对象，⽽是在调⽤ intern() ⽅法时，才会去字符串常量池检测并创建字符串。
那我们就先来说说这个「字符串常量池」。
字符串常量池字符串的分配和其他的对象分配⼀样，需要耗费⾼昂的时间和空间为代价，如果需要⼤量频繁的创建字符串，会极⼤程度地影响程序的性能，因此 JVM 为了提⾼性能和减少内存开销引⼊了字符串常量池（Constant Pool Table）的概念。
字符串常量池相当于给字符串开辟⼀个常量池空间类似于缓存区，对于直接赋值的字符串（String s="xxx"）来说，在每次创建字符串时优先使⽤已经存在字符串常量池的字符串，如果字符串常量池没有相关的字符串，会先在字符串常量池中创建该字符串，然后将引⽤地址返回变量，如下图所⽰：别再问我 new 字符串创建了⼏个对象了！我来证明给你看！以上说法可以通过如下代码进⾏证明：public class StringExample {public static void main(String[] args) {String s1 = "Java";String s2 = "Java";System.out.println(s1 == s2);}}以上程序的执⾏结果为：true，说明变量 s1 和变量 s2 指向的是同⼀个地址。
String,到底创建了多少个对象？
String，到底创建了多少个对象？Java代码1.String str=new String("aaa");这行代码究竟创建了几个String对象呢？答案是2个，而不是3个。
由于new String("aaa")相当于"aaa"与一个就是创建出来的放在堆时原实例对象，而另一个就是放在常量池中的"aaa" 对象，当然这里的str本身只是一个引用，放在栈里，用来指向堆中创建出来的对象。
常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。
它包括了关于类、方法、接口等中的常量，也包括字符串常量。
Java代码1.String str="aaa";只创建1个对象。
这里涉及到字符串常量池，在JVM中有一个字符串池，它用来保存很多可以被共享的String对象，这样如果我们在使用同样字面字符串时，它就使用字符串池中同字面的字符串。
当然我们可以使用String对象的intern()方法来访问String对象在字符串池中所对应的常量对象。
上面这行代码被执行的时候，JVM先到字符串池中查找，看是否已经存在值为"aaa"的对象，如果存在，则不再创建新的对象，直接返回已存在对象的引用；如果不存在，则先创建这个对象，然后把它加入到字符串池中，再将它的引用返回。
Java代码1.String str1="aaa";2.String str2="aaa";也只创建1个对象。
能过上面的解释这个就更清楚了，在执行第二行代码时，aaa字符串对象在池中已存在，所以直接返回池中已存在的那个字符串对象。
Java代码1.String str="aaa"+"bbb";还是只创建1个对象。
由于常量字符串是在编译的时候就也被确定的，又因"aaa"和"bbb"都是常量，因此变量str的值在编译时就可以确定。
java工程师面试题及答案
java工程师面试题及答案Java工程师面试中，面试官通常会通过一系列技术问题来评估候选人的技术能力和经验。
以下是一些常见的Java面试题及答案，供参考：1. Java和C++的主要区别是什么？- Java是一种纯面向对象的语言，而C++支持面向过程和面向对象两种编程范式。
- Java不支持指针操作，而C++支持。
- Java有垃圾回收机制，而C++需要手动管理内存。
- Java是跨平台的，而C++不是。
2. 什么是JVM？- JVM（Java虚拟机）是一个可以执行Java字节码的虚拟计算机。
它将Java源代码编译成字节码，然后在JVM上运行。
3. 什么是多线程？- 多线程是程序设计中的一种方法，允许两个或多个线程同时执行。
Java通过`Thread`类和`Runnable`接口来实现多线程。
4. 同步和异步的区别是什么？- 同步是指多个线程访问共享资源时，一次只允许一个线程访问，这样可以防止数据不一致。
- 异步是指多个线程可以同时访问共享资源，但需要额外的机制来保证数据的一致性。
5. Java中的集合框架有哪些？- Java集合框架包括`List`、`Set`、`Map`等接口，以及它们的实现类如`ArrayList`、`HashSet`、`HashMap`等。
6. 什么是泛型？- 泛型是一种类型安全的特性，它允许在编译时检查类型，从而避免类型转换的错误。
泛型在Java 5中被引入。
7. Java中的异常处理机制是怎样的？- Java使用`try`、`catch`和`finally`块来处理异常。
`try`块包含可能会抛出异常的代码，`catch`块捕获并处理异常，`finally`块则无论是否发生异常都会执行。
8. 什么是Java反射？- 反射允许程序在运行时查询、访问和修改类和对象的属性和方法。
它在Java中是通过`ng.reflect`包实现的。
9. 什么是序列化？- 序列化是将对象的状态信息转换为可以存储或传输的格式的过程。
Java初级面试题及答案
1、String s = new String("xyz")创建了几个字符串对象（）A.0B.1C.2D.32、当n=5时，下列函数的返回值是（）int foo(int n) {if(n<2) return n;return foo(n-1) + foo(n-2);}A.5B. 7C. 8D. 13、已知一棵二叉树，如果先序遍历的节点顺序是:ADCEFGHB，中序遍历是:CDFEGHAB，则后序遍历结果为:（）A.CFHGEBDAB. CDFEGHBAC. FGHCDEBAD. CFHGEDBA4、下列说法正确的有（）E.class中constructor不可忽略B. constructor可以作为普通方法被调用C. constructor在一个对象被new时被调用D. 一个class只能定义一个constructor5、ArrayList list = new ArrayList(20);语句中的 list 集合大小扩充了几次（）A.0B.1C.2D.36、Java中一个short占几个字节（）A.0B.1C.2D.37、以下语句输出的结果是什么（）System.out.print(Integer.MAX_VALUE*2);System.out.print(Integer.MIN_VALUE*2);A.-2-1B.-1-2C.-20D.-1-18、设 String s1 =”Topwalk”;String s2 =”Company”; 以下方法不可以得到字符串“TopwalkCompany”是（）A.s2+s1;B.s1.concat(s2)C.s1.append(s2);D.StringBuffer buf = new StringBuffer(s1);buf.append(s2);9、JAVA中 short类型与char类型变量在内存中分别占多少个字节分别是多少（）A.1,1B.4,2C.2,1D.2,210、下面哪个不是Object类所定义的public method？（）A.finalize()B.clone()C.wait()D.sleep()11、在List、Map、Set等接口中，不能包含重复元素的接口是哪个？（）A.ListB.MapC.SetD.均不是12、下列程序的输出结果是什么？（）import java.util.*;public class Test {public static void main(String[] args) {for(int i=0; i <=10;i++)Integer k= new Integer(i);System.out.println( "Hello world");}}A.Hello worldB.HelloC.编译错误D.以上答案都不对13、redis中常用的几种数据结构是：14、==和equals的区别:15、写出5个常见的运行时异常RuntimeException1、C2、A3、D4、C5、A6、C7、C8、C9、D10、D11、C12、C13、string、list、set、zset、hash14、==：如果比较的对象是基本数据类型，则比较的是数值是否相等；如果比较的是引用数据类型，则比较的是对象的地址值是否相等。
java-String类的常见面试题
java-String类的常见⾯试题package com.day7.one;public class DemoString { /** * @param args */ public static void main(String[] args) { demo1(); demo2(); demo3(); demo4(); demo5(); } private static void demo1() { String s1="abc"; //在常量池中创建了abc字符串 String s2="abc"; System.out.println(s1==s2); //s1和s2指向的是同⼀个地址(true) System.out.println(s1.equals(s2)); //将此字符串与指定的对象⽐较。
当且仅当该参数不为 null， //并且是与此对象表⽰相同字符序列的 String 对象时，结果才为 (true)。
} private static void demo2() { String s3=new String("abc"); //创建了两个对象，⼀个在常量池中，副本在堆内存中 } private static void demo3() { String s4=new String("abc"); String s5="abc"; System.out.println(s4==s5); //false，因为s4指向的是堆中abc的地址值，s5指向的是常量池中的地址值 System.out.println(s4.equals(s5)); //true，字符序列相同就⾏ } private static void demo4() { String s6="a"+"b"+"c"; String s7="abc"; System.out.println(s6==s7); //true，java中有常量优化机制 System.out.println(s6.equals(s7)); //true，因为s7直接指向已有的"abc"字符串地址 } private static void demo5() { String s8="ab"; String s9="abc"; String s10=s8+"c"; //s10是指向对内存中的地址 System.out.println(s8==s9); //false， System.out.println(s9.equals(s10)); //true， }}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
-JAVA程序员JAVA工程师面试必看JAVA面试题解惑系列（二）——到底创建了几个String对象？关键字: java 面试题 string 创建几个对象作者：臧圩人（zangweiren）网址：>>>转载请注明出处！<<<我们首先来看一段代码：Java代码1.String str=new String("abc");紧接着这段代码之后的往往是这个问题，那就是这行代码究竟创建了几个String对象呢？相信大家对这道题并不陌生，答案也是众所周知的，2个。
接下来我们就从这道题展开，一起回顾一下与创建String对象相关的一些JAVA知识。
我们可以把上面这行代码分成String str、=、"abc"和new String()四部分来看待。
String str只是定义了一个名为str的String类型的变量，因此它并没有创建对象；=是对变量str进行初始化，将某个对象的引用（或者叫句柄）赋值给它，显然也没有创建对象；现在只剩下new String("abc")了。
那么，new String("abc")为什么又能被看成"abc"和new String()呢？我们来看一下被我们调用了的String的构造器：Java代码1.public String(String original) {2. //other code ...3.}大家都知道，我们常用的创建一个类的实例（对象）的方法有以下两种：1.使用new创建对象。
2.调用Class类的newInstance方法，利用反射机制创建对象。
我们正是使用new调用了String类的上面那个构造器方法创建了一个对象，并将它的引用赋值给了str变量。
同时我们注意到，被调用的构造器方法接受的参数也是一个String对象，这个对象正是"abc"。
由此我们又要引入另外一种创建String对象的方式的讨论——引号内包含文本。
这种方式是String特有的，并且它与new的方式存在很大区别。
Java代码1.String str="abc";毫无疑问，这行代码创建了一个String对象。
Java代码1.String a="abc";2.String b="abc";那这里呢？答案还是一个。
Java代码1.String a="ab"+"cd";再看看这里呢？答案仍是一个。
有点奇怪吗？说到这里，我们就需要引入对字符串池相关知识的回顾了。
在JAVA虚拟机（JVM）中存在着一个字符串池，其中保存着很多String对象，并且可以被共享使用，因此它提高了效率。
由于String类是final的，它的值一经创建就不可改变，因此我们不用担心String对象共享而带来程序的混乱。
字符串池由String类维护，我们可以调用intern()方法来访问字符串池。
我们再回头看看String a="abc";，这行代码被执行的时候，JAVA虚拟机首先在字符串池中查找是否已经存在了值为"abc"的这么一个对象，它的判断依据是String类equals(Object obj)方法的返回值。
如果有，则不再创建新的对象，直接返回已存在对象的引用；如果没有，则先创建这个对象，然后把它加入到字符串池中，再将它的引用返回。
因此，我们不难理解前面三个例子中头两个例子为什么是这个答案了。
对于第三个例子：Java代码1.String a="ab"+"cd";由于常量的值在编译的时候就被确定了。
在这里，"ab"和"cd"都是常量，因此变量a的值在编译时就可以确定。
这行代码编译后的效果等同于：Java代码1.String a="abcd";因此这里只创建了一个对象"abcd"，并且它被保存在字符串池里了。
现在问题又来了，是不是所有经过“+”连接后得到的字符串都会被添加到字符串池中呢？我们都知道“==”可以用来比较两个变量，它有以下两种情况：1.如果比较的是两个基本类型（char，byte，short，int，long，float，double，boolean），则是判断它们的值是否相等。
2.如果表较的是两个对象变量，则是判断它们的引用是否指向同一个对象。
下面我们就用“==”来做几个测试。
为了便于说明，我们把指向字符串池中已经存在的对象也视为该对象被加入了字符串池：Java代码1.public class StringTest {2. public static void main(String[] args) {3. String a = "ab";// 创建了一个对象，并加入字符串池中4. System.out.println("String a = \"ab\";");5. String b = "cd";// 创建了一个对象，并加入字符串池中6. System.out.println("String b = \"cd\";");7. String c = "abcd";// 创建了一个对象，并加入字符串池中8.9. String d = "ab" + "cd";10. // 如果d和c指向了同一个对象，则说明d也被加入了字符串池11. if (d == c) {12. System.out.println("\"ab\"+\"cd\" 创建的对象 \"加入了\" 字符串池中");13. }14. // 如果d和c没有指向了同一个对象，则说明d没有被加入字符串池15. else {16. System.out.println("\"ab\"+\"cd\" 创建的对象 \"没加入\" 字符串池中");17. }18.19. String e = a + "cd";20. // 如果e和c指向了同一个对象，则说明e也被加入了字符串池21. if (e == c) {22. System.out.println(" a +\"cd\" 创建的对象 \"加入了\" 字符串池中");23. }24. // 如果e和c没有指向了同一个对象，则说明e没有被加入字符串池25. else {26. System.out.println(" a +\"cd\" 创建的对象 \"没加入\" 字符串池中");27. }28.29. String f = "ab" + b;30. // 如果f和c指向了同一个对象，则说明f也被加入了字符串池31. if (f == c) {32. System.out.println("\"ab\"+ b 创建的对象 \"加入了\" 字符串池中");33. }34. // 如果f和c没有指向了同一个对象，则说明f没有被加入字符串池35. else {36. System.out.println("\"ab\"+ b 创建的对象 \"没加入\" 字符串池中");37. }38.39. String g = a + b;40. // 如果g和c指向了同一个对象，则说明g也被加入了字符串池41. if (g == c) {42. System.out.println(" a + b 创建的对象 \"加入了\" 字符串池中");43. }44. // 如果g和c没有指向了同一个对象，则说明g没有被加入字符串池45. else {46. System.out.println(" a + b 创建的对象 \"没加入\" 字符串池中");47. }48. }49.}运行结果如下：1.String a = "ab";2.String b = "cd";3."ab"+"cd" 创建的对象 "加入了" 字符串池中4. a +"cd" 创建的对象 "没加入" 字符串池中5."ab"+ b 创建的对象 "没加入" 字符串池中6. a + b 创建的对象 "没加入" 字符串池中从上面的结果中我们不难看出，只有使用引号包含文本的方式创建的String对象之间使用“+”连接产生的新对象才会被加入字符串池中。
对于所有包含new方式新建对象（包括null）的“+”连接表达式，它所产生的新对象都不会被加入字符串池中，对此我们不再赘述。
但是有一种情况需要引起我们的注意。
请看下面的代码：Java代码1.public class StringStaticTest {2. // 常量A3. public static final String A = "ab";4.5. // 常量B6. public static final String B = "cd";7.8. public static void main(String[] args) {9. // 将两个常量用+连接对s进行初始化10. String s = A + B;11. String t = "abcd";12. if (s == t) {13. System.out.println("s等于t，它们是同一个对象");14. } else {15. System.out.println("s不等于t，它们不是同一个对象");16. }17. }18.}这段代码的运行结果如下：s等于t，它们是同一个对象这又是为什么呢？原因是这样的，对于常量来讲，它的值是固定的，因此在编译期就能被确定了，而变量的值只有到运行时才能被确定，因为这个变量可以被不同的方法调用，从而可能引起值的改变。