入学测试题
package com.itheima;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;
/**
* 4、 有五个学生，每个学生有3门课（语文、数学、英语）的成绩，
* 写一个程序接收从键盘输入学生的信息，输入格式为：name,30,30,30（姓名，三门课成绩），
* 然后把输入的学生信息按总分从高到低的顺序写入到一个名称"stu.txt"文件中。
* 要求：stu.txt文件的格式要比较直观，打开这个文件，就可以很清楚的看到学生的信息。
*
*
* 定义一个学生类，让自身具备比较性，实现Comparable，覆写compareTo。
* 学生按照总分排序，属性应该是名字，各门成绩和总成绩
* 因为有对应关系，所以考虑map集合
* 用BufferedWriter写入stu.txt文件。
*/
public class Test1
{
public static void main(String[] args)
{
//因为有对应关系所以可以考虑使用TreeMap集合
TreeMap<Student,Integer> tm = new TreeMap<Student,Integer>();
//扫描学生信息
Scanner in = new Scanner(System.in);
System.out.println("请输入学生信息(over结束)：");
c : while (true)
{
String str = in.nextLine();
//如果输入over则跳出循环
if (str.equals("over"))
break;
//为了方便对象数据的转换，所以切割分别进行操作
String[] split = str.split(",");
//如果格式不对，则继续从新开始循环
if (split.length != 4)
{
System.out.print("输入有误，正确格式为name,ch,ma,en");
continue c;
}
//把分数都从字符串转成十进制数
String name = split[0];
int ch = Integer.parseInt(split[1]);
int ma = Integer.parseInt(split[2]);
int en = Integer.parseInt(split[3]);
Student s = new Student(name,ch,ma,en);
tm.put(s, s.getSum());
}
writerFile(tm);
}
//定义一个函数，函数功能是把集合里的数据打印到stu.txt文件中
public static void writerFile(TreeMap<Student, Integer> tm)
{
BufferedWriter bw = null;
try
{
bw = new BufferedWriter(new FileWriter("stu.txt"));
//取出Map集合的方式之一，Entry迭代。
Set<Entry<Student,Integer>> entrySet = tm.entrySet();
for (Iterator<Entry<Student, Integer>> it = entrySet.iterator();it.hasNext(); )
{
Map.Entry<Student, Integer> me = it.next();
Student student = me.getKey();
Integer value = me.getValue();
bw.write(student.toString());
bw.write("\t总分："+value);
bw.newLine();
bw.flush();
}
}
catch (IOException e)
{
throw new RuntimeException("读写错误");
}
finally
{
try
{
if (bw != null)
bw.close();
}
catch (IOException e)
{
throw new RuntimeException("写入关闭失败");
}
}
}
}
//定义学生类，要让学生自身具备比较性，所以实现Comparable方法
class Student implements Comparable<Student>
{
private String name;
private int ch;
private int ma;
private int en;
private int sum;
Student(String name,int ch,int ma,int en)
{
this.name = name;
this.ch = ch;
this.ma = ma;
this.en = en;
this.sum = ch + ma + en;
}
//覆写compareTo方法，使学生按照总分来排序
public int compareTo (Student s)
{
int num = s.getSum() - this.getSum();
if (num == 0)
return s.getName().compareTo(this.getName());
return num;
}
//覆写toString()，格式化输出
public String toString()
{
return "姓名："+name+"\t语文成绩："+ch+"\t数学成绩："+ma+"\t英语成绩："+en;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getCh() {
return ch;
}
public void setCh(int ch) {
this.ch = ch;
}
public int getMa() {
return ma;
}
public void setMa(int ma) {
this.ma = ma;
}
public int getEn() {
return en;
}
public void setEn(int en) {
this.en = en;
}
public int getSum() {
return sum;
}
public void setSum(int sum) {
this.sum = sum;
}
}
package com.itheima;
/**
* 2、 假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：姓名、工号以及工资。经理也是员工，除了含有员工的属性外，
* 另为还有一个奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。
*
* 声明一个员工类，员工包含 3 个属性：姓名、工号以及工资。
* 私有属性，提供属性访问方法，
* 声明一个经理类，因为经理也是员工，包含员工的属性所以要继承员工类
* 经理额外有个奖金属性，私有，并且提供属性访问方法，
*
*/
public class Test2
{
public static void main(String[] args)
{
Employee e = new Employee("leilei","007",5000);
Manager m = new Manager("hanmeimei","001",10000,20000);
System.out.println("员工姓名："+e.getName()+"\t工号："+e.getId()+"\t工资："+e.getMoney());
System.out.println("经理姓名："+m.getName()+"\t工号："+m.getId()+"\t工资："+m.getMoney()+"\t奖金："+m.getBonus());
}
}
//声明一个员工类，员工包含 3 个属性：姓名、工号以及工资。
class Employee
{
private String name;
private String id;
private double money;
Employee(String name,String id,double money)
{
this.name = name;
this.id = id;
this.money = money;
}
//一些获取和设置的方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public double getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
//声明一个经理类，经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。
class Manager extends Employee
{
private double bonus;
Manager(String name,String id,double money,double bonus)
{
super(name, id, money);
this.bonus = bonus;
}
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
}
package com.itheima;
import java.util.ArrayList;
import java.util.Iterator;
/**
* 3、 一个ArrayList对象aList中存有若干个字符串元素，现欲遍历该ArrayList对象，删除其中所有值为"abc"的字符串元素，请用代码实现。
*
* 遍历集合，如果有"abc"相同的，则remove()
*/
public class Test3
{
public static void main(String[] args)
{
ArrayList<String> aList = new ArrayList<String>();
aList.add("sasdabc");
aList.add("abc");
aList.add("come");
aList.add("osiuabcu");
System.out.println(aList);//删除前的aList
//遍历元素，如果为"abc"，则删除该元素
for (Iterator<String> lt = aList.iterator();lt.hasNext(); )
{
String str = lt.next();
if (str.equals("abc"))//如果"abc"，则删除
lt.remove();
}
System.out.println(aList);//删除后的aList
}
}
package com.itheima;
import java.lang.reflect.Field;
/**
* 写一个方法，此方法可将obj对象中名为propertyName的属性的值设置为value.
*
* public void setProperty(Object obj, String propertyName, Object value)
* {
* }
*
* 反射知识，用Field方法把一个类的propertyName获取字段
* 可以考虑反射中的暴力反射，强行修改
* 记得修改完要关闭访问权限
* 测试
*
*/
public class Test4
{
public static void main(String[] args)
{
TestClass tc = new TestClass();
System.out.println(tc.pri+"---"+tc.pub);
//修改后的
setProperty(tc,"pub",345);
setProperty(tc,"pri",567);
System.out.println(tc.pri+"---"+tc.pub);
}
public static void setProperty(Object obj,String propertyName,Object value)
{
try
{
Field f = obj.getClass().getDeclaredField(propertyName);//获取一个类的所有字段
f.setAccessible(true);//暴力反射，强行开启访问权限
f.set(obj,value);//修改
f.setAccessible(false);//关闭访问权限
}
catch (Exception e)
{
System.out.println("修改错误！");
}
}
public static class TestClass//测试内部类
{
private int pri = 123;
public int pub = 234;
}
}
package com.itheima;
/**
* 5、 将字符串中进行反转。abcde --> edcba
*
* 字符串转成char数组
* 定义一个反转功能的数组
* 调用反转
* char数组转成字符串
*/
public class Test5
{
public static void main(String[] args)
{
String str = "abcde";
System.out.println(reverseAll(str));
}
//定义一个函数，函数功能反转一个字符串
public static String reverseAll(String str)
{
int start,end;
char[] ch = str.toCharArray();
for (start=0,end=ch.length-1;start<end;start++,end--)
{
change(ch,start,end);
}
return new String(ch);
}
//定义一个函数，函数功能交换两个char类型函数位置函数
public static void change(char[] ch,int x,int y)
{
char temp =ch[x];
ch[x] = ch[y];
ch[y] = temp;
}
}
package com.itheima;
import java.util.HashSet;
import java.util.Random;
/**
* 6、 编写一个程序，获取10个1至20的随机数，要求随机数不能重复
*
* Random获得随机数
* 定义一个数组，如果不同则存入，相同不存,考虑HashSet
* 计数器满存入10个则停滞产生随机数
* 打印随机数
*/
public class Test6
{
public static void main(String[] args)
{
//创建Random对象，获取随机数
Random r = new Random();
//因为考虑随机数不重复，所以用Set集合,因为没有要求排序，所以可以考虑HashSet
HashSet<Integer> s = new HashSet<Integer>();
while (s.size()<10)//如果集合中元素小于10个就继续存数
{
s.add(r.nextInt(20)+1);//随机把1~20的数添加进集合
}
System.out.println(s);
}
}
package com.itheima;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
/**
* 7、 自定义字符输入流的包装类，通过这个包装类对底层字符输入流进行包装，让程序通过这个包装类读取某个文本文件（例如，一个java源文件）时，能够在读取的每行前面都加上有行号和冒号
*
* 定义MyLineNumReader类。用StringBuffer，如果一行中有\r\n则代表需要换行了
* 那么前面需要加上计数器和冒号
*/
public class Test7
{
public static void main(String[] args) throws IOException
{
MyLineNumReader mlnr = new MyLineNumReader(new FileReader("Test.java"));
String s=null;
while( (s = mlnr.readLine()) != null )
{
System.out.println(s);
}
mlnr.close();//关闭流
}
}
class MyLineNumReader
{
private Reader r;
int linenum = 0;//行前面的序号
MyLineNumReader(Reader r)
{
this.r = r;
linenum = 0;
}
public String readLine() throws IOException
{
StringBuffer sb = new StringBuffer();
int num = 0;
while ((num = r.read()) != -1)
{
//如果碰到\r\n就代表要换行了
if (num == '\r')
continue;
if (num == '\n')
{
linenum ++;
return linenum + ":" + sb.toString();
}
else
{
sb.append((char)num);
}
}
if (sb.length()>0)
{
linenum ++;
return linenum + ":" + sb.toString();
}
return null;
}
public void close() throws IOException
{
r.close();
}
}
package com.itheima;
/**
* 8、 有一个类为ClassA,有一个类为ClassB，在ClassB中有一个方法b，此方法抛出异常，在ClassA类中有一个方法a，请在这个方法中调用b,然后抛出异常。
* 在客户端有一个类为TestC,有一个方法为c ,请在这个方法中捕捉异常的信息。完成这个例子，请说出java中针对异常的处理机制。
*
*
*/
public class Test8
{
public static void main(String[] args)
{
C.c();//主函数调用测试
}
}
class A
{
public static void a() throws Exception//声明异常，不处理，再抛给上一级调用者
{
B.b();//调用b，b的异常被抛给a处理
}
}
class B
{
public static void b() throws Exception//声明异常
{
throw new Exception("b发生异常");//b产生并抛出异常，异常不处理，抛给调用者a
}
}
class C
{
public static void c()
{
try
{
A.a();//异常被抛给调用者a
}
catch(Exception e)//捕捉异常
{
System.out.println(e.toString());//(处理异常)，打印异常信息
}
}
}
package com.itheima;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* 9、 编写一个程序，它先将键盘上输入的一个字符串转换成十进制整数，然后打印出这个十进制整数对应的二进制形式。这个程序要考虑输入的字符串不能转换成一个十进制整数的情况，
* 并对转换失败的原因要区分出是数字太大，还是其中包含有非数字字符的情况。
*
* 提示：十进制数转二进制数的方式是用这个数除以2，余数就是二进制数的最低位，接着再用得到的商作为被除数去除以2，这次得到的余数就是次低位，如此循环，直到被除数为0为止。
* 其实，只要明白了打印出一个十进制数的每一位的方式（不断除以10，得到的余数就分别是个位，十位，百位），就很容易理解十进制数转二进制数的这种方式。
*
*
*/
public class Test9{
public static void main(String[] args) throws IOException
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入一个数：");
String str = br.readLine();
int m = 0;
try {
m = Integer.parseInt(str);//把字符串转成十进制数
long quotient = m/2;
long remainder = m%2;
StringBuffer sb = new StringBuffer();
//余数就是二进制数的最低位，接着再用得到的商作为被除数去除以2
sb.append(remainder);
//这次得到的余数就是次低位，如此循环，直到被除数为0为止
while(quotient != 0)
{
remainder = quotient%2;
quotient = quotient/2;
sb.append(remainder);
}
System.out.println(sb.reverse().toString());//翻转
}
catch(NumberFormatException e)
{
//正则表达式的匹配方法
String regx = ".*\\D+.*";
if(str.matches(regx))
{
System.out.println("字符串中包含非数字字符");
}
else
{
System.out.println("数据范围超出");
}
}
finally
{
try
{
if (br != null)
br.close();
}
catch(IOException e)
{
System.out.println("流关闭失败！");
}
}
}
}
package com.itheima;
/**
* 10、 28人买可乐喝，3个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，够28人喝？假如是50人，又需要买多少瓶可乐？（需写出分析思路）
*
* 3个瓶盖换1瓶可乐
* 定义可乐。瓶盖，买的瓶数
* 每买一瓶，可乐，瓶盖，买的瓶数都会+1个
* 3个瓶盖等于一个瓶盖加一瓶可乐
*/
public class Test10
{
public static void main(String[] args)
{
System.out.println(getCoke(28));
System.out.println(getCoke(50));
}
//定义一个函数，函数功能，输入可乐数，可以返回要买的瓶数
public static int getCoke(int num)
{
int coke = 0;//可乐数
int cap = 0;//瓶盖数
int buy = 0;//买的可乐数
while (coke < num)//每买一瓶饮料，买的数，瓶盖数和可乐数都加一
{
buy++;
cap++;
coke++;
if (cap == 3)//3个瓶盖等于一个瓶盖加一瓶可乐
{
cap = 1;
coke++;
}
}
return buy;
}
}
