Kevin.Kang 发表于 2015-9-2 11:15

你的这个程序是指定目录下所有.txt文件拷贝到另一个目的中，并将扩展名改为.java吧

楼主好厉害

值得收藏，

额，貌似。。。。。。和谐了

哇哇 这个很屌

回复看题 学习一下

多谢分享，可以借鉴学习。

已收  谢谢分享

收了，以后好好练习

最好还是加上注释,好多看的费解

多谢分享！

Kevin.Kang 发表于 2015-9-2 13:04

这一题似乎不能用bos你用代码读中文试试

Kevin.Kang 发表于 2015-9-3 22:44

楼主好帅气，总结这么多，有考试里面的题吗

1. package threadTest;
   
2. 
   
3. /*
   
4. * 编写三各类Ticket、SealWindow、TicketSealCenter
   
5. * 分别代表票信息、售票窗口、售票中心。售票中心分配一定数量的票，由若干个售票窗口进行出售，
   
6. * 利用你所学的线程知识来模拟此售票过程。
   
7. */
   
8. public class Ticket {
   
9.         private String name;
   
10.         private int i;
    
11. 
    
12.         public Ticket(String name, int i) {
    
13.                 super();
    
14.                 this.name = name;
    
15.                 this.i = i;
    
16.         }
    
17. 
    
18.         public Ticket() {
    
19.                 super();
    
20.                 // TODO Auto-generated constructor stub
    
21.         }
    
22. 
    
23.         public String getName() {
    
24.                 return name;
    
25.         }
    
26. 
    
27.         public void setName(String name) {
    
28.                 this.name = name;
    
29.         }
    
30. 
    
31.         public int getI() {
    
32.                 return i;
    
33.         }
    
34. 
    
35.         public void setI(int i) {
    
36.                 this.i = i;
    
37.         }
    
38. 
    
39. }

复制代码

1. package threadTest;
   
2. 
   
3. public class TicketCenter {
   
4.         private int num;
   
5. 
   
6.         public TicketCenter() {
   
7.                 super();
   
8.                 // TODO Auto-generated constructor stub
   
9.         }
   
10. 
    
11.         public TicketCenter(int num) {
    
12.                 super();
    
13.                 this.num = num;
    
14.         }
    
15. 
    
16.         public int getNum() {
    
17.                 return num;
    
18.         }
    
19. 
    
20.         public void setNum(int num) {
    
21.                 this.num = num;
    
22.         }
    
23. 
    
24. }

复制代码

1. package threadTest;
   
2. 
   
3. public class TicketWindow implements Runnable {
   
4.         private TicketCenter tc;
   
5.         private Ticket t;
   
6.         private int tickets;
   
7. 
   
8.         public TicketWindow(Ticket t, TicketCenter tc) {
   
9.                 super();
   
10.                 this.tc = tc;
    
11.                 this.t = t;
    
12.                 tickets = tc.getNum();
    
13.         }
    
14. 
    
15.         @Override
    
16.         public void run() {
    
17.                 // TODO Auto-generated method stub
    
18.                 while (true) {
    
19.                         synchronized (this) {
    
20.                                 if (tickets > 0) {
    
21.                                         System.out.println(Thread.currentThread().getName() + "正在出售第" + (tickets--) + "张票");
    
22.                                 }
    
23.                         }
    
24.                 }
    
25.         }
    
26. 
    
27. }
    

复制代码

1. 
   
2. 
   
3. import java.util.Random;
   
4. 
   
5. /*
   
6. * 声明一个共享数组，起两个线程，
   
7. *两个线程分别隔一段时间(可以写一个随机数)，给数组中添加数据，
   
8. *每一个线程为数组添加3个数据即可
   
9. */
   
10. public class Test04 {
    
11.         public static void main(String[] args) {
    
12.                 int[] in = new int[6]; // 需要控制因素
    
13.                 ArrayAdd aa = new ArrayAdd(in); // 既然要共享资源,那么这里就只能创建一个线程执行地.
    
14.                 for (int x = 0; x < 2; x++) {
    
15.                         new Thread(aa).start(); // 创建多个线程.
    
16.                 }
    
17.         }
    
18. }
    
19. 
    
20. class ArrayAdd implements Runnable {
    
21.         private int[] in; // 共享的资源,在创建时候,只能拥有一份.
    
22.         private int num = 0;
    
23. 
    
24.         ArrayAdd(int[] in) {
    
25.                 this.in = in;
    
26.         }
    
27. 
    
28.         public void run() {
    
29.                 while (num < in.length) {
    
30. 
    
31.                         synchronized (in) {
    
32.                                 if (num < in.length) {
    
33.                                         try {
    
34.                                                 Thread.sleep(500); // 线程只是等待一会时间,并没有释放锁.
    
35.                                         } catch (InterruptedException e1) {
    
36.                                                 e1.printStackTrace();
    
37.                                         }
    
38.                                         Random rd = new Random();
    
39.                                         int i = rd.nextInt(20) + 1;
    
40.                                         System.out.println(Thread.currentThread().getName() + "添加了:" + i);
    
41.                                         in[num] = i;
    
42.                                         num++;
    
43.                                         try {
    
44.                                                 in.wait(1000); // 放弃cup,放弃锁.让其他线程拿锁.
    
45.                                         } catch (InterruptedException e) {
    
46.                                                 e.printStackTrace();
    
47.                                         }
    
48.                                 } else {
    
49.                                         break;
    
50.                                 }
    
51.                         }
    
52.                 }
    
53.         }
    
54. }

