测试题

package com.itheima;

import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;

public class Test1 {

  /**
   * 1、 取出一个字符串中字母出现的次数。如：字符串："abcdekka27qoq" ，输出格式为：a(2)b(1)k(2)...
   * @author 汤柳清
   */

  public static void main(String[] args) {
    String str = "abcdekka27qoq";
    System.out.println(charCount(str));
  }

  public static String charCount(String str) {
    char[] chs = str.toCharArray();//转换成数组
    Map<Character, Integer> m = new TreeMap<Character, Integer>();//加入泛型，前一参数是字符类型，后一个参数是整型
    int count = 0;
    for (int x = 0; x < chs.length; x++) {
      if (chs[x] >= 'a' && chs[x] <= 'z' || chs[x] >= 'A'
          && chs[x] <= 'Z') {
        Integer value = m.get(chs[x]);//得到key所对应的value
        System.out.print(chs[x]+",");//查看key的值
        System.out.println(value);//查看value的值
        if (value != null)
          count = value;
        count++;
        m.put(chs[x], count);
        count = 0;//清0
      }
    }
    StringBuilder sb = new StringBuilder();//保存将从集合中迭代出来的字母和次数
    //迭代map集合         
    Iterator<Entry<Character, Integer>> it = m.entrySet().iterator();
    while (it.hasNext()) {
      Map.Entry<Character, Integer> me = it.next();
      //加到容器sb中
      sb.append(me.getKey() + "(" + me.getValue() + ")");
    }
    return sb.toString();

  }
}

package com.itheima;

public class Test2 {

  /**
   * 2、 定义一个交通灯枚举，包含红灯、绿灯、黄灯，需要有获得下一个灯的方法，例如：红灯获取下一个灯是绿灯，绿灯获取下一个灯是黄灯。 分析：
   * 1.定义一个交通灯枚举 2.枚举中包含3个对象即RED、GREEN、YELLOW
   * 3.定义抽象方法nextLamp()，类型为TrafficLamp 4.用匿名内部类的方式为3个对象实现抽象方法 5.构造方法私有化
   * 
   * @author 汤柳清
   */
  public static void main(String[] args) {
    TrafficLamp t = TrafficLamp.RED;
    System.out.println(t.nextLamp());

    TrafficLamp t1 = TrafficLamp.GREEN;
    System.out.println(t1.nextLamp());

    TrafficLamp t2 = TrafficLamp.YELLOW;
    System.out.println(t2.nextLamp());
  }
}

enum TrafficLamp {
  RED {// 匿名内部类
    public TrafficLamp nextLamp() {
      return GREEN;
    }
  },
  GREEN() {// 匿名内部类
    public TrafficLamp nextLamp() {
      return YELLOW;
    }
  },
  YELLOW() {// 匿名内部类
    public TrafficLamp nextLamp() {
      return RED;
    }
  };
  public abstract TrafficLamp nextLamp();// 带抽象方法的枚举

  private TrafficLamp() {// 构造方法私有化，目的是不允许程序员自己创建该类的对象。

  }
}

package com.itheima;

public class Test3 {

  /**
   * 3、 方法中的内部类能不能访问方法中的局部变量，为什么？ 
   * 答： 方法中的内部类可以访问方法中的局部变量，但是该局部变量必须用final关键字修饰。
   * 因为方法中的代码是由上而下顺序执行的，方法运行结束后，局部变量就被销毁，
   * 内部类的生命周期可能会比局部变量的生命周期长；用final修饰符修饰局部变量后，
   * 局部变量的生命周期会延长，其不会因为语句块的结束而结束，还会长期存在。
   * 所以方法中的内部类可以访问方法中的局部变量。 如下，示例代码所示。
   * 
   * @author 汤柳清
   */
  public static void main(String[] args) {
    Outter o = new Outter();
    o.getInner();
  }
}

class Outter {
  public void getInner() {
    final int a = 3; // 定义局部变量
    class Inner { // 定义内部类Inner
      public void show() {
        System.out.println(a);
      }
    }
    // 创建局部内部类对象
    Inner inner = new Inner();
    inner.show();
  }

}

