Java基础测试题
1、
package itheima.exam;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test01 {
/**
* 需求：1、 一个ArrayList对象aList中存有若干个字符串元素，
* 现欲遍历该ArrayList对象，删除其中所有值为"abc"的字符串元素，请用代码实现
* 思路：
* 想要在遍历集合的同时，删除集合中的元素，使用listIterator迭代器;
*
* @param args
*/
public static void main(String[] args) {
// 1、创建一个ArrayList集合
List<String> aList = new ArrayList<String>();
// 2、向集合中添加元素
aList.add("itheima1");
aList.add("itheima2");
aList.add("itheima3");
aList.add("itheima4");
aList.add("abc");
aList.add("abc");
aList.add("abc");
aList.add("itheima5");
// 3、打印原集合
System.out.println(aList);
// 4、删除集合中值为"abc"的元素
Iterator<String> listIterator = aList.listIterator();
while (listIterator.hasNext()) {
String element = listIterator.next();
if (element.equals("abc")) {
listIterator.remove();
}
}
// 5、打印删除"abc"元素后的集合
System.out.println(aList);
}
}2、
package itheima.exam;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Collections;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
public class Test02 {
/**
* 需求：
* 有五个学生，每个学生有3门课（语文、数学、英语）的成绩，
* 写一个程序接收从键盘输入学生的信息，输入格式为：name,30,30,30（姓名，三门课成绩），
* 然后把输入的学生信息按总分从高到低的顺序写入到一个名称"stu.txt"文件中。
* 要求：stu.txt文件的格式要比较直观，打开这个文件，就可以很清楚的看到学生的信息。
*
* 思路：
* 1、通过获取键盘录入一行数据，以"over"作为结束标记，并将信息取出封装成学生对象
* 2、学生为对象，用集合存储，要排序，用TreeSet
* 3、将集合中的数据写到文件中
*
* @param args
*/
public static void main(String[] args) {
Comparator<Student> cmp = Collections.reverseOrder();
Set<Student> stus = null;
try {
stus = StudentInfoTool.getStudents(cmp);
} catch (IOException e) {
throw new RuntimeException("键盘录入数据异常");
}
try {
StudentInfoTool.write2File(stus);
} catch (IOException e) {
throw new RuntimeException("数据写入磁盘文件异常");
}
}
}
// 描述学生的类，自身具备比较性，实现Comparable即可
class Student implements Comparable<Student> {
private String name;
private int chinese;
private int math;
private int english;
private int sum;
public Student(String name, int chinese, int math, int english) {
this.name = name;
this.chinese = chinese;
this.math = math;
this.english = english;
this.sum = math + chinese + english;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getSum() {
return sum;
}
public void setSum(int sum) {
this.sum = sum;
}
// 学生对象有可能存到HashSet或HashMap中，所以复写hashCode方法与equals方法
@Override
public int hashCode() {
return name.hashCode() + sum * 50;
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof Student))
throw new ClassCastException("类型不匹配异常");
Student stu = (Student) obj;
return this.name.equals(stu.name) && (this.sum == stu.sum);
}
// stu.txt文件的格式要比较直观，所以复写toString方法
@Override
public String toString() {
return "Student [name= " + name + ",math= " + math + ",chinese= "
+ chinese + ", english= " + english + ", sum= " + sum + "]";
}
// 存入TreeSet中，应该让元素自身具备比较性
@Override
public int compareTo(Student o) {
int num = this.sum - o.sum;
if (0 == num)
return this.name.compareTo(o.name);
return num;
}
}
class StudentInfoTool {
public static Set<Student> getStudents() throws IOException {
return getStudents(null);
}
public static Set<Student> getStudents(Comparator<Student> cmp)
throws IOException {
// 1、通过获取键盘录入一行数据，并将信息取出封装成学生对象
BufferedReader bufr = new BufferedReader(new InputStreamReader(
System.in));
String line = null;
Set<Student> stus = null;
if (cmp == null)
stus = new TreeSet<Student>();
else
stus = new TreeSet<Student>(cmp);
while ((line = bufr.readLine()) != null) {
if ("over".equals(line))
break;
String[] info = line.split(",");
Student stu = new Student(info[0], Integer.parseInt(info[1]),
Integer.parseInt(info[2]), Integer.parseInt(info[3]));
// 2、将学生对象存到TreeSet集合中
stus.add(stu);
}
bufr.close();
return stus;
}
// 3、将集合中的学生对象存到文件中
public static void write2File(Set<Student> stus) throws IOException {
BufferedWriter bufw = new BufferedWriter(new FileWriter("stu.txt"));
for (Student stu : stus) {
bufw.write(stu.toString());
bufw.newLine();
bufw.flush();
}
bufw.close();
}
}3、
package itheima.exam;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
public class Test03 {
/**
* 需求：ArrayList<Integer> list = new ArrayList<Integer>();
* 在这个泛型为Integer的ArrayList中存放一个String类型的对象。
* 思路：
* 其实泛型只是给编译器使用的，ArrayList<String>与ArrayList<Integer>
* 在内存中完全是同一个字节码，反射可以透过编译器!
* 所以：必须用反射！
* @param args
*/
public static void main(String[] args) {
// 1、创建一个ArrayList集合，泛型限定为Integer
List<Integer> list = new ArrayList<Integer>();
// 2、往集合中添加Integer类型的元素
list.add(1);
list.add(2);
list.add(3);
list.add(5);
list.add(8);
System.out.println(list);
// 3、反射，透过编译器往集合中添加String类型的元素
try {
list.getClass().getMethod("add", Object.class)
.invoke(list, "hello,itheima");
} catch (IllegalAccessException | IllegalArgumentException
| InvocationTargetException | NoSuchMethodException
| SecurityException e) {
throw new RuntimeException("反射时发生异常");
}
// 4、打印集合
System.out.println(list);
}
}4、
package itheima.exam;
public class Test04 {
/**
* 请说明Java中字符'\'的含义，有什么作用？
*
* @param args
*/
public static void main(String[] args) {
// 在Java中，'\'称为：转义符号；它与紧跟在它后面的字符构成转义字符;
// 转义字符在计算机中代表特殊的含义,不但Java中有，C/C++ 中也有！，
// 比如：
// \r\n:windows系统下的回车符
// \n:linux系统下的回车符
// \b：退格
// \t：制表符
String str = "hello" + "\t" + "itheima" + "\r" + "\n";
System.out.println(str);
// 在Java中，有三个字符是要使用转义字符表示的:"\\"(反斜杠)；"\""(双引号);"\'"(单引号)。
System.out.println("\\");
System.out.println("\"");
System.out.println("\'");
// 转义符号还在正则表达式中代表特殊的含义
// 例如：
// \d:代表数字
// \b:代表单词边界
String str1 = "843631536";
System.out.println(str1.matches("\\d{5,11}"));
}
}5、
package itheima.exam;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import com.sun.org.apache.bcel.internal.generic.ARRAYLENGTH;
public class Test05 {
/**
* 需求：
* 编写程序，循环接收用户从键盘输入多个字符串， 直到输入“end”时循环结束，并将所有已输入的字符串按字典顺序倒序打印
* 思路：
* 1、字符串本身提供的比较性为字典顺序，可以使用工具类Collections.reverse()方法将原来的比较性反序，即：字典顺序倒序
* 但也可以自定一个比较器，让集合自身必备比较性；
* 2、键盘录入的是字节流，操作的是字符流，可以使用转换流，并加入缓冲区技术，提高效率；
* 3、录入的字符串存储到ArrayList集合中；
* 4、使用Collections工具类给ArrayList中元素排序
* 4、打印ArrayList集合中的元素
*
* @param args
*/
public static void main(String[] args) {
// 1、定义一个ArrayList集合
List<String> list = new ArrayList<String>();
// 键盘录入字符串，转换流，缓冲区
BufferedReader bufr = new BufferedReader(new InputStreamReader(
System.in));
String line = null;
try {
while ((line = bufr.readLine()) != null) {
if ("end".equals(line))
break;
// 往ArrayList集合中添加元素
list.add(line);
}
} catch (IOException e) {
throw new RuntimeException("IO异常");
}
// 给ArrayList排序，字典倒序
Collections.sort(list, Collections.reverseOrder());
// 打印集合
Iterator<String> it = list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}6、
package itheima.exam;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Random;
public class Test06 {
/**
* 需求： 编写程序，生成5个1至10之间的随机整数， 存入一个List集合，编写方法对List集合进行排序
* （自定义排序算法，禁用Collections.sort方法和TreeSet），然后遍历集合输出。
* 思路：
* 1、使用Random对象产生5个随机数
* 2、把这5个随机数存到ArrayList集合中
* 3、自定义排序算法，选择排序，冒泡排序
* 4、迭代器变量输出
*
* @param args
*/
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
// 1、产生5个1--10的随机数
Random r = new Random();
for (int i = 0; i < 5; i++) {
Integer ii = r.nextInt(10) + 1;
// 2、添加到ArrayList集合中
list.add(ii);
}
// 3、调用自定义的排序算法
sort(list);
// 4、迭代器，遍历
Iterator<Integer> it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
// 自定义的排序算法
private static void sort(List<Integer> list) {
Integer[] arr = list.toArray(new Integer[list.size()]);
selectSort(arr);
ListIterator<Integer> i = list.listIterator();
for (int j = 0; j < arr.length; j++) {
i.next();
i.set((Integer) arr[j]);
}
}
// 选择排序
public static void selectSort(Integer[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[i] > arr[j])
swap(arr, i, j);
}
}
}
// 冒泡排序
public static void bubbleSort(Integer[] arr) {
for (int x = 0; x < arr.length - 1; x++) {
for (int y = 0; y < arr.length - x - 1; y++) {
if (arr[y] > arr[y + 1]) {
swap(arr, y, y + 1);
}
}
}
}
private static void swap(Integer[] arr, int i, int j) {
Integer temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}7、
package itheima.exam;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;
public class Test07 {
/**
* 需求：
* 已知文件a.txt文件中的内容为“bcdeadferwplkou”，
* 请编写程序读取该文件内容，并按照自然顺序排序后输出到b.txt文件中。
* 即b.txt中的文件内容应为“abcd…………..”这样的顺序。
* 思路：
* 1、用一个字符读取流读取a.txt中的内容，用String对象存储
* 2、Sting-->char[],调用Arrays工具类的排序功能，也可以自定义排序功能，
* 但在开发中，一般不干这种事！
* 3、用一个字符写出流把排好序的字符串写到b.txt文件中
*
* @param args
* @throws IOException
*/
public static void main(String[] args) {
// 1、读取流与a.txt相关联
FileReader fr =null;
try {
fr = new FileReader("a.txt");
} catch (FileNotFoundException e) {
throw new RuntimeException("找不到指定的文件");
}
BufferedReader bufr = new BufferedReader(fr);
// 2、读取
String str =null;
try {
str = bufr.readLine();
} catch (IOException e) {
throw new RuntimeException("读取文件异常");
}
// 3、用完了流，及时关闭
try {
if(bufr!=null)
bufr.close();
} catch (IOException e) {
throw new RuntimeException("读取流关闭失败");
}
// 4、字符串转成字符数组
char[] arr = str.toCharArray();
// 5、对字符数组进行排序
Arrays.sort(arr);
// System.out.println(arr);
FileWriter fw =null;
try {
fw = new FileWriter("b.txt");
} catch (IOException e) {
throw new RuntimeException("创建文件失败");
}
// 6、把排好序的数据写到指定的文件中
try {
fw.write(arr);
} catch (IOException e) {
throw new RuntimeException("数据写入磁盘文件异常");
}
// 7、关闭流
try {
if(null !=fw)
fw.close();
} catch (IOException e) {
throw new RuntimeException("写出流关闭失败");
}
}
}8、
package itheima.exam;
public class Test08 {
/**
* 需求：
* 将字符串中进行反转。abcde --> edcba
* 思路：
* 1、字符串转为字符数组
* 2、对字符数组进行反转，并返回字符串
*
* @param args
*/
public static void main(String[] args) {
String str = "abcde";
str = reverse(str);
System.out.println(str);
}
// 反转字符串的方法
private static String reverse(String str) {
// 1、字符串转成字符数组
char[] arr = str.toCharArray();
// 2、对字符数组进行反转
for (int start = 0, end = arr.length - 1; start <= end; start++, end--) {
swap(arr, start, end);
}
// 3、返回字符串
return new String(arr);
}
// 功能抽取，提高复用性
private static void swap(char[] arr, int start, int end) {
char temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
}9、
package itheima.exam;
public class Test09 {
/**
* 需求：
* 在一个类中编写一个方法，这个方法搜索一个字符数组中是否存在某个字符，
* 如果存在，则返回这个字符在字符数组中第一次出现的位置（序号从0开始计算），否则，返回-1。
* 要搜索的字符数组和字符都以参数形式传递传递给该方法，如果传入的数组为null，应抛出IllegalArgumentException异常。
* 在类的main方法中以各种可能出现的情况测试验证该方法编写得是否正确， 例如，字符不存在，字符存在，传入的数组为null等。
* 思路：
* 其实这有点象String对象中的indexOf方法，
* 那么可以将字符数组转成String对象，底层封装String的indexOf方法
* 也可以自定义具体的实现
*
* @param args
*/
public static void main(String[] args) {
String str = "hello,itheima";
char[] arr = str.toCharArray();
char[] arr1 = null;
System.out.println("myIndexOf_1::" + myIndexOf_1(arr, 'h'));
System.out.println("myIndexOf_1::" + myIndexOf_1(arr, 'i'));
System.out.println("myIndexOf_1::" + myIndexOf_1(arr, '5'));
// System.out.println("myIndexOf_1::"+myIndexOf_1(arr1,'1'));
System.out.println("myIndexOf_2::" + myIndexOf_2(arr, 'h'));
System.out.println("myIndexOf_2::" + myIndexOf_2(arr, 'i'));
System.out.println("myIndexOf_2::" + myIndexOf_2(arr, '5'));
// System.out.println("myIndexOf_2::"+myIndexOf_2(arr1,'1'));
}
// 方式一
public static int myIndexOf_1(char[] arr, char ch) {
if(arr == null)
throw new IllegalArgumentException("字符数组不能为null！");
String str = new String(arr);
return str.indexOf(ch);
}
// 方式二
public static int myIndexOf_2(char[] arr, char ch) {
if(arr == null)
throw new IllegalArgumentException("字符数组不能为null！");
for(int i = 0; i < arr.length; i++)
if(ch == arr[i])
return i;
return -1;
}
}10、
package itheima.exam;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Test10 {
/**
* 需求：
* 10、金额转换，阿拉伯数字转换成中国传统形式。 例如：101000001010 转换为 壹仟零壹拾亿零壹仟零壹拾圆整
* 分析：
* 我们都知道：英文的数字读法是按照三位为一个大单位的；中文的数字读法是四位为一个大单位的：万、亿
* 例如："1010 0001 1010"：一千零一十亿零一万一千零一十元；
* 可以看出：
* 1、满四位，则加上一个大单位；
* 2、当连续几个零时，只读出一个零
* 思路：
* 1、键盘录入表示金额的阿拉伯数字形式的字符串
* 2、使用正则表达式进行检验，不符合规则，重新录入
* 3、将阿拉伯数字转成传统的中文读取形式，用到数组查表法，比较简单
*
* @param args
*/
public static void main(String[] args) {
String money = null;
// 1、键盘录入数据
try {
money = getArabNumber();
} catch (IOException e) {
throw new RuntimeException("键盘录入失败，请重启程序");
}
// 2、转成传统的中文读法
System.out.println(ChangeToChinenseNumber(money));
}
// 键盘录入数据 单独封装成函数
public static String getArabNumber() throws IOException {
BufferedReader bufr = new BufferedReader(new InputStreamReader(
System.in));
String line = null;
System.out.println("请录入一个1到12位数的金额：");
while (true) {
line = bufr.readLine();
// 正则判断
if (line.matches("[1-9][0-9]{1,11}"))
return line;
else
System.out.println("您好，您录入的数据不符，请重新录入：");
continue;
}
}
// 转成传统的中文形式
public static String ChangeToChinenseNumber(String money) {
char[] ArabNumber = new char[] { '0', '1', '2', '3', '4', '5', '6',
'7', '8', '9' };
char[] ChineseNumber = new char[] { '零', '壹', '贰', '叁', '肆', '伍', '陆',
'柒', '捌', '玖', };
// 先将阿拉伯数字转成大写中文
for (int i = 0; i < ArabNumber.length; i++)
money = money.replace(ArabNumber[i], ChineseNumber[i]);
System.out.println(money);
// 单位，后三位为大单位；前三位为小单位
char[] numberUnit = new char[] { '仟', ' ', '拾', '佰', '圆', '万', '亿' };
// 大家都知道，中文的数字是按四位为一个大单位的：圆，万，亿
// shang代表大单位，yushu代表小单位
int shang;
int yushu;
// 用一个容器存储
StringBuilder sb = new StringBuilder();
for (int length = money.length(), index = 0; length > 0; length--, index++) {
shang = length / 4;
yushu = length % 4;
// 为'零'时，单独处理
if (money.charAt(index) == '零') {
// 余数为1，这时正是个位、万位、亿位的情况
if (yushu == 1) {
if (!(shang != 2 && money.substring(index - 3, index + 1)
.equals("零零零零"))) {
// 大单位上的四位数不全为'零'，加上大单位：圆、万、亿
sb.append(numberUnit[4 + shang]);
}
} else {
// 否则，暂时不加
}
continue;
}
// 前面已经处理了数字为'零'的情况，当数字不为零，且前面一位为零时，应该额外加上一个'零'字
if (length != money.length() && yushu != 0
&& money.charAt(index - 1) == '零') {
sb.append('零');
}
// 普通情况，先添加数字，然后添加单位
sb.append(money.charAt(index));
if (yushu == 1) {
sb.append(numberUnit[4 + shang]);
} else {
sb.append(numberUnit[yushu]);
}
}
// 最后，往容器中添加一个'整'字
sb.append("整");
return sb.toString();
}
}
901
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