复制代码

1. import java.util.Scanner;
   
2. import java.util.TreeSet;
   
3. 
   
4. /*
   
5. * 编写程序，循环接收用户从键盘输入多个字符串，
   
6. * 直到输入“end”时循环结束，并将所有已输入的字符串按字典顺序倒序打印。
   
7. */
   
8. public class Test03 {
   
9.         public static void main(String[] args) {
   
10.                 Scanner s = new Scanner(System.in);
    
11.                 TreeSet<String> ts = new TreeSet<>();
    
12.                 System.out.println("请开始输入：");
    
13.                 while (true) {
    
14.                         String str = s.nextLine(); // 字符串每次需要重新获得,因此要定义在循环内.
    
15.                         if (str.equals("end")) {
    
16.                                 System.out.println("输入结束");
    
17.                                 break;
    
18.                         } else {
    
19.                                 ts.add(str);
    
20.                         }
    
21.                 }
    
22.                 for (String str : ts) {
    
23.                         System.out.println(str);
    
24.                 }
    
25.         }
    
26. }

复制代码

1. import java.io.BufferedReader;
   
2. import java.io.BufferedWriter;
   
3. import java.io.File;
   
4. import java.io.FileReader;
   
5. import java.io.FileWriter;
   
6. import java.io.IOException;
   
7. import java.util.HashMap;
   
8. import java.util.Map;
   
9. import java.util.Set;
   
10. 
    
11. /*
    
12. * 把当前文本中的所有文本拷贝,存入一个txt文件,统计每个字符出现的次数
    
13. * 并输出,例如   a : 21次   b: 12次.....
    
14. */
    
15. public class Test02 {
    
16.         public static void main(String[] args) throws IOException {
    
17.                 File fiReade = new File("c:\\a.txt");
    
18.                 File fiWrite = new File("c:\\b.txt");
    
19.                 IORW(fiReade, fiWrite);
    
20.         }
    
21. 
    
22.         // 1.这是一个将数据分离成字符串,并输出到指定文件的程序.(1)分离字符串,进行后续操作(2)写入文件,完成一个写入文件需求
    
23.         public static void IORW(File fiReade, File fiWrite) throws IOException {
    
24.                 BufferedReader br = new BufferedReader(new FileReader(fiReade));
    
25.                 BufferedWriter bw = new BufferedWriter(new FileWriter(fiWrite));
    
26.                 StringBuilder sb = new StringBuilder();
    
27. 
    
28.                 String s = null;
    
29.                 while ((s = br.readLine()) != null) {
    
30.                         sb.append(s); // 先装进字符串.等结束后一次性给调用者.
    
31.                         bw.write(s);
    
32.                 }
    
33.                 ergodic(sb.toString()); // 这是一个注意.应该所有数据完成之后才可以进行迭代遍历出次数.
    
34.                 br.close();
    
35.                 bw.close();
    
36. 
    
37.         }
    
38. 
    
39.         // 2.接受分离出来的字符串,然后对字符串进行遍历,并将结果存入map集合.
    
40.         public static void ergodic(String s) {
    
41.                 Map<Character, Integer> ma = new HashMap<Character, Integer>();
    
42.                 char[] ch = s.toCharArray();
    
43. 
    
44.                 for (int x = 0; x < ch.length; x++) {
    
45.                         int num = 1;
    
46.                         if (!ma.containsKey(ch[x])) {
    
47.                                 ma.put(ch[x], 1);
    
48.                         } else {
    
49.                                 num = ma.get(ch[x]); // 这是一个应该注意的,此时要记住之前的value值,再此基础上+1
    
50.                                 ma.put(ch[x], ++num);
    
51.                         }
    
52.                 }
    
53.                 ergodicMap(ma);
    
54.         }
    
55. 
    
56.         // 3.将map集合进行迭代,
    
57.         public static void ergodicMap(Map<Character, Integer> ma) {
    
58.                 Set<Character> se = ma.keySet();
    
59. 
    
60.                 for (char key : se) {
    
61.                         System.out.println(key + "  : " + ma.get(key) + " 次");
    
62.                 }
    
63.         }
    
64. }

复制代码

1. package classTest;
   
2. 
   
3. /*
   
4. * 定义一个交通灯枚举，包含红灯、绿灯、黄灯，
   
5. *  需要有获得下一个灯的方法，例如：红灯获取下一个灯是绿灯，绿灯获取下一个灯是黄灯。
   
6. */
   
