从一道面试题想到的

贴贴我的实现，呵呵，虽然没有楼主的精辟，但是欢迎大家一块参考一下

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class TestArray {
private int index=0;
private Integer[][] array;
public TestArray(){

}
public void doGenerateArray(int  ind){
this.index=ind;
int content=1;
array=new Integer[index][index];
if(index>=1){
for(int i=0;i<index;i++){
array[0][i]=content++;
}
int rowIndex=1;
int colIndex=index-1;
for(int i=index-1;i>0;i--){
for(int cir=0;cir<i;rowIndex++,cir++){
array[rowIndex][colIndex]=content++;
}
rowIndex--;
colIndex--;
for(int cir=0;cir<i;colIndex--,cir++){
array[rowIndex][colIndex]=content++;
}
rowIndex--;
colIndex++;
i--;
for(int cir=0;cir<i;rowIndex--,cir++){
array[rowIndex][colIndex]=content++;
}
rowIndex++;
colIndex++;
for(int cir=0;cir<i;colIndex++,cir++){
array[rowIndex][colIndex]=content++;
}
rowIndex++;
colIndex--;
}
}
}
public void doPrintArray(){
StringBuffer s;
Integer outputStr;
if(index>=1){
for(int i=0;i<index;i++){
for(int j=0;j<index;j++){
outputStr=array[i][j];
s=new StringBuffer(5);
s.append(outputStr);
if(outputStr>99&&outputStr<=999){
s.append(" ");
}
if(outputStr>9&&outputStr<=99){
s.append("  ");
}else if(outputStr<=9){
s.append("   ");
}
System.out.print(s.toString());
}
System.out.println("");
}
}else{
System.out.println("这是一个空数组!");
}
}

public boolean isNumeric(String str)
{
Pattern pattern=Pattern.compile("[0-9]*");
Matcher isNum=pattern.matcher(str);
if(!isNum.matches()){
return false;
}
return true;
}

public static void main(String[] args){
TestArray testArray=new TestArray();
String str=null;
InputStreamReader reader=new InputStreamReader(System.in);
BufferedReader bufferReader=new BufferedReader(reader);
System.out.println("请输入矩阵长度，例如5：");
try{
str=bufferReader.readLine();
if(testArray.isNumeric(str)){
testArray.doGenerateArray(Integer.parseInt(str));
testArray.doPrintArray();
}
}catch(Exception e){
e.printStackTrace();
}
}
}

不想为了oo 而 oo

这个是我见过最OO的算法了
OO不是要多建类.
而是要有一个现实中可以对应的例子
以帮助理解.
这个算法就是对原题的描述.
削土豆可以用来形容这个算法
把已经削下去的部分就不放在数组中了.

学C语言的时候做过这个题，应该是谭浩强那本《C语言程序设计》里面的，代码比较简短

发个我的。思路就是，先初始化一个二维数组，然后通过行和列的index变化的往里添数据。

public class PrintSquare {
    private int sideLength = 1;
    private String[][] elementList;
    private static final String GO_RIGHT = "right";
    private static final String GO_DOWN = "down";
    private static final String GO_LEFT = "left";
    private static final String GO_UP = "up";

    PrintSquare() {
    }

    PrintSquare(int sideLength) {
        this.sideLength = sideLength;
        elementList = new String[sideLength][sideLength];
    }

    public void printSquareToConsole() {
        int num;
        int column = 0;
        int row = 0;
        String mark1 = GO_RIGHT;
        for (num = 0;num < sideLength * sideLength;num++) {
            elementList[row][column] = String.valueOf(num);
            if ((mark1) == GO_RIGHT) {
                column++;
                if (column == sideLength || elementList[row][column] != null) {
                    column--;
                    row++;
                    mark1 = GO_DOWN;
                }
            } else if ((mark1) == GO_DOWN) {
                row++;
                if (row == sideLength || elementList[row][column] != null) {
                    column--;
                    row--;
                    mark1 = GO_LEFT;
                }
            } else if ((mark1) == GO_LEFT) {
                column--;
                if (column == -1 || elementList[row][column] != null) {
                    column++;
                    row--;
                    mark1 = GO_UP;
                }
            } else if ((mark1) == GO_UP) {
                row--;
                if (row == -1 || elementList[row][column] != null) {
                    column++;
                    row++;
                    mark1 = GO_RIGHT;
                }
            }
        }

        for (int i = 0;i < this.sideLength;i++) {
            for (int j = 0;j < this.sideLength;j++) {
                System.out.print(elementList[i][j]);
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        PrintSquare ps = new PrintSquare(3);
        ps.printSquareToConsole();
    }
}

哎。。
不知道该说什么。
有人说有意义，有人说没意义。
如果是应聘，这样的代码可能在有效时间里无法实现。
但是对于学习JAVA的人来说，确实应该重视起来。
OO思想。
对于某些人的简单问题复杂化？？？真的不想说什么了！

人的思维=效率低+复杂

难道用Java做这个题目就是考你的OOP？ 不一定吧，写程序最重要是的逻辑思维能力，如果什么都像你这样用OOP那么，如果让你写一个1—1=0 是不是要用到OOP来个封装，继承，多态呢？

不过你也提供了对这人问题的另一种解法，也不错，不过这样很容易让面试的人认为你过于学术派。有点生搬硬套，过份OOP的样子

看到楼主对问题的分析，让我对JAVA的理解和认识，有了眼前一亮的感觉。感谢楼主，订阅了。。

简单问题复杂化确实是不好的习惯， 不过也因情况而异。
这种问题确实需要做些设计的， 也许客户需求变化了呢？不是螺旋矩阵而是贪吃蛇呢？
如果是一个网络游戏， 物体行走路线算法呢？Point, Direction这种封装还是有必要的。
当然这种问题在面试时回答要看对方是什么样的公司， 考察什么内容， 如果C程序员职位， 做底层开发的， 自然不用这么封装， 如果是Java程序员， 做游戏或者产品的， 不封装一下才是找抽呢。