1. package com.isoftstone.interview.traffic;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. import java.util.Random;
   
6. 
   
7. public class MainClass {
   
8.         public static void main(String[] args) {
   
9.                 new Controller();
   
10.         }
    
11. }
    
12. 
    
13. class Controller {
    
14.         /*
    
15.          * 一个十字路口就是两条路相交，所以这里创建两条路 一条东西干道，一条南北干道 初始状态为东西干道的绿灯亮，南北干道的红灯亮
    
16.          */
    
17.         private Road roadEW = new Road(true, "东西干道");
    
18.         private Road roadSN = new Road(false, "南北干道");
    
19. 
    
20.         public Controller() {
    
21.                 System.out.println("东西干道 绿灯亮，南北干道红灯亮");// 打印初始状态
    
22.                 new Thread(new Runnable() {
    
23.                         @Override
    
24.                         public void run() {
    
25.                                 while (true) {
    
26.                                         try {
    
27.                                                 Thread.sleep(30000);
    
28.                                         } catch (InterruptedException e) {
    
29.                                                 e.printStackTrace();
    
30.                                         }
    
31.                                         roadEW.changeLight();
    
32.                                         roadSN.changeLight();
    
33.                                 }
    
34.                         }
    
35. 
    
36.                 }).start();// 每隔30秒换次信号灯
    
37.         }
    
38. }
    
39. 
    
40. class Road {
    
41.         /* 每条道上的车的去向只有3个，即向左转，直行，向右转 */
    
42.         private static final String[] goTo = { "left", "front", "right" };
    
43.         /*
    
44.          * 每条道上都有一个信号等，本来这里可以是静态的，但是为了体现面向对象的设计思想， 我就没有把它定义为静态的
    
45.          */
    
46.         private boolean light;
    
47.         /* 保存路的名字，这主要是为了方便测试，在打印时可以打印出是哪条路在通行 */
    
48.         private String name;
    
49. 
    
50.         /**
    
51.          *
    
52.          * @param light
    
53.          *            道路上路灯的初始状态
    
54.          * @param name
    
55.          *            道路的名字
    
56.          */
    
57.         public Road(boolean light, String name) {
    
58.                 this.light = light;
    
59.                 this.name = name;
    
60.                 /* 当道路一创建，道路上就开始行驶车辆了 */
    
61.                 this.removeThread(left, "左边");
    
62.                 this.removeThread(right, "右边");
    
63.                 this.addThread(left);
    
64.                 this.addThread(right);
    
65.         }
    
66. 
    
67.         public void changeLight() {
    
68.                 light = true == light ? false : true;// 路灯转换
    
69.                 if (light) {
    
70.                         System.out.println(this.name + "绿灯亮，");
    
71.                 } else {
    
72.                         System.out.println(this.name + "红灯亮，");
    
73.                 }
    
74.         }
    
75. 
    
76.         public void removeThread(final List<Car> list, final String listname) {
    
77.                 new Thread(new Runnable() {
    
78. 
    
79.                         @Override
    
80.                         public void run() {
    
81.                                 while (true) {
    
82.                                         try {
    
83.                                                 Thread.sleep(1000);
    
84.                                         } catch (InterruptedException e) {
    
85.                                                 e.printStackTrace();
    
86.                                         }
    
87.                                         if (0 != list.size()) {// 如果道上的车辆数不为0
    
88.                                                 if (Road.this.light
    
89.                                                                 | list.get(0).getGoTo().equals("right")) {
    
90.                                                         /* 道路上亮的是绿灯或者最前面的那辆车是向右转就旅行 */
    
91.                                                         System.out.println(Road.this.name + listname
    
92.                                                                         + "使过一辆向" + list.get(0).getGoTo()
    
93.                                                                         + "方向行驶的车");
    
94.                                                         list.remove(0);
    
95.                                                 }
    
96.                                         }
    
97.                                 }
    
98.                         }
    
99.                 }).start();
    
100.         }
     
101. 
     
102.         public void addThread(final List<Car> list) {
     
103.                 new Thread(new Runnable() {
     
104. 
     
105.                         @Override
     
106.                         public void run() {
     
107.                                 while (true) {
     
108.                                         try {
     
109.                                                 Thread.sleep(1000);
     
110.                                         } catch (InterruptedException e) {
     
111.                                                 e.printStackTrace();
     
112.                                         }
     
113.                                         /* 增加车辆 */
     
114.                                         list.add(new Car(goTo[new Random().nextInt(3)]));
     
115.                                 }
     
116.                         }
     
117.                 }).start();
     
118.         }
     
119. 
     
120.         /* 每条道路都是双向道，所以我们这里就用两个集合来存储这两个道上的车辆 */
     
121.         private List<Car> left = new ArrayList<Car>();
     
122.         private List<Car> right = new ArrayList<Car>();
     
123. }
     
124. 
     
125. class Car {
     
126.         private String goTo;// 储存车辆的去向，左转，直行或者右转
     
127. 
     
128.         public Car(String goTo) {
     
129.                 this.goTo = goTo;
     
130.         }
     
131. 
     
132.         /* 获取车辆的去向 */
     
133.         public String getGoTo() {
     
134.                 return goTo;
     
135.         }
     
136. }

复制代码

强悍啊！

刘圣伟 发表于 2012-10-8 10:27
不错欧,不过现实中的问题有一些没解决，
1.一般右转的车轮都在右边车道的最右边。，而你写的只判断第一辆， ...

嗯  又看了下你的第2点问题，呵呵……这点居然还想落了，3Q，帮我找出了BUG

刘圣伟 发表于 2012-10-8 10:27
不错欧,不过现实中的问题有一些没解决，
1.一般右转的车轮都在右边车道的最右边。，而你写的只判断第一辆， ...

这个模拟是这样的，公路只有2个车道，且方向相反，这样就不存在有2辆车并排同向而行，如果说是4个车道的话，那么你说的这些情况就应该考虑了

很厉害!

不错欧,不过现实中的问题有一些没解决，
1.一般右转的车轮都在右边车道的最右边。，而你写的只判断第一辆，
2.转弯和直行，在现实中一般都是先直行，在转弯，大城市，这个细节地方，必须不能一起执行。

但就程序方面，很好了，有自己的思路。很8错！