7. public class Test01 {
   
8.         public static void main(String[] args) {
   
9.                 traffic s = traffic.RED.next(); //调用枚举元素以及方法.返回枚举元素.
   
10.                 System.out.println(s);
    
11.         }
    
12. }
    
13. enum traffic
    
14. {
    
15.         RED
    
16.         {
    
17.                 public traffic next()  //复写父类的抽象方法.返回还是枚举元素.
    
18.                 {
    
19.                         return GRE;
    
20.                 }
    
21.         },GRE
    
22.         {
    
23.                 public traffic next()
    
24.                 {
    
25.                         return YEL;
    
26.                 }
    
27.         },YEL
    
28.         {
    
29.                 public traffic next()
    
30.                 {
    
31.                         return RED;
    
32.                 }
    
33.         };
    
34.         public abstract traffic next(); //枚举的抽象方法,子类需要复写.
    
35. }

复制代码

1. /*
   
2. * 28人买可乐喝，3个可乐瓶盖可以换一瓶可乐，那么要买多少瓶可乐，
   
3. * 够28人喝？假如是50人，又需要买多少瓶可乐？
   
4. */
   
5. public class Test {
   
6.         public static void main(String[] args) {
   
7.                 int person = 13; // 自定义需求.
   
8.                 int cola = run(person); // 接受需要购买的次数.
   
9.                 System.out.println(cola);
   
10.         }
    
11. 
    
12.         public static int run(int person) {
    
13.                 int lid = 0; // 盖子数
    
14.                 int cola = 0; // 可以喝的可乐数
    
15.                 int gouMai = 0; // 需要购买的可乐数.
    
16.                 for (; cola < person; cola++) // 无论如何,可以喝的可乐都在增加.
    
17.                 {
    
18.                         if (lid == 3) // 当盖子够三个了,盖子数又定义为一个.
    
19.                         { // 可以喝的可乐在上面已经增加了.
    
20.                                 lid = 1;
    
21.                         } else {
    
22.                                 gouMai++;// 如果不够三个,那么就要去买了,买一瓶,盖子自然增加一个.
    
23.                                 lid++;
    
24.                         }
    
25.                 }
    
26.                 return gouMai; // 把购买的次数返回.
    
27.         }
    
28. }

复制代码

1. package ioTest;
   
2. 
   
3. import java.io.File;
   
4. import java.io.FileReader;
   
5. import java.io.IOException;
   
6. import java.io.Reader;
   
7. 
   
8. /*
   
9. * 自定义字符输入流的包装类，通过这个包装类对底层字符输入流进行包装，
   
10.    让程序通过这个包装类读取某个文本文件（例如，一个java源文件）时，
    
11.    能够在读取的每行前面都加上有行号和冒号。
    
12. 
    
13. */
    
14. public class BaoZhuang {
    
15.         public static void main(String[] args) throws IOException {
    
16.                 File fi = new File("c:\\stu.txt");
    
17.                 String s = LineFile(fi);
    
18. 
    
19.                 System.out.println(s);
    
20.         }
    
21. 
    
22.         public static String LineFile(File fi) throws IOException {
    
23.                 MyLineReader mr = new MyLineReader(new FileReader(fi));
    
24.                 String s = null;
    
25.                 StringBuilder sb = new StringBuilder(); // 为了让程序拥有自主控制输出,因此创建.
    
26.                 mr.setLen(0); // 设置开始行号.
    
27.                 while ((s = mr.MyreadLine()) != null) {
    
28.                         sb.append(mr.getLen() + ":" + s + "\r\n");
    
29.                 }
    
30.                 return sb.toString(); // 将数据返回,让客户拥有输出权利.
    
31.         }
    
32. }
    
33. 
    
34. class MyLineReader {
    
35.         private int len; // 自定义行数变量
    
36.         private Reader fi; // 读取数据流.
    
37. 
    
38.         public MyLineReader(Reader fi) {
    
39.                 this.fi = fi;
    
40.         }
    
41. 
    
42.         public String MyreadLine() throws IOException {
    
43.                 len++; // 读取一行之后,len自增.
    
44.                 StringBuilder sb = new StringBuilder(); // 将数据存储起来.
    
45.                 int i = 0;
    
46.                 while ((i = fi.read()) != -1) {
    
47.                         if (i == '\r')
    
48.                                 continue;
    
49.                         if (i == '\n') // 当独到行标记时候,将数据全部返回.
    
50.                                 return sb.toString();
    
51.                         sb.append((char) i); // 没有到达行标记就继续读取.
    
52.                 }
    
53.                 if (sb.length() != 0) // StringBuilder的长度不为0,就继续返回数据.
    
54.                         return sb.toString();
    
55.                 return null; // 否则返回空.因为调用方法时候,是依靠返回是不是null来判断,是不是应该结束.
    
56.         }
    
57. 
    
58.         public int getLen() { // get,set方法,用来获取行号和设置行号.
    
59.                 return len;
    
60.         }
    
61. 
    
62.         public void setLen(int len) {
    
63.                 this.len = len;
    
64.         }
    
65. }

复制代码