package com.itheima;

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 Test4 {

  /**
   * 4、 有五个学生，每个学生有3门课（语文、数学、英语）的成绩，写一个程序接收从键盘输入学生的信息，
   * 输入格式为：name,30,30,30（姓名，三门课成绩），然后把输入的学生信息按总分从高到低的顺序
   * 写入到一个名称"stu.txt"文件中。要求：stu.txt文件的格式要比较直观， 打开这个文件，就可以很清楚的看到学生的信息。
   * 
   * @author 汤柳清
   */
  public static void main(String[] args) throws IOException {
    // 自定义强制反转的比较器
    Comparator<Student> cmp = Collections.reverseOrder();
    //以下把比较器作为参数传递
    Set<Student> stus = StudentInfoTool.getStudents(cmp);
    StudentInfoTool.writeToFile(stus);
  }
}

class Student implements Comparable<Student> {
  private String name;
  private int ma, cn, en;
  private int sum;

  Student(String name, int ma, int cn, int en) {
    this.name = name;
    this.ma = ma;
    this.cn = cn;
    this.en = en;
    sum = ma + cn + en;
  }

  public String getName() {
    return name;
  }

  public int getSum() {
    return sum;
  }

  public int hashCode()// 重写方法
  {
    return name.hashCode() + sum * 56;// 56是随便乘的
  }

  public boolean equals(Object obj)// 重写方法
  {
    if (!(obj instanceof Student))
      throw new ClassCastException("不是学生类！");
    Student s = (Student) obj;
    return this.name.equals(s.name) && this.sum == s.sum;
  }

  // 实现接口中的方法，分数相同再比较姓名。如果总分和姓名都相同，就是同一个人。
  public int compareTo(Student s) {
    int num = new Integer(this.sum).compareTo(new Integer(s.sum));
    if (num == 0)
      return this.name.compareTo(s.name);
    return num;
  }

  public String toString() {
    return "student["+name+", "+ma+", "+cn+", "+en+"]";
  }
}

class StudentInfoTool {

  public static Set<Student> getStudents() throws IOException// 不论带不带比较器，调用的都是带比较器的方法
  {
    return getStudents(null);// 不带比较器的比较
  }

  public static Set<Student> getStudents(Comparator<Student> cmp)
      throws IOException// 带自定义比较器的比较
  {
    BufferedReader bufr = new BufferedReader(new InputStreamReader(
        System.in));
    String line = null;
    Set<Student> stus = null;
    if (cmp == null)// 不论带不带比较器，调用的都是掉比较器的方法
      stus = new TreeSet<Student>();// treeset内部已经按默认自然排序，排好序啦！！！
    else
      stus = new TreeSet<Student>(cmp);
    while ((line = bufr.readLine()) != null) {
      if ("over".equals(line))// 输入over就结束
        break;
      String[] info = line.split(",");// 以逗号分隔输入的信息
      Student stu = new Student(info[0], Integer.parseInt(info[1]),
          Integer.parseInt(info[2]), Integer.parseInt(info[3]));// 字符串要转换为整形
      stus.add(stu);
    }
    bufr.close();
    return stus;
  }

  public static void writeToFile(Set<Student> stus) throws IOException {

    BufferedWriter bufw = new BufferedWriter(new FileWriter("stuinfo.txt"));

    for(Student stu : stus)
    {
      bufw.write(stu.toString()+"\t");
      bufw.write(stu.getSum()+"");//要转换成字符串
      bufw.newLine();
      bufw.flush();
    }

    bufw.close();
  }
}

package com.itheima;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Test5 {

  /**
   * 5、 编写程序，生成5个1至10之间的随机整数，存入一个List集合，
   * 编写方法对List集合进行排序（自定义排序算法，禁用Collections.sort方法和TreeSet）， 
   * 然后遍历集合输出。
   * 
   * @author 汤柳清
   */

  public static void main(String[] args) throws InterruptedException {
    int[] number = new int[5];// 定义一个int数组长度为5
    List<Integer> list = new ArrayList<Integer>();// 定义一个int数组长度为5
    for (int i = 0; i < 5; i++) {
      number[i] = (int) (Math.random() * 10 + 1);// 返回1~10之间的随机整数给number[i]
      for (int j = 0; j < i; j++) {
        if (number[i] == number[j]) {// 与之前的数对比，防止重复
          i--;
          break;
        }
      }
    }
    System.out.println("将随机数添加到list集合中");
    for (int n : number) {
      Thread.sleep(100);// 为了打印好看些
      list.add(n);
      System.out.print(n + " ");
    }
    System.out.println("\n5个1至10的随机数从小到大排序如下：");
    Collections.sort(list);// 按升序排序
    // 冒泡排序
    for (int i = 0; i < list.size() - 1; i++) {
      for (int j = 1; j < list.size() - i; j++) {
        if ((list.get(j - 1)).compareTo(list.get(j)) > 0) { // 比较两个整数的大小
          int temp = list.get(j - 1); // 如果J-1大于J的交换位置
          list.set((j - 1), list.get(j));
          list.set(j, temp);
        }
      }
    }
    // 遍历输出
    for (int n : list) {
      Thread.sleep(100);// 为了打印好看些
      System.out.print(n + " ");
    }
  }
}

