JAVA_SE 测试
一、填空题（共20个题目）
1.Java application中的主类需要包含main方法，main方法的返回类型是 void 。
2.Java正则表达式中,通配符\w等同于_____[A-Za-z0-9]____________。
3.System.out.println(true?false:true==true?false:true);输出结果为 false 。
4.在Java中对于基本类型变量，Java是传值的副本；对于一切对象型变量，Java都是传 地址 的副本。
5.Java中初始化一个类时,类中的方法,本质上通过_____对象.___________来引用。
6.定义一个整型数组arr，它有5个元素分别是1、2、3、4、5。用一个语句实现对数组y的声明、创建和赋值： int[] y={1,2,3,4,5} 。
7.如果一个类定义了几个相同名字的方法，且这些方法的参数都是整数类型，则这些方法的 参数个数、参数类型 必须是不同的，这种现象称为方法的重载。
8.在Java中，有时会遇到子类中的成员变量或方法与父类中的成员变量或方法同名。如果我们想使用父类中的这个成员变量或方法，就需要用到 super 关键字。
9.增强型for循环可以遍历数组，也可以遍历实现了 list 接口的集合类型。但增强型for循环不可替代for循环，因为它无法处理和下标相关的数组遍历操作。
10.需要存储元素到某种数据结构中，而且要确保元素在自然队列中没有重复，Java中的
Set 接口能保证这种能力。
11. 泛型 是Java SE1.5的新特性，其本质是参数化类型，也就是说，所操作的数据类型被指定为一个参数。这种类参数类型可用在类、接口和方法的创建中。
12.String s=”a”+”b”+”c”;一共创建了 1 个对象。
13.StringBuffered类能够灵活定义字符串，与String相比优点是 只开辟一个空间 。
14.在Java程序运行时，常常会出现一些非正常的现象。根据其严重程度的不同可以分为Error和 Exception 。
15.按照线程的模型，一个具体的线程也是由虚拟的 方法 、代码和数据组成，其中代码与数据构成了线程体，线程的行为由它决定。
16.正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须使用 synchronized 关键字进行同步存取。
17.Java的IO操作中有面向字节和面向字符两种方式。面向字节的操作以 byte 位为单位对二进制的数据进行操作，对数据不进行转换，这些类都是InputStream和OutputStream的子类。
18.一个Socket包括两个流：一个输入流和一个输出流。如果一个进程要通过网络UDP向另一个进程发送数据，只需要简单地写入与Socket相关联的 输出 流。
19.Java中用于网络操作的功能包是 net ，它包含了多个访问多种标准网络协议（必如TCP和UDP协议）的类库。
20.有一序列为23、28、32、35、 ？，请问按照排列规律问号处应填入的数字是 37 。 //5 4 3 2
二、选择题
-
国际通用编码集是（ B ）。（选择一项）
A ASCII characters
B. Unicode characters
C. Cp1252
D. UTF-8 -
下面哪个将正确编译（CD ）。（选择两项）
A Short myshort=99S; //S错误
B. float z=1.0; //未加f
C. int t=”abc”.length( );
D. char c=17; -
关于静态变量的创建，哪个选项是正确的（ CD ）。（选择两项）
A 一旦一个静态变量被分配，它就不允许改变 //地址不变，值可以改变
B. 一个静态变量在一个方法中创建，它在被调用的时候值保持不变
C. 在任意多个类的实例中，一个静态变量只存在一个
D. 一个静态标识符可以被应用到类称为静态内部类 -
以下关于条件运算符执行的代码的输出结果是（ D ）。（选择一项）
public class Test {
public static void main(String[] args) {
int a=5;
System.out.println("value is "+((a<5)?10.9:9));
//三元要求后面两值类型相同，不同往最高类型转
}
}
A 编译错误
B. 10.9
C. 9
D. 以上答案都不对 //value is 9.0 -
以下选项中关于Java语言错误的是（ BC ）。（选择两项）
A Java是强类型语言
B. Java是面向对象语言
C. Java语言的夸平台性是通过JVM实现
D. Java是动态语言 -
下列二维数组初始化语句中，错误的是（AB ）。（选择两项）
A int a[2][]={{1,2},{3,4}};
B. float a[2][2]={0};
C. int a[][]=new int[][]{{1,2},{3,4}};
D. float[] b[]={{1.0f,2.0f},{3.0f,4.0f,5.0f}}; -
以下代码输出结果是（ C ）。（选择一项）
public class Test {
public static void main(String[] args) {
int counter=0;
for(counter++;counter++<10;counter++);
//counter++只执行了第一次,count++<10,先判断count是否小于10再加1
System.out.println(counter);
}
}
A 2
4
6
8
10
B. 11
C. 12
D. 编译不正确 -
下列程序的输出结果是多少（ C ）。（选择一项）
public class Test {
static{
int x=5;
}
static int x,y;
public static void main(String[ ] args) {
x–; //-1
myMethod();
System.out.println(x+ y++ +x); //1+0+1=2
}
public static void myMethod(){
y=x++ + ++x; //y：-1+1=0
} //x：1
}
A 4
B. 3
C. 2
D. 1 -
给定如下代码输出结果是（ A ）。（选择一项）
public class Test {
public static void main(String[] args) {
String[] argg={“a”,“1”,“b”,“8”};
Set s=new TreeSet();
s.addAll(Arrays.asList(argg)); //先放入list（有序）再放入set
System.out.println(s);
}
}
A [1,8,a,b]
B. [b,a,8,1]
C. [a,1,b,8]
D. 编译不正确 -
以下代码输出结果是（ D ）。（选择一项）
public class Test {
private String value;
private Test(String value){
this.value=value;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public static void changeStr(String str,Test tempTest){
str=“welcome”;
tempTest.setValue(“ht”);
}
public static void main(String[] args) {
String str=“1234”;
Test test=new Test(“5678”);
changeStr(str, test); //值传递，地址传递
System.out.println(str+";"+test.getValue());
}
}
A 执行时报错
B. Welcomce;ht
C. 1234;5678
D. 1234;ht -
放在第8行的哪个方法会导致编译错误（ C ）。（选择一项）
1 class Super{
2 public float getNum(){
3 return 3.0f;
4 }
5 }
6
7 public class Sub extends Super{
8
9 }
A public float getNum(){
return 4.0f;
}
B. public void getNum(){}
C. public float getNum(double d){} //返回值
D. public double getNum(float d){
return 4.0d;
} -
如下代码的运行结果是 （ A ）。（选择一项）
public class Test{
public static void main(String[] args) {
List list=new ArrayList();
list.add(“hello”);
list.add(“world”);
list.add(“world”);
list.add(".");
for(Iterator i=list.iterator();i.hasNext( ) ; ){
String s=i.next(); //类型不一致，后者为Object
System.out.print(s);
}
}
}
A 编译不正确
B. helloworldworld.
C. helloworld.
D. 运行时异常 -
下列关于抽象类说法错误的是（ BC ）。（选择两项）
A 抽象类中可以不存在任何的抽象方法 //可以不存在
B. 抽象类可以被别的抽象类所继承，结果仍是抽象类
//肯定错误，抽象类不能继承，但可以通过多态实现
C. 抽象类可以使用private修饰的
D. 如果一个非抽象类从抽象类派生，不一定要通过覆盖来实现抽象类的抽象成员 -
如下代码的输出结果是（ A ）。（选择一项）
public class Test {
public static void main(String[] args) {
Father father=new Father();
Father child=new Child();
System.out.print(father.getName());
System.out.print(child.getName());
}
}
class Father{
public static String getName(){ //静态方法不能被重写
return “Father”;
}
}
class Child extends Father{
public static String getName(){
return “Child”;
}
}
A FatherFather
B. FatherChild
C. 编译失败
D. 以上答案都不对 -
针对如下代码，输出的结果为false的选项是（ AC ）。（选择两项）
public class Test {
public static void main(String[] args) {
String str1=“java”;
String str2=“java”;
String str3=new String(“java”);
StringBuffer str4=new StringBuffer(“java”);
}
}
Astr2= =str3
B str3.equals(str4) //值相等
C str1==str4
Dstr1= =str2 //地址相同 -
以下关于链式存储结构的叙述中哪个是正确的（ D ）。（选择一项）
A 链式存储结构不是顺序存取结构
B. 逻辑上相邻的节点物理上必须邻接
C. 可以通过计算直接确定第i个节点的存储地址
D. 插入、删除运算操作方便，不必移动节点 -
给定如下代码输出结果是（ C ）。（选择一项）
public class Test {
public static void main(String[] args) {
StringBuffer a=new StringBuffer(“A”);
StringBuffer b=new StringBuffer(“B”);
operate(a, b);
System.out.println(a+","+b); //a的地址没变 a:A, b经过方法发生改变 b:BB
}
static void operate(StringBuffer x,StringBuffer y){
x=y; //x指向了y的地址
x.append(y); //x追加了”B” x:BB y:BB
y=x; //y指向x的地址（一样的没变化）,这一行代码可要可无
}
}
A The code compiles and prints “A,B”.
B. The code compiles and prints “A,A”.
C. The code compiles and prints “A,BB”.
D. The code compiles and prints “AB,B”. -
定义了如下类和测试方法，请问测试时期待要捕获下面哪个选项的异常（ C ）。（选择一项）
class MyException extends Exception{
MyException(){}
}
class A{
public int format(String str) throws MyException{
int i=Integer.valueOf(str);
return i;
}
}
public class Test{
public static void main(String[] args) {
new A().format(“1”);
}
}
A Exception
B. MyException
C. MyException和NumberFormatException
D. RuntimeException -
编译并运行如下Java程序，将输出（ D ）。（选择一项）
public class Test {
public static void main(String[] args) {
try {
int num1 = 2;
int num2 = 0;
int result = num1 / num2; //除数为0，匹配异常为Exception
System.out.println(result);
throw new NumberFormatException( );
} catch (ArrayIndexOutOfBoundsException e) {
System.out.print(“1”);
} catch (NumberFormatException e) {
System.out.print(“2”);
} catch (Exception e) {
System.out.print(“3”);
} finally {
System.out.print(“4”); //不管发生什么都会执行
}
System.out.print(“5”);
}
}
A 134
B. 2345
C. 1345
D. 345 -
需要读一个比较大的文本文件，这个文件里有很多字节的数据，那么下列最合适读这类文件的选项是哪个（ A ）。（选择一项）
A FileInputStream fis = new FileInputStream(“file.name”);
B. InputStreamReader isr = new InputStreamReader(new FileInputStream(“file.name”));
C. BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(“file.name”)));
D. RandomAccessFile raf=new RandomAccessFile(“myfile.txt”,”+rw”): -
下面IO流类中属于字节输入节点流的选项是（ B ）。（选择一项）
A PrintStream和BufferedInputStream
B. FileInputStream和BufferedInputStream
C. InputStreamReader和FileInputStream
D. ByteArrayInputStream和FileInputStream -
以下哪个方法可以改变线程的状态（ AD ）。（选择两项）
A stop()
B. run()
C. start()
D. sleep() -
下面关于多线程的程序的运行结果是（ B ）。（选择一项）
public class Test {
public static void main(String[] args) {
Thread t=new Thread(){
public void run() {
pong();
}
};
t.run();
System.out.print(“ping”);
}
static void pong(){
System.out.print(“pong”);
}
}
A pingpong
B. pongping
C. pingpong和pongping都有可能
D. 都不输出 -
在TCP/IP协议中，采用什么来区分不同的应用进程（ A ）。（选择一项）
A 端口号
B. IP地址
C. 协议类型
D. MAC地址 -
TCP/IP如何解决read阻塞问题（ C ）。（选择二项）
A 两端约定文件大小,一次读取
B. 使用shutdownOutput()
C. AB都正确
D. 以上都是错误
三、不定项选择
1：Java 提供哪几种运算符 多选 ( ABCDE )。
A）算术运算符 B）位运算符
C）关系运算符 D）逻辑运算符 E）条件运算符
2：java.lang包的（）方法比较二个对象是否相等返回true.。 （B）
A:toString() B:equals() C:compare D:以上都不正确
3：下列对Java 的变量与函数说法正确的是 多选（C E ） 。
A）变量是用来保存数据的 B）变量是用来实现操作过程的C）函数是用来实现操作过程的
D）函数是用来保存数据的 E）函数的参数是数据的入口
4：已知：int[] a = new int[100];在下列给出的数组元素中，非法的是。 （D）
A:a[0] B:a[1] C:a[99] D:a[100]
5：在java中,一个类可同时定义许多同名的方法，在这些方法的形式参数个数，类型或顺序各不相同，传值也可以各不相同。这种面向对象程序的特性称为。 （C）
A:隐藏 B:覆盖 C:重载 D:Java不支持此特性
6：（）是一组常量和抽象方法的集合。 （D）
A:实例 B:类 C:包 D:接口
7：下面关于数组说法正确的是 多选（BCD） 。
A）一维数组实质上是相同类型变量的列表
B）创建一个数组首先定义数组变量所需的类型
C）char c[]=new char[26];可声明一个含有 26 个元素的 char型数组
D）当为一个多维数组的时候分配内存时，仅需要为第一指定内存，然后再分配其他维的存
E）int twain[][] = new int[4][5];可声明一个二维数组
8：Java源文件和编译后的文件扩展名分别为。 （B）
A:.class和.java B:.java各.class C:.class和.class D:.java和.java
9：设x=5;则y=x–和y=–x的结果，使y分别为。 （C）
A:5,5 B:5,6 C:5,4 D:4,4
10：若x是float类变量，x=10/4;则x 的值是。 （C）
A:2 B:2.0 C:2.5 D:编译错误
11：．下面方法中，用于调度线程使其运行的是？ 多选（ B ）
A. init() B. start()
C. run() D. resume() E. sleep()
12.下面哪种情况能实现自动转换 多选（ AC ）。
A）byte 型转换成 int 型 B）int 型转换成 byte 型
C）float 型转换成 double型 D）double 型转换成 int 型 E）char型转换成 int 型
13：下列那些是正确的JAVA字符串？多选（ AB）。
A. “”"" B. “Oxzabc”
C. “”" D. “\t\t\r\n” E. "boolean"5
14： 在使用super 和this关键字时，以下描述正确的是。（AD）
A:：在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过
B：super（）和this（）不一定要放在构造方法内第一行
C：this（）和super（）可以同时出现在一个构造函数中
D：this（）和super（）可以在static环境中使用，包括static方法和static语句块
15：以下对封装的描述正确的是。（D）
A：只能对一个类中的方法进行封装，不能对属性进行封装
B：如果子类继承了父类，对于父类中进行封装的方法，子类仍然可以直接调用
C：封装的意义不大，因此在编码时尽量不要使用
D：封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性
16：以下对继承的描述错误的。（A）
A：Java中的继承允许一个子类继承多个父类B：父类更具有通用性，子类更具体
C：Java中的继承存在着传递性D：当实例化子类时会递归调用父类中的构造方法
17： 以下关于final关键字说法错误的是（AC）（两项）
A：final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性 B：final修饰的类肯定不能被继承 C：final修饰的方法不能被重载 D：final修饰的变量不允许被再次赋值
18： 访问修饰符作用范围由大到小是。（D）
A：private-default-protected-public B：public-default-protected-private
C：private-protected-default-public D：public-protected-default-private
19： 以下（ ）不是Object类的方法。（D）
A： clone（） B：finalize（） C：toString（） D：hasNext（）
20：多态的表现形式有。（A）
A：重写 B：抽象 C：继承 D：封装
21： 以下对重载描述错误的是。（B）
A：方法重载只能发生在一个类的内部 B：构造方法不能重载
C： 重载要求方法名相同，参数列表不同 D：方法的返回值类型不是区分方法重载的条件
22：以下对接口描述错误的有。（D）
A： 接口没有提供构造方法 B： 接口中的方法默认使用public、abstract修饰
C： 接口中的属性默认使用public、static、final修饰 D： 接口不允许多继承
23： 以下对自定义异常描述正确的是。（C）
A：自定义异常必须继承Exception B：自定义异常可以继承自Error
C：自定义异常可以更加明确定位异常出错的位置和给出详细出错信息
D：程序中已经提供了丰富的异常类，使用自定义异常没有意义
24：在Java中，下面对于构造函数的描述正确的是。（D）
A：类必须显示定义构造函数 B：构造函数的返回类型是void
C：构造函数和类有相同的名称，并且不能带任何参数D： 一个类可以定义多个构造函数
25：根据下面的代码，String s = null;会抛出NullPointerException异常的有（AB）。[两项]
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) )
26：下列选项中关于java中super关键字的说法错误的是。（B）
A：super关键字是在子类对象内部指代其父类对象的引用
B：super关键字不仅可以指代子类的直接父类，还可以指代父类的父类
C：子类可以通过super关键字调用父类的方法
D：子类可以通过super关键字调用父类的属性
27：下列声明哪个是错误的。（B）
A ：int i = 10； B： float f = 1.1； C： double d = 34.4； D： long m = 4990；
28：关于抽象类的说法正确的是（B）
A：抽象类中一定包含抽象方法，否则是错误 B：包含抽象方法的类一定是抽象类 C：抽象方法可以没有方法体，也可以有方法体 D：抽象类的子类一定不是抽象类
29：所有类的基类。（A）
A：java.lang.Object B：java.lang.Class C java.applet.Applet D：java.awt.Frame
30：关于String 和 StringBuffer 下面说法正确的是 (A )
A：String操作字符串不改变原有字符串的内容 B：StringBuffer连接字符串速度没有String 快 C：String 可以使用append方法连接字符串 D：StringBuffer 在java.util包中
四、判断题（共20个题目，，正确√，错误×）
1.若源程序文件中只定义一个名为”JavaClass”的类，则文件的扩展名为JavaClass.class。（ × ）
2.基本数据类型按照容量大小，从小到大的排列为byte-short-int-char-long-float-double，转换时遵循的原则是容量小的类型自动转换为容量大的类型，容量大的类型转换为容量小的类型时，要进行强制转换。（ × ）
3.break语句可以用在switch语句中，通过break语句而退出switch语句，使程序从switch语句结构后面的第一条语句开始执行。（ √ ）
4.语句 System.out.println(4+8+“Hello,world!”); 的输出结果是48Hello,world!（ × ）
5.局部变量在定义该变量的方法被调用时被创建，而在该方法退出后被撤销，其生存期和
定义该变量的方法的生存期相同。（ √ ）
6.接口中所有成员变量都默认使用public static final修饰，所以接口中只有常量，没有变量。接口中所有的成员方法都默认使用public abstract修饰。（ √ ）
7.重写CompareTo,实现按age从大到小排序,应该this.age-o.age。（ × ）
8.Java语言允许程序为任何方法添加final()方法，该方法会在垃圾收集器你换回收对象之前被调用。但不要过分依赖该方法对系统资源进行回收和再利用，因为该方法调用后的执行结果是不可预知的。（ √ ）
9.对于要存储50个字符的字符串数组，可以使用String s[50]来声明。（ × ）
10.LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get,remove,add方法在LinkedList的首部或尾部进行相应操作。这些操作使用LinkedList可被用作堆栈、队列或双向队列。（ √ ）
11.HashSet是Set接口的一个子类，主要的特点是:不能存放重复元素，而且采用散列的存储方法，所以没有顺序。（ √ ）
12.运行时异常都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)，IOException等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。（ × ）
13.String是一个支持非可变性的类，这种类的特点是状态固定。在该对象的生命周期内，它的值是永远不变的，它是线程安全的。（ √ ）
14.Calender类中定义了一系列将日期中的年、月、日等信息单独返回进行显示或处理的方法，通常是先创建一个Date实例，然后通过Calender中的setDate()方法将该Date的实例与其关联。（ √ ）
15.Java的输入输出流包括字节流、字符流、文件流、对象流以及多线程之间通信的管道。（ √ ）
16.文件类File类是java.io中的一个重要的非流类，里面封装了对文件系统进行操作的功能。比如：创建一个空的文件的功能 newCreateFile()。（ × ）
17.Thread类提供了一系列基于线和控制的方法，如果我们需要让与当前线程具有相同优先级的线程也有运行的机会则可以设用yield()方法。（ × ）
18.Java中，新建的线程调用start()方法，如myThread.start()将使线程的状态从新生状态转为运行状态。（ × ）
19.TCP网络通信的工作步骤分为：创建Socket、打开连接到Socket的输入/输出流、按某个协议对Socket进行读/写操作、关闭Socket。（ √ ）
20.Java提供的类库支持TCP/IP协议，read阻塞是因为一直在发送数据（ √ ）
五 、简答题（）
1.int与Integer的区别。
答：int是基本数据类型，Integer是java所提供的类，int的初始值是0，Integer的初始值是null,二者可相互转化拆箱装箱过程。
2.请说明HashMap和Hashtable的区别。（）
答：
3.方法重载和方法重写的区别。
答：方法重载是在一个类的内部，方法重写必须是类继承后在类中重写；
方法重载要求的是参数列表不同、参数类型不同，其他要求一致，而重写要求方法名一样，方法的权限修饰符权限不大于父类方法，返回值类型不大于父类方法，抛出异常不大于父类方法，参数部分要求相同，所不同的是方法内部。
4.对象序列化的含义，如何实现序列化？（提示：如何序列化写出操作代码）
答：对象的序列化是指讲对象类实现Serializable接口，将对象封装在对象流里进行传输，实现序列化的代码：ObjectOutputStream a=new ObjectOutputStream(new FileOutputStream(文件名)); 其中对象的类要实现Serializable接口。
5.Java异常处理try-catch-finally的执行过程。（提示：分别从无异常与产生异常，以及如果try或catch中存在return的情况的执行过程
答：java异常处理是将可能出现异常的代码放在try里，将可能会出现的错误卸载catch内，并可以设置多个catch类匹配不同的错误类型，finally里存储是不管是否有异常都会执行的代码，因此无异常则try-finally，有一场try-catch-finally。
6.String是最基本的数据类型吗，Java基本类型有哪些?
答：String不是，java基本数据类型有：byte、short、int、long、char、float、double、boolean。
7.阐述StringBUilder和 StringBuffer区别
答：StringBuffer是线程安全,方法都是同步修饰的，每次获取tostring都直接使用缓存区来构造字符串，而StringBuilder是线程不安全的，每次复制一次字符数组，再构造一个字符串。
8.介绍hashmap底层实现原理
答：hashmap是键值对的形式存储数据，底层是通过数组的结构，数组的每一项都是链表，因而是一种数组＋链表的结构。
9.阐述list和array区别，以及各自优势
答：Array是数组：长度固定，查询快，插入慢；list是列表：长度不固定，查询慢，插入快。
10.final、finally、finalize的区别
答：final是修饰符，用来声明属性、方法、类，分别表示属性不可改变值、不可覆盖、不可继承；finally是配合try-catch使用，表示不管怎样都会执行的代码区。Finalzie是objefct类的一个方法。
11.GC是什么？为什么要有GC？
答：GC就是一种垃圾回收的机制，主要是为了将用完或者不用数据进行回收，释放空间内存。
12.简述逻辑操作(&,|)与条件操作(&&,||)的区别?
答：条件操作只能操作布尔类型的，而逻辑操作不仅可以操作布尔还有数值类型的，其中，条件操作还有短路的功能，逻辑操作没有此功能。
13.swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上
答：可以作用于byte、String上，不能用于long
六、编码题
1.编写一个Worker类，为Worker类添加相应的代码，使得Worker对象能正确放入TreeSet中。并编写相应的测试代码。
提示:
1)Worker类含有name,age,salary三个属性
2)取值，赋值的方法可省略
3)比较时，先比较工人的年龄大小，年龄小的排在前面。如果两个工人年龄相同，则根据字典顺序比较工人姓名。
4)编写测试类，向集合中添加三条数据
5)遍历集合，输出集合中的元素信息(Worker类编写toString方法)
Worker：
public class Worker implements Comparable<Worker> {
private String name;
private int age;
private double salary;
public Worker() {
}
public Worker(String name, int age, double salary) {
this.name = name;
this.age = age;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
@Override
public String toString() {
return "Worker{" +
"name='" + name + '\'' +
", age=" + age +
", salary=" + salary +
'}';
}
@Override
public int compareTo(Worker o) {
if (this.age != o.age) {
return this.age - o.age;
} else {
Comparator<Object> com = Collator.getInstance(Locale.CHINA);
return ((Collator) com).compare(this.name, o.name);
}
}
}
WorkerTest：
public class WorkerTest {
public static void main(String[] args) {
Worker w1 = new Worker("xiao",20,5555);
Worker w2 = new Worker("you",19,6666);
Worker w3 = new Worker("pei",18,7777);
TreeSet<Worker> set = new TreeSet<>();
set.add(w1);
set.add(w2);
set.add(w3);
for (Worker worker : set) {
System.out.println(worker.toString());
}
}
}
2.设计一个多线程的程序如下：设计一个火车售票模拟程序。假如火车站要有100张火车票要卖出，现在有5个售票点同时售票，用5个线程模拟这5个售票点的售票情况。（7分）
提示：要求打印出每个售票点序号及所卖出的票号。
Service：
public class Service implements Runnable {
static int ticket = 100;
@Override
public void run() {
while (true) {
synchronized (this) {
if (ticket > 0) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖出第" + ticket + "张票");
ticket--;
}
}
}
}
}
ServiceTest：
public class ServiceTest {
public static void main(String[] args) {
Service service = new Service();
Thread t1=new Thread(service);
Thread t2=new Thread(service);
Thread t3=new Thread(service);
Thread t4=new Thread(service);
Thread t5=new Thread(service);
t1.setName("1号售票员");
t2.setName("2号售票员");
t3.setName("3号售票员");
t4.setName("4号售票员");
t5.setName("5号售票员");
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
}
}
3.模拟qq聊天功能：实现客户端与服务器（一对一）的聊天功能，客户端首先发起聊天，输入的内容在服务器端和客户端显示，然后服务器端也可以输入信息，同样信息在客户端和服务端显示。
提示:
客户端
1)客户端编写聊天的方法chat()
2)要求使用BufferedReader与BufferedWriter缓冲类
3)编写用于测试的主方法调用chat()方法
服务器端
1)编写提供服务的方法service()
2)编写用于测试的主方法调用service()方法
Client：
public class clientTcp {
public static void main(String[] args) throws Exception {
chat();
}
public static void chat() throws Exception{
Socket socket = new Socket("127.0.0.1", 8888);
Scanner scanner = new Scanner(System.in);
while (true) {
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
String s = scanner.nextLine();
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
bw.write(c);
}
bw.flush();
if (s.equals("byte")) {
break;
}
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
char[] chars = new char[1024];
int i = br.read(chars);
String str = new String(chars, 0, i);
System.out.println(str);
if (str.equals("byte")) {
break;
}
}
socket.close();
}
}
Server：
public class ServerTcp {
public static void main(String[] args) throws Exception{
service();
}
public static void service() throws Exception{
ServerSocket serverSocket = new ServerSocket(8888);
Socket socket = serverSocket.accept();
Scanner scanner = new Scanner(System.in);
while(true){
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
char[] chars = new char[1024];
int i=br.read(chars);
String str=new String(chars,0,i);
System.out.println(str);
if(str.equals("byte")){
break;
}
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
String s=scanner.nextLine();
for (int j = 0; j<s.length(); j++) {
char c=s.charAt(j);
bw.write(c);
}
bw.flush();
if(s.equals("byte")){
break;
}
}
socket.close();
}
}
4.数组[8,5,6,1,2,3,4,7],使用冒泡循环和选择排序完成从小到大进行排序
冒泡排序：
public class ArraySort {
public static void main(String[] args) {
int[] a={8,5,6,1,2,3,4,7};
//冒泡排序
for (int i = 0; i <a.length ; i++) {
for (int j = 0; j < a.length-i-1; j++) {
if(a[j]>a[j+1]){
int temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
for (int i : a) {
System.out.print(i+" ");
}
}
}
选择排序：
public class ArraySort {
public static void main(String[] args) {
int[] a = {8, 5, 6, 1, 2, 3, 4, 7};
int min, temp;
//选择排序
for (int i = 0; i < a.length; i++) {
// 初始化未排序序列中最小数据数组下标
min = i;
for (int j = i + 1; j < a.length; j++) {
// 在未排序元素中继续寻找最小元素，并保存其下标
if (a[j] < a[min]) {
min = j;
}
}
// 将未排序列中最小元素放到已排序列末尾
if (min != i) {
temp = a[min];
a[min] = a[i];
a[i] = temp;
}
}
for (int i : a) {
System.out.print(i+" ");
}
}
}
5试编写一个程序，输入一个字符串，统计其中有多少各单词？单词之间用空格分开。
Countword;
public class countword {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入单词(用空格隔开)：");
String s=scanner.nextLine();
String[] strings=s.split(" ");
TreeSet<String> set = new TreeSet<>();
for (String string : strings) {
set.add(string);
}
System.out.println("共有"+set.size()+"个单词");
}
}
6 试编写程序，从一个给定的字符串中删去某一个给定的字符。
public class deleteChar {
public static void main(String[] args) {
String s="abcdea";
Scanner scanner = new Scanner(System.in);
System.out.println("请选择你要删除的字符(输入一个字母即可)：");
String str=scanner.nextLine();
char c=str.charAt(0);
char[] chars = new char[s.length()];
String s1="";
for (int i = 0; i < s.length(); i++) {
chars[i]=s.charAt(i);
}
for (char aChar : chars) {
if(aChar!=c){
s1=s1+aChar;
}
}
System.out.println(s1);
}
}
7：第一三维不平衡数组如下：Int a[][] []= {{{1,2},{3,4,5}},{{6,7},{8,9,10,11}}};
编程实现输出数组a各个元素，并求各元素之和。
public class SumIndex {
public static void main(String[] args) {
int a[][][]= {{{1,2},{3,4,5}},{{6,7},{8,9,10,11}}};
int sum=0;
for (int[][] ints : a) {
for (int[] anInt : ints) {
for (int i : anInt) {
System.out.print(i+" ");
sum+=i;
}
}
}
System.out.println("各元素之和为："+sum);
}
}
8 求1+2!+3!+…+20!的和？
public class sum {
public static void main(String[] args) {
System.out.println(sumtest(20));
}
public static int jiecheng(int n){
if(n==1){
return 1;
}else{
return n*jiecheng(n-1);
}
}
public static int sumtest(int n){
if(n==1){
return jiecheng(1);
}else{
return jiecheng(n)+sumtest(n-1);
}
}
}
答案：
一、填空题（共20个题目）
1.Java application中的主类需要包含main方法，main方法的返回类型是 void 。
2.Java正则表达式中,通配符\w等同于_______[A-Za-z0-9_]__________。
3.System.out.println(true?false:true==true?false:true);输出结果为 false 。
4.在Java中对于基本类型变量，Java是传值的副本；对于一切对象型变量，Java都是传 地址 的副本。
5.Java中初始化一个类时,类中的方法,本质上通过____二进制字符串(地址)____________来引用。
6.定义一个整型数组arr，它有5个元素分别是1、2、3、4、5。用一个语句实现对数组y的声明、创建和赋值： int[] arr=[1,2,3,4,5] 。
7.如果一个类定义了几个相同名字的方法，且这些方法的参数都是整数类型，则这些方法的 参数个数和类型 必须是不同的，这种现象称为方法的重载。
8.在Java中，有时会遇到子类中的成员变量或方法与父类中的成员变量或方法同名。如果我们想使用父类中的这个成员变量或方法，就需要用到 super 关键字。
9.增强型for循环可以遍历数组，也可以遍历实现了 Iterable 接口的集合类型。但增强型for循环不可替代for循环，因为它无法处理和下标相关的数组遍历操作。
10.需要存储元素到某种数据结构中，而且要确保元素在自然队列中没有重复，Java中的
Set 接口能保证这种能力。
11. 泛型 是Java SE1.5的新特性，其本质是参数化类型，也就是说，所操作的数据类型被指定为一个参数。这种类参数类型可用在类、接口和方法的创建中。
12.String s=”a”+”b”+”c”;一共创建了 1 个对象。
13.StringBuffered类能够灵活定义字符串，与String相比优点是 创建一个空间多次使用 。
14.在Java程序运行时，常常会出现一些非正常的现象。根据其严重程度的不同可以分为Error和 Exception 。
15.按照线程的模型，一个具体的线程也是由虚拟的 CPU 、代码和数据组成，其中代码与数据构成了线程体，线程的行为由它决定。
16.正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须使用 synchronized 关键字进行同步存取。
17.Java的IO操作中有面向字节和面向字符两种方式。面向字节的操作以 8 位为单位对二进制的数据进行操作，对数据不进行转换，这些类都是InputStream和OutputStream的子类。
18.一个Socket包括两个流：一个输入流和一个输出流。如果一个进程要通过网络UDP向另一个进程发送数据，只需要简单地写入与Socket相关联的 输出 流。
19.Java中用于网络操作的功能包是 java.net ，它包含了多个访问多种标准网络协议（必如TCP和UDP协议）的类库。
20.有一序列为23、28、32、35、 ？，请问按照排列规律问号处应填入的数字是 37 。
二、选择题
-
国际通用编码集是（ B ）。（选择一项）
A ASCII characters
B. Unicode characters
C. Cp1252
D. UTF-8 -
下面哪个将正确编译（ CD ）。（选择两项）
A Short myshort=99S;
B. float z=1.0;
C. int t=”abc”.length( );
D. char c=17; -
关于静态变量的创建，哪个选项是正确的（ CD ）。（选择两项）
A 一旦一个静态变量被分配，它就不允许改变
B. 一个静态变量在一个方法中创建，它在被调用的时候值保持不变
C. 在任意多个类的实例中，一个静态变量只存在一个
D. 一个静态标识符可以被应用到类称为静态内部类 -
以下关于条件运算符执行的代码的输出结果是（ D ）。（选择一项）
public class Test {
public static void main(String[] args) {
int a=5;
System.out.println("value is "+((a<5)?10.9:9));
}
}
A 编译错误
B. 10.9
C. 9
D. 以上答案都不对 -
以下选项中关于Java语言错误的是（ BD ）。（选择两项）
A Java是强类型语言
B. Java是面向对象语言
C. Java语言的夸平台性是通过JVM实现
D. Java是动态语言 -
下列二维数组初始化语句中，错误的是（ AB ）。（选择两项）
A int a[2][]={{1,2},{3,4}};
B. float a[2][2]={0};
C. int a[][]=new int[][]{{1,2},{3,4}};
D. float[] b[]={{1.0f,2.0f},{3.0f,4.0f,5.0f}}; -
以下代码输出结果是（ C ）。（选择一项）
public class Test {
public static void main(String[] args) {
int counter=0;
for(counter++;counter++<10;counter++);
System.out.println(counter);
}
}
A 2
4
6
8
10
B. 11
C. 12
D. 编译不正确 -
下列程序的输出结果是多少（ C ）。（选择一项）
public class Test {
static{
int x=5;
}
static int x,y;
public static void main(String[ ] args) {
x–;
myMethod();
System.out.println(x+ y++ +x);
}
public static void myMethod(){
y=x++ + ++x;
}
}
A 4
B. 3
C. 2
D. 1 -
给定如下代码输出结果是（ A ）。（选择一项）
public class Test {
public static void main(String[] args) {
String[] argg={“a”,“1”,“b”,“8”};
Set s=new TreeSet();
s.addAll(Arrays.asList(argg));
System.out.println(s);
}
}
A [1,8,a,b]
B. [b,a,8,1]
C. [a,1,b,8]
D. 编译不正确 -
以下代码输出结果是（ D ）。（选择一项）
public class Test {
private String value;
private Test(String value){
this.value=value;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public static void changeStr(String str,Test tempTest){
str=“welcome”;
tempTest.setValue(“ht”);
}
public static void main(String[] args) {
String str=“1234”;
Test test=new Test(“5678”);
changeStr(str, test);
System.out.println(str+";"+test.getValue());
}
}
A 执行时报错
B. Welcomce;ht
C. 1234;5678
D. 1234;ht -
放在第8行的哪个方法会导致编译错误（ B ）。（选择一项）
- class Super{
-
public float getNum(){ -
return 3.0f; -
} -
}
-
public class Sub extends Super{
-
}
A public float getNum(){
return 4.0f;
}
B. public void getNum(){}
C. public float getNum(double d){
return 1.2f;
}
D. public double getNum(float d){
return 4.0;
} -
如下代码的运行结果是 （ A ）。（选择一项）
public class Test{
public static void main(String[] args) {
List list=new ArrayList();
list.add(“hello”);
list.add(“world”);
list.add(“world”);
list.add(".");
for(Iterator i=list.iterator();i.hasNext()😉{
String s=i.next();
System.out.print(s);
}
}
}
A 编译不正确
B. helloworldworld.
C. helloworld.
D. 运行时异常 -
下列关于抽象类说法错误的是（ CD ）。（选择两项）
A 抽象类中可以不存在任何的抽象方法
B. 抽象类可以被别的抽象类所继承，结果仍是抽象类
C. 抽象类可以使用private修饰的
D. 如果一个非抽象类从抽象类派生，不一定要通过覆盖来实现抽象类的抽象成员 -
如下代码的输出结果是（ A ）。（选择一项）
public class Test {
public static void main(String[] args) {
Father father=new Father();
Father child=new Child();
System.out.print(father.getName());
System.out.print(child.getName());
}
}
class Father{
public static String getName(){
return “Father”;
}
}
class Child extends Father{
public static String getName(){
return “Child”;
}
}
A FatherFather
B. FatherChild
C. 编译失败
D. 以上答案都不对 -
针对如下代码，输出的结果为false的选项是（ AB ）。（选择两项）
public class Test {
public static void main(String[] args) {
String str1=“java”;
String str2=“java”;
String str3=new String(“java”);
StringBuffer str4=new StringBuffer(“java”);
}
}
A str2str3
B. str3.equals(str4)
C. str1str4
D. str1==str2 -
以下关于链式存储结构的叙述中哪个是正确的（ D ）。（选择一项）
A 链式存储结构不是顺序存取结构
B. 逻辑上相邻的节点物理上必须邻接
C. 可以通过计算直接确定第i个节点的存储地址
D. 插入、删除运算操作方便，不必移动节点 -
给定如下代码输出结果是（ C ）。（选择一项）
public class Test {
public static void main(String[] args) {
StringBuffer a=new StringBuffer(“A”);
StringBuffer b=new StringBuffer(“B”);
operate(a, b);
System.out.println(a+","+b);
}
static void operate(StringBuffer x,StringBuffer y){
x=y;
x.append(y);
y=x;
}
}
A The code compiles and prints “A,B”.
B. The code compiles and prints “A,A”.
C. The code compiles and prints “A,BB”.
D. The code compiles and prints “AB,B”. -
定义了如下类和测试方法，请问测试时期待要捕获下面哪个选项的异常（ B ）。（选择一项）
class MyException extends Exception{
MyException(){}
}
class A{
public int format(String str) throws MyException{
int i=Integer.valueOf(str);
return i;
}
}
public class Test{
public static void main(String[] args) {
new A().format(“1”);
}
}
A Exception
B. MyException
C. MyException和NumberFormatException
D. RuntimeException -
编译并运行如下Java程序，将输出（ D ）。（选择一项）
public class Test {
public static void main(String[] args) {
try {
int num1 = 2;
int num2 = 0;
int result = num1 / num2;
System.out.println(result);
throw new NumberFormatException( );
} catch (ArrayIndexOutOfBoundsException e) {
System.out.print(“1”);
} catch (NumberFormatException e) {
System.out.print(“2”);
} catch (Exception e) {
System.out.print(“3”);
} finally {
System.out.print(“4”);
}
System.out.print(“5”);
}
}
A 134
B. 2345
C. 1345
D. 345 -
需要读一个比较大的文本文件，这个文件里有很多字节的数据，那么下列最合适读这类文件的选项是哪个（ C ）。（选择一项）
A FileInputStream fis = new FileInputStream(“file.name”);
B. InputStreamReader isr = new InputStreamReader(new FileInputStream(“file.name”));
C. BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(“file.name”)));
D. RandomAccessFile raf=new RandomAccessFile(“myfile.txt”,”+rw”): -
下面IO流类中属于字节输入节点流的选项是（ D ）。（选择一项）
A PrintStream和BufferedInputStream
B. FileInputStream和BufferedInputStream
C. InputStreamReader和FileInputStream
D. ByteArrayInputStream和FileInputStream -
以下哪个方法可以改变线程的状态（ AD ）。（选择两项）
A stop()
B. run()
C. start()
D. sleep() -
下面关于多线程的程序的运行结果是（ B ）。（选择一项）
public class Test {
public static void main(String[] args) {
Thread t=new Thread(){
public void run() {
pong();
}
};
t.run();
System.out.print(“ping”);
}
static void pong(){
System.out.print(“pong”);
}
}
A pingpong
B. pongping
C. pingpong和pongping都有可能
D. 都不输出 -
在TCP/IP协议中，采用什么来区分不同的应用进程（ A ）。（选择一项）
A 端口号
B. IP地址
C. 协议类型
D. MAC地址 -
TCP/IP如何解决read阻塞问题（ AB ）。（选择二项）
A 两端约定文件大小,一次读取
B. 使用shutdownOutput()
C. AB都不正确
D. 以上都是错误
三、不定项选择
1：Java 提供哪几种运算符 多选 ( ABCDE )。
A）算术运算符 B）位运算符
C）关系运算符 D）逻辑运算符 E）条件运算符
2：java.lang包的（）方法比较二个对象是否相等返回true.。 （B）
A:toString() B:equals() C:compare D:以上都不正确
3：下列对Java 的变量与函数说法正确的是 多选（ ACE ） 。
A）变量是用来保存数据的 B）变量是用来实现操作过程的C）函数是用来实现操作过程的
D）函数是用来保存数据的 E）函数的参数是数据的入口
4：已知：int[] a = new int[100];在下列给出的数组元素中，非法的是。 （D）
A:a[0] B:a[1] C:a[99] D:a[100]
5：在java中,一个类可同时定义许多同名的方法，在这些方法的形式参数个数，类型或顺序各不相同，传值也可以各不相同。这种面向对象程序的特性称为。 （C）
A:隐藏 B:覆盖 C:重载 D:Java不支持此特性
6：（）是一组常量和抽象方法的集合。 （D）
A:实例 B:类 C:包 D:接口
7：下面关于数组说法正确的是 多选（ABCDE） 。
A）一维数组实质上是相同类型变量的列表
B）创建一个数组首先定义数组变量所需的类型
C）char c[]=new char[26];可声明一个含有 26 个元素的 char型数组
D）当为一个多维数组的时候分配内存时，仅需要为第一指定内存，然后再分配其他维的存
E）int twain[][] = new int[4][5];可声明一个二维数组
8：Java源文件和编译后的文件扩展名分别为。 （B）
A:.class和.java B:.java各.class C:.class和.class D:.java和.java
9：设x=5;则y=x–和y=–x的结果，使y分别为。 （C）
A:5,5 B:5,6 C:5,4 D:4,4
10：若x是float类变量，x=10/4;则x 的值是。 （B）
A:2 B:2.0 C:2,5 D:编译错误
11：．下面方法中，用于调度线程使其运行的是？ 多选（ B ）
A. init() B. start()
C. run() D. resume() E. sleep()
12.下面哪种情况能实现自动转换 多选（ ACE ）。
A）byte 型转换成 int 型 B）int 型转换成 byte 型
C）float 型转换成 double型 D）double 型转换成 int 型 E）char型转换成 int 型
13：下列那些是正确的JAVA字符串？多选（ABD ）。
A. “”"" B. “Oxzabc”
C. “”" D. “\t\t\r\n” E. "boolean"5
14： 在使用super 和this关键字时，以下描述正确的是。（A）
A:：在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过
B：super（）和this（）不一定要放在构造方法内第一行
C：this（）和super（）可以同时出现在一个构造函数中
D：this（）和super（）可以在static环境中使用，包括static方法和static语句块
15：以下对封装的描述正确的是。（D）
A：只能对一个类中的方法进行封装，不能对属性进行封装
B：如果子类继承了父类，对于父类中进行封装的方法，子类仍然可以直接调用
C：封装的意义不大，因此在编码时尽量不要使用
D：封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性
16：以下对继承的描述错误的。（A）
A：Java中的继承允许一个子类继承多个父类B：父类更具有通用性，子类更具体
C：Java中的继承存在着传递性D：当实例化子类时会递归调用父类中的构造方法
17： 以下关于final关键字说法错误的是（AC）（两项）
A：final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性 B：final修饰的类肯定不能被继承 C：final修饰的方法不能被重载 D：final修饰的变量不允许被再次赋值
18： 访问修饰符作用范围由大到小是。（D）
A：private-default-protected-public B：public-default-protected-private
C：private-protected-default-public D：public-protected-default-private
19： 以下（ ）不是Object类的方法。（D）
A： clone（） B：finalize（） C：toString（） D：hasNext（）
20：多态的表现形式有。（A）
A：重写 B：抽象 C：继承 D：封装
21： 以下对重载描述错误的是。（B）
A：方法重载只能发生在一个类的内部 B：构造方法不能重载
C： 重载要求方法名相同，参数列表不同 D：方法的返回值类型不是区分方法重载的条件
22：以下对接口描述错误的有。（D）
A： 接口没有提供构造方法 B： 接口中的方法默认使用public、abstract修饰
C： 接口中的属性默认使用public、static、final修饰 D： 接口不允许多继承
23： 以下对自定义异常描述正确的是。（C）
A：自定义异常必须继承Exception B：自定义异常可以继承自Error
C：自定义异常可以更加明确定位异常出错的位置和给出详细出错信息
D：程序中已经提供了丰富的异常类，使用自定义异常没有意义
24：在Java中，下面对于构造函数的描述正确的是。（D）
A：类必须显示定义构造函数 B：构造函数的返回类型是void
C：构造函数和类有相同的名称，并且不能带任何参数D： 一个类可以定义多个构造函数
25：根据下面的代码，String s = null;会抛出NullPointerException异常的有（AC）。[两项]
A：if( (s!=null) & (s.length()>0) ) B：if( (s!=null) & & (s.length()>0) )
C：if( (s==null) | (s.length()0) ) D：if( (snull) || (s.length()==0) )
26：下列选项中关于java中super关键字的说法错误的是。（B）
A：super关键字是在子类对象内部指代其父类对象的引用
B：super关键字不仅可以指代子类的直接父类，还可以指代父类的父类
C：子类可以通过super关键字调用父类的方法
D：子类可以通过super关键字调用父类的属性
27：下列声明哪个是错误的。（B）
A ：int i = 10； B： float f = 1.1； C： double d = 34.4； D： long m = 4990；
28：关于抽象类的说法正确的是（B）
A：抽象类中一定包含抽象方法，否则是错误 B：包含抽象方法的类一定是抽象类 C：抽象方法可以没有方法体，也可以有方法体 D：抽象类的子类一定不是抽象类
29：所有类的基类。（A）
A：java.lang.Object B：java.lang.Class C java.applet.Applet D：java.awt.Frame
30：关于String 和 StringBuffer 下面说法正确的是 (A )
A：String操作字符串不改变原有字符串的内容 B：StringBuffer连接字符串速度没有String 快 C：String 可以使用append方法连接字符串 D：StringBuffer 在java.util包中
四、判断题（共20个题目，，正确√，错误×）
1.若源程序文件中只定义一个名为”JavaClass”的类，则文件的扩展名为JavaClass.class。（ F ）
2.基本数据类型按照容量大小，从小到大的排列为byte-short-int-char-long-float-double，转换时遵循的原则是容量小的类型自动转换为容量大的类型，容量大的类型转换为容量小的类型时，要进行强制转换。（ F ）
3.break语句可以用在switch语句中，通过break语句而退出switch语句，使程序从switch语句结构后面的第一条语句开始执行。（ T ）
4.语句 System.out.println(4+8+“Hello,world!”); 的输出结果是48Hello,world!（ F ）
5.局部变量在定义该变量的方法被调用时被创建，而在该方法退出后被撤销，其生存期和
定义该变量的方法的生存期相同。（ T ）
6.接口中所有成员变量都默认使用public static final修饰，所以接口中只有常量，没有变量。接口中所有的成员方法都默认使用public abstract修饰。（ T ）
7.重写CompareTo,实现按age从大到小排序,应该this.age-o.age。（ F ）
8.Java语言允许程序为任何方法添加final()方法，该方法会在垃圾收集器你换回收对象之前被调用。但不要过分依赖该方法对系统资源进行回收和再利用，因为该方法调用后的执行结果是不可预知的。（ F ）
9.对于要存储50个字符的字符串数组，可以使用String s[50]来声明。（ F ）×
10.LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get,remove,add方法在LinkedList的首部或尾部进行相应操作。这些操作使用LinkedList可被用作堆栈、队列或双向队列。（ T ）
11.HashSet是Set接口的一个子类，主要的特点是:不能存放重复元素，而且采用散列的存储方法，所以没有顺序。（ T ）
12.运行时异常都是RuntimeException类及其子类异常，如NullPointerException(空指针异常)，IOException等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。（ F ）
13.String是一个支持非可变性的类，这种类的特点是状态固定。在该对象的生命周期内，它的值是永远不变的，它是线程安全的。（ T ）
14.Calender类中定义了一系列将日期中的年、月、日等信息单独返回进行显示或处理的方法，通常是先创建一个Date实例，然后通过Calender中的setDate()方法将该Date的实例与其关联。（ T ）
15.Java的输入输出流包括字节流、字符流、文件流、对象流以及多线程之间通信的管道。（ T ）
16.文件类File类是java.io中的一个重要的非流类，里面封装了对文件系统进行操作的功能。比如：创建一个空的文件的功能 newCreateFile()。（ F ）
17.Thread类提供了一系列基于线和控制的方法，如果我们需要让与当前线程具有相同优先级的线程也有运行的机会则可以设用yield()方法。（ F ）
18.Java中，新建的线程调用start()方法，如myThread.start()将使线程的状态从新生状态转为运行状态。（ F ）
19.TCP网络通信的工作步骤分为：创建Socket、打开连接到Socket的输入/输出流、按某个协议对Socket进行读/写操作、关闭Socket。（T ）
20.Java提供的类库支持TCP/IP协议，read阻塞是因为一直在发送数据（T ）
五 、简答题（）
1.int与Integer的区别。）
1)int是java提供的8种原始数据类型之一。Integer是java为int提供的封装类。(1分)
2)int的默认值是0，而Integer的默认值为null（1分）。
3)Integer可以区分出未赋值和值为0的区别，int则无法表达未赋值的情况。（1分）
4)Integer提供了多个与整数相关的操作方法，将一个字符串转换成整数,还定义了表示整数的最大值和最小值的常量。（1分）
5)在使用集合存整数时，只能使用Integer而不能使用int。(1分)
2.请说明HashMap和Hashtable的区别。（）
1)它们都属于Map接口的类，实现了将唯一键映射到特定的值上（1分）
2)HashMap类没有分类或者排序，它允许一个null键和多个null值(0.5分)
3)Hashtable类似于HashMap，但是不允许null键和null值（0.5分）
4)Hashtable继承自Dictinary类，而HashMap是java1.2引进的Map接口的一个实现.(1分)
5)HashMap把Hashtable的contains方法去掉，改成了containsvalue()和containsKey()（1分）
6)Hashtable是线程同步的，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap则是非同步的，必须为之提供外同步。（1分）
3.方法重载和方法重写的区别。
英文 位置不同 作用不同
重载 overload 同一个类中 在一个类里面为一种行为提供多种实现方式并提高可读性
重写 override 子类和父类间 父类方法无法满足子类的要求，子类通过方法重写满足要求
修饰符 返回值 方法名 参数 抛出异常
重载 无关 无关 相同 不同 无关
重写 大于等于 小于等于 相同 相同 小于等于
4.对象序列化的含义，如何实现序列化？（提示：如何序列化写出操作代码）
1)Java 序列化技术可以使你将一个对象的状态写入一个Byte 流里，并且可以从其它地方把该Byte 流里的数据读出来，重新构造一个相同的对象。(1分)
2)这种机制允许你将对象通过网络进行传播(1分),并可以随时把对象持久化到数据库、文件等系统里。(1分)
3)ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(File对象或文件名)); (1分)
4)oos.writeObject(需要序列化的对象);(1)分
5.Java异常处理try-catch-finally的执行过程。（提示：分别从无异常与产生异常，以及如果try或catch中存在return的情况的执行过程
1)程序首先执行可能发生异常的try语句块。如果try语句没有出现异常则执行完后跳至finally语句块执行；（1分）
2)如果try语句出现异常，则中断执行并根据发生的异常类型跳至相应的catch语句块执行处理。(1分)catch语句块可以有多个，分别捕获不同类型的异常。catch语句块执行完后程序会继续执行finally语句块。(1分)
3)finally语句是可选的，如果有的话，则不管是否发生异常，finally语句都会被执行（0.5分）。除非使用System.exit(0)退出java虚拟机(0.5分)
4)需要注意的是即使try和catch块中存在return语句，finally语句也会执行。是在执行完finally语句后再通过return退出。(1分)
6.String是基本的数据类型吗,java基本数据类型有哪些
String不是最基本的数据类型，而是一个对象。
Java基本类型有：
布尔型：boolean
字符型：char
整数型：byte、short、int、long
浮点数型：float、double
7.阐述StringBuilder和 StringBuffer区别
1.StringBuffer：线程安全，StringBuilder：线程不安全。因为 StringBuffer 的所有公开方法都是 synchronized 修饰的，而 StringBuilder 并没有 StringBuilder 修饰。
2.StringBuffer 每次获取 toString 都会直接使用缓存区的 toStringCache 值来构造一个字符串。而 StringBuilder 则每次都需要复制一次字符数组，再构造一个字符串。
3.StringBuffer 是线程安全的，它的所有公开方法都是同步的，StringBuilder 是没有对方法加锁同步的，所以毫无疑问，StringBuilder 的性能要远大于 StringBuffer。
8.介绍hashmap底层实现原理
“HashMap底层就是一个数组结构,数组中的每一项又是一个链表。数组+链表结构,新建一个HashMap的时候,就会初始化一个数组。
9.阐述list和array区别，以及各自优势
list是数组结构拥有固定的大小
Array是一个链表结构,长度不固定
数组结构查询快,增删满
链表结构查询慢,增删快
10.final、finally、finalize的区别
Final用于声明属性，方法和类，分别表示属性不可交变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法
11.GC是什么？为什么要有GC？
GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。
12.简述逻辑操作(&,|)与条件操作(&&,||)的区别?
a.条件操作只能操作布尔型的,而逻辑操作不仅可以操作布尔型,而且可以操作数值型
b.逻辑操作不会产生短路
c:&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。
&&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式。
&还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们通常使用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位。
13.swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上
可以作用在byte和String上，不能作用在long上
六、编码题
1.编写一个Worker类，为Worker类添加相应的代码，使得Worker对象能正确放入TreeSet中。并编写相应的测试代码。
提示:
1)Worker类含有name,age,salary三个属性
2)取值，赋值的方法可省略
3)比较时，先比较工人的年龄大小，年龄小的排在前面。如果两个工人年龄相同，则根据字典顺序比较工人姓名。
4)编写测试类，向集合中添加三条数据
5)遍历集合，输出集合中的元素信息(Worker类编写toString方法)
Worker类
/**实现Comparable接口正确0.5分,无泛型不得分*/
public class Worker implements Comparable<Worker> {
/**声明三个私有属性 -->0.5分*/
private String name;//姓名
private int age;//年龄
private double salary;//薪水
//取值，赋值的方法省略
/**带参与无参构造方法编写正确 -->0.5分*/
//带参构造方法
public Worker(String name, int age, double salary) {
super();
this.name = name;
this.age = age;
this.salary = salary;
}
//无参构造方法
public Worker() {
super();
}
/**重写compareTo方法共2分*/
@Override
public int compareTo(Worker o) {
if (this.age>o.getAge()) {
return 1; //0.5分
}else if (this.age<o.getAge()) {
return -1; //0.5分
}
return this.name.compareTo(o.getName());//1分
}
@Override//0.5分
public String toString() {
return name+"\t"+age+"\t"+salary;
}
Test测试类
public class Test {
public static void main(String[] args) {
//创建集合对象
Set<Worker> set=new TreeSet<Worker>();/**0.5分*/
//添加数据
set.add(new Worker("zhang", 28, 900.00));/**0.5分*/
set.add(new Worker("wang",28,890.00));
set.add(new Worker("li",19,780.00));
//遍历输出
System.out.println("姓名\t年龄\t薪水");
for (Worker w:set) { /**1分*/
System.out.println(w);
}
}
}
2.设计一个多线程的程序如下：设计一个火车售票模拟程序。假如火车站要有100张火车票要卖出，现在有5个售票点同时售票，用5个线程模拟这5个售票点的售票情况。（7分）
提示：要求打印出每个售票点序号及所卖出的票号。
线程类
/*实现接口0.5分/
public class SaleTicket implements Runnable {
/**变量定义正确0.5分*/
public int total=100;//总票数
public int count=0;//票号
//实现run方法
/**编写run方法0.5分*/
public void run() {
while (total > 0) {
synchronized (this) {/**线程同步0.5分*/
if (total > 0) {/**正确判断0.5分*/
try { /**添加异常 0.5分*/
Thread.sleep(500);/**休眠 0.5分*/
} catch (InterruptedException e) {
e.printStackTrace();
}
/**变量改变0.5分*/
count++; //票号++
total--;//总数减少
//输出当前的售票窗口和票号
/**正确输出0.5分*/
System.out.println(Thread.currentThread().getName()
+ "\t当前票号：" + count);
}
}
}
}
测试类
public class Test{
public static void main(String[] args) {
// 创建线程类对象
/** 创建线程对象0.5 */
SaleTicket st = new SaleTicket();
// 启动5次线程
for (int i = 1; i <= 5; i++) {
/** 创建5个Thread类对象 1分 */
new Thread(st, "售票点" + i).start();
/** 调用5次start方法1分 */
}
}
}
3.模拟qq聊天功能：实现客户端与服务器（一对一）的聊天功能，客户端首先发起聊天，输入的内容在服务器端和客户端显示，然后服务器端也可以输入信息，同样信息在客户端和服务端显示。
提示:
客户端
1)客户端编写聊天的方法chat()
2)要求使用BufferedReader与BufferedWriter缓冲类
3)编写用于测试的主方法调用chat()方法
服务器端
1)编写提供服务的方法service()
2)编写用于测试的主方法调用service()方法
客户端
public class ChatClient {
public void chat() {
try {
// 连接到服务器
/**连接到服务器0.5分*/
Socket socket = new Socket("localhost", 9000);
try {
/** 读取服务器端传过来信息的输入流对象 --0.5分 */
InputStream is=socket.getInputStream();
Reader r=new InputStreamReader(is);
BufferedReader br=new BufferedReader(r);
/** 向服务器端发送信息的输出流对象--0.5分 */
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
// 装饰标准输入流，用于从控制台输入
Scanner scanner = new Scanner(System.in);
while (true) {
String send = scanner.nextLine();
System.out.println("客户端：" + send);
/** 把从控制台得到的信息传送给服务器 0.5分*/
bw.write(send);
/** 读取来自服务器的信息 0.5分*/
String accpet =br.readLine();
System.out.println(accpet);
}
} finally {
socket.close(); /**关闭0.5分*/
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new ChatClient().chat(); /**测试0.5*/
}
}
服务器端
public class ChatServer {
// 提供服务
public void service() {
try {/**建立服务器连接 0.5分*/
ServerSocket server = new ServerSocket(9000);
/**等待客户连接 0.5分*/
Socket socket = server.accept();
try {
/** 读取客户端传过来信息的输入流对象 --0.5分 */
InputStream is=socket.getInputStream();
Reader r=new InputStreamReader(is);
BufferedReader br=new BufferedReader(r);
/** 向客户端发送信息的输出流对象--0.5分 */
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
// 获取控制台输入的Scanner
Scanner scanner = new Scanner(System.in);
while (true) {
/** 读取来自服务器的信息 0.5分*/
String accpet =br.readLine();
System.out.println(accpet);
String send = scanner.nextLine();
System.out.println("客户端：" + send);
/** 把从控制台得到的信息传送给服务器 0.5分*/
bw.write(send);
}
} finally {// 建立连接失败的话不会执行socket.close();
socket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new ChatServer().service(); /**0.5分*/
}
}
4.数组[8,5,6,1,2,3,4,7],使用冒泡循环和选择排序完成从小到大进行排序
5试编写一个程序，输入一个字符串，统计其中有多少各单词？单词之间用空格分开。
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入:");
String sentence = input.nextLine();
// 将输入的句子转化为单词数组
String[] words = sentence.split(" ");
// 单词数组的长度就是单词数
System.out.println("共有 " + words.length + " 个单词.");
}
}
6 试编写程序，从一个给定的字符串中删去某一个给定的字符。
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.println("请输入一个字符和字符串：");
String str2=input.next()//输入一个字符
String str1=input.next()//输入一个字符串
String newStr =str1.replace(str2,"");//替换字符串中的字符为空
}
7：第一三维不平衡数组如下：Int a[][] []= {{{1,2},{3,4,5}},{{6,7},{8,9,10,11}}};
编程实现输出数组a各个元素，并求各元素之和。
8 求1+2!+3!+…+20!的和？
public class Test{
public static void main(String[] args){
System.out.println("1!+2!+3!+……+20!="+getSum(20));
}
public static long getSum(int n){
int i,k,fac,sum=0;
for(i=1;i<=n;i++){
fac=1;
for(k=1;k<=i;k++)
fac=fac*k;
sum=sum+fac;
}
return sum;
}
}
202
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
