选择题：
1.下面关于集合和数组说法错误的是？（）
A.数组的长度一旦定义就无法更改
B.数组可以存储基本和引用数据类型
C.集合只可以存储引用数据类型，所以无法存储整数和小数
D.集合和数组其实都是容器，都是用来存储数据的
2.下面关于List集合说法错误的是？（）
A.List集合拥有Collection集合的所有方法
B.List集合是线性结构，所以拥有通过索引操作集合元素的方法
C.List集合是Collection集合子类，可以直接创建List对象使用
D.ArrayList是数组结构，LinkedList是链表结构
3.下面关于Iterator集合迭代器说法错误的是？（）
A.Iterator只能迭代Collection类型的单列集合
B.Iterator提供的方法只能正向遍历集合元素
C.ListIterator是List集合特有的迭代器，提供了增删改查的方法
D.删除集合元素时，可以使用迭代器进行遍历，然后通过集合引用直接 删除该元素
4.阅读下面代码选择正确的结果是？（）
HashSet<String> set = new HashSet<String>();
set.add("张三");
set.add("李四");
set.add("张三");
set.add("四里");
set.add("111");
set.add("三张");
System.out.println(set);
A.[张三, 李四, 张三, 四里, 三张]
B.[李四, 张三, 四里, 111, 三张]
C.[李四, 张三, 四里]
D.打印的顺序得不到保障
5.下面关于Set集合说法错误的是？（）
A.Set集合可以通过索引操作集合的元素
B.Set集合的元素对象都是不重复的，原理是依赖元素对象的hashCode 和equals方法
C.HashSet存入的元素顺序和取出的顺序不保证一致
D.TreeSet集合可以对元素对象自动排序，排序的规则是根据元素对象自 身的比较规则决定的
6.ArrayList list = new ArrayList(20);中的 list 扩充几次?
A. 0
B. 1
C. 2
D. 3
7．下面程序的运行结果是什么()
public static void main(String[] args){
String s1 = “abc”;
String s2 = “xyz”;
show(s1,s2);
System.out.println(s1+”-----”+s2);
}
static void show(String s1,String s2){
s1 = s2+s1+”Q”;
s2 = “W”+s1;
}
A.abc-----xyz
B.xyzabcQ-----xyzWabc
C.xyzabcQ---- xyzabcQWabc
D.xyzQ----Wabc
8.关于StringBuffer和StringBuilder说法正确的是( )
A.StringBuffer和StringBuilder的方法不同
B.StringBuffer和StringBuilder都是线程安全的
C.StringBuffer是线程安全的，StringBuilder不是线程安全的
D.StringBuffer不是线程安全的，StringBuilder是线程安全的
9.下列流中哪一个使用了缓冲区技术？（）
A. BufferedOutputStream B. FileInputStream
C. FileOutputStream D. FileReader
10.下面关于字节流和字符流说法错误的？（）
A.字节流的基类分别是OutputStream和InputStream
B.字节流的子类的后缀名都是以基类的名字结尾的
C.内存操作流是一种特殊的流，不属于字节流也不属于字符流
D.字符流是由字节流+编码表包装得来的
11. 字节输出流的抽象基类是( )
A. OutputStream类 B. InputStream类 C. Writer类 D. Reader类
12. 下面程序的运行结果是( )
FileOutputStream fos = new FileOutputStream(“c:\\demo.txt”);
fos.write(“abc”); 字节流不能写入字符串fos.close();
A. 在C盘创建文件demo.txt,但文件是空的 B. 在C盘创建文件demo.txt,并写入数据abc C. 将C盘已有的文件demo.txt中追加写入abc D. 编译失败
13. 下列关于Java中文件输入输出的说法正确的是 ( )
A. 在Java中，文件的输入输出功能是通过流来实现的
B. 如果要把数据写入一个文件中，需要创建一个流对象
C. 字符流在某些方面比如图片的处理，比字节流更方便
D. 可以通过Reader r = new Reader(“c:\\java.txt”);创建一个输入流对象
14. Properties类中的哪个方法可以和IO流相关联( )
A. getProperty() B. setProperty() C. load() D. stringPropertyNames()
15. 下面的程序创建了一个文件输出流对象，用来向文件test.txt中输出数据，假设程 序当前目录下不存在文件test.txt，编译下面的程序Test.java后，将该程序运行3次，则文件test.txt 的内容是( )。
import java.io.*;
public class Test {
public static void main(String args[]) {
try {
String s="ABCDE ";
byte b[]=s.getBytes();
FileOutputStream file=
new FileOutputStream("test.txt",true);
file.write(b);
file.close();
} catch(IOException e) {
System.out.println(e.toString());
}
} } 追加,启用追加了
A. ABCABC B. ABCDE C. Test D. ABCDE ABCDE ABCDE
简答题
1．获取字符串：432jdefds$%[www.abc.com]+)()*(* 中的网址
2．简述ArrayList 和LinkedList的区别
3．简述HashMap的实现原理
4．Iterator是什么？使用的时候需要注意的地方？
编程题
1. 编写一个文本分析类TextProcessor有如下方法：
public int getWordNum(String fileName) throwsFileException
统计一个含有英文单词的文本文件的单词个数。
2.public void getWordNumFile(StringformfileName,Stringword)throwsException
统计指定的文件中含有指定单词的个数。
3.有7个学生信息，内容如下：
学号，姓名，年龄，总分
173620,王康,22,470
173623,刘明,22,450
173628,王瑞,20,460
173624,李玉,21,432
173622,李倩,24,480
173634,刘军,23,550
173632,刘向,20,650
需求：将数据读取到ArrayList<Student>中，然后按照学号为第一条件、年龄为第二条件、总分为第三条件的方式进行排序，并将排序之后的结果输出到控制台
一：
1-5：DCADA
6-10：AACAC
11-15：ADACD
二：
1：import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Test5 {
public static void main(String[] args) {
String s = "432jdefds$%[www.abc.com]+)()*(*";
Matcher m = Pattern.compile(",?(\\w+\\.(com|net))").matcher(s);
while(m.find()){
System.out.println(m.group(1));
}
}
}
2： ArrayList和LinkedList的区别：
ArrayList 采用的是数组形式来保存对象的，这种方式将对象放在连续的位置中，所以最大的缺点就是插入删除时非常麻烦
LinkedList 采用的将对象存放在独立的空间中，而且在每个空间中还保存下一个链接的索引 但是缺点就是查找非常麻烦 要从第一个索引开始
3：HashMap里实现了一个静态的内部类Entry,重要的属性有key,value,next,hash。map中的数据就存储在Entry[]中，每次 put数据时，通过该key的hashcode,得到该key在Entry[]中的索引，然后以e.next遍历，如果存在对应value，返回 value，不存在就将其添加到Entry[]。
put(key,value)时，如果Entry[]的size超过threshold，则进行扩容，即table.length*2。
get(key) 时先定位到该数组元素，再遍历该元素处的链表。
4：迭代器是一种设计模式，他是一个对象，可以遍历并选择序列中的对象
Iterator模式是用于遍历集合类的标准访问方法。它可以把访问逻辑从不同类型的集合类中抽象出来，
从而避免向客户端暴露集合的内部结构。
迭代器在使用时，如果在循环内迭代，每循环一次迭代，不能iterator.next多次，使用多次就相当于迭代多次。
三：
1：第一题
（1）geshu.txt
my name is lijian lijian lijian lijian
(2)
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Test {
public static void main(String[] args) throws IOException {
String fileName = "D:\\geshu.txt";
Test.getWordNum(fileName);
}
// 统计一个含有英文单词的文本文件的单词个数
public static int getWordNum(String fileName) throws IOException {
File file = new File(fileName);
int count = 0;
if (file.exists()) {
FileReader fr = new FileReader(fileName);
//创建一个BufferedReader缓存对象
BufferedReader reader = new BufferedReader(fr);
String line = null;
StringBuffer sbf = new StringBuffer();
while ((line = reader.readLine()) != null) {
sbf.append(line);
String newString = sbf.toString();
newString = newString.replace('\'', ' ');
newString = newString.replace(',', ' ');
newString = newString.replace('.', ' ');
String[] strword = newString.split("\\s+");
System.out.println(Arrays.toString(strword));
for (int i = 0; i < strword.length; i++) {
Pattern pattern = Pattern.compile("[a-zA-Z]*");
Matcher matcher = pattern.matcher(strword[i]);
if(matcher.find()){
count++;
}
}
System.out.println(fileName + " 文件中有" + count + "个英文单词");
}
reader.close();
fr.close();
}
return count;
}
2：第二题
(1)zdgeshu.txt
my name is lijian lijian lijian lijian
(2)
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class Test {
public static void main(String[] args) throws IOException {
String formfileName = "D:\\zdgeshu.txt";
String word = "lijian";
Test.getWordNumFile(formfileName, word);
}
// 统计指定的文件中含有指定单词的个数
public static void getWordNumFile(String formfileName, String word) throws IOException {
File file = new File(formfileName);
int count = 0;
if (file.exists()) {
FileReader fr = new FileReader(formfileName);
BufferedReader reader = new BufferedReader(fr);
String line = null;
StringBuffer sbf = new StringBuffer();
while ((line = reader.readLine()) != null) {
sbf.append(line);
String newString = sbf.toString();
newString = newString.replace('\'', ' ');
newString = newString.replace(',', ' ');
newString = newString.replace('.', ' ');
String[] strword = newString.split("\\s+");
for (int i = 0; i < strword.length; i++) {
if (strword[i].contains(word)) {
count++;
}
}
}
System.out.println( " 文件中的" + word + "单词有" + count + "个英文单词");
reader.close();
fr.close();
}
}
}
第三题
(1) Test3.java
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map.Entry;
public class Test3 {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<Student>();
list.add(new Student("173620", "王康", 22, 470));
list.add(new Student("173623", "刘明", 22, 450));
list.add(new Student("173628", "王瑞", 20, 460));
list.add(new Student("173624", "李玉", 21, 432));
list.add(new Student("173622", "李倩", 24, 480));
list.add(new Student("173634", "刘军", 23, 550));
list.add(new Student("173632", "刘向", 20, 650));
LinkedHashMap<String, Integer> hashMap = new LinkedHashMap<String, Integer>();
for (Student s : list) {
String name = s.getName().substring(0, 1);
if (hashMap.containsKey(name)) {
hashMap.put(name, hashMap.get(name) + 1);
} else {
hashMap.put(name, 1);
}
}
for (Entry<String, Integer> entry : hashMap.entrySet()) {
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key + "," + value);
}
System.out.println("----------------------------------------");
Collections.sort(list);
for (Student s: list) {
System.out.println(s);
}
}
}
(2)Student.java
public class Student implements Comparable<Student>{
private String number;
private String name;
private int age;
private char sex;
private String address;
private float score;
public Student() {
super();
}
public Student(String number, String name, int age, float score) {
super();
this.number = number;
this.name = name;
this.age = age;
this.score = score;
}
public Student(String name, int age, char sex, String address, float score) {
super();
this.name = name;
this.age = age;
this.sex = sex;
this.address = address;
this.score = score;
}
public Student(String name, int age, char sex, String address) {
super();
this.name = name;
this.age = age;
this.sex = sex;
this.address = address;
}
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 char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public float getScore() {
return score;
}
public void setScore(float score) {
this.score = score;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
@Override
public String toString() {
return "Student [number=" + number + ", name=" + name + ", age=" + age + ", sex=" + sex + ", address=" + address
+ ", score=" + score + "]";
}
@Override
public int compareTo(Student o) {
//学号第一、年龄第二、总分第三排序
if(this.getNumber().equals(o.getNumber())){
if(this.getAge()==o.getAge()){
if(this.getScore()>o.getScore()){
return 1;
}else if(this.getScore()==o.getScore()){
return 0;
}else{
return -1;
}
}else{
return this.getAge()-o.getAge();
}
}else{
return this.getNumber().compareTo(o.getNumber());
}
}
}