package com.itheima;

public class Test6 {

  /**
   * 6、 编写三各类Ticket、SealWindow、TicketSealCenter分别代表票信息、售票窗口、售票中心。
   * 售票中心分配一定数量的票，由若干个售票窗口进行出售，利用你所学的线程知识来模拟此售票过程。
   * 
   * @author 汤柳清
   */
  public static void main(String[] args) {
    Test6 t = new Test6();
    t.new Ticket();

  }

  class Ticket {
    public Ticket() {
      TicketSealCenter tsc = new TicketSealCenter(100);// 定义有100张票
      for (int i = 0; i < 5; i++) {// 定义有5个窗口
        new Thread(new SealWindow(i, tsc)).start();// 启动售票窗口售票
      }
    }
  }

  /**
   * 售票中心类 定义了票的总数，同步售票方法
   */
  class TicketSealCenter {
    int ticketNum = 50;
    boolean flag = false; // 定义票是否卖完

    public TicketSealCenter(int num) {// 定义一个改变票数的方法
      this.ticketNum = num;
    }

    public synchronized void sellTicket(SealWindow s) {
      if (ticketNum > 0) {//票数如果大于0
        int n = s.num + 1;//n表示第几号窗口
        System.out
            .println("第--" + n + "--售票窗口卖出了第" + ticketNum + "张票!");
        ticketNum--;//卖出一张票后减1
      } else {
        flag = true;
      }
    }
  }

  /**
   * 售票窗口类
   */
  class SealWindow implements Runnable {
    int num;//num表示第几号窗口-1，即i
    TicketSealCenter tsc;

    public SealWindow(int num, TicketSealCenter tsc) {
      this.num = num;
      this.tsc = tsc;
    }

    public final void run() {
      while (!tsc.flag) {
        tsc.sellTicket(this); // 调用售票中心类的同步票数
        try {
          Thread.sleep(100);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }
  }
}

package com.itheima;

public class Test7 {

  /**
   * 7、 有一个类为ClassA,有一个类为ClassB，在ClassB中有一个方法b，此方法抛出异常，
   * 在ClassA类中有一个方法a，请在这个方法中调用b,然后抛出异常。 在客户端有一个类为TestC,有一个方法为c
   * ,请在这个方法中捕捉异常的信息。 完成这个例子，请说出java中针对异常的处理机制。
   * 答：Java提供两种异常处理机制
   * （1）用try...catch语句捕获并且处理异常；    
   * （2）使用throw抛出异常，异常必须是java.lang.Throwable类的对象或者该类的子类的对象；    
   * （3）使用throws声明方法抛出异常；    
   * （4）使用finally语句声明在任何情况下都会执行的代码。
   *如下，类A和类B都是跑出了异常，而类C捕获了异常。 
   * @param 汤柳清
   */
  public static void main(String[] args) {
    ClassC.methodC();

  }
}

class ClassB {
  public static void methodB() throws Exception {
    System.out.println("This is methodB");
  }
}

class ClassA {
  public static void methodA() throws Exception {
    ClassB.methodB();
  }
}

class ClassC {
  public static void methodC() {
    try {
      ClassA.methodA();
    } catch (Exception e) {
      System.out.println(e.getMessage());
    }
  }
}

package com.itheima;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
/**
 * 1
 * 2
 * 3
 * @author Administrator
 *
 */
public class Test8 {

