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;
public class Demo {
// 实例方法
public void showMessage() {
System.out.println("hello,heima!\thello,teacher!");
}
}
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;
}
}
java试题1：
请在一个类中编写一个方法，这个方法搜索一个字符数组中是否存在某个字符，如果存在，则返回这个字符在字符数组中第一次出现的位置（序号从0开始计算），否则，返回-1。要搜索的字符数组和字符都以参数形式传递传递给该方法，如果传入的数组为null，应抛出IllegalArgumentException异常。在类的main方法中以各种可能出现的情况测试验证该方法编写得是否正确，例如，字符不存在，字符存在，传入的数组为null等。
java试题2：
编写一个程序，这个程序把一个整数数组中的每个元素用逗号连接成一个字符串，例如，根据内容为[1][2][3]的数组形成内容为"1,2,3"的字符串。
java试题3：
编写一个程序，它先将键盘上输入的一个字符串转换成十进制整数，然后打印出这个十进制整数对应的二进制形式。
十进制数转二进制数的方式是用这个数除以2，余数就是二进制数的最低位，接着再用得到的商作为被除数去除以2，这次得到的余数就是次低位，如此循环，直到被除数为0为止。其实，只要明白了打印出一个十进制数的每一位的方式（不断除以10，得到的余数就分别是个位，十位，百位），就很容易理解十进制数转二进制数的这种方式。这个程序要考虑输入的字符串不能转换成一个十进制整数的情况，并对转换失败的原因要区分出是数字太大，还是其中包含有非数字字符的情况。
java试题4：
请用移位的方式打印出一个十进制整数的十六进制形式。提示：按每4个二进制位对整数进行移位和去高位处理，得到的结果就是十六进制数的一位，然后按下面三种方式之一（作为作业，要求每种方式都用到）计算出一个十六进制数值对应的十六进制形式：
1)0-9之间的数值直接加上字符'0'，9以上的数值减去10以后再加上字符'A'
2)定义一个数组，其中包含0-F这些字符，然后用要计算的数值作为数组的索引号，即可获得其对应的十六进制数据。
3)Character.forDigit静态方法可以将一个十六进制的数字转变成其对应的字符表示形式，例如，根据数值15返回字符'F'。
java试题5：
请结合我们的《javascript网页开发》一书中介绍的正则表达式与String.split方法，从"http://www.it315.org/get.jsp?user=zxx&pass=123"这样的URL地址中提取出每个参数的名称和值。这里要注意在正则表达式中要对?进行转义处理.
java试题6：
编写一个程序，用于实现文件的备份，程序运行时的命令语法为：
java MyCopy <sourcefile> <destfile>
java试题7：
请编写一个字符输入流的包装类，通过这个包装类对底层字符输入流进行包装，让程序通过这个包装类读取某个文本文件（例如，一个java源文件）时，能够在读取的每行前面都加上有行号和冒号。
java试题8：
在javascript视频的第七讲的第一个片断，也就是网站上提供的免费片断《正则表达式的应用》中，讲到了将一个保存有ip地址与地区对照关系的文本文件导入到数据库时，应该将其中的某些空格替换成逗号（,），即对于如下格式的文本文件内容： 起始IP 结束IP 地区--------------------------------------------------------------- 61.54.231.245 61.54.231.245 河南省安阳市 新世纪网吧 61.54.231.246 61.54.231.246 河南省安阳市 未知地区 61.54.231.9 61.54.231.247 河南省安阳市 红日网吧 61.54.231.248 61.54.231.248 河南省安阳市 安阳师范学院 61.54.231.249 61.54.231.249 河南省安阳市 黑蜘蛛网吧(师范学院附近)应转换成下面的这种格式： 61.54.231.245,61.54.231.245,河南省安阳市 新世纪网吧 61.54.231.246,61.54.231.246,河南省安阳市 未知地区 61.54.231.247,61.54.231.247,河南省安阳市 红日网吧 61.54.231.248,61.54.231.248,河南省安阳市 安阳师范学院 61.54.231.249,61.54.231.249,河南省安阳市 黑蜘蛛网吧(师范学院附近)在视频教程中，讲解了使用UltraEdit的正则表达式替换功能来完成上面的转换。从jdk1.4开始，java语言中提供用于处理正则表达式的相关API类和方法，在jdk帮助文档中，查看String类的replaceAll方法，可以看到该方法就支持类似UltraEdit的正则表达式替换功能。任务：阅读String.replaceAll方法的帮助，以及它提供的相关超链接，了解该方法的用法后，编写一个java程序来自动实现上面的正则表达式替换，将a.txt（下载）替换后的结果保存到b.txt文件中。另外，我们在实现IT315网站的ip地区查询系统时，使用的是类似如下的sql语法：select 地区 from ip表 where 用户ip>起始IP and 用户ip<结束ip通过这条sql语句就可以查询出用户ip所对应的地区结果。由于用户ip与起始ip和结束ip的比较属于字符串比较，如果用户ip为9.1.1.1，那么它与61.54.231.245比较的结果就是前者大于后者，因为用户ip的第一个字符“9”大于61.54.231.245中的第一个字符“6”。现在请你想出一种解决办法，让上面的sql语句能够返回正确结果。提示:将9.1.1.1变化成009.001.001.001后与061.054.231.245进行比较就可以了。请按这种思路在你的程序中增加进行这种改变的正则表达式替换。注意，起始IP和结束IP的四个字段都有可能是1位、2位或3位数字，例如，61.5.23.1。在源程序中，要对程序代码的功能进行注释说明，提交你编写的程序给我们时,请附带该程序的使用说明。
编写一个程序，这个程序把一个整数数组中的每个元素用逗号连接成一个字符串，例如，根据内容为[1][2] [3]的数组形成内容为"1,2,3"的字符串。
class ConnectDemo
{
public static void main(String[] args)
{
int[] array = new int[]{1,2,3,4,5,6,7,8,9};
StringBuffer sb = new StringBuffer();
for(int i=0;i<array.length;i++)
{
sb.append(array[i]);
sb.append(",");
}
sb.deleteCharAt(sb.length()-1);
System.out.println(sb);
}
}
2、 请在一个类中编写一个方法，这个方法搜索一个字符数组中是否存在某个字符，如果存在，则返回这个字符在字符数组中第一次出现的位置（序号从0开始计算），否则，返回-1。要搜索的字符数组和字符都以参数形式传递传递给该方法，如果传入的数组为null，应抛出IllegalArgumentException异常。在类的main方法中以各种可能出现的情况测试验证该方法编写得是否正确，例如，字符不存在，字符存在，传入的数组为null等。
class SearchDemo
{
public static void main(String[] args)
{
char[] array = new char[]{'a','b','c','d','e','f','7','$'};
char[] array_null = null;
Search s1 = new Search();
s1.searchChar(array,'d');
Search s2 = new Search();
s2.searchChar(array,'8');
Search s3 = new Search();
s3.searchChar(array_null,'8');
}
}
class Search
{
public void searchChar(char[] array,char ch)
{
if(array == null)
throw new IllegalArgumentException("传入数组参数为空！");
else
{
int i=0;
while(i<array.length)
{
if(ch != array[i])
i++;
else
{
System.out.println(i);
break;
}
}
if(i == array.length)
System.out.println("-1");
}
}
}
3、编写一个程序，它先将键盘上输入的一个字符串转换成十进制整数，然后打印出这个十进制整数对应的二进制形式。这个程序要考虑输入的字符串不能转换成一个十进制整数的情况，并对转换失败的原因要区分出是数字太大，还是其中包含有非数字字符的情况。
import java.io.*;
class StringToBinaryDemo
{
public static void main(String[] args)
{
BufferedReader br = new BufferedReader( new InputStreamReader(System.in));
int num = 0;
try
{
String s = br.readLine();
num = Integer.parseInt(s);
}
catch(NumberFormatException e)
{
System.out.println("传入字符串错误！");
}
catch(IOException e)
{
e.getMessage();
}
int array[] = new int[20];
int i = 0;
while(num!=0)
{
try
{
array[i]=num%2;
num/=2;
i++;
}
catch (ArrayIndexOutOfBoundsException e)
{
System.out.println("传入字符过大！");
System.exit(-1);
}
}
for(int j=i-1;j>=0;j--)
System.out.print(array[j]+" ");
}
}
4、请用移位的方式打印出一个十进制整数的十六进制形式。提示：按每4个二进制位对整数进行移位和去高位处理，得到的结果就是十六进制数的一位，然后按下面三种方式之一（作为作业，要求每种方式都用到）计算出一个十六进制数值对应的十六进制形式：
（1）0-9之间的数值直接加上字符'0'，9以上的数值减去10以后再加上字符'A'
（2）定义一个数组，其中包含0-F这些字符，然后用要计算的数值作为数组的索引号，即可获得其对应的十六进制数据。
（3）Character.forDigit静态方法可以将一个十六进制的数字转变成其对应的字符表示形式，例如，根据数值15返回字符'F'。
class ToHex
{
public static void main(String[] args)
{
int num = 266;
int temp = 0;
int[] array = new int[8];
System.out.println(num);
for(int i = 0;i<8;i++)
{
temp = num & 15;
num = num>>4;
array[i] = temp;
}
System.out.println("第一种方法:"+first(array));
System.out.println("第二种方法:"+second(array));
System.out.println("第三种方法:"+third(array));
}
public static String first(int[] array)
{
String str = "";
char ch = 0;
char a = 0;
for(int i = 0;i<8;i++)
{
if(array[i]<=9)
{
a= (char) ('0'+array[i]);
str = a + str;
}
else
{
ch= (char) ((array[i]-10)+'a');
str = ch + str;
}
}
return str;
}
public static String second(int[] array)
{
String str = "";
char[] ch = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
for(int i = 0;i<8;i++)
{
str = ch[array[i]]+ str;
}
return str;
}
public static String third(int[] array)
{
String str = "";
for(int i = 0;i<8;i++)
{
str = Character.forDigit(array[i], 16) + str;
}
return str;
}
}
5、 编写一个程序，用于实现文件的备份，程序运行时的命令语法为：java MyCopy (sourcefile) (destfile)
import java.io.*;
import java.util.*;
class CopyDemo
{
public static void main (String [] args)
{
try
{
FileInputStream in = new FileInputStream(args[0]);
FileOutputStream out = new FileOutputStream(args[1]);
byte b[] = new byte[1024];
int line = 0;
while((line=in.read())!=-1)
{
out.write((byte)line);
}
in.close();
out.close();
}
catch (IOException e)
{
e.getMessage();
}
}
}
6、 在javascript视频的第七讲的第一个片断，讲到了将一个保存有ip地址与地区对照关系的文本文件导入到数据库时，应该将其中的某些空格替换成逗号（，），即对于如下格式的文本文件内容：
起始IP 结束IP 地区
61.54.231.245 61.54.231.245 河南省安阳市 新世纪网吧
61.54.231.246 61.54.231.246 河南省安阳市 未知地区
61.54.231.9 61.54.231.247 河南省安阳市 红日网吧
61.54.231.248 61.54.231.248 河南省安阳市 安阳师范
61.54.231.249 61.54.231.249 河南省安阳市 黑蜘蛛网吧
应转换成下面的这种格式：
61.54.231.245，61.54.231.245 ，河南省安阳市 新世纪网吧
61.54.231.246，61.54.231.246，河南省安阳市 未知地区
61.54.231.9，61.54.231.247 ，河南省安阳市 红日网吧
61.54.231.248，61.54.231.248，河南省安阳市 安阳师范学院
61.54.231.249，61.54.231.249，河南省安阳市 黑蜘蛛网吧(师范学院附近)
import java.io.*;
class IPTransform
{
public static void main(String[] args) throws IOException
{
BufferedReader br = new BufferedReader(new FileReader("D:\\java\\a\\a.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\java\\a\\b.txt"));
String s = null;
while((s=br.readLine())!=null)
{
String str = s.replaceAll("(?<=\\d)\\s+",",");
String[] array = str.split(",");
for(int i = 0;i<array.length-1;i++)
{
String[] sub_array = array[i].split("\\.");
String num ="";
for(int j = 0;j<sub_array.length;j++)
{
String sub_str = "";
if(sub_array[j].length() == 1)
{
sub_str = "00" + sub_array[j];
}
else if (sub_array[j].length() == 2)
{
sub_str = "0" + sub_array[j];
}
else
{
sub_str = sub_array[j];
}
if( 3 == j )
{
num = num + sub_str + ',';
}
else
{
num = num + sub_str + '.';
}
}
System.out.print(num);
bw.write(num);
if( i%2 ==1)
{
System.out.println(array[2]);
bw.write(array[2]+"\r\n");
}
}
}
bw.flush();
br.close();
bw.close();
}
}
7、 请编写一个字符输入流的包装类，通过这个包装类对底层字符输入流进行包装，让程序通过这个包装类读取某个文本文件（例如，一个java源文件）时，能够在读取的每行前面都加上有行号和冒号。
import java.io.*;
class BufferedReaderDemo
{
public static void main (String args[])
{
try
{
BufferedReader br = new BufferedReader(
new FileReader("e:\\1.txt"));
String str = "";
int num=1;
while((str=br.readLine())!=null)
{
String s = num+":"+str;
num++;
System.out.println(s);
}
br.close();
}
catch (IOException e)
{
e.getMessage();
}
}
}
8、 请结合我们的《javascript网页开发》一书中介绍的正则表达式与String.split方法，从"http://www.it315.org/get.jsp?user=zxx&pass=123"这样的URL地址中提取出每个参数的名称和值。这里要注意在正则表达式中要对?进行转义处理
import java.util.*;
class SplitDemo
{
public static void main(String[] args)
{
String s = "http://www.it315.org/get.jsp?user=zxx&pass=123";
String array[] = s.split("\\?");
String s1 =array[1];
String array1[] = s1.split("\\&");
Map<String,String> hashmap = new HashMap<String,String>();
for(int i=0;i<array1.length;i++)
{
String s2 = array1[i];
String array2[] = s2.split("=");
hashmap.put(array2[0],array2[1]);
}
System.out.println(hashmap);
}
}
9、请按下面内容编写一个页面，点页面里的“全选”时，能选中或清除上面的所有水果。
选择你喜欢的水果：
□苹果 □桔子 □香蕉 □葡萄 □桃子 □全选
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>无标题文档</title>
<script language="javascript">
function selectAll()
{
for(var i=0;i<document.form1.nameid.length;i++)
{
var temp=document.form1.nameid[i];
temp.checked=true;
}
}
function deleteAll()
{
for(var i=0;i<document.form1.nameid.length;i++)
{
var temp=document.form1.nameid[i];
temp.checked=false;
}
}
</script>
</head>
<body>
<form name="form1" method="post" action="">
<input type="checkbox" name="nameid" />苹果</br>
<input type="checkbox" name="nameid" />桔子</br>
<input type="checkbox" name="nameid" />香蕉</br>
<input type="checkbox" name="nameid" />萄萄</br>
<input type="checkbox" name="nameid" />桃子</br>
<input type="button" name=selectButton value="全选" onClick="selectAll()" />
<input type="button" name=selectButton value="重置" onClick="deleteAll()" />
</form>
</body>
10、请登陆访问http://www.it315.org/bbs/页面，这个页面左侧导航栏部分可以收缩、显示，请参照此页面编写一个也能把导航栏收缩、显示的页面。
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312" />
<title>无标题文档</title>
<style>
dl {overflow:hidden; height:16px;}
.open { overflow:visible}
.close { overflow:hidden; height:16px;}
</style>
<script>
function oc(dt)
{
var dl = dt.parentNode;
var dlarr = document.getElementsByTagName("dl");
for(var x=0; x<dlarr.length; x++)
{
if(dlarr[x].id == dl.id)
{
if("open"==dl.className)
{
dl.className = "close";
}
else
{
dl.className = "open";
}
}
else
{
dlarr[x].className= "close";
}
}
}
</script>
</head>
<body>
<dl id="dl_1" >
<dt onclick="oc(this)">中国</dt>
<dd>北京</dd>
<dd>上海</dd>
</dl>
<dl id="dl_2" >
<dt onclick="oc(this)">美国</dt>
<dd>纽约</dd>
<dd>华盛顿</dd>
</dl>
</body>
</html>