1．下面哪种类型的文件可以在Java虚拟机中运行（ ）。
A．.java
B．.class
C．.exe
D．.jre
2．下列关于变量作用域的说法中，正确的是（ ）。
A．在main()方法中任何位置定义的变量，其作用域为整个main()方法
B．代码块中定义的变量，在代码块外也是可以使用的
C．变量的作用域为：从定义处开始，到变量所在代码块结束的位置
D．变量的作用域不受代码块的限制
3．请阅读下面的程序：
public class Test {
public static void main(String[] args) {
for(int x =0;x<5;x++)
{
if(x%2==0)
break;
System.out.print(x+” “);
}
}
}
下列选项中，哪一个是程序的运行结果（ ）。
A．12345
B．024
C．13
D．不输出任何内容
4．下列关于数组最值的描述中，错误的是（ ）。
A．要想求数组的最值必须先定义一个数组
B．在求数组最值时，初始时一定要将数组中的第一个元素的值赋给变量
C．求数组最值过程中，一定要对数组进行遍历
D．在求数组最大值时，使用变量记住每次比较后较大的那个值
5．Java中，如果类C是类B的子类，类B是类A的子类，那么下面描述正确的是（ ）。
A．C可以继承B中的公有成员，同样也可以继承A中的公有成员
B．C只继承了B中的成员
C．C只继承了A中的成员
D．C不能继承A或B中的成员
6．请阅读下面的程序：
class Parent {
Parent() {
System.out.println("parent");
}
}
public class Child extends Parent {
Child(String s) {
System.out.println(s);
}
public static void main(String[] args) {
Child child = new Child("child");
}
}
上述程序的运行结果为（ ）。
A．child
B．child parent
C．parent child
D．编译错误
7．在Java中，提供了4种访问级别，以下访问控制级别由小到大顺序排列正确的是（ ）。
A．private、default、protected、public
B．default、public、protected、private
C．private、default、public、protected
D．protected、public、private、default
8．请阅读下面的程序：
public class Test {
int x, y;
Test(int x, int y) {
this.x = x;
this.y = y;
}
public static void main(String[] args) {
Test pt1, pt2;
pt1 = new Test(3, 3);
pt2 = new Test(4, 4);
System.out.print(pt1.x + pt2.x);
}
}
上述程序的运行结果为（ ）。
A．6
B．3 4
C．8
D．7
9．下列关于匿名内部类的描述，错误的是（ ）。
A．匿名内部类是内部类的简化形式
B．匿名内部类的前提是必须要继承父类或实现接口
C．匿名内部类的格式是"new父类(参数列表)或父接口(){}"
D．匿名内部类可以有构造方法
10．下列数据结构中，哪一个是ArrayList类的底层实现（ ）。
A．数组结构
B．链表结构
C．哈希表结构
D．红黑树结构
11．请阅读下面的程序：
import java.util.ArrayList;
public class Demo {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
for (Object obj : list)
{
if (obj.equals("bbb"))
{
list.remove(obj);
}
}
System.out.println(list);
}
}
下列选项中，哪一个是程序执行后的结果（ ）。
A．[aaa,ccc]
B．[aaa,bbb,ccc]
C．[]
D．以上都不对
12．请将下列四个步骤进行排列，完成文件的赋值操作（ ）。
① 将字节流输入流和源文件相关联，输出流和目标文件相关联
② 明确源文件和目标文件
③ 使用输入流的读取方法读取文件，并将字节写入到目标文件中
④ 关闭资源
A．①②③④
B．②①③④
C．②③①④
D．①③②④
13．请阅读下面的程序：
import java.io.*;
public class Example{
public static void main(String[] args) throws Exception {
OutputStream out = new FileOutputStream("itcast.txt ", true);
String str = "欢迎你!";
byte[] b = str.getBytes();
for (int i = 0; i < b.length; i++) {
out.______(b[i]);
}
out.close();
}
}
请说出下划线上，填写的方法名称（ ）。
A．read()
B．write()
C．close()
D．available()
14．以下关于File类的isDirectory ()方法的描述，哪个是正确的（ ）。
A．判断该File对象所对应的是否是文件
B．判断该File对象所对应的是否是目录
C．返回文件的最后修改时间
D．在当前目录下生成指定的目录
15．下列选项中，关于BorderLayout边界布局管理器的说法错误的是（ ）。
A．向BorderLayout布局管理器的容器中添加组件时需要使用add(Component comp,Object constraints)方法
B．add(Component comp,Object constraints)方法参数constraints是Object类型
C．BorderLayout的布局管理器的每个区域只能显示一个组件
D．向BorderLayout的布局管理器添加组件时默认添加到SOUTH区域
1．下列关于JDK的说法中，错误的是（ ）。
A．JDK是Java开发环境的简称
B．JDK包括Java编译器、Java文档生成工具、Java打包工具等
C．安装JDK后，还需要单独安装JRE
D．JDK是整个Java的核心
2．下面关于Java程序的描述中，错误的是（ ）。
A．Java程序运行时，必须经过编译和运行两个步骤。
B．Java具有自动垃圾回收的机制
C．main()函数是Java程序的执行入口
D．不同操作系统上的Java虚拟机是相同的
3．请阅读下面的代码片段
public static int add(int a,int b) {
return a + b;
}
下列选项中，可以在main()方法中成功调用add()方法的是（ ）。
A．int num = add(1.0, 2.0);
B．int num = add(true, flase);
C．int num = add('a', 'b');
D．int num = add("1", "2");
4．下列关于类的继承的描述，正确的是（ ）。
A．一个类可以继承多个父类
B．一个类可以具有多个子类
C．子类可以使用父类的所有方法
D．子类一定比父类有更多的成员方法
5．请阅读下面的程序代码，选择正确的运行结果（ ）。
public class Example {
public static void main(String[] args) {
new Father () {
public void show() {
System.out.println("helloworld");
}
}.show();
}
}
class Father {
public void show() {
System.out.println("hellofather");
}
}
A．hellofather
B．helloworld
C．编译报错
D．编译通过，运行报错
6．一个具体类实现接口时，需要重写接口中的（ ）。
A．成员方法
B．构造方法
C．成员变量
D．局部变量
7．下列关于super关键字的说法中，正确的是（ ）。
A．super关键字是在子类对象内部指代其父类对象的引用
B．super关键字不仅可以指代子类的直接父类，还可以指代父类的父类
C．子类通过super关键字只能调用父类的方法，而不能调用父类的属性
D．子类通过super关键字只能调用父类的属性，而不能调用父类的方法
8．下面关于java.util.Random类中方法，说明错误的是（ ）。
A．nextDouble()方法返回的是0.0和1.0之间double类型的值
B．nextFloat()方法返回的是0.0和1.0之间float类型的值
C．nextInt(int n)返回的是0（包括）和指定值n（不包括）之间的值
D．nextInt()返回的是0（包括）和2147483647之间的值
9．下列选项中，关于 GridLayout（网格布局管理器）的说法错误的是（ ）。
A．放置在GridLayout布局管理器中的组件将自动占据网格的整个区域
B．GridLayout布局管理器可以设置组件的大小
C．GridLayout布局管理器中，组件的相对位置不随区域的缩放而改变，但组件的大小会随之改变，组件始终占据网格的整个区域
D．GridLayout布局管理器缺点是总是忽略组件的最佳大小，所有组件的宽高都相同
10．下列选项中，哪个可以正确地定义一个泛型（ ）。
A．ArrayList<String> list = new ArrayList<String>();
B．ArrayList list<String> = new ArrayList ();
C．ArrayList list<String> = new ArrayList<String>();
D．ArrayList<String> list = new ArrayList ();
11．阅读下面的程序
public class Example{
public static void main(String[] args) {
String[] strs = { "Tom", "Jerry", "Donald" };
for (String str : strs) {
str = "Tuffy";
}
System.out.println(strs[0] + "," + strs[1] + "," + strs[2]);
}
}
下列选项中，程序的运行结果是（ ）。
A．Tom,Jerry,Donald
B．Tuffy,Jerry,Donald
C．Tuffy,Tuffy,Tuffy
D．发生异常，输出异常信息
12．下列有关HashSet集合的描述中，错误的是（ ）。
A．HashSet是Set接口的一个实现类
B．向HashSet存入对象时，对象一般会重写hashCode()和equals()方法
C．向HashSet存入对象时，对象的equals()方法一定会被执行
D．HashSet存储的元素是不可重复的
13．public class Example {
public static void main(String[] args) {
ArrayList list = new ArrayList(); // 创建ArrayList集合
list.add("Tom"); // 向该集合中添加字符串
list.add("Jerry");
Iterator it = list.iterator(); //获取迭代器
it.next();
it.next();
System.out.println(it.next());
}
}
运行以上程序，输出结果是（ ）。
A．Tom
B．null
C．""
D．发生异常，输出异常信息
14．假设在E盘下的cn文件夹中有文件abc.txt，则下列代码的运行结果为（ ）。
class Example {
public static void main(String[] args) {
File file = new File("E:\\cn"); // 这是一个代表目录的File对象
if (file.exists()) {
System.out.println(file.delete());
}
}
}
A．false文件夹删除不成功，abc.txt删除不成功
B．false文件夹删除不成功，abc.txt删除成功
C．true文件夹删除成功
D．true文件夹删除不成功，abc.txt删除成功
15．下列选项中，关于BorderLayout边界布局管理器的说法错误的是（ ）。
A．向BorderLayout布局管理器的容器中添加组件时需要使用add(Component comp,Object constraints)方法
B．add(Component comp,Object constraints)方法参数constraints是Object类型的
C．BorderLayout的布局管理器的每个区域只能放置一个组件
D．向BorderLayout的布局管理器添加组件时默认添加到SOUTH区域
1、下列关于JDK和JRE的说法中，错误的是（ ）
A、 JDK是java开发核心组件，是用来编译解释java程序的核心组件
B、 JDK包括Java编译器、Java文档生成工具、Java打包工具等
C、 JRE是个单独的软件，所以安装JDK后，还需要单独安装JRE
D、 JRE是java运行环境，用来支持java程序的运行
2、关于变量类型转换的描述中，正确的是（）
A、 只有数据类型相同的数据才能进行运算。
B、 byte类型和short类型的数据是不能一起运算的。
C、 两个byte类型数据一起运算时会把先自动提升到int类型再运算。
D、 两个整型在一起运算时，结果一定是int。
3、在for循环中，分别用①表示初始化表达式，②表示循环条件，③表示操作表达式，④表示循环体，通过序号分析for循环的执行流程。在循环条件的结果为true时，下列执行步骤正确的是（ ）
A、 ①②④③ B、 ①②③④ C、 ④③②① D、 ④②③①
4、在Java中，提供了4种访问级别，以下访问控制级别由小到大顺序排列正确的是（）
A、 private、default、protected、public
B、 default、public、protected、private
C、 private、default、public、protected
D、 protected、public、private、default
5、下列选项中关于Java中super关键字的说法，错误的是（ ）。
A、 当子类和父类中成员变量重名的时候,在子类方法中想输出父类成员变量的值,可以用super区分子父类成员变量
B、 super语句可以放在构造函数的任意一行
C、 子类可以通过super关键字调用父类的方法
D、 子类可以通过super关键字调用父类的属性
6、在Java中，如果父类中的某些方法不包含任何逻辑，并且需要有子类重写，应该使用（）关键字来声明父类的这些方法
A、 final B、 static C、 abstract D、 void
7、下面关于java.util.Random类中方法，说法错误的是（ ）
A、 nextDouble()方法返回的是0.0和1.0之间double类型的值
B、 nextFloat()方法返回的是0.0和1.0之间float类型的值
C、 nextInt(int n)返回的是0（包括）和指定值n（不包括）之间的值
D、 nextInt( )返回的是0（包括）和 2147483647 之间的值
8、下列选项中，哪个可以正确地定义一个泛型（）
A、 ArrayList<String> list = new ArrayList<String>();
B、 ArrayList list<String> = new ArrayList ();
C、 ArrayList list<String> = new ArrayList<String>();
D、 ArrayList<String> list = new ArrayList ();
9、假设在E盘下的cn文件夹中有文件abc.txt，则下列代码的运行结果为（）
class Example {
public static void main(String[] args) {
File file = new File("E:\\cn"); // 这是一个代表目录的File对象
if (file.exists()) {
System.out.println(file.delete());
}
}
}
A、 false文件夹删除不成功，abc.txt删除不成功
B、 false文件夹删除不成功，abc.txt删除成功
C、 true文件夹删除成功
D、 true文件夹删除不成功，abc.txt删除成功
10、关于Thread类join()方法的作用，下列描述中正确的是（ ）
A、 使线程由运行状态进入阻塞状态
B、 使线程由运行状态进入就绪状态
C、 使线程由阻塞状态进入等待状态
D、 使线程由阻塞状态进入运行状态
11、以下选项中可以正确定义一个同步代码块的是（ ）
A、 synchronized(常量){} B、 synchronized(对象){}
C、 synchronized(){} D、 synchronized(任意基本数据类型){}
12、在使用UDP套接字通信时，可以把要发送的信息打包的类是（ ）
A、 String B、 DatagramSocket
C、 MulticastSocket D、 DatagramPacket
13、下列选项中，关于Statement描述错误的是（）
A、 Statement是用来执行SQL语句的
B、 Statement是PreparedStatement的子接口
C、 获取Statement实现需要使用Connection的createStatement()方法
D、 PreparedStatement能使用参数占位符，而Statement不行
14、下面JFrame类的常用操作方法中，哪个方法是用来设置组件的显示位置的？（）
A、 public void setSize(int width,int height)
B、 public void Background(Color c)
C、 public void setLocation(Point p)
D、 public void setVisiable(boolean b)
15、当鼠标按键被放开时，会调用以下哪个事件处理器方法（）
A、 mouseReleased() B、 mouseUp()
C、 mouseOff() D、 mouseLetGo()
1. 将.java源文件编译为.class文件的是（ ）命令。
2. 用于比较两个整数是否相等的运算符是（ ）。
3. 根据转换方式的不同，数据类型转换可分为（ ）和强制类型转换两种。
4. 被static关键字修饰的成员变量被称为（ ），它可以被该类所有的实例对象共享。
5. 一个类中可以定义多个构造方法，只要每个构造方法的（ ）或（ ）不同，即可实现重载。
6. （ ）关键字用于在方法中声明抛出异常的实例对象。
7. 当对字符串进行修改时，（ ）类和（ ）类的对象都可以被多次修改，并不产生新的未使用对象。
8. InputStream类中专门用于读取文件中数据的子类是（ ）。
1．通过创建一个String类型的数组students来存储多个同学的姓名，借助_________类通过键盘输入的方式输入同学的姓名，并将这些姓名依次存储到数组元素中。
2．在Java中，如果父类中的某些方法不包含任何逻辑，并且需要有子类重写，应该使用________关键字来声明父类的这些方法。
3．一个类可以从其他的类中派生出来，派生出来的类称为________，用于派生的类称为基类或者_______。
4．JDBC驱动管理器专门负责注册特定的JDBC驱动器，主要通过_______类实现。
5．class Person {
int age;
public Person(int age) {
______________ //让局部变量的age给成员变量的age赋值
}
public int getAge() {
return this.age;
}
}
在横线处填入正确的代码，实现让局部变量age给成员变量age赋值。
6．RuntimeException类及其子类都是________异常。
7．Set接口和List接口一样，同样继承自________接口。
8．File类中用于删除文件或整个目录的方法是________。
9．处理ActionEvent事件的监听器对象需要实现________接口。
1．在一个Java类中，可以使用_______关键字来修饰成员变量，该变量称作静态变量，静态变量被所有实例共享，可以使用类名.变量名的形式来访问。
2．异常处理结构中，_________里面放置产生异常的语句，catch里面放置异常处理语句，________里面的语句一定会执行。
3．当一个类中成员变量和局部变量重名时，可以使用_______关键字进行区分。
4．JDBC驱动管理器专门负责注册特定的JDBC驱动器，主要通过_______类实现。
5．请阅读下面的程序，在空白处填写正确的代码，完成构造方法重载，并为成员变量赋值。
public class Person {
String name;
int age;
public Person() {
}
public ________ (String n, int a) {
name = n;
age = a;
}
}
6．在Java中，如果父类中的某些方法不包含任何逻辑，并且需要有子类重写，应该使用________关键字来声明父类的这些方法。
7．向文件中写入字符需要使用________类，它是Writer的一个子类。
8．如果想在JScrollPane面板中添加多个组件，应该先将组件添加到________中，然后将其添加到JScrollPane中。
9．阅读下面的程序，在不new Cat类的情况下，添加代码运行Demo的main()方法后执行Cat的eat()方法。
public class Demo{
public static void main(String[] args) {
Animal animal = new Cat();
cat.eat();
}
}
class Animal{
public void eat(){
System.out.println("animal eat");
}
}
class Cat extends Animal{
public void eat(){
System.out.println("cat eat");
}
}
（ ）1．垃圾回收器会随时将垃圾对象从内存中释放。
（ ）2．Java允许在一个程序中定义多个同名的方法，但是参数的类型或个数必须不同，这就是方法的重写。
（ ）3．方法的返回值类型可以定义也可以不定义。
（ ）4．final修饰的成员变量可以在构造方法中对其重新赋值。
（ ）5．方法重写时，子类抛出的异常类型小于等于父类抛出的异常类型。
（ ）6．使用String类的toCharArray()方法可以将一个字符串转为一个字符数组。
（ ）7．Set接口是一种双列集合，它的每个元素都包含一个键对象Key和值对象Value。
（ ）8．字节流的缓冲区就是使用一个字节数组存放多个字节进行读写操作。
（ ）9．File类可以用于封装一个绝对路径或相对路径。
（ ）10．在应用程序中，当对窗体事件进行处理时，首先需要定义一个类实现MouseListener接口作为窗体监听器。
（ ）1．在命令行窗口中，编译Demo.java文件可以输入javac Demo。
（ ）2．静态方法不占用对象的内存空间，而非静态方法占有对象的内容空间。
（ ）3．case关键字后面的break必须存在。
（ ）4．构造方法在类定义的时候被调用。
（ ）5．如果一个类继承了一个抽象类，但是没有完全重写父类的所有的抽象方法，那么这个类也必须是抽象类。
（ ）6．Object类中的toString()方法用于返回对象的字符串表示形式。
（ ）7．LinkedList集合对于元素的查找操作比ArrayList集合效率高。
（ ）8．StringBuffer类似一个字符容器，当在其中添加或删除字符时，并不会产生新的StringBuffer对象。
（ ）9．文件的拷贝是指读取一个文件中的数据并将这些数据写入到另一个文件中。
（ ）10．在应用程序中，当对窗体事件进行处理时，首先需要定义一个类实现WindowEvent接口作为窗体监听器。
1. 在为double类型的变量赋值时，后面可以加字母D或d，也可以不添加。（ ）
2. Java中的每个类都至少有一个构造方法，一个类中如果没有定义构造方法，系统会自动为这个类创建一个默认的构造方法。（ ）
3. 抽象方法必须定义在抽象类中，所以抽象类中的方法都是抽象方法。（ ）
4. String类的equals()方法和“= =”的作用是一样的。（ ）
5. java.util.Iterator接口中的hashNext()方法是用来判断集合中是否存在下一个元素的。（ ）
6. File类可以用于封装一个绝对路径或相对路径。（ ）
7. 线程对象创建完成时，该线程处于就绪状态。（ ）
8. UDP协议是一种面向无连接的、可靠的、基于字节流的传输层通信协议，该协议占用系统资源多、效率较低。（ ）
9. 作为一种好的编程风格，应在不需要Statement对象和Connection对象时显式地关闭它们。（ ）
10. 事件处理机制专门用于响应用户的操作。（ ）
1. 编写一个完整的Java Application 程序。包含接口ShapeArea，MyRectangle类及Test类，具体要求如下：
1.接口ShapeArea：
double getArea()：求一个形状的面积
double getPerimeter ()：求一个形状的周长
2.类 MyRectangle：实现ShapeArea接口，另有以下属性和方法：
(1)属性
width： double类型，表示矩形的长
height： double类型，表示矩形的高
(2)方法
MyRectangle(double w, double h)：构造函数
toString()方法 ：输出矩形的描述信息，如“width=1.0,height=2.0, perimeter=6.0, area=2.0”
3.Test类作为主类要完成测试功能
(1)生成MyRectangle对象
(2)调用对象的toString方法，输出对象的描述信息
public class TestShape {
public static void main(String args[]) {
MyRectangle r = new MyRectangle(1.0, 2.0);
System.out.println(r.toString());
}
}
interface ShapeArea // 接口定义
{
（1） ;
（2） ;
}
class MyRectangle implements ShapeArea {
double width, height;
MyRectangle(double w, double h) {
width = w;
height = h;
} // 构造方法
public double getPerimeter() {
return 2 * (width + height);
} // 求周长方法
public double getArea() {
return width * height;
} // 求面积方法
public String toString() // toString()方法
{
Return （3） ;
}
}
2. 使用基于UDP的Java Socket编程，完成在线咨询功能：
（1）客户向咨询人员咨询。
（2）咨询人员给出回答。
（3）客户和咨询人员可以一直沟通，直到客户发送bye给咨询人员。
AskServer.java
public class AskServer {
public static void main(String[] args) {
// 创建DatagramSocket，发送接收数据都依赖他
（1） ;
try {
socket = new DatagramSocket(8888);
（2） ;//输入
while (true) {
// 准备一个空的数据包，用来接收数据
byte[] buf = new byte[1024];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
// 接收数据使用空的数据包
（3） ;
// 输出信息
String info = new String(packet.getData(), 0,
packet.getLength());
System.out.println("客户端请求：" + info);
// 判断是否退出
if ("bye".equals(info)) {
break;
}
// 发送数据
String result = input.nextLine();
（4） ;
DatagramPacket packet2 = new DatagramPacket(buf2, buf2.length,
packet.getAddress(), packet.getPort());
socket.send(packet2);
}
} catch (SocketException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
（5） ;
}
}
}
AskClient.java
public class AskClient {
public static void main(String[] args) {
// 创建DatagramSocket，发送接收数据都依赖他
DatagramSocket socket = null;
try {
socket = new DatagramSocket(9999);
Scanner input = new Scanner(System.in);
while (true) {
// 准备要发送的数据
String str = input.nextLine();// bye
// 使用数据包把数据封装起来
byte[] buf = str.getBytes();
DatagramPacket packet = new DatagramPacket(buf, buf.length,
InetAddress.getByName("192.168.1.252"), （6） );
// 发送数据包
（7） ;
// 判断是否退出
if ("bye".equals(str)) {
break;
}
// 接收数据
byte[] buf2 = new byte[1024];
DatagramPacket packet2 = new DatagramPacket(buf2, buf2.length);
socket.receive(packet2);
System.out
.println("服务器端反馈："
+ new String(packet2.getData(), 0, packet2
.getLength()));
}
} catch (SocketException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
socket.close();
}
}
}
1．public class Test {
static String[] strs = {"李白","杜甫","苏轼"};
public static void main(String[] args) {
for (String str : strs) {
str = "屈原";
System.out.println(str);
}
System.out.println(
"foreach循环修改后的数组："+strs[0]+','+strs[1]+','+strs[2]);
}
}
运行结果：
2．
class Father{
void fatherMethod(){
System.out.println("Father Method");
}
}
class Son extends Father{
void sonMethod1(){
System.out.println("Son Method1");
}
void sonMethod2(){
System.out.println("Son Method2");
}
}
public class Test1 {
public static void main(String[] args) {
Father f1 = new Son();
f1.fatherMethod();
Son s1 = (Son)f1;
s1.fatherMethod();
s1.sonMethod1();
s1.sonMethod2();
Father f2 = new Father();
f2.fatherMethod();
}
}
运行结果：
以下程序实现遍历指定目录下所有扩展名为“.java”的文件，请补全程序代码。
import java.io.File;
import java.io.FilenameFilter;
public class Test {
public static void main(String[] args) （1） Exception {
File file = new File("C:\\Users\\Lenovo\\Desktop\\Test");
// 创建过滤器对象
FilenameFilter filter = new （2） {
// 实现accept()方法
public boolean accept(File dir , String name) {
File currFile = new File(dir , name);
// 如果文件名以.java结尾返回true，否则返回false
if (currFile.isFile() && name. （3） ) {
return true;
} else {
return false;
}
}
};
if ( （4） ) { // 判断File对象对应的目录是否存在
String[] lists = file.list(filter); //获得过滤后的所有文件名数组
for (String name : （5） ) {
System.out.println(name);
}
}
}
}
1．public class Demo {
public static void main(String[] args) {
String str = "张三-爱好-编程";
System.out.println( str.substring(3));
System.out.println(str.substring(3, 5));
String[] strArray = str.split("-");
for (int i = 0; i < strArray.length; i++) {
if (i != strArray.length - 1) {
System.out.print(strArray[i] + ",");
} else {
System.out.println(strArray[i]);
}
}
}
}
运行结果：
2．package cn.edu.hsnc;
import java.util.*;
class Student {
private String id;
private String name;
public Student(String id, String name) {
this.id = id;
this.name = name;
}
// 重写toString()方法
public String toString() {
return id + ":" + name;
}
// 重写hashCode方法
public int hashCode() {
return id.hashCode();
}
// 重写equals方法
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof Student)) {
return false;
}
Student stu = (Student) obj;
boolean b = this.id.equals(stu.id);
return b;
}
}
public class Open{
public static void main(String[] args) {
HashSet hs = new HashSet();
Student stu1 = new Student("1", "张三");
Student stu2 = new Student("2", "李四");
Student stu3 = new Student("2", "王五");
Student stu4 = new Student("3", "赵六");
hs.add(stu1);
hs.add(stu2);
hs.add(stu3);
hs.add(stu4);
System.out.println(hs);
}
}
运行结果：
1．编写一个静态方法uniqueArray (ArrayList list)，实现去除ArrayList集合中重复元素的功能。
public static ArrayList uniqueArray(ArrayList list) {
ArrayList newList = new （1） ; //创建新的集合
for(Object obj : list) { //遍历原有集合
//如果新的集合中不包含原有集合中的对象
if(!newList.contains(obj)) {
newList. （2） ; //添加到原有集合中
}
}
return newList;
}
2．编写一个程序实现删除指定文件目录的功能。
public class Example {
public static void main(String[] args) {
File file = new File("C:\\Users\\Lenovo\\Desktop\\test");
deleteDir(file); //删除文件目录
}
private static void deleteDir(File dir) {
if( （3） ) { //判断传入的File对象是否存在
File[] files = （4） ; //获得dir目录下的所有文件数组，存
放在files文件数组中
for(File file : files) { //遍历所有的子目录和文件
if( （5） ) { //判断是否为目录
deleteDir(file);
}else {
file.delete();
}
}
dir.delete();
}
}
}
请按照下列要求编写程序。
（1） 编写一个Student类，包含name和age属性，提供有参构造方法。
（2） 在Student类中，重写toString()方法，输出age和name的值。
（3） 在Student类中，重写hashCode()和equals()方法 a.hashCode()的返回值是name的hash值与age的和。b.equals()判断对象的name和age是否相同，相同则返回true不同返回false。
（4）最后编写一个测试类，创建一个HashSet<Student>对象hs，向hs中添加多个Student对象，假设有两个Student对象相等，输出HashSet，观察是否添加成功。
1．编写一个程序，使用字节缓冲流实现图片文件的拷贝，具体要求如下：
（1）文件路径为源文件D:\童心向党.PNG，目标文件E:\童心向党.PNG。
（2）创建字节缓冲输入流和字节缓冲输出流对象，用于文件的读取和写入。
（3）定义一个1024长度的字节数组作为缓冲区完成文件拷贝。
（4）计算拷贝文件总耗时。
运行结果如下所示：
2．编写一个程序，实现如下功能：
（1）编写类文件，创建一个窗体，采用边界布局方式，窗口命名为“MyJFrame”；
（2）在窗体创建按钮对象和标签对象，分别位于窗体的北部和中部，分别显示为“提交”和“Welcome to our shop!”
（3）为按钮添加事件监听器，当点击按钮时，标签显示“Welcome to come again！”
（4）自定义窗口的大小和定位，并设置关闭窗口时退出程序功能。
运行结果如下所示：
1．编写一个程序，分别使用字节流和字符流实现一个文本文件的拷贝（源文件D:/src.txt，目标文件E:/copy.txt）。要求如下：
（1）使用FileInputStream、FileOutputStream和FileReader、FileWriter分别进行拷贝。
（2）使用字节流拷贝时，定义一个1024长度的字节数组作为缓冲区；
使用字符流拷贝时，利用BufferedReader、BufferedWriter包装流进行包装。
2．编写一个JFrame窗口，要求如下：
（1）采用流式布局管理器设计如下用户图形界面，窗口命名为“MyJFrame”，并为“单击”按钮添加单击事件。默认窗体的标签显示“Hello!Welcome you!”，当单击该按钮时，标签显示“I am clicked!!!”。
（2）自定义设置窗口的大小和定位，并设置关闭窗口时退出程序。
1291
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
