java基础demo， 用任意符号在控制台打印菱形，主要是编程规范及面向对象思想。

java基础练习，通过入口函数随机一个N值，打印出一个相应的菱形

首先这个题目不难，思路也很清晰，画图即可。

其次实现到什么程度，如何提高代码可重用性，及可扩展性。下面这段代码实际相当于一个工具类了，用于画出菱形的形状，

菱形的形状可能菱形高度（随机数代替）是奇数或偶数，这里当高度为偶数时打印的菱形不算很严谨。由于比较懒不想手动在控制台输入一些数，于是采用随机数代替。

用Star类可以控制每一个输出的形状，虽然整体是一个菱形，但是可以自定义用任何符号(空格除外)拼图。

 

对了，方法多种，下列非最优解，欢迎探讨。

1、CreateStar 类，用于创建菱形

public class CreateStar {

    private static int xLength = 0 ; //行高度
    private static int yLength = 0 ; //列高度
    private static Map< Integer,List<Star> > map = new HashMap< Integer,List<Star> >(); // 存
    private int num = 0; //打印多少行
    private boolean odevity = false; //默认奇数

    private static class lazyHolder {
        private static final CreateStar INSTANCE = new CreateStar();
    }

    public static CreateStar me() {
        return getInstance();
    }

    public static CreateStar getInstance() {
        System.out.println(LogUtil.getLog());
        return lazyHolder.INSTANCE;
    }

    public CreateStar() {
        //
        System.out.println(LogUtil.getLog());
    }

    public CreateStar(int num) {
        System.out.println(LogUtil.getLog());
        this.num = num;
        this.odevity = num % 2 == 0 ? true : false;
        this.xLength = num % 2 != 0 ? num : (num-1);
        this.yLength = num;
    }

    public void setnum(int num) {
        System.out.println(LogUtil.getLog());
        this.num = num;
    }

    public Map<Integer,List<Star>> getStars() {
        System.out.println(LogUtil.getLog());
        if(yLength == 0 && num != 0) {
            new CreateStar(this.num);
        }
        int start = startIndex(xLength);  // 起始点
        int invert;  //反转偏移

        for ( int y =0; y < yLength; y ++ ) {
            List list = new ArrayList();
            int index = 0;  //当前游标
            if(this.odevity) invert = 2*y >= xLength  ? (xLength  - y) : 0; //奇偶性决定反转游标偏移量
            else invert = 2*y >= xLength  ? (xLength -1 - y) : 0;

            for( int x = 0; x < xLength; x++ ) {
                index ++;
                Star star = new Star();
                star.setId(UUID.randomUUID().toString().replaceAll("-"," "));
                if(2*y >= xLength) { //反转
                    if( index >= (start - invert) && index <= (start + invert) ) {
                        star.setCode(1);
                    }else {
                        star.setCode(0);
                    }
                }else if( index >= (start - y) && index <= (start + y) ) {
                    star.setCode(1);
                }else {
                    star.setCode(0);
                }
                list.add(star);
            }

            map.put(y,list);
        }
        return map;
    }

    /**
     * 起始点坐标
     * @param width
     * @return
     */
    private static int startIndex( int width ) {
        System.out.println(LogUtil.getLog());
        return width%2 ==0 ? width/2 : width/2+1;
    }

    public void printStarsMap (Map<Integer,List<Star>> map) {
        System.out.println(LogUtil.getLog());
        for (int h=0; h < (num == 0 ? map.size() : num); h++) {
            map.get(h).forEach( star -> System.out.print(star.getStar() ));
            System.out.println();
        }
    }

    public void printStarsMap (Map<Integer,List<Star>> map,String sign) {
        System.out.println(LogUtil.getLog());
        for (int h=0; h < (num == 0 ? map.size() : num); h++) {
            map.get(h).forEach( star -> System.out.print(star.getStar(sign) ));
            System.out.println();
        }
    }

    public void printStarsMap (String sign) {
        System.out.println(LogUtil.getLog());
        map = map.size()<=0 ? this.getStars() : map;
        for (int h=0; h < (num == 0 ? map.size() : num); h++) {
            map.get(h).forEach( star -> System.out.print(star.getStar(sign) ));
            System.out.println();
        }
    }
}