  /**
   *8、 编写一个类，增加一个实例方法用于打印一条字符串。并使用反射手段创建该类的对象， 并调用该对象中的方法。##
   * ##分析：
   * 1.加载类
   * 2.加载无参构造方法
   * 3.创建Demo对象
   * 4.获得自定义的实例方法
   * 5.调用showMessage方法
   * @author 汤柳清
   */
  @SuppressWarnings({ "rawtypes", "unchecked" })
  public static void main(String[] args) {

    try {
      /** 加载类*/
      Class clazz = Class.forName("com.itheima.Demo");
      // 加载无参构造方法
      Constructor constructor = clazz.getConstructor();
      // 创建Demo对象
      Demo demo = (Demo) constructor.newInstance();
      // 获得自定义的实例方法
      Method method = clazz.getMethod("showMessage");
      // 调用该方法
      method.invoke(demo);
    } catch (Exception e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

  }
}

package com.itheima;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test9 {

  /**
   * 9、 编写一个程序，它先将键盘上输入的一个字符串转换成十进制整数， 然后打印出这个十进制整数对应的二进制形式。这个程序要考虑输入的字符串
   * 不能转换成一个十进制整数的情况，并对转换失败的原因要区分出是数字太大，
   * 还是其中包含有非数字字符的情况。提示：十进制数转二进制数的方式是用这个数除以2， 余数就是二进制数的最低位，接着再用得到的商作为被除数去除以2，
   * 这次得到的余数就是次低位，如此循环，直到被除数为0为止。 其实，只要明白了打印出一个十进制数的每一位的方式
   * （不断除以10，得到的余数就分别是个位，十位，百位），就很容易理解十进制数转二进制数的这种方式。
   * 
   * @author 汤柳清
   * @throws IOException
   */
  public static void main(String[] args) throws IOException {
    // TODO Auto-generated method stub
    BufferedReader bufr = new BufferedReader(new InputStreamReader(
        System.in));
    String line = bufr.readLine();
    bufr.close();

    ChangeToBinary(line);
  }

  public static void ChangeToBinary(String arr) {
    char[] array = arr.toCharArray();
    StringBuilder sb = new StringBuilder();
    char[] number = new char[] { '0', '1', '2', '3', '4', '5', '6', '7',
        '8', '9' };
    for (int i = 0; i < array.length; i++) {
      for (int j = 0; j < number.length; j++) {

        if (array[i] == number[j]) {
          continue;
        }
        if (j >= number.length) {
          break;
        }
      }
    }
    double d = 0;
    try {
      d = Double.parseDouble(arr);
    } catch (Exception e) {
      throw new RuntimeException("包含有非数字字符");
    }
    if (d > Integer.MAX_VALUE) {
      System.out.println("数字太大");
    } else {
      int data = Integer.parseInt(arr);

      while (data > 0) {// 转二进制数

        int b = data % 2;

        sb.append(b);

        data = data / 2;

      }
    }
    System.out.println(sb.reverse());
  }
}

package com.itheima;

/**
 * 10：28人买可乐喝，3个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，够28人喝？假如是50人，又需要买多少瓶可乐？（需写出分析思路）
 * 分析：
 * 定义一个变量代表瓶盖数，当瓶盖数没有到3的时候，就继续购买可乐，同时瓶盖数加1，
 * 当瓶盖数达到3，就把瓶盖数置为1，这次就不要购买可乐。
 * 循环28次，可以使28人都能喝到可乐。
 * 同理，50人喝可乐一样。
 * @author 汤柳清
 */
public class Test10 {
  public static void main(String[] args) {
    System.out.println("28人买可乐喝,需要买:" + BuyCokes(28) + "瓶");
    System.out.println("50人买可乐喝,需要买:" + BuyCokes(50) + "瓶");

  }

  // 购买可乐方法
  public static int BuyCokes(int num) {
    // 瓶盖数
    int bottle_cap = 0;
    // 需要购买总瓶数
    int sum = 0;
    for (int i = 0; i < num; i++) {
      if (bottle_cap != 3) {
        // 购买一瓶
        sum++;
        // 同时瓶盖增加一个
        bottle_cap++;
      } else if (bottle_cap == 3) {
        bottle_cap = 1;// 瓶盖数置为1
      }
    }
    return sum;
  }

}