一、题目
（一）填空题
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循环可以遍历数组，也可以遍历实现了 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 。
（二）选择题
1) 国际通用编码集是（ B ）。（选择一项）
A ASCII characters
B. Unicode characters
C. Cp1252
D. UTF-8
2) 下面哪个将正确编译（ CD ）。（选择两项）
A Short myshort=99S;
B. float z=1.0;
C. int t=”abc”.length( );
D. char c=17;
3) 关于静态变量的创建，哪个选项是正确的（ C D ）。（选择两项）
A 一旦一个静态变量被分配，它就不允许改变
B. 一个静态变量在一个方法中创建，它在被调用的时候值保持不变
C. 在任意多个类的实例中，一个静态变量只存在一个
D. 一个静态标识符可以被应用到类称为静态内部类
4) 以下关于条件运算符执行的代码的输出结果是（ 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. 以上答案都不对
//解析：？：是一个运算符，类型都应该相同，才能运算，结果为9.0，如果类型不同，向精度高的转化
5) 以下选项中关于Java语言错误的是（ BD ）。（选择两项）
A Java是强类型语言
B. Java是面向对象语言
C. Java语言的夸平台性是通过JVM实现
D. Java是动态语言
//是面向对象是思想，java是伪动态语言
6) 下列二维数组初始化语句中，错误的是（ 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}};
7) 以下代码输出结果是（ 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. 编译不正确
//for循环第一个初始化时，只有第一次执行一次，后期循环不执行
8) 下列程序的输出结果是多少（ 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);
}
public static void myMethod(){
y=x++ + ++x;X=1,Y=0
}
}
A 4
B. 3
C. 2
D. 1
解析：x 用默认值0
9) 给定如下代码输出结果是（ 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. 编译不正确
10) 以下代码输出结果是（ 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
11) 放在第8行的哪个方法会导致编译错误（ B ）。（选择一项）
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和C是重载，D是子类的独有方法，B和父类的函数名相同，参数相同，返回值却不同，故会报错
12) 如下代码的运行结果是 （ 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. 运行时异常
13) 下列关于抽象类说法错误的是（ C D ）。（选择两项）
A 抽象类中可以不存在任何的抽象方法
B. 抽象类可以被别的抽象类所继承，结果仍是抽象类
C. 抽象类可以使用private修饰的
D. 如果一个非抽象类从抽象类派生，不一定要通过覆盖来实现抽象类的抽象成员
14) 如下代码的输出结果是（ 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. 以上答案都不对
15) 针对如下代码，输出的结果为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 str2==str3
B. str3.equals(str4)
C. str1==str4
D. str1==str2
//C选项，类型不同，不能判断，编译时报错
16) 以下关于链式存储结构的叙述中哪个是正确的（ D ）。（选择一项）
A 链式存储结构不是顺序存取结构
B. 逻辑上相邻的节点物理上必须邻接
C. 可以通过计算直接确定第i个节点的存储地址
D. 插入、删除运算操作方便，不必移动节点
17) 给定如下代码输出结果是（ 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”.
18) 定义了如下类和测试方法，请问测试时期待要捕获下面哪个选项的异常（ 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
19) 编译并运行如下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
20) 需要读一个比较大的文本文件，这个文件里有很多字节的数据，那么下列最合适读这类文件的选项是哪个（ 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”):
21) 下面IO流类中属于字节输入节点流的选项是（ D ）。（选择一项）
A PrintStream和BufferedInputStream
B. FileInputStream和BufferedInputStream
C. InputStreamReader和FileInputStream
D. ByteArrayInputStream和FileInputStream
22) 以下哪个方法可以改变线程的状态（ AD ）。（选择两项）
A stop()
B. run()
C. start()
D. sleep()
解析：stop和sleep可以将线程的状态由运行变阻塞，线程的状态都是start执行后有的，不能说他可以改变线程状态
23) 下面关于多线程的程序的运行结果是（ 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. 都不输出
24) 在TCP/IP协议中，采用什么来区分不同的应用进程（ A）。（选择一项）
A 端口号
B. IP地址
C. 协议类型
D. MAC地址
25) TCP/IP如何解决read阻塞问题（ C ）。
A 两端约定文件大小,一次读取
B. 使用shutdownOutput()
C. AB都正确
D. 以上都是错误
（三）不定项选择
1：Java 提供哪几种运算符 多选 (ACDBE )。 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）//结果为整形，转为float类型 A:2 B:2.0 C:2,5 D:编译错误 11：．下面方法中，用于调度线程使其运行的是？ （ B ） A. init() B. start() C. run() D. resume() E. sleep() 12.下面哪种情况能实现自动转换 多选（ AC E）。 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 A.选项为两个””进行转义标识。 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： 以下（D ）不是Object类的方法。（） 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：程序中已经提供了丰富的异常类，使用自定义异常没有意义 解析：A不是必须继承exception，也可以继承他的子类 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( (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包中
（四）判断
1.若源程序文件中只定义一个名为”JavaClass”的类，则文件的扩展名为 JavaClass.class。（ X ） 2.基本数据类型按照容量大小，从小到大的排列为byte-short-int-char-long- float-double，转换时遵循的原则是容量小的类型自动转换为容量大的类型， 容量大的类型转换为容量小的类型时，要进行强制转换。（ X ） //char=>int 3.break语句可以用在switch语句中，通过break语句而退出switch语句，使程 序从switch语句结构后面的第一条语句开始执行。（ T ） 4.语句 System.out.println(4+8+"Hello,world!"); 的输出结果是48Hello,world!（ X ） 5.局部变量在定义该变量的方法被调用时被创建，而在该方法退出后被撤 销，其生存期和定义该变量的方法的生存期相同。（ T ） 6.接口中所有成员变量都默认使用public static final修饰，所以接口中只有常 量，没有变量。接口中所有的成员方法都默认使用public abstract修饰。（ T ） 7.重写CompareTo,实现按age从大到小排序,应该this.age-o.age。（X ） 8.Java语言允许程序为任何方法添加final()方法，该方法会在垃圾收集器你换 回收对象之前被调用。但不要过分依赖该方法对系统资源进行回收和再利 用，因为该方法调用后的执行结果是不可预知的。（ F ）//final是关键字 9.对于要存储50个字符的字符串数组，可以使用String s[50]来声明。（ X ） 10.LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的 get,remove,add方法在LinkedList的首部或尾部进行相应操作。这些操作使用 LinkedList可被用作堆栈、队列或双向队列。（ T ） 11.HashSet是Set接口的一个子类，主要的特点是:不能存放重复元素，而且 采用散列的存储方法，所以没有顺序。（ T ） 12.运行时异常都是RuntimeException类及其子类异常，如 NullPointerException(空指针异常)，IOException等，这些异常是不检查异 常，程序中可以选择捕获处理，也可以不处理。（ F ）//io异常必须处理 13.String是一个支持非可变性的类，这种类的特点是状态固定。在该对象的 生命周期内，它的值是永远不变的，它是线程安全的。（ T ） 14.Calender类中定义了一系列将日期中的年、月、日等信息单独返回进行显 示或处理的方法，通常是先创建一个Date实例，然后通过Calender中的 setDate()方法将该Date的实例与其关联。（ T） 15.Java的输入输出流包括字节流、字符流、文件流、对象流以及多线程之间 通信的管道。（ T ） 16.文件类File类是java.io中的一个重要的非流类，里面封装了对文件系统进 行操作的功能。比如：创建一个空的文件的功能 newCreateFile()。（ F ）//createNewFile() 17.Thread类提供了一系列基于线和控制的方法，如果我们需要让与当前线程 具有相同优先级的线程也有运行的机会则可以设用yield()方法。（ X ） 18.Java中，新建的线程调用start()方法，如myThread.start()将使线程的状态 从新生状态转为运行状态。（ X ） 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.方法重载和方法重写的区别。
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区别，以及各自优势
Array是数组结构拥有固定的大小
list是一个链表结构,长度不固定
数组结构查询快,增删满
链表结构查询慢,增删快
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.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 int salary;
public Worker(){
}
public Worker(String name,int age,int salary){
this.name=name;
this.age=age;
this.salary=salary;
}
@Override
public String toString() {
return "Worker{
" +
"name='" + name + '\'' +
", age=" + age +
", salary=" + salary +
'}';
}
@Override
public int compareTo(Worker o) {
int i=this.age-o.age;
int j=(i==0)?this.name.compareTo(o.name):i;
return j;
}
}
Test
public class Test {
public static void main(String[] args) {
Set<Worker> set=new TreeSet<>();
Worker worker=new Worker("张三",20,3000);
Worker worker1=new Worker("李四",23,5000);
Worker worker2=new Worker("王五",19,8000);
Worker worker3=new Worker("阿强",23,2000);
set.add(worker);
set.add(worker1);
set.add(worker2);
set.add(worker3);
for(Worker w:set){
System.out.println(w.toString());
}
}
}
2.2.设计一个多线程的程序如下：设计一个火车售票模拟程序。假如火车站要有100张火车票要卖出，现在有5个售票点同时售票，用5个线程模拟这5个售票点的售票情况。（7分）
提示：要求打印出每个售票点序号及所卖出的票号。
Ticket
public class Ticket implements Runnable {
private int ticket = 100;
Object object = new Object();
@Override
public void run() {
while (true) {
synchronized (object) {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "售出第" + ticket + "张票");
ticket--;
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
} else break;
}
}
}
}
Test
public class Test {
public static void main(String[] args) {
Ticket ticket=new Ticket();
Thread thread1=new Thread(ticket,"售票口1");
Thread thread2=new Thread(ticket,"售票口2");
Thread thread3 = new Thread(ticket, "售票口3");
Thread thread4 = new Thread(ticket, "售票口4");
Thread thread5 = new Thread(ticket, "售票口5");
thread1.start();
thread2.start();
thread3.start();
thread4.start();
thread5.start();
}
}
3.模拟qq聊天功能：实现客户端与服务器（一对一）的聊天功能，客户端首先发起聊天，输入的内容在服务器端和客户端显示，然后服务器端也可以输入信息，同样信息在客户端和服务端显示。
提示:
客户端
1)客户端编写聊天的方法chat()
2)要求使用BufferedReader与BufferedWriter缓冲类
3)编写用于测试的主方法调用chat()方法
服务器端
1)编写提供服务的方法service()
2)编写用于测试的主方法调用service()方法
public class ServiceTest {
public static void main(String[] args) throws Exception{
chat();
}
public static void chat()throws Exception{
ServerSocket ss=new ServerSocket(1666);
Socket socket=ss.accept();
while (true){
BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
String s;
s=br.readLine();
long l=System.currentTimeMillis();
Date date=new Date();
SimpleDateFormat ssa=new SimpleDateFormat("yyyy:mm:dd,hh:mm:ss");
System.out.println(ssa.format(date)+"收到的数据为:");
System.out.println(s);
if(s.equals("bye")){
System.out.println("通信结束");
break;
}
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
System.out.println("请输入要发送的数据");
Scanner sc=new Scanner(System.in);
String string=sc.next();
bw.write(string);
bw.newLine();
bw.flush();
if(string.equals("bye")){
System.out.println("通信结束");
break;
}
}
socket.close();
ss.close();
}
}
public class CilentTest {
public static void main(String[] args)throws Exception {
chat();
}
public static void chat()throws Exception {
Socket socket = new Socket("192.168.0.37", 1666);
while (true) {
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
System.out.println("请输入要发送的数据");
Scanner scanner = new Scanner(System.in);
String string = scanner.next();
bw.write(string);
bw.newLine();
bw.flush();
if (string.equals("bye")) {
System.out.println("通信结束");
break;
}
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String s = br.readLine();
long l = System.currentTimeMillis();
Date date = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy:mm:dd,hh:mm,ss");
System.out.println(simpleDateFormat.format(date) + "接收的数据为：");
System.out.println(s);
if (s.equals("bye")) {
System.out.println("通信结束");
break;
}
}
socket.close();
}
}
4.数组[8,5,6,1,2,3,4,7],使用冒泡循环和选择排序完成从小到大进行排序
冒泡：
public class Maopao {
public static void main(String[] args) {
int[] arr=new int[]{
8,5,6,1,2,3,4,7};
Printarr(arr);
arrSort(arr);
Printarr(arr);
}
public static int[] arrSort(int[] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
int tem=arr[j+1];
arr[j+1]=arr[j];
arr[j]=tem;
}
}
}
return arr;
}
public static void Printarr(int[] arr){
StringBuffer buffer=new StringBuffer();
buffer.append("[");
for(int i=0;i<arr.length;i++){
if(i==arr.length-1){
buffer.append(arr[i]);
buffer.append("]");
break;
}
buffer.append(arr[i]);
buffer.append(",");
}
System.out.println(buffer);
}
}
选择：
public class Xuanze {
public static void main(String[] args) {
int arr[] = new int[]{
8, 5, 6, 1, 2, 3, 4, 7};
Printarr(arr);
sort(arr);
Printarr(arr);
}
public static void sort(int[] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
int temp=arr[j];
arr[j]=arr[i];
arr[i]=temp;
}
}
}
}
public static void Printarr(int[] arr){
StringBuffer buffer=new StringBuffer();
buffer.append("[");
for(int i=0;i<arr.length;i++){
if(i==arr.length-1){
buffer.append(arr[i]);
buffer.append("]");
break;
}
buffer.append(arr[i]);
buffer.append(",");
}
System.out.println(buffer);
}
}
5试编写一个程序，输入一个字符串，统计其中有多少各单词？单词之间用空格分开。
public class Test {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String s=sc.nextLine();
String strings[]=s.split(" ");
System.out.println("单词数为（包括重复）："+strings.length);
Set<String> set=new TreeSet<>();
for(String str:strings){
set.add(str);
}
System.out.println("不包含重复单词数为"+set.size());
}
}
6 试编写程序，从一个给定的字符串中删去某一个给定的字符。
public class Test {
public static void main(String[] args) {
String s="dsfanffdasfjbdf";
System.out.println(s);
String s1=delete(s,'a');
System.out.println(s1);
}
public static String delete(String s,char c){
StringBuffer str=new StringBuffer();
char[] chars = s.toCharArray();
for(char ss:chars){
if (ss!=c){
str.append(ss);
}
}
return str.toString();
}
}
7：第一三维不平衡数组如下：Int a[][] []= {
{
{1,2},{3,4,5}},{
{6,7},{8,9,10,11}}};
编程实现输出数组a各个元素，并求各元素之和。
public class Test {
public static void main(String[] args) {
int a[][][] = {
{
{
1, 2}, {
3, 4, 5}}, {
{
6, 7}, {
8, 9, 10, 11}}};
System.out.println("各元素和为:"+Print(a));
}
public static int Print(int[][][] a) {
int sum = 0;
for (int[][] s : a) {
for (int[] ss : s) {
for (int sss : ss) {
System.out.print(sss + "\t");
sum = sum + sss;
}
System.out.println("\n");
}
}
return sum;
}
}
8 求1+2!+3!+…+20!的和？
public class Test {
public static void main(String[] args) {
System.out.println(sum(20));
}
public static int jiechng(int n){
if(n==1){
return 1;
}
return n*jiechng(n-1);
}
public static int sum(int x){
if (x==1){
return 1;
}
return jiechng(x)+sum(x-1);
}
}
相关代码验证
二、易错总结：
1.单|为按位或，结果是值，双或号||为逻辑或，结果为布尔值 2.递归的优缺点： 定义：直接或间接调用自己本身的函数； 优点：结构清晰、可读性强； 缺点：运行效率低，耗费计算时间与存储空间。 3.super和this的异同： super: 它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参） this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名） super()和this()类似,区别是，super()在子类中调用父类的构造方法，this()在本类内调用本类的其它构造方法。 super()和this()均需放在构造方法内第一行。 尽管可以用this调用一个构造器，但却不能调用两个。 this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。 this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。 从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。 4.string是特殊的引用类型，做基本类型使用String的值不可被更改！！！ 5.集合中的元素必须是引用数据类型，会涉及到拆箱和装箱的问题 6.创建文件时，mkdir创建的是文件夹，尽快以文件名命名，也是文件夹,newcreatefile创建的是文件，没有后缀名也是文件 7.抛出异常时，异常后面的代码将不在执行，若异常编译时报错，抛出后会继续执行 eg:file.createNewFile();异常 throw new MyException()异常 8.文件中相对路径是相对于项目名 9.接口中的变量默认是常量，修饰符为public static fina,要赋初值 方法为抽象方法，默认为public abstract ，其他报错 10.FileOutputStream fos=new FileOutputStream();有没有都会创建指向的文件，有会覆盖 11.FileInputStream读数据，每个数据只能读一次，读完之后不可在读，偏移量为读在数组中的偏移量 12.节点流：可以从某节点读数据或向某节点写数据的流。如 FileInputStream 处理流：对已存在的流的连接和封装，实现更为丰富的流数据处理，处理流的构造方法必需其他的流对象参数。如 BufferedReader 13.wait()、notify()、notifyAll()必须在synchronized方法或者代码块中使用 14.Comparable比较器用于类，compareTo(T o) 当前的o为之前插入的，this为正在插入的，，i结果如果为正，按原序输出，如果为负，逆序输出， 即要求元素按从小到大排列，应用当前的减去进去过的 CompataTo比较器用于对象，compare(T o1,T o2)o1为当前的，O2为已经插入的，o1-o2，从小到大，，，o2-o1从大到小 15、scanner接收数据时，如果有int型和String型，需先接收String型、后接收int型 16、static修饰的方法不能被重写，不具有多态的特性 17、Collection：List列表，Set集 Map：Hashtable，HashMap，TreeMap
各运算符优先级顺序
8个基本类型精度大小
java入门基础学习（一）
java入门基础学习（二）
java入门基础学习（三）
java入门基础学习（四）
java入门基础学习（五）
java入门基础学习（六）
java入门基础学习（七）
java入门基础学习（八）
java入门基础学习（九）
java入门基础学习（十）
java入门基础学习（十一）
java入门基础学习（十二)
java入门基础学习（十三）
java进阶之常见对象（一）
java进阶之常见对象（二）
java进阶之冒泡排序
java进阶之选择排序
java进阶之面向对象（封装）
java进阶之面向对象（代码块、继承）
java进阶之面向对象（多态、抽象、接口）
java进阶之匿名内部类、访问修饰符、包
java进阶之io流（字节流，字符流）