package com.itheima;
public class Test1 {
/**
1、
写一个ArrayList类的代理，实现和ArrayList中完全相同的功能，并可以计算每个方法运行的时间。
*
* @param args
*
*/
public
static void main(String[] args) {
@SuppressWarnings("unchecked")
List<String> arrayListProxy =
(List<String>) Proxy.newProxyInstance(
/*
定义代理类的加载器，用于创建类的对象 */
ArrayList.class.getClassLoader(),
/* 代理类要实现的接口列表
*/
ArrayList.class.getInterfaces(),
/*
指派方法调用的处理程序，匿名内部类 */
new
InvocationHandler() {
//
目标对象
private ArrayList<String>
taret = new ArrayList<String>();
@Override
public Object invoke(Object proxy,
Method method, Object[] args)
throws Throwable
{
// 开始时间
long startTime =
System.currentTimeMillis();
TimeUnit.MICROSECONDS.sleep(1);
//
实际调用的方法，并接受方法的返回值
Object obj = method.invoke(taret,
args);
//
结束时间
long endTime =
System.currentTimeMillis();
System.out.println("[" +
method.getName()+ "]需要的时间"
+ (endTime - startTime) + "毫秒");
//
返回实际调用的方法的返回值
return
obj;
}
});
arrayListProxy.add("abc");
arrayListProxy.add("abcdf");
arrayListProxy.add("abcdefg");
System.out.println("..........................");
for (String i : arrayListProxy) {
System.out.println("i=" + i);
}
}
}
package com.itheima;
public class
Test2 {
/**
2、
编写一个类，在main方法中定义一个Map对象（采用泛型），加入若干个对象，
然后遍历并打印出各元素的key和value。
*
* @param args
*/
public static void main(String[] args)
{
Map<String,Integer> map = new
HashMap<String,Integer>();
map.put("小赵", 12);
map.put("小钱",
21);
map.put("小孙", 25);
map.put("小李", 9);
//先获取map集合的所有键的Set集合，keyset();
Set<String> set = map.keySet();
//迭代
Iterator<String> it =
set.iterator();
while(it.hasNext()){
String key = it.next();
//有了键通过map集合的get方法获取其对应的值
Integer value =
map.get(key);
System.out.println("key="+key+"
"+"value="+value);
}
}
}
package com.itheima;
public
class Test3 {
/**
3、
有五个学生，每个学生有3门课（语文、数学、英语）的成绩，写一个程序接收从键盘输入学生的信息，输入格式为：name,30,30,30（姓名，三门课成绩），然后把输入的学生信息按总分从高到低的顺序写入到一个名称"stu.txt"文件中。要求：stu.txt文件的格式要比较直观，打开这个文件，就可以很清楚的看到学生的信息。
* @param args
*/
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
chinese,english,maths;
private int
sum;
Student(String name, int chinese, int english, int maths)
{
this.name = name;
this.chinese = chinese;
this.english = english;
this.maths
= maths;
sum = chinese + english + maths;
}
public String getName() {
return
name;
}
public int getSum() {
return
sum;
}
//覆盖hashCode方法
public int hashCode()
{
return name.hashCode()+sum * 78;
}
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+", "+"语文："+chinese+",
"+"英语："+english +", "+"数学："+maths+"]";
}
}
//定义学生工具类
class
StudentInfoTool {
// 不带比较器的比较
public static
Set<Student> getStudents() {
return getStudents(null);
}
// 带自定义比较器的比较
public static Set<Student> getStudents(Comparator<Student>
cmp){
//读取键盘
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);
try {
while ((line = bufr.readLine()) !=
null) {
// 输入over就结束
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]));
stus.add(stu);
}
} catch (NumberFormatException e1) {
System.out.println("输入格式错误，输入格式为：name,30,30,30");
} catch (IOException e1)
{
System.out.println("读取数据失败");
}
try {
bufr.close();
} catch (IOException e) {
System.out.println("关闭失败");
}
return stus;
}
public static void writeToFile(Set<Student> stus) throws
IOException{
BufferedWriter bufw = null;
bufw = new BufferedWriter(new
FileWriter("E:\\stuinfo.txt"));
for
(Student stu : stus) {
bufw.write(stu.toString() + "\t");
bufw.write(stu.getSum() + "");
bufw.newLine();
bufw.flush();
}
bufw.close();
}
}
package com.itheima;
public class
Test4 {
/**
4、
取出一个字符串中字母出现的次数。如：字符串："abcdekka27qoq" ，
输出格式为：a(2)b(1)k(2)...
*
* @param args
*/
public static void main(String[] args)
{
String str =
"abcdekka27qoq";
System.out.println(charCount(str));
}
public static String
charCount(String str){
//将字符串转成字符数组
char[] chs = str.toCharArray();
//定义集合（打印有顺序使用TreeMap集合）
TreeMap<Character,Integer> tm = 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‘))
continue;
//chs[x]作为键找集合
Integer value =
tm.get(chs[x]);
if(value!=null)
count=value;
count++;
tm.put(chs[x], count);
count=0;
}
//定义缓冲区
StringBuilder sb = new StringBuilder();
Set<Map.Entry<Character,Integer>> entrySet
= tm.entrySet();
//迭代
Iterator<Map.Entry<Character,Integer>> it =
entrySet.iterator();
while(it.hasNext()){
Map.Entry<Character,Integer> me = it.next();
Character ch =
me.getKey();
Integer
value = me.getValue();
sb.append(ch+"("+value+")");
}
return
sb.toString();
}
}
package com.itheima;
public class
Test5 {
/**
5、
将字符串中进行反转。abcde --> edcba
* @param args
*/
public static void main(String[] args)
{
String str = "abcde";
System.out.println(reverseString(str));
}
public static String reverseString(String
str){
//将字符串转成字符数组
char[] chs = str.toCharArray();
reverse(chs);
//将字符数组转成字符串
return new String(chs);
}
//反转数组
private
static void reverse(char[] chs) {
for(int
start=0,end=chs.length-1;start<end;start++,end--){
swap(chs,start,end);
}
}
//换位置
private static
void swap(char[] chs, int start, int end) {
char temp = chs[start];
chs[start] = chs[end];
chs[end] =
temp;
}
}
package com.itheima;
public class
Test6 {
/**
6、 已知一个类，定义如下：
package cn.itcast.heima;
public class DemoClass {
publicvoid run() {
System.out.println("welcome
to heima!"); } }
(1)写一个Properties格式的配置文件，配置类的完整名称。
(2)写一个程序，读取这个Properties配置文件，获得类的完整名称并加载这个类，用反射
的方式运行run方法。
*
* @param
args
*/
@SuppressWarnings({ "rawtypes", "unchecked"
})
public static void main(String[] args) throws Exception
{
// 用Properties类加载配置文件
Properties props = new Properties();
InputStream fis =
Test6.class.getClassLoader().getResourceAsStream(
"com/itheima/Test6.Properties");
props.load(fis);
fis.close();
//
取出类的完整名称
String className =
props.getProperty("className");
System.out.println(className);
DemoClass dc = new DemoClass();
//加载类
Class clazz = Class.forName(className);
Method method = clazz.getMethod("run");
method.invoke(dc);
}
}
当前目录建一个Test6.Properties 内存入：className=cn.itcast.heima.DemoClass
package cn.itcast.heima;
public class DemoClass {
public void run() {
System.out.println("welcome to heima!");
}
}
package com.itheima;
public class Test7
{
/**
7、
有一个类为ClassA,有一个类为ClassB，在ClassB中有一个方法b，此方法抛出异常，在ClassA类中有一个方法a，请在这个方法中调用b,然后抛出异常。
在客户端有一个类为TestC,有一个方法为c,请在这个方法中捕捉异常的信息。
完成这个例子，请说出java中针对异常的处理机制。
*
* @param args
*/
/*
1，处理方式有两种：try 或者 throws。
try {
需要被检测的代码；}
catch ( 异常类 变量 ) { 处理异常的代码；(处理方式) }
finally
{ 一定会执行的语句； }
2，调用到抛出异常的功能时，抛出几个，就处理几个。一个try对应多个catch。
3，多个catch，父类的catch放到最下面。
4，catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。也不要不写。
当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。
*/
public static void main(String[] args) {
TestC.c();
}
}
class
ClassA {
public static void a() throws Exception
{
ClassB.b();
}
}
class ClassB {
public static void b()
throws Exception {
throw new
Exception("方法b异常");
}
}
class TestC
{
public static void c() {
try {
ClassA.a();
}
catch (Exception e) {
System.out.println(e.getMessage()+"..."+e.toString());
}
}
package com.itheima;
public class Test8
{
/**
8、
存在一个JavaBean，它包含以下几种可能的属性：
1:boolean/Boolean
2:int/Integer
3:String
4:double/Double
属性名未知，现在要给这些属性设置默认值，以下是要求的默认值：
String类型的默认值为字符串"itheima.com"
int/Integer类型的默认值为100
boolean/Boolean类型的默认值为true
double/Double的默认值为0.01D.
只需要设置带有getXxx/isXxx/setXxx方法的属性，非JavaBean属性不设置，请用代码实现
*
* @param args
*/
public static void main(String[] args)
{
JavaBean jb = new
JavaBean();
jb.setString("itheima.com");
jb.setInteger(100);
jb.setBooleam(true);
jb.setDoublo(0.01D);
System.out.println("String类型的值="+jb.getString()+"\t\n"
+"int/Integer类型的值="+jb.getInteger()+"\t\n"
+"boolean/Boolean类型的值="+jb.isBooleam()+"\t\n"
+"double/Double的值="+jb.getDoublo());
}
}
package
com.itheima;
public class JavaBean {
private
String string ;
private Integer integer;
private Boolean booleam ;
private Double doublo
;
public String getString() {
return string;
}
public void setString(String string) {
this.string = string;
}
public
Integer getInteger() {
return
integer;
}
public void
setInteger(Integer integer) {
this.integer = integer;
}
public Boolean isBooleam() {
return booleam;
}
public void
setBooleam(Boolean booleam) {
this.booleam = booleam;
}
public Double getDoublo() {
return doublo;
}
public void
setDoublo(Double doublo) {
this.doublo
= doublo;
}
}
package com.itheima;
public class Test9
{
/**
9、 使用TCP协议写一个可以上传文件的服务器和客户端。
*
*
@param args
*/
public static void main(String[] args)
{
}
}
class
Client{
public static void main(String[] args) throws
Exception{
Socket s = new
Socket("192.168.1.102",10001);
BufferedReader bufr
=
new
BufferedReader(new
FileReader("F:\\1.mp3"));
//定义目的，将数据写入到socket输出流。发给服务端。
PrintWriter out = new
PrintWriter(s.getOutputStream(),true);
String line = null;
while((line=bufr.readLine())!=null){
out.println(line);
}
s.shutdownOutput();//关闭客户端的输出流。相当于给流中加入一个结束标记-1.
//定义一个socket读取流，读取服务端返回的信息。
BufferedReader bufIn = new
BufferedReader(new
InputStreamReader(s.getInputStream()));
String str = bufIn.readLine();
System.out.println(str);
bufr.close();
s.close();
}
}
class
Server{
public static void main(String[] args) throws
Exception{
ServerSocket ss = new
ServerSocket(10001);
Socket s =
ss.accept();
String ip =
s.getInetAddress().getHostAddress();
System.out.println(ip+"....connected");
//读取socket读取流中的数据。
BufferedReader bufIn = new BufferedReader(new
InputStreamReader(s.getInputStream()));
//目的。socket输出流。将大写数据写入到socket输出流，并发送给客户端。
PrintWriter out = new PrintWriter(new
FileWriter("F:\\server.mp3"),true);
String line = null;
while((line=bufIn.readLine())!=null){
out.println(line);
}
PrintWriter pw = new
PrintWriter(s.getOutputStream(),true);
pw.println("上传成功");
out.close();
s.close();
ss.close();
}
}
package com.itheima;
public class Test10
{
/**
10、
金额转换，阿拉伯数字转换成中国传统形式。
*
* 例如：101000001010 转换为 壹仟零壹拾亿零壹仟零壹拾圆整
*
*
@param args
*/
public static void main(String[] args)
{
// 测试
long L = 101000001010L;
System.out.println(convert(L));
}
public static String convert(long number)
{
// 定义字符数组存储中国数字写法格式
final char[] chinese = new char[] { ‘零‘, ‘壹‘, ‘贰‘, ‘叁‘,
‘肆‘, ‘伍‘,
‘陆‘, ‘柒‘, ‘捌‘, ‘玖‘ };
//
定义字符数组存储中国数字的单位
final char[]
units = new char[] { ‘圆‘, ‘拾‘, ‘佰‘, ‘仟‘, ‘万‘, ‘拾‘, ‘佰‘,
‘仟‘, ‘亿‘, ‘拾‘,
‘佰‘, ‘仟‘ };
//
定义一个字符串缓冲区对字符进行存储
StringBuilder
sb = new StringBuilder();
int index =
0;
long lastNumber = 0;
while (number != 0) {
lastNumber = number %
10;
sb.insert(0,
units[index++]);
sb.insert(0, chinese[(int) lastNumber]);
number = number /
10;
}
//
去零操作，通过正则表达式
return
sb.toString().replaceAll("零[拾佰仟]", "零").replaceAll("零+亿", "亿")
.replaceAll("零{4}万", "零").replaceAll("零+万", "万")
.replaceAll("零+圆", "圆").replaceAll("零+", "零")
+
"整";
}
}
原文：http://www.cnblogs.com/In-order-to-tomorrow/p/3650576.html