入学测试题

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("	总分："+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+"	语文成绩："+ch+"	数学成绩："+ma+"	英语成绩："+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()+"	工号："+e.getId()+"	工资："+e.getMoney());
		System.out.println("经理姓名："+m.getName()+"	工号："+m.getId()+"	工资："+m.getMoney()+"	奖金："+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，如果一行中有
则代表需要换行了
 * 那么前面需要加上计数器和冒号
 */
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)
		{
			//如果碰到
就代表要换行了
			if (num == '
')
				continue;
			if (num == '
')
			{
				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;
	}
}