看到了有人面试后的帖子，看到了这个面试题，那个帖子下面的答案我也看不懂
声明一个共享数组，起两个线程，两个线程分别隔一段时间(可以写一个随机数)，
    给数组中添加数据，每一个线程为数组添加3个数据即可。

由于我刚学到线程，试着做了一下（可能没理解清题意），我看着我做的感觉都不对，请大神们给看看我的代码符合题意吗？然后给一个正确的代码（简洁明了的那种，不要太难的方法哦！）

1. package lianxibao2;
   
2. 
   
3. import java.util.*;
   
4. 
   
5. public class Demo01 {
   
6.         public static void main(String[] args) {
   
7.                 int[] arr = new int[6];
   
8.                 new Thread(new add1(arr)).start();
   
9.                 new Thread(new add1(arr)).start();
   
10.                 System.out.println(Arrays.toString(arr));
    
11.         }
    
12. }
    
13. 
    
14. class add1 implements Runnable {
    
15.         private int[] arr;
    
16. 
    
17.         add1(int[] arr) {
    
18.                 this.arr = arr;
    
19.         }
    
20. 
    
21.         public void run() {
    
22.                 for (int i = 0; i < arr.length; i++) {
    
23.                         arr[i] = i;
    
24.                 }
    
25.         }
    
26. }

复制代码

运行结果是：[0, 1, 2, 3, 4, 5]

和我的一样。。。。。只不过方法不一样。。。你的约束呢？

Rain2692 发表于 2014-11-28 23:27
和我的一样。。。。。只不过方法不一样。。。你的约束呢？

和你的一样？你面试过了吧！我还没有面试呢，我是看到别人发的面试题帖子，刚好学到了拿来做做，我想知道正确的答案。

楼主是不是这样。。。。代码有问题，谨慎使用:lol

1. import java.util.Arrays;
   
2. import java.util.Random;
   
3. 
   
4. /*
   
5. * 声明一个共享数组，起两个线程，两个线程分别隔一段时间(可以写一个随机数)，
   
6.     给数组中添加数据，每一个线程为数组添加3个数据即可
   
7. */
   
8. <blockquote>class myArray

复制代码

马个了黑_邓 发表于 2014-11-29 09:54
楼主是不是这样。。。。代码有问题，谨慎使用

晕。。上面搞乱了  

1. import java.util.ArrayList;
   
2. import java.util.Arrays;
   
3. import java.util.Random;
   
4. 
   
5. /*
   
6. * 声明一个共享数组，起两个线程，两个线程分别隔一段时间(可以写一个随机数)，
   
7.     给数组中添加数据，每一个线程为数组添加3个数据即可
   
8. */
   
9. class myArray
   
10. {
    
11.         private ArrayList<Integer> al = new ArrayList<Integer>(); //首先建立一个集合(原因长度可变)
    
12.         int count = 0;
    
13.         public void add(int i)
    
14.         {
    
15.                 synchronized(myArray.class)
    
16.                 {
    
17.                         try
    
18.                         {
    
19.                                 Thread.sleep(2000);
    
20.                         }
    
21.                         catch (Exception e)
    
22.                         {
    
23.                         }
    
24. 
    
25.                         al.add(i);
    
26.                         System.out.println(Thread.currentThread().getName()+"添加了"+i);
    
27.                         count++;
    
28.                 }
    
29.                 Object[ ] obj = al.toArray();   //题目要求数组就装到数组里
    
30.                 System.out.println(Arrays.toString(obj));
    
31.         }
    
32.        
    
33. }
    
34. class addIn implements Runnable
    
35. {
    
36.         private myArray my = new myArray();
    
37.         public void run()
    
38.         {
    
39.                 for(int x =0;x<3;x++)
    
40.                 {
    
41.                         Random r = new Random();
    
42.                         int index = r.nextInt(200);
    
43.                         my.add(index);
    
44.                 }
    
45.         }
    
46. }
    
47. public class ThreadDemo {
    
48. 
    
49.         /**
    
50.          * @param args
    
51.          */
    
52.         public static void main(String[] args) {
    
53.                 // TODO Auto-generated method stub
    
54. 
    
55.                 addIn ad = new addIn();
    
56.                 new Thread(ad).start();
    
57.                 new Thread(ad).start();
    
58.         }
    
59. }
    

复制代码

，，重写发次

马个了黑_邓 发表于 2014-11-29 10:21
晕。。上面搞乱了   ，，重写发次

谢谢大神了，根据你的代码我弄清了题意。

我也来看看看，嘿嘿

学习了  来看看

马个了黑_邓 发表于 2014-11-29 10:21
晕。。上面搞乱了   ，，重写发次

这代码才全面嘛，楼主的代码感觉功能太简单了

马个了黑_邓 发表于 2014-11-29 10:21
晕。。上面搞乱了   ，，重写发次

总感觉题意是睡眠随机数长度的时间...不过这个应该无所谓
这么一想确实应该写个集合，不会多几句代码..就体现了自己集合学的也不错..受教了，这是可贵的面试经验...

学习学习

这道题的目的是为了检测随机和Sleep的长度吗？已经学习了多线程，但是没看到这个知识点。学习了~~

public class Test2
{
          public static void main(String[] args) throws Exception
      {
                T t=new T();
                Thread t1=new Thread(t,"线程1");
                Thread t2=new Thread(t,"线程2");
               
               
                for (int i = 0; i < 2; i++)
                {
                        if(i==0)
                        {
                                t1.start();
                                t1.join();
                        }else
                        {
                                t2.start();
                                t2.join();
                        }
                }
      
                for (int i = 0; i < T.arr.length; i++)
                {
                        System.out.println(T.arr[i]);
                }
      }
}
class T  implements Runnable
{
        public static  int []arr=new int[6];
        int count=0;
        public void run()
        {
               
                for (int i = 0; i < 3; i++)
                   {
                           try
                           {
                                Thread.sleep(1000);
                               
                       
                           } catch (Exception e)
                           {
                                e.printStackTrace();
                           }
                          arr[count]=(new Random().nextInt(100));
                          count++;
                         System.out.println( Thread.currentThread().getName());;
                   }
        }
       
       
       
}

哇哇， 看来我要多学习下了 ~ 这些都不会 TAT