String s1=new String( ” xyz ” );
String s2=new String( ” xyz ” );
Boolean b1=s1.equals(s2);
Boolean b2=(s1==s2);
System .out.print(b1+ ” ” +b2);
结果:true false
==
,对于基本类型,==
是比较的是它们的值;对于引用类型,比较的是它们的地址A.short
B.Boolean
C.byte
D.float
public class Test
{
public static void changeStr(String str)
{
str = "welcome";
}
public static void main(String[] args)
{
String str = "1234";
changeStr(str);
System.out.println(str);
}
}
A.1234
B.welcome
C.空
D.不确定
A.final修饰的类不能被继承
B.final修饰的成员变量只允许赋值一次,且只能在类方法赋值
C.final修饰的局部变量即为常量,只能赋值一次。
D.final修饰的方法不允许被子类覆盖
public static void main(String[] args){
final Student s1 = new Student("lisi",18);
Student s2 = new Student("zhangsi",32);
//s1=s2; 报错 想改变地址
System.out.println("name:"+s1.getName()+" age:"+s1.getAge());
s1.setName("zhangsi");//改变对象内容
s1.setAge(32);//改变对象内容
System.out.println("name:"+s1.getName()+" age:"+s1.getAge());
}
name:lisi age:18
name:zhangsi age:32
A.ASCII
B,BCD
C.DCB
D.Unicode
A.final类的方法肯定不能被同一个包的类访问
B.final类的方法能否被同一个包的类访问不是由final决定
C.final方法等同于private方法
D.final对象本身的引用和值都不能改变
A.标准ASCII只使用7个bit
B.在简体中文的Windows系统中,ANSI就是GB2312
C.ASCII码是ANSI码的子集
D.ASCII码都是可打印字符
A.循环上万次的字符串处理
B.在一段代码内申请上百M甚至上G的内存
C.使用CGLib技术直接操作字节码运行,生成大量的动态类
D.不断创建对象
堆内存设置原理
JVM堆内存分为2块:Permanent Space 和 Heap Space。
Permanent 即 持久代(Permanent Generation),主要存放的是Java类定义信息,与垃圾收集器要收集的Java对象关系不大。
Heap = { Old + NEW = {Eden, from, to} },Old 即 年老代(Old Generation),New 即 年轻代(Young Generation)。年老代和年轻代的划分对垃圾收集影响比较大。
年轻代
所有新生成的对象首先都是放在年轻代。年轻代的目标就是尽可能快速的收集掉那些生命周期短的对象。年轻代一般分3个区,1个Eden区,2个Survivor区(from 和 to)。
大部分对象在Eden区中生成。当Eden区满时,还存活的对象将被复制到Survivor区(两个中的一个),当一个Survivor区满时,此区的存活对象将被复制到另外一个Survivor区,当另一个Survivor区也满了的时候,从前一个Survivor区复制过来的并且此时还存活的对象,将可能被复制到年老代。
2个Survivor区是对称的,没有先后关系,所以同一个Survivor区中可能同时存在从Eden区复制过来对象,和从另一个Survivor区复制过来的对象;而复制到年老区的只有从另一个Survivor区过来的对象。而且,因为需要交换的原因,Survivor区至少有一个是空的。特殊的情况下,根据程序需要,Survivor区是可以配置为多个的(多于2个),这样可以增加对象在年轻代中的存在时间,减少被放到年老代的可能。
针对年轻代的垃圾回收即 Young GC。
年老代
在年轻代中经历了N次(可配置)垃圾回收后仍然存活的对象,就会被复制到年老代中。因此,可以认为年老代中存放的都是一些生命周期较长的对象。
针对年老代的垃圾回收即 Full GC。
持久代
用于存放静态类型数据,如 Java Class, Method 等。持久代对垃圾回收没有显著影响。但是有些应用可能动态生成或调用一些Class,例如 Hibernate CGLib 等,在这种时候往往需要设置一个比较大的持久代空间来存放这些运行过程中动态增加的类型。
所以,当一组对象生成时,内存申请过程如下:
JVM会试图为相关Java对象在年轻代的Eden区中初始化一块内存区域。
当Eden区空间足够时,内存申请结束。否则执行下一步。
JVM试图释放在Eden区中所有不活跃的对象(Young GC)。释放后若Eden空间仍然不足以放入新对象,JVM则试图将部分Eden区中活跃对象放入Survivor区。
Survivor区被用来作为Eden区及年老代的中间交换区域。当年老代空间足够时,Survivor区中存活了一定次数的对象会被移到年老代。
当年老代空间不够时,JVM会在年老代进行完全的垃圾回收(Full GC)。
Full GC后,若Survivor区及年老代仍然无法存放从Eden区复制过来的对象,则会导致JVM无法在Eden区为新生成的对象申请内存,即出现“Out of Memory”。
OOM(“Out of Memory”)异常一般主要有如下2种原因:
年老代溢出,表现为:java.lang.OutOfMemoryError:Javaheapspace
这是最常见的情况,产生的原因可能是:设置的内存参数Xmx过小或程序的内存泄露及使用不当问题。
例如循环上万次的字符串处理、创建上千万个对象、在一段代码内申请上百M甚至上G的内存。还有的时候虽然不会报内存溢出,却会使系统不间断的垃圾回收,也无法处理其它请求。这种情况下除了检查程序、打印堆内存等方法排查,还可以借助一些内存分析工具,比如MAT就很不错。
持久代溢出,表现为:java.lang.OutOfMemoryError:PermGenspace
通常由于持久代设置过小,动态加载了大量Java类而导致溢出 ,解决办法唯有将参数 -XX:MaxPermSize 调大(一般256m能满足绝大多数应用程序需求)。将部分Java类放到容器共享区(例如Tomcat share lib)去加载的办法也是一个思路,但前提是容器里部署了多个应用,且这些应用有大量的共享类库
A.context.getParameter()
B.context.getInitParameter()
C.context.getAttribute()
D.context.getRequestDispatcher()
A.List
B.Map
C.Set
D.Iterator
A.可以三种类所引用:该类自身、与它在同一包中的其他类,在其他包中的该类的子类
B.可以被两种类访问和引用:该类本身、该类的所有子类
C.只能被该类自身所访问和修改
D.只能被同一个包中的类访问
A.Tree t=new Tree;
B.Tree t=new Tree();
C.Tree t=Tree();
D.Tree t[ ]=new Tree[10];
A.抽象类和接口都能实例化的
B.抽象类不能实现接口
C.抽象类方法的访问权限默认都是public
D.接口方法的访问权限默认都是public
考察接口和抽象类的特点
关于抽象类的特点
关于接口的特点
所以这题选D
public class EqualsMethod
{
public static void main(String[] args)
{
Integer n1 = new Integer(47);
Integer n2 = new Integer(47);
System.out.print(n1 == n2);
System.out.print(",");
System.out.println(n1 != n2);
}
}
A.false,false
B.false,true
C.true,false
D.true,true
public class MyClass{
static int i;
public static void main(String argv[]){
System.out.println(i);
}
}
A.有错误,变量i没有初始化。
B.null
C.1
D.0
\u0000
A.对
B.错
A.draw
B.paint
C.repaint
D.update
A.1.3
B.1.5
C.1.6
D.1.7
JMX(Java Management Extensions,即Java管理扩展)是一个为应用程序、设备、系统等植入管理功能的框架。JMX可以跨越一系列异构操作系统平台、系统体系结构和网络传输协议,灵活的开发无缝集成的系统、网络和服务管理应用
顶多考1.8和1.9的新特性。。。。所以选A。。。。。。。
A.引导类加载器(bootstrap class loader):它用来加载 Java 的核心库,是用原生代码来实现的
B.扩展类加载器(extensions class loader):它用来加载 Java 的扩展库。
C.系统类加载器(system class loader):它根据 Java 应用的类路径(CLASSPATH)来加载 Java 类
D.tomcat 为每个 App 创建一个 Loader,里面保存着此 WebApp 的 ClassLoader。需要加载 WebApp 下的类时,就取出 ClassLoader 来使用
A.栈空间满
B.年轻代空间满
C.老年代满
D.持久代满
E.System.gc()
full GC触发的条件,除直接调用System.gc外,触发Full GC执行的情况有如下四种
旧生代空间不足:旧生代空间只有在新生代对象转入及创建为大对象、大数组时才会出现不足的现象,当执行Full GC后空间仍然不足,则抛出如下错误:java.lang.OutOfMemoryError: Java heap space 为避免以上两种状况引起的FullGC,调优时应尽量做到让对象在Minor GC阶段被回收、让对象在新生代多存活一段时间及不要创建过大的对象及数组
Permanet Generation空间满:PermanetGeneration中存放的为一些class的信息等,当系统中要加载的类、反射的类和调用的方法较多时,Permanet Generation可能会被占满,在未配置为采用CMS GC的情况下会执行Full GC。如果经过Full GC仍然回收不了,那么JVM会抛出如下错误信息:java.lang.OutOfMemoryError: PermGen space 为避免Perm Gen占满造成Full GC现象,可采用的方法为增大Perm Gen空间或转为使用CMS GC
CMS GC时出现promotion failed和concurrent mode failure:对于采用CMS进行旧生代GC的程序而言,尤其要注意GC日志中是否有promotion failed和concurrent mode failure两种状况,当这两种状况出现时可能会触发Full GC。
promotionfailed是在进行Minor GC时,survivor space放不下、对象只能放入旧生代,而此时旧生代也放不下造成的;concurrent mode failure是在执行CMS GC的过程中同时有对象要放入旧生代,而此时旧生代空间不足造成的。
应对措施为:增大survivorspace、旧生代空间或调低触发并发GC的比率,但在JDK 5.0+、6.0+的版本中有可能会由于JDK的bug29导致CMS在remark完毕后很久才触发sweeping动作。对于这种状况,可通过设置-XX:CMSMaxAbortablePrecleanTime=5(单位为ms)来避免
统计得到的Minor GC晋升到旧生代的平均大小大于旧生代的剩余空间:这是一个较为复杂的触发情况,Hotspot为了避免由于新生代对象晋升到旧生代导致旧生代空间不足的现象,在进行Minor GC时,做了一个判断,如果之前统计所得到的Minor GC晋升到旧生代的平均大小大于旧生代的剩余空间,那么就直接触发Full GC。例如程序第一次触发MinorGC后,有6MB的对象晋升到旧生代,那么当下一次Minor GC发生时,首先检查旧生代的剩余空间是否大于6MB,如果小于6MB,则执行Full GC。当新生代采用PSGC时,方式稍有不同,PS GC是在Minor GC后也会检查,例如上面的例子中第一次Minor GC后,PS GC会检查此时旧生代的剩余空间是否大于6MB,如小于,则触发对旧生代的回收
除了以上4种状况外,对于使用RMI来进行RPC或管理的Sun JDK应用而言,默认情况下会一小时执行一次Full GC。可通过在启动时通过- java-Dsun.rmi.dgc.client.gcInterval=3600000来设置Full GC执行的间隔时间或通过-XX:+ DisableExplicitGC来禁止RMI调用System.gc
所以CDE
A.JTextField b = new JTextField(“开始”);
B.JLabel b = new JLabel(“开始”);
C.JCheckbox b = new JCheckbox(“开始”);
D.JButton b = new JButton(“开始”);
A.完全相同
B.基本相同
C.不相同
D.无关系
A.对
B.错
class Parent {
private int data;
public Parent(int d){ data = d; }
}
class Child extends Parent{
String name;
public Child(String s, int d){
___________________
name = s;
}
}
A.data = d;
B.super.data = d;
C.Parent(d);
D.super(d);
A.0
B.1
C.2
D.以上都不是
short a =128;
byte b =(byte) a;
A.128 127
B.128 - 128
C.128 128
D.编译错误
A.设置HTTP头标
B.设置cookie
C.读取路径信息
D.输出返回数据
response.setHeader(“Refresh”,“3”); //三秒刷新页面一次
设置cookie
Cookie c1 = new Cookie(“username”,“only”);
response.addCookie(c1);
输出返回数据
HttpServleteResponse.getOutputStream().write();
读取路径信息,request读取路径信息
从request获取各种路径总结
request.getRealPath("url"); // 虚拟目录映射为实际目录
request.getRealPath("./"); // 网页所在的目录
request.getRealPath("../"); // 网页所在目录的上一层目录
request.getContextPath(); // 应用的web目录的名称
A.sleep是线程类(Thread)的方法,wait是Object类的方法;
B.sleep不释放对象锁,wait放弃对象锁
C.sleep暂停线程、但监控状态仍然保持,结束后会自动恢复
D.wait后进入等待锁定池,只有针对此对象发出notify方法后获得对象锁进入运行状态
A.-1
B.0
C.1
D.以上都不是
A.{company:4399}
B.{“company”:{“name”:[4399,4399,4399]}}
C.{[4399,4399,4399]}
D.{“company”:[4399,4399,4399]}
E.{“company”:{“name”:4399}}
A.public
B.abstract
C.final
D.static
A.支持
B.不支持
public class Test {
public static void main(String[] args) {
Object o = new Object() {
public boolean equals(Object obj) {
return true;
}
};
System.out.println(o.equals("Fred"));
}
}
A.Fred
B.true
C.编译错误
D.运行时抛出异常
public class ZeroTest {
public static void main(String[] args) {
try{
int i = 100 / 0;
System.out.print(i);
}catch(Exception e){
System.out.print(1);
throw new RuntimeException();
}finally{
System.out.print(2);
}
System.out.print(3);
}
}
A.3
B.123
C.1
D.12
A.FilterReader
B.InputStreamReader
C.PipedReader
D.Reader
A.import java.awt.和import java.awt.event.都可以
B.只能是import java.awt.
C.只能是import java.awt.event.
D.import java.awt.*和import java.awt.event.*都不可以
A.子类可以继承父类的构造函数
B.子类中调用父类构造函数不可以直接书写父类构造函数,而应该用super();
C.用new创建子类的对象时,若子类没有带参构造函数,将先执行父类的无参构造函数,然后再执行自己的构造函数
D.子类的构造函数中可以调用其他函数
A.一个子类只能继承一个父类
B.子类可以继承父类的构造方法
C.继承具有传递性
D.父类一般具有通用性,子类更具体
public class OuterClass{
private float f=1.0f;
//插入代码到这里
}
A.class InnerClass{
public static float func(){return f;}
}
B.abstract class InnerClass{
public abstract float func(){}
}
C.static class InnerClass{
protected static float func(){return f;}
}
D.public class InnerClass{
static float func(){return f;}
}
这题主要考察以后几个知识点
所以选ABCD
A.select * from game_order where plat_game_id=5 and plat_id=134
B.select * from game_order where plat_id=134 and
plat_game_id=5 and plat_order_id=’100’
C.select * from game_order where plat_order_id=’100’
D.select * from game_order where plat_game_id=5 and
plat_order_id=’100’ and plat_id=134
E.select * from game_order where plat_game_id=5 and plat_order_id=’100’
int findSum(int m, int n){
int sum=0;
for(int i=m;i<=n;i++){
sum+=i;
}
return sum;
}
A.1
B.5
C.10
D.15
A.2japro
B.&Class
C.const
D._123
A.int x( ){ char ch=’a’; return (int)ch; }
B.void x( ){ ...return true; }
C.int x( ){ ...return true; }
D.int x( int a, b){ return a+b; }
A.public
B.private
C.static
D.final
A.private
B.无修饰符
C.public
D.protected
A.客户端通过new ServerSocket()创建TCP连接对象
B.客户端通过TCP连接对象调用accept()方法创建通信的Socket对象
C.客户端通过new Socket()方法创建通信的Socket对象
D.服务器端通过new ServerSocket()创建通信的Socket对象
A.1
B.-1
C.263+262+…+22+21+2^0
D.–(263+262+…+22+21+2^0)
A.正确
B.错误
实际上这道题考查的是两同两小一大原则
在实现接口方法的时候,也必须使用public(接口默认方法权限也是public)
String s = null;
会抛出NullPointerException异常的有()
A.if( (s!=null) & (s.length()>0) )
B.if( (s!=null) && (s.length()>0) )
C.if( (s==null) | (s.length()==0) )
D.if( (s==null) || (s.length()==0) )
A.InputStreamReader
B.BufferedReader
C.Writer
D.PipedInputStream
int c = 1;
if ( a>0 ){
if ( a>3){
c = 2;
}
else{
c = 3;
}
}
else{
c = 4;
}
A.1
B.2
C.3
D.4
A.java
B.class
C.html
D.exe
A.不需要定义类,就能创建对象
B.对象中必须有数据域和方法
C.数据域可以是基本类型变量,也可以是一个对象
D.数据域必须是基本类型变量
int i, sum=0;
for(i=0;i<10;++i,sum+=i);
A.10
B.9
C.11
D.以上答案都不正确
A.类A和类B在同一包中,类B有个protected的方法testB,类A不是类B的子类(或子类的子类),类A可以访问类B的方法testB
B.类A和类B在同一包中,类B有个protected的方法testB,类A不是类B的子类(或子类的子类),类A不可以访问类B的方法testB
C.访问权限大小范围:public > 包权限 > protected > private
D.访问权限大小范围:public > 包权限 > private > protected
A.程序可以任意指定释放内存的时间
B.JAVA程序不能依赖于垃圾回收的时间或者顺序
C.程序可明确地标识某个局部变量的引用不再被使用
D.程序可以显式地立即释放对象占有的内存
A.Swing是一个基于Java的跨平台MVC框架。使用单线程模式。
B.Swing 是为了解决 AWT 存在的问题而新开发的包,它以 AWT 为基础的
C.Swing优化了AWT,运行速度比AWT快
D.Swing是一个基于组件的框架,所有的组件都是从javax.swing.JComponent类继承来的
A.Swing是AWT的子类
B.AWT在不同操作系统中显示相同的风格
C.AWT不支持事件类型,Swing支持事件模型
D.Swing在不同的操作系统中显示相同的风格
A.ThreadLocal继承自Thread
B.ThreadLocal实现了Runnable接口
C.ThreadLocal重要作用在于多线程间的数据共享
D.ThreadLocal是采用哈希表的方式来为每个线程都提供一个变量的副本
E.ThreadLocal保证各个线程间数据安全,每个线程的数据不会被另外线程访问和破坏
ThreadLocal的类声明:
public class ThreadLocal
static class ThreadLocalMap {
static class Entry extends WeakReference {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal k, Object v) {
super(k);
value = v;
}
}
/**
* The table, resized as necessary.
* table.length MUST always be a power of two.
*/
private Entry[] table;
}
60.JDK提供的用于并发编程的同步器有哪些
A.Semaphore
B.CyclicBarrier
C.CountDownLatch
D.Counter
A.java.io
B.java.sql
C.java.awt
D.java.rmi
java.awt javax.swing
C
A.一个类只能有一个构造方法
B.一个类可以有多个不同名的构造方法
C.构造方法与类同名
D.构造方法必须自己定义,不能使用父类的构造方法
A.start( )
B.stop( )
C.init( )
D.paint( )
A.init()方法是servlet生命的起点。一旦加载了某个servlet,服务器将立即调用它的init()方法
B.service()方法处理客户机发出的所有请求
C.destroy()方法标志servlet生命周期的结束
D.servlet在多线程下使用了同步机制,因此,在并发编程下servlet是线程安全的
A.抽象类不可以实例化
B.抽象类就是一种特殊的接口
C.抽象类的方法都是抽象方法
D.抽象类的导出类一定不是抽象类
A.1
B.2
C.3
D.4
http://blog.sina.com.cn/s/blog_6a6b14100100zn6r.html
class A{}
class B extends A{}
class C extends A{}
class D extends B{}
A obj = new D();
System.out.println(obj instanceof B);
System.out.println(obj instanceof C);
System.out.println(obj instanceof D);
System.out.println(obj instanceof A);
A.1
B.2
C.3
D.4
A
| |
B C
|
D
public void getCustomerInfo() {
try {
// do something that may cause an Exception
} catch (java.io.FileNotFoundException ex) {
System.out.print("FileNotFoundException!");
} catch (java.io.IOException ex) {
System.out.print("IOException!");
} catch (java.lang.Exception ex) {
System.out.print("Exception!");
}
}
A.IOException!
B.IOException!Exception!
C.FileNotFoundException!IOException!
D.FileNotFoundException!IOException!Exception!
A.Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”); //指定MySQL JDBC驱动程序
B.String url=”jdbc:odbc:student_access”; //指定数据源为student_access
C.Connection con=DriverManager.getConnection(url); //创建连接指定数据库的对象
D.Statement stmt=con.creatStatement();//创建执行SQL语句的Statement对象
A.ActionForm
B.ValidatorActionForm
C.ValidatorForm
D.DynaValidatorActionForm
DynaValidatorActionForm 动态验证表单
Validation 确认的意思
这个好像是struts 1 的知识…
A.正确
B.错误
A.LinkedeList和ArrayList都实现了List接口
B.ArrayList是可改变大小的数组,而LinkedList是双向链接串列
C.LinkedList不支持高效的随机元素访问
D.在LinkedList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动;而在ArrayList的中间插入或删除一个元素的开销是固定的
A.正确
B.错误
A.让该类不使用任何关键字
B.使用private关键字
C.使用protected关键字
D.使用void关键字
A.正确
B.错误
A.他们都继承自Collection接口
B.List是有序的Collection,使用此接口能够精确的控制每个元素插入的位置
C.Set是一种不包含重复的元素的Collection
D.Map提供key到value的映射。一个Map中不能包含相同的key,每个key只能映射一个value
A.标准输出流System.out.println()。
B.建立数据字节输出流。
C.建立数据字节输入流。
D.标准输入流System.in.read()
A.建立
B.撤消
C.赋值
D/引用
A.RuntimeException is the superclass of those exceptions that can be thrown during the normal operation of the Java Virtual Machine.
B.A method is not required to declare in its throws clause any subclasses of RuntimeExeption that might be thrown during the execution of the method but not caught
C.An RuntimeException is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch.
D.NullPointerException is one kind of RuntimeException
A.正确
B.错误
JVM 内存可简单分为三个区:
堆区(heap):用于存放所有对象,是线程共享的(注:数组也属于对象)
栈区(stack):用于存放基本数据类型的数据和对象的引用,是线程私有的(分为:虚拟机栈和本地方法栈)
方法区(method):用于存放类信息、常量、静态变量、编译后的字节码等,是线程共享的(也被称为非堆,即 None-Heap)
Java 的垃圾回收器(GC)主要针对堆区
所以B
A.创建线程可以通过实现Runnable接口和继承Thread类
B.java利用线程使整个系统成为异步
C.新线程一旦被创建,它将自动开始运行
A.public
B.private
C.protected
D.static
A.Java中所有的类都直接或间接继承自Object,无论是否明确的指明,无论其是否是抽象类。
B.Java中的接口(interface)也继承了Object类
C.利用“==”比较两个对象时,Java调用继承自Object的equals方法,判断是否相等。
D.如果类的定义中没有重新定义toString()方法,则该类创建的对象无法使用toStrig()方法。
A.所有类的实例和数组都是在堆上分配内存的
B.堆内存由存活和死亡的对象,空闲碎片区组成
C.数组是分配在栈中的
D.对象所占的堆内存是由自动内存管理系统回收
A.依赖注入能够独立开发各组件,然后根据组件间关系进行组装
B.依赖注入提供使用接口编程
C.依赖注入使组件之间相互依赖,相互制约
D.依赖注入指对象在使用时动态注入
A.try
B.catch
C.throw
D.throws
处理异常常用的两种方式:
注意细节:使用try…catch块捕获时可以没有catch块,但当没用catch块的时候必须得有finally块
所以选A
A.this.A(x)
B.this(x)
C.super(x)
D.A(x)
A.LinkedList继承自List
B.AbstractSet继承自Set
C.HashSet继承自AbstractSet
D.WeakMap继承自HashMap
A.private
B.public
C.protected
D.static
A.session
B.Cookie
C.地址重写
D.隐藏域
,非常适合步需要大量数据存储的会话应用1 . public class ABC{
2 . public int max( int a, int b) { }
3 .
4 . }
将以下哪个方法插入行 3 是不合法的
A.public float max(float a, float b, float c){ }
B.public int max (int c, int d){ }
C.public float max(float a, float b){ }
D.private int max(int a, int b, int c){ }
A.只有通过Spring才能实现依赖注入(DI)
B.依赖注入的主要目的是解耦合
C.常见的依赖注入方式有Setter和构造方法
A.正确
B.错误
A.request.getRequestURL()
B.request. getAttribute()
C.request.getParameter()
D.request.getWriter()
A.可以实例化
B.不可以被继承
C.子类为abstract
D.只能被继承
E.可以被抽象类继承
A.地址一样,在堆栈区。
B.地址不一样,在堆栈区。
C.地址一样,在全局区。
D.地址不一样,在全局区。
int i=5;
int s=(i++)+(++i)+(i--)+(--i);
s=( )//s 的值是什么?
A.28
B.25
C.21
D.26
E.24
F.23
int s = (5)+(++6)+(7–)+(–6)
=5+7+7+5
=24;
A.ConcurrentHashMap使用synchronized关键字保证线程安全
B.HashMap实现了Collction接口
C.Array.asList方法返回java.util.ArrayList对象
D.SimpleDateFormat是线程不安全的
A.call by value不会改变实际参数的数值
B.call by reference能改变实际参数的参考地址
C.call by reference不能改变实际参数的参考地址
D.call by reference能改变实际参数的内容
A.每个中文字符占用2个字节,每个英文字符占用1个字节
B.假设数据库中的字符是以GBK编码的,那么显示数据库数据的网页也必须是GBK编码的。
C.Java的char类型,通常以UTF-16 Big Endian的方式保存一个字符。
D.实现国际化应用常用的手段是利用ResourceBundle类
显然是错误的,Java一律采用Unicode编码方式,每个字符无论中文还是英文字符都占用2个字节
也是不正确的,不同的编码之间是可以转换的,通常流程如下:
将字符串S以其自身编码方式分解为字节数组,再将字节数组以你想要输出的编码方式重新编码为字符串。
例:String newUTF8Str = new String(oldGBKStr.getBytes(“GBK”), “UTF8”);
是正确的。Java虚拟机中通常使用UTF-16的方式保存一个字符
也是正确的。ResourceBundle能够依据Local的不同,选择性的读取与Local对应后缀的properties文件,以达到国际化的目的
所以CD