3．编写一个应用程序，用一个二维数组模拟4×4方阵，然后将整数1~8随机放入方阵中，要求1~8中的每个数在方阵中恰好出现两次。
提示：首先将1~8添加到链表中，使得链表的长度为16，如链表的前八个节点中的数据是1，2，3，4，5，6，7，8，后八个节点的数据也是1，2，3，4，5，6，7，8；然后随机删除链表中的节点，同时将该节点中的数据顺序地放入方阵中。

import java.util.*;
public class Example_3 {
    public static void main(String args[ ]) {
        int block[][] = null;
        LinkedList list=new LinkedList();  // 创建list
        for(int i=0;i<8;i++){
            list.add(i+1);
        }
        for(int i=1;i<=8;i++){
            list.addLast(i);
        }
        for(int i=0;i<16;i++){
            System.out.println("第"+(i+1)+"节点中的数据："+list.get(i));
        }
        for(int i=0;i<16;i++){
            int temp=(Integer) list.remove(i);
            for(int j=0;j<4;j++) {
                for(int z=0;z<4;z++) {
                    block[j][z]=(Integer) temp;
                }
            }
        }
        for(int i=0;i<4;i++) {
            for(int j=0;j<4;j++) {
                System.out.printf("%2d",block[i][j]);
            }
            System.out.printf("%n");
         }
        }
    }

怎么把节点中的数据顺序地放入方阵中？

int block[][] = new Int[4][4];

int k = 16;
         for(int i=0;i<16;i++){
            int tempIndex = Random.nextInt(k);
            int temp=(Integer) list.remove(tempIndex);
            block[i/4][i%4] = temp;
        }

没有打开eclipse,不知道有没有错，楼主自己调整下啊

这个算法提示真是不怎么样，思路比较差。
主要原因：
（1）利用随机数算法取得的随机数可能是重复的，那么你将1到8放入到链表中，其实还在在1到8之间取到随机数字，没有必要。
（2）既然随机数可能是重复的，那也就是说你将链表总的元素添加到矩阵中的时候，可能填满矩阵的时候链表中的元素可能还没有取完。
（3）如果要取判断后面取到的随机数字不能和前一个相等，那么就效率又不是很高了。
鉴于以上取舍，个人认为其实就从1到8中随机取得数字，添加到矩阵中就可以了，不必那么麻烦。

大概如下：
public class Example_3 {
    public static void main(String args[ ]) {
        Random ran = new Random();
        int block[][] = new int[4][];
        int temp = 0;
        for(int i=0;i<4;i++) {
            for(int j=0;j<4;j++) {
                temp = ran.nextInt(8);
                while(temp < 0)  //取到的值必须是个整数，就可以保证是在0到8之间
                {
                    temp = ran.nextInt(8);
                }
                block[i][j] = temp;
            }
        }
    }
}

楼上理解错了啊，要求1~8中的每个数在方阵中恰好出现两次。是恰好。。。。
也就是说16个格中要随机放16个数字，而这16个数字必须是1，2,....,8,1,2....,8而且是随机的

没看出来题目中有这个含义，你的算法中缺少关于正数的判断，如果真是这样，那就要判断获得的随机数不能与前面的重复了

java api中Random类
public int nextInt(int n)返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。

所以nextInt()不需要去判断是否正数。另外，你说去判断生成的值是否重复的算法也是不可行的。因为是随机的，所以有一个数字可能要随机200次以上才能出现，那么这个效率就挺低的了，在这个题目中显示不出来。但是，假如要随机生成1000个不重复的1到1000的随机序列，用判断生成数是否重复的方法，可能程序要运行好久。

自己先试一试吧，没有负数是假的吧

java.util.Collections有个方法叫做shuffle. over

public class Test {
   
    public static void main(String[] args) {
        Random random = new Random();
        for(int i = 0;i<100; i++){
            int temp = random.nextInt(16);
            System.out.print(temp);
            if(temp/10==0)
                System.out.print("  ");
            else
                System.out.print(" ");
            if((i+1)%10==0)
                System.out.println();
        }
    }

}

我运行过了，其中的一次结果如下图所示，你举个会出现负数的例子来看看，让大家一起学习学习，谢谢
 

你们说的我不是很懂啊，谁能在我的基础上改下。（另外题目看清楚哦）

import java.util.LinkedList;
import java.util.Random;

/*

 3．编写一个应用程序，用一个二维数组模拟4×4方阵，然后将整数1~8随机放入方阵中，要求1~8中的每个数在方阵中恰好出现两次。
提示：首先将1~8添加到链表中，使得链表的长度为16，如链表的前八个节点中的数据是1，2，3，4，5，6，7，8，
后八个节点的数据也是1，2，3，4，5，6，7，8；然后随机删除链表中的节点，同时将该节点中的数据顺序地放入方阵中。
*/

/*class Block{
    String number;
    public void setNumber(String number){
        this.number=number;
    }
    public String getNumber(){
        return number;
    }
}*/

public class Example_3{
    public static void main(String agrs[]){
        int block[][]=new int[4][4];
        /*Block block[ ][ ]=new Block[4][4];
        for(int i=0;i<4;i++) {
           for(int j=0;j<4;j++) {
               block[i][j]=new Block( );
           }
        }*/
        LinkedList list=new LinkedList();
        for(int i=0;i<16;i++){
            if(i<=7)
                list.add(i+1);
            else
                list.add(i-7);
        }
        System.out.println("输出链表：");
        for(int i=0;i<16;i++)
            System.out.println("第"+(i+1)+"个节点的值："+list.get(i));
       
        //然后随机删除链表中的节点，同时将该节点中的数据顺序地放入方阵中
        int k = 16;
        for (int i = 0; i < 16; i++) {
            int tempIndex = Random.nextInt(k);
            int temp = (Integer) list.remove(tempIndex);
            block[i / 4][i % 4] = temp;
        }

        /*for(int i=0;i<16;i++){
            Object temp = list.remove(i);
            for(int j=0;j<4;j++){
                for(int z=0;z<4;z++){
                    block[j][z]= (Integer) temp;
                }
            }
        }*/
        for(int i=0;i<4;i++) {
               for(int j=0;j<4;j++) {
                   System.out.printf("%2s",block[i][j]);
               }
               System.out.printf("%n");
            }
    
    }
}

主要改下这条代码

for(int i=0;i<16;i++){
            Object temp = list.remove(i);
            for(int j=0;j<4;j++){
                for(int z=0;z<4;z++){
                    block[j][z]= (Integer) temp;
                }
            }
        }

谢谢！