2、PrintStars 类，用于测试打印菱形

使用一些随机数，模拟用户想要的数据（不想自己手动输入）

public class PrintStars {

    private static int height = 0;
    public static void main(String[] args)throws Exception {
        System.out.println(LogUtil.getLog());
        height =  Integer.parseInt(  String.valueOf(new Date().getTime()).substring(11,12) ) ;
//        CreateStar createStar = new CreateStar();
//        createStar.setnum(height < 1 ? 1 : height);
//        new PrintStars().printStarsMap(createStar.getStars());
        System.out.println(height);
        new CreateStar(StringUtil.random(20)).printStarsMap("&*");
        CreateStar.me().printStarsMap( new CreateStar(14).getStars() );
//        CreateStar.newInstance().printStarsMap( new CreateStar(height < 1 ? 1 : height).getStars() );
    }

}

 

3、Star 类，打印格式，默认打印☆，可自定义

 

public class Star implements Serializable {

    private static final String STAR = "☆";

    private String id;
    // 0 空格  1 ☆
    private int code;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getStar () {
        return code == 0 ? "  " : STAR ;
    }

    public String getStar (String star) {
        if( code == 0) {
            StringBuilder sb = new StringBuilder("");
            for (int i = 0; i < star.length(); i++) {
                sb.append(" ");
            }
            return  sb.toString();
        }else {
            return star;
        }
    }
}

4、DateUtil，常用时间处理工具类

public class DateUtil {

    private static Random random = new Random();
    private static String pool = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM" ;

    /**
     * 根据系统时间随机获取一个编号
     * @param len
     * @return
     */
    public static Long createNumber(int len){
        StringBuilder sb = new StringBuilder(getNow("yyyyMMddHHmmss"));
        for(int i = 0 ; i++<len ;){
            sb.append(random(10));
        }
        return Long.parseLong(sb.toString());
    }

    /**
     * 根据系统时间随机获取一个编号
     * @param len
     * @return
     */
    public static String createCode(int len){
        StringBuilder sb = new StringBuilder(getNow("yyyyMMddHHmmss"));
        for(int i = 0 ; i++<len ;){
            sb.append( pool.charAt(random(pool.length()) ));
        }
        return sb.toString();
    }

    /**
     * 获取处理耗时
     * @param start
     * @param end
     * @return
     */
    public static String getTimeConsuming( long start,long end){
        long time=end-start;//计算插入耗时
        return "耗时:\t"+(time>10000?getTime(time, "mm分ss秒"):time+"毫秒");
    }

    /**
     * 获取当前系统时间
     * @param format 日期转化格式
     *               建议格式:yyyy-MM-dd HH:mm:ss
     * @return String 日期
     */
    public static String getNow(String format){
        return new SimpleDateFormat(format).format(new Date());
    }
    public static String getNow(){
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
    }
    /**
     * 毫秒值转为 format类型的时间字符
     * @param time
     * @param format
     * @return
     */
    public static String getTime(long time,String format){
        Calendar calendar=Calendar.getInstance();
        calendar.setTimeInMillis(time);
        return new SimpleDateFormat(format).format(calendar.getTime());
    }

    /**
     * 获取系统当前毫秒值
     * @return
     */
    public static long getTime(){
        return System.currentTimeMillis();
    }

    /**
     * 获取时间
     *
     * @param str 字符串日期格式 2017-06-26 13:21:12
     *                     统一解析格式 yyyy-MM-dd HH:mm:ss
     * @return date
     */
    public static Date getDate(String str){
        String format="yyyy-MM-dd HH:mm:ss";
        SimpleDateFormat sdf=new SimpleDateFormat(format);
        Date date=null;
        try {
            date=sdf.parse(str);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 获取随机数
     * @param ran
     * @return
     */
    public static int random(int ran){
        return random.nextInt(ran == 0 ? 1 : ran );
    }
}

 

 

5.StringUtil

public class StringUtil extends DateUtil {

    private static final String POOL = "qwertyuiopasdfghjklzxcvbnm";
    /**
     * 获取字符串子串t在母串中的下标
     * @param s    母串
     * @param t    子串
     * @return 存在则返回第一次查到的下标  查不到则返回-1
     */
    public static int getIndex(String s,String t){
        int length=t.length();
        char c=t.charAt(0);
        for(int i=0;i<s.length();){
            if(c==s.charAt(i)){
                for(int j=1;;j++){
                    char sc=s.charAt(++i);
                    char st=t.charAt(j);
                    if(sc==st){
                        if(j<length-1) continue;
                        else return i-j;
                    }else{
                        i-=j-1;
                        break;
                    }
                }
            }else{
                i++;
            }
        }
        return -1;
    }

    public static boolean isBlank(String string) {
        return string == null ? true : "".equals(string) ? true: false;
    }

    public static boolean isNotBlank(String string) {
        return !isBlank(string);
    }

    public static String createCode() {
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i<random(Integer.parseInt(String.valueOf(System.currentTimeMillis()).substring(12,13))); i++) {
            sb.append( random(2)%2 == 0 ? POOL.charAt(random(POOL.length())) : String.valueOf(POOL.charAt(random(POOL.length()))).toUpperCase() );
        }
        return sb.toString();
    }
}

LogUtil 用于控制台打印日志

public class LogUtil {

    public LogUtil() {
    }

//    private static final String LOG_LEVEL = StringUtil.isBlank(Globals.LOG_LEVEL) ? Globals.DEFAULT_LOG_LEVEL : Globals.LOG_LEVEL; //默认LOG级别
    private static DBUtil dao = DBUtil.me();
    private static final String LOG_DEFAULT = "LOG";
    private static final String LOG_WARNING = "WARN";
    private static final String LOG_ERROR = "ERROR";

    private static String logs = "";

    public static LogUtil me() {
        return lazyInit.INITIALIZATION;
    }
    private static class lazyInit {
        private static final LogUtil INITIALIZATION = new LogUtil();
    }
    public void log(Object log) {
//        System.out.println(log.getClass().getName());
        String string = "";
        switch (log.getClass().getName()){
            case "java.lang.String":
                logs = "["+LOG_DEFAULT+" ] "+getLog(2)+"\t"+String.valueOf(log == null ? "" : log);
                System.out.println(logs);
                break;
            case "java.util.Arrays$ArrayList":
                for(Object o : (List)log) {
                   log(o);
                }
                break;
            case "java.lang.StackTraceElement":
                logs = "\t"+String.valueOf(log == null ? "" : log);
                System.out.println(logs);
                break;
            default:
                logs = "["+LOG_DEFAULT+" ] "+getLog(2)+"\t"+String.valueOf(log == null ? "" : log);
                System.out.println(logs);
        }
    }

    public void warn(Object log) {
        logs = "["+LOG_WARNING+" ] "+getLog(2)+"\t"+String.valueOf(log == null ? "" : log);
        System.out.println(logs);
        save();
    }

    public void error(Exception log) {
        logs = "["+LOG_ERROR+" ] "+getLog(2)+"\t"+String.valueOf(log == null ? "" : log);
        System.out.println(logs);
        save();
        log(Arrays.asList(log.getStackTrace()));
    }



    private static String className(int i) {
        return Thread.currentThread().getStackTrace()[++i].getClassName();
    }

    private static String methodName(int i) {
        return Thread.currentThread().getStackTrace()[++i].getMethodName();
    }

    private static int lineNumber(int i) { return Thread.currentThread().getStackTrace()[++i].getLineNumber();}

    /**
     *
     * @return
     */
    public static String getLog() {
        return DateUtil.getNow()+"\t==>\t"+className(2)+":"+methodName(2);
    }

    public static String getLog(int i) {
        return DateUtil.getNow()+"\t==>\t"+className((i+1))+":("+methodName((i+1))+"."+lineNumber((i+1))+")";
    }

    private void save() {
        //Persistence
    }

}

老结果图，新的自己去运行一下吧