【无私分享】修订版干货！！！一个炫酷的自定义日历控件，摆脱日历时间选择烦恼，纯福利~

可能不少的小伙伴都有看楼主昨天发的自定义日历控件，虽然实现功能不多，但也还算将就吧。

没有看的小伙伴如果有兴趣的话可以去看看：http://www.cnblogs.com/liushilin/p/5759750.html

但是看了的小伙伴就很心急了，说楼主上传到gitHub的东西有问题，楼主下载来看了看，基本都没问题吧，没弄好的小伙伴自己再去我的github首页提取哦~因为我还上传了一个新的。

有的小伙伴又不满意了，楼主，你发的东西代码量那么大也搞得很麻烦，小生纵有远大理想，可思前虑后，还是不得正果，倘若楼主能指点一二便好了。

有的小伙伴说，楼主，你的东西就不能封装一下吗？封装一下，方便你我他~

有的小伙伴说，楼主，你的东西是挺不错，但是界面也略丑了吧~这里gank到22楼住的小伙伴说，中间分隔太低，信息太密集，建议添加行间距和留白，希望能做的漂亮些~

......

小主已成功gank到各位的中肯建议，但是不要慌，大家一个一个来。

大家的建议小主都非常地认可，所以楼主觉得把整个东西该封装的算法封装起来，也UI也弄得漂亮一些。

照例先给个运行图吧~

下面给大家讲解一下我们这个自定义日历的简单思路，肯定还是使用GridView的。

由于昨天是纯定义画的UI，所以大家看起来可能有所困难，所以今天楼主简化了UI，把UI放在了xml文件中，供大家食用。

楼主不是废话多的人，具体看代码，代码中我也做了更多的注释。

1）先准备好我们的算法，我们现在把它完全分离。

闰年月的算法应该大家都懂吧。SpecialCalendar.java 

三个方法，判断闰年，这个可能只要学程序前面肯定就学了的。

对于判断月份，貌似也不用多说，就一个switch语句，闰年的时候2月是29天，平年是28天。

还有一个判断某一天是星期几的，这个在Calendar中已经很明显了，但是要注意的是Month在calendar中是0-11

package com.example.nanchen.calendarviewdemo.view;

import java.util.Calendar;

/**
 * 闰年月算法
 *
 * @author nanchen
 * @date  2016-08-11 08:54:44
 *
 */
public class SpecialCalendar {

    private int daysOfMonth = 0; // 某月的天数
    private int dayOfWeek = 0; // 具体某一天是星期几

    // 判断是否为闰年
    public boolean isLeapYear(int year) {
        if (year % 100 == 0 && year % 400 == 0) {
            return true;
        } else if (year % 100 != 0 && year % 4 == 0) {
            return true;
        }
        return false;
    }

    // 得到某月有多少天数
    public int getDaysOfMonth(boolean isLeapYear, int month) {
        switch (month) {
        case 1:
        case 3:
        case 5:
        case 7:
        case 8:
        case 10:
        case 12:
            daysOfMonth = 31;
            break;
        case 4:
        case 6:
        case 9:
        case 11:
            daysOfMonth = 30;
            break;
        case 2:
            if (isLeapYear) {
                daysOfMonth = 29;
            } else {
                daysOfMonth = 28;
            }

        }
        return daysOfMonth;
    }

    /**
     * 指定某年中的某月的第一天是星期几
     */
    public int getWeekdayOfMonth(int year, int month) {
        Calendar cal = Calendar.getInstance();
        cal.set(year, month - 1, 1);
        dayOfWeek = cal.get(Calendar.DAY_OF_WEEK) - 1;
        return dayOfWeek;
    }

}

 

2)然后带来的是算农历的算法。LunarCalendar.java

就算法本身而言，楼主参考了网上留下的算法。基本就是定义好这些要用的数组，然后考虑完所有的情况。

这里需要心细严谨一些，毕竟你或许错一个参数，一个值就会让你一直搞不出原因，所以写出算法不妨先在Eclipse中看看控制台运行的结果是否正确吧。

高配置随便带Android studio的童鞋当我没说。

这里需要注意的是，我们要做农历，肯定必须想到年份，闰月，闰月是哪个月，这个月有多少天，这些都是需要考虑的。

楼主这简单添加几个节日，节日大家可以随便添加哦。只是一个显示问题。

package com.example.nanchen.calendarviewdemo.view;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;

/**
 * 农历算法
 *
 * @author nanchen
 * @date 2016-08-11  08-57:24
 */
public class LunarCalendar {
    private int year; // 农历的年份
    private int month;
    private int day;
    private String lunarMonth; // 农历的月份
    public int leapMonth = 0; // 闰的是哪个月

    final static String chineseNumber[] = {"一", "二", "三", "四", "五", "六", "七", "八", "九", "十", "十一", "十二"};
    static SimpleDateFormat chineseDateFormat = new SimpleDateFormat("yyyy年MM月dd日", Locale.CHINA);
    final static long[] lunarInfo = new long[]{ //
            0x04bd8, 0x04ae0, 0x0a570, 0x054d5, 0x0d260, 0x0d950, 0x16554, 0x056a0, 0x09ad0, //
            0x055d2, 0x04ae0, 0x0a5b6, 0x0a4d0, 0x0d250, 0x1d255, 0x0b540, 0x0d6a0, 0x0ada2, //
            0x095b0, 0x14977, 0x04970, 0x0a4b0, 0x0b4b5, 0x06a50, 0x06d40, 0x1ab54, 0x02b60, //
            0x09570, 0x052f2, 0x04970, 0x06566, 0x0d4a0, 0x0ea50, 0x06e95, 0x05ad0, 0x02b60, //
            0x186e3, 0x092e0, 0x1c8d7, 0x0c950, 0x0d4a0, 0x1d8a6, 0x0b550, 0x056a0, 0x1a5b4, //
            0x025d0, 0x092d0, 0x0d2b2, 0x0a950, 0x0b557, 0x06ca0, 0x0b550, 0x15355, 0x04da0, //
            0x0a5d0, 0x14573, 0x052d0, 0x0a9a8, 0x0e950, 0x06aa0, 0x0aea6, 0x0ab50, 0x04b60, //
            0x0aae4, 0x0a570, 0x05260, 0x0f263, 0x0d950, 0x05b57, 0x056a0, 0x096d0, 0x04dd5, //
            0x04ad0, 0x0a4d0, 0x0d4d4, 0x0d250, 0x0d558, 0x0b540, 0x0b5a0, 0x195a6, 0x095b0, //
            0x049b0, 0x0a974, 0x0a4b0, 0x0b27a, 0x06a50, 0x06d40, 0x0af46, 0x0ab60, 0x09570, //
            0x04af5, 0x04970, 0x064b0, 0x074a3, 0x0ea50, 0x06b58, 0x055c0, 0x0ab60, 0x096d5, //
            0x092e0, 0x0c960, 0x0d954, 0x0d4a0, 0x0da50, 0x07552, 0x056a0, 0x0abb7, 0x025d0, //
            0x092d0, 0x0cab5, 0x0a950, 0x0b4a0, 0x0baa4, 0x0ad50, 0x055d9, 0x04ba0, 0x0a5b0, //
            0x15176, 0x052b0, 0x0a930, 0x07954, 0x06aa0, 0x0ad50, 0x05b52, 0x04b60, 0x0a6e6, //
            0x0a4e0, 0x0d260, 0x0ea65, 0x0d530, 0x05aa0, 0x076a3, 0x096d0, 0x04bd7, 0x04ad0, //
            0x0a4d0, 0x1d0b6, 0x0d250, 0x0d520, 0x0dd45, 0x0b5a0, 0x056d0, 0x055b2, 0x049b0, //
            0x0a577, 0x0a4b0, 0x0aa50, 0x1b255, 0x06d20, 0x0ada0};

    // 农历部分假日
    final static String[] lunarHoliday = new String[]{"0101 春节", "0115 元宵", "0505 端午", "0707 情人", "0715 中元", "0815 中秋", "0909 重阳", "1208 腊八", "1224 小年", "0100 除夕"};

    // 公历部分节假日
    final static String[] solarHoliday = new String[]{ //
            "0101 元旦", "0214 情人", "0308 妇女", "0312 植树", "0315 消费者权益日", "0401 愚人", "0501 劳动", "0504 青年", //
            "0512 护士", "0601 儿童", "0701 建党", "0801 建军", "0808 父亲", "0910 教师", "0928 孔子诞辰",//
            "1001 国庆", "1006 老人", "1024 联合国日", "1112 孙中山诞辰纪念", "1220 澳门回归纪念", "1225 圣诞"};

    /**
     * 传回农历 y年的总天数
     *
     * @param y 年份
     * @return 该年的总天数
     */
    private static int yearDays(int y) {
        int i, sum = 348;
        for (i = 0x8000; i > 0x8; i >>= 1) {
            if ((lunarInfo[y - 1900] & i) != 0)
                sum += 1;
        }
        return (sum + leapDays(y));
    }

    /**
     * 传回农历 y年闰月的天数
     *
     * @param y 年份
     * @return 改年闰月天数
     */
    private static int leapDays(int y) {
        if (leapMonth(y) != 0) {
            if ((lunarInfo[y - 1900] & 0x10000) != 0)
                return 30;
            else
                return 29;
        } else
            return 0;
    }

    /**
     * 传回农历 y年闰哪个月 1-12 , 没闰传回 0
     *
     * @param y 年份
     * @return 改年闰月的月数
     */
    private static int leapMonth(int y) {
        return (int) (lunarInfo[y - 1900] & 0b1111);
    }

    /**
     * 传回农历 y年m月的总天数
     *
     * @param y 年份
     * @param m 月份
     * @return 该月份的总天数
     */
    private static int monthDays(int y, int m) {
        if ((lunarInfo[y - 1900] & (0x10000 >> m)) == 0)
            return 29;
        else
            return 30;
    }

    /**
     * 传回农历 y年的生肖
     *
     * @param year 年份
     * @return 生肖
     */
    public String animalsYear(int year) {
        final String[] Animals = new String[]{"鼠", "牛", "虎", "兔", "龙", "蛇", "马", "羊", "猴", "鸡", "狗", "猪"};
        return Animals[(year - 4) % 12];
    }

    /**
     * 传入 月日的offset 传回干支, 0=甲子
     */
    private static String cyclicalm(int num) {
        final String[] Gan = new String[]{"甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸"};
        final String[] Zhi = new String[]{"子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥"};
        return (Gan[num % 10] + Zhi[num % 12]);
    }

    /**
     * 传入 offset 传回干支, 0=甲子
     */
    public String cyclical(int year) {
        int num = year - 1900 + 36;
        return (cyclicalm(num));
    }

    public static String getChinaDayString(int day) {
        String chineseTen[] = {"初", "十", "廿", "卅"};
        int n = day % 10 == 0 ? 9 : day % 10 - 1;
        if (day > 30)
            return "";
        if (day == 10)
            return "初十";
        else
            return chineseTen[day / 10] + chineseNumber[n];
    }

    /**
     * 传出y年m月d日对应的农历. yearCyl3:农历年与1864的相差数 ? monCyl4:从1900年1月31日以来,闰月数
     * dayCyl5:与1900年1月31日相差的天数,再加40 ?
     * <p/>
     * isday: 这个参数为false---日期为节假日时，阴历日期就返回节假日 ，true---不管日期是否为节假日依然返回这天对应的阴历日期
     *
     * @return
     */
    public String getLunarDate(int year_log, int month_log, int day_log,
                               boolean isday) {
        // @SuppressWarnings("unused")
        int yearCyl, monCyl, dayCyl;
        // int leapMonth = 0;
        String nowadays;
        Date baseDate = null;
        Date nowaday = null;
        try {
            baseDate = chineseDateFormat.parse("1900年1月31日");
        } catch (ParseException e) {
            e.printStackTrace(); // To change body of catch statement use
            // Options | File Templates.
        }

        nowadays = year_log + "年" + month_log + "月" + day_log + "日";
        try {
            nowaday = chineseDateFormat.parse(nowadays);
        } catch (ParseException e) {
            e.printStackTrace(); // To change body of catch statement use
            // Options | File Templates.
        }

        // 求出和1900年1月31日相差的天数
        int offset = (int) ((nowaday.getTime() - baseDate.getTime()) / 86400000L);
        dayCyl = offset + 40;
        monCyl = 14;

        // 用offset减去每农历年的天数
        // 计算当天是农历第几天
        // i最终结果是农历的年份
        // offset是当年的第几天
        int iYear, daysOfYear = 0;
        for (iYear = 1900; iYear < 10000 && offset > 0; iYear++) {
            daysOfYear = yearDays(iYear);
            offset -= daysOfYear;
            monCyl += 12;
        }
        if (offset < 0) {
            offset += daysOfYear;
            iYear--;
            monCyl -= 12;
        }
        // 农历年份
        year = iYear;
        setYear(year); // 设置公历对应的农历年份

        yearCyl = iYear - 1864;
        leapMonth = leapMonth(iYear); // 闰哪个月,1-12
        boolean leap = false;

        // 用当年的天数offset,逐个减去每月（农历）的天数，求出当天是本月的第几天
        int iMonth, daysOfMonth = 0;
        for (iMonth = 1; iMonth < 13 && offset > 0; iMonth++) {
            // 闰月
            if (leapMonth > 0 && iMonth == (leapMonth + 1) && !leap) {
                --iMonth;
                leap = true;
                daysOfMonth = leapDays(year);
            } else
                daysOfMonth = monthDays(year, iMonth);

            offset -= daysOfMonth;
            // 解除闰月
            if (leap && iMonth == (leapMonth + 1))
                leap = false;
            if (!leap)
                monCyl++;
        }
        // offset为0时，并且刚才计算的月份是闰月，要校正
        if (offset == 0 && leapMonth > 0 && iMonth == leapMonth + 1) {
            if (leap) {
                leap = false;
            } else {
                leap = true;
                --iMonth;
                --monCyl;
            }
        }
        // offset小于0时，也要校正
        if (offset < 0) {
            offset += daysOfMonth;
            --iMonth;
            --monCyl;
        }
        month = iMonth;
        setLunarMonth(chineseNumber[month - 1] + "月"); // 设置对应的阴历月份
        day = offset + 1;

        if (!isday) {
            // 如果日期为节假日则阴历日期则返回节假日
            // setLeapMonth(leapMonth);
            for (int i = 0; i < solarHoliday.length; i++) {
                // 返回公历节假日名称
                String sd = solarHoliday[i].split(" ")[0]; // 节假日的日期
                String sdv = solarHoliday[i].split(" ")[1]; // 节假日的名称
                String smonth_v = month_log + "";
                String sday_v = day_log + "";
                String smd = "";
                if (month_log < 10) {
                    smonth_v = "0" + month_log;
                }
                if (day_log < 10) {
                    sday_v = "0" + day_log;
                }
                smd = smonth_v + sday_v;
                if (sd.trim().equals(smd.trim())) {
                    return sdv;
                }
            }

            for (int i = 0; i < lunarHoliday.length; i++) {
                // 返回农历节假日名称
                String ld = lunarHoliday[i].split(" ")[0]; // 节假日的日期
                String ldv = lunarHoliday[i].split(" ")[1]; // 节假日的名称
                String lmonth_v = month + "";
                String lday_v = day + "";
                String lmd = "";
                if (month < 10) {
                    lmonth_v = "0" + month;
                }
                if (day < 10) {
                    lday_v = "0" + day;
                }
                lmd = lmonth_v + lday_v;
                if (ld.trim().equals(lmd.trim())) {
                    return ldv;
                }
            }
        }
        if (day == 1)
            return chineseNumber[month - 1] + "月";
        else
            return getChinaDayString(day);

    }

    public String toString() {
        if (chineseNumber[month - 1] == "一" && getChinaDayString(day) == "初一")
            return "农历" + year + "年";
        else if (getChinaDayString(day) == "初一")
            return chineseNumber[month - 1] + "月";
        else
            return getChinaDayString(day);
        // return year + "年" + (leap ? "闰" : "") + chineseNumber[month - 1] +
        // "月" + getChinaDayString(day);
    }

//
//    public static void main(String[] args) {
//        System.out.println(new
//                LunarCalendar().getLunarDate(2012, 1, 23));
//    }


    public int getLeapMonth() {
        return leapMonth;
    }

    public void setLeapMonth(int leapMonth) {
        this.leapMonth = leapMonth;
    }

    /**
     * 得到当前日期对应的阴历月份
     *
     * @return
     */
    public String getLunarMonth() {
        return lunarMonth;
    }

    public void setLunarMonth(String lunarMonth) {
        this.lunarMonth = lunarMonth;
    }

    /**
     * 得到当前年对应的农历年份
     *
     * @return
     */
    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }
}

3）为了设置点击事件，这里就分离一个接口出来吧。

ClickDataListener.java

package com.example.nanchen.calendarviewdemo.view;

/**
 * 选中日期的监听事件
 *
 * @author nanchen
 * @date   2016-08-11 09:14:21
 */
public interface ClickDataListener {
    /**
     * 点击日期day的点击事件监听
     * @param year    年
     * @param month   月
     * @param day     日
     */
    void onClickData(int year, int month, int day);
}

这里暂且只有一个点击事件，这个东西大家可以自行创新。

4）这里定义一个格式，可能大家格式都不一样，自己弄呗。

FormatDate.java

package com.example.nanchen.calendarviewdemo.view;

/**
 * @author nanchen
 * @date 16-8-12 上午8:15
 */
public class FormatDate {
    public static String DATE_FORMAT = "yyyy-MM-dd";
}

5）先来看看Adapter的代码，毕竟只有Adapter做好了，才能好好显示。

这里大家需要注意的是设置点击左右和滑动的时候都要显示上月或者下月，这个其实之前楼主写了一个TimeUtils的工具类。

这个可以通过Calendar里面的set方法来解决的，里面有两个参数。

这里先给大家看看我写的两个方法，与本例无关哦。

/**
     * 获得指定日期的前一月
     * @param specifiedDay 指定的字符串日期  格式：yyyy-MM
     * @return   指定的前一月
     */
    public static String getSpecifiedMonthBefore(String specifiedDay){
        Calendar c = Calendar.getInstance();
        Date date = null;
        try {
            date = new SimpleDateFormat("yyyy-MM").parse(specifiedDay);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        c.setTime(date);
        int month = c.get(Calendar.MONTH);
        c.set(Calendar.MONTH,month-1);
        return new SimpleDateFormat("yyyy-MM").format(c.getTime());
    }
    /**
     * 获得指定日期的后一月
     * @param specifiedDay 指定的字符串日期  格式：yyyy-MM
     * @return   指定的后一月
     */
    public static String getSpecifiedMonthAfter(String specifiedDay){
        Calendar c = Calendar.getInstance();
        Date date=null;
        try {
            date = new SimpleDateFormat("yyyy-MM").parse(specifiedDay);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        c.setTime(date);
        int month = c.get(Calendar.MONTH);
        c.set(Calendar.MONTH,month+1);
        return new SimpleDateFormat("yyyy-MM").format(c.getTime());
    }

 

上面只是教大家如何达到上月下月的效果，其实同样你可以通过Calendar和format方式对day和year等其他做同样的功能实现，大家可能以后还是有用的。

下面是Adapter，我想大家应该都很明白吧？就用new Date获取当前日期，然后字符串split分离成小数组，然后获取年月日，获取年月日方式不限，很多的。

要说到显示还是得看我们的getView,毕竟Adapter的精髓就在这个方法里，它可以觉得你到底是用怎么显示，这里楼主抛弃了以前画的方法，直接搞一个xml，把大小限制了，这样就不会像昨天那样布局密集，而丑了。

布局很简单啦。

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#FFFFFF" >

    <TextView
        android:id="@+id/tvtext"
        android:layout_width="45dp"
        android:layout_height="55dp"
        android:gravity="center" />

</LinearLayout>

我们在getView中设置了颜色等属性。并把非当前月设置为暗色，不可点击。

然后对于week做一些处理，好的，Adapter就OK了。

package com.example.nanchen.calendarviewdemo.view;

import android.content.Context;
import android.content.res.Resources;
import android.graphics.Color;
import android.text.SpannableString;
import android.text.Spanned;
import android.text.TextUtils;
import android.text.style.RelativeSizeSpan;
import android.text.style.StyleSpan;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.TextView;

import com.example.nanchen.calendarviewdemo.R;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;

/**
 * 日历GridView中的每一个item显示的文本
 *
 * @author nanchen
 * @date  2016-08-11 10:14:52
 */
public class CalendarAdapter extends BaseAdapter {
    private boolean isLeapYear = false; // 是否为闰年
    private int daysOfMonth = 0; // 某月的天数
    private int dayOfWeek = 0; // 具体某一天是星期几
    private int lastDaysOfMonth = 0; // 上一个月的总天数
    private Context context;
    private String[] dayNumber = new String[42]; // 一个GridView中的日期存入此数组中，因为一般日历都是6行7列
    private SpecialCalendar sc = null;
    private LunarCalendar lc = null;
    private Resources res = null;
    private int currentYear = 0;
    private int currentMonth = 0;
    private int currentDay = 0;

    private SimpleDateFormat sdf = new SimpleDateFormat(FormatDate.DATE_FORMAT, Locale.CHINA);//格式化日期格式
    private String showYear = ""; // 用于在头部显示的年份
    private String showMonth = ""; // 用于在头部显示的月份
    private String animalsYear = "";
    private String leapMonth = ""; // 闰哪一个月
    private String cyclical = ""; // 天干地支
    // 系统当前时间
    private String sysDate = "";
    private String sys_year = "";
    private String sys_month = "";
    private String sys_day = "";
    private int colorDataPosition = -1;
    private boolean isClickData = false;

    public CalendarAdapter() {
        Date date = new Date();
        sysDate = sdf.format(date); // 当期日期
        sys_year = sysDate.split("-")[0];
        sys_month = sysDate.split("-")[1];
        sys_day = sysDate.split("-")[2];

    }

    public CalendarAdapter(Context context, Resources rs, int jumpMonth,
            int jumpYear, int year_c, int month_c, int day_c) {
        this();
        this.context = context;
        sc = new SpecialCalendar();
        lc = new LunarCalendar();
        this.res = rs;

        int stepYear = year_c + jumpYear;
        int stepMonth = month_c + jumpMonth;
        if (stepMonth > 0) {
            // 往下一个月滑动
            if (stepMonth % 12 == 0) {
                stepYear = year_c + stepMonth / 12 - 1;
                stepMonth = 12;
            } else {
                stepYear = year_c + stepMonth / 12;
                stepMonth = stepMonth % 12;
            }
        } else {
            // 往上一个月滑动
            stepYear = year_c - 1 + stepMonth / 12;
            stepMonth = stepMonth % 12 + 12;
            if (stepMonth % 12 == 0) {

            }
        }

        currentYear = stepYear; // 得到当前的年份
        currentMonth = stepMonth; // 得到本月
                                                    // （jumpMonth为滑动的次数，每滑动一次就增加一月或减一月）
        currentDay = day_c; // 得到当前日期是哪天

        getCalendar(currentYear, currentMonth);

    }

    public CalendarAdapter(Context context, Resources rs, int year, int month,
            int day) {
        this();
        this.context = context;
        sc = new SpecialCalendar();
        lc = new LunarCalendar();
        this.res = rs;
        currentYear = year;// 得到跳转到的年份
        currentMonth = month; // 得到跳转到的月份
        currentDay = day; // 得到跳转到的天
        getCalendar(currentYear, currentMonth);
    }

    @Override
    public int getCount() {
        return dayNumber.length;
    }

    @Override
    public Object getItem(int position) {
        return dayNumber[position];
    }

    @Override
    public long getItemId(int position) {
        return position;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {

        if (convertView == null) {
            convertView = LayoutInflater.from(context).inflate(R.layout.calen_calendar_item, parent,false);
        }
        TextView textView = (TextView) convertView.findViewById(R.id.tvtext);
        String d = dayNumber[position].split("\\.")[0];
        String dv = dayNumber[position].split("\\.")[1];

        SpannableString sp = new SpannableString(d + "\n" + dv);
        sp.setSpan(new StyleSpan(android.graphics.Typeface.BOLD), 0,
                d.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
        sp.setSpan(new RelativeSizeSpan(1.2f), 0, d.length(),
                Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
        if (dv != null || !TextUtils.isEmpty(dv)) {
            sp.setSpan(new RelativeSizeSpan(0.75f), d.length() + 1,
                    dayNumber[position].length(),
                    Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
        }
        textView.setText(sp);
        textView.setTextColor(Color.GRAY);

        if (position < daysOfMonth + dayOfWeek && position >= dayOfWeek) {
            // 当前月信息显示
            textView.setTextColor(Color.BLACK);// 当月字体设黑
            // drawable = new ColorDrawable(Color.rgb(23, 126, 214));
            if (position % 7 == 0 || position % 7 == 6) {
                // 当前月信息显示
                textView.setTextColor(Color.rgb(23, 126, 214));// 当月字体设黑
            }
        }

        if (colorDataPosition == position) {
            // 设置当天的背景
            textView.setTextColor(Color.WHITE);

            textView.setBackgroundResource(R.drawable.bg_circle);
        } else {
            textView.setBackgroundColor(res.getColor(android.R.color.transparent));
        }
        return convertView;
    }

    // 得到某年的某月的天数且这月的第一天是星期几
    private void getCalendar(int year, int month) {
        isLeapYear = sc.isLeapYear(year); // 是否为闰年
        daysOfMonth = sc.getDaysOfMonth(isLeapYear, month); // 某月的总天数
        dayOfWeek = sc.getWeekdayOfMonth(year, month); // 某月第一天为星期几
        lastDaysOfMonth = sc.getDaysOfMonth(isLeapYear, month - 1); // 上一个月的总天数
        getweek(year, month);
    }

    // 将一个月中的每一天的值添加入数组dayNuber中
    private void getweek(int year, int month) {
        int j = 1;
        String lunarDay = "";
        // 得到当前月的所有日程日期(这些日期需要标记)
        for (int i = 0; i < dayNumber.length; i++) {
            if (i < dayOfWeek) { // 前一个月
                int temp = lastDaysOfMonth - dayOfWeek + 1;
                lunarDay = lc.getLunarDate(year, month - 1, temp + i, false);
                dayNumber[i] = (temp + i) + "." + lunarDay;

            } else if (i < daysOfMonth + dayOfWeek) { // 本月
                String day = String.valueOf(i - dayOfWeek + 1); // 得到的日期
                lunarDay = lc.getLunarDate(year, month, i - dayOfWeek + 1,
                        false);
                dayNumber[i] = i - dayOfWeek + 1 + "." + lunarDay;
                // 对于当前月才去标记当前日期
                if (sys_year.equals(String.valueOf(year))
                        && sys_month.equals(String.valueOf(month))
                        && sys_day.equals(day)) {
                    // 标记当前日期
                    colorDataPosition = i;
                }
                setShowYear(String.valueOf(year));
                setShowMonth(String.valueOf(month));
                setAnimalsYear(lc.animalsYear(year));
                setLeapMonth(lc.leapMonth == 0 ? "" : String
                        .valueOf(lc.leapMonth));
                setCyclical(lc.cyclical(year));
            } else { // 下一个月
                lunarDay = lc.getLunarDate(year, month + 1, j, false);
                dayNumber[i] = j + "." + lunarDay;
                j++;
            }
        }

        String abc = "";
        for (int i = 0; i < dayNumber.length; i++) {
            abc = abc + dayNumber[i] + ":";
        }
        Log.d("DAYNUMBER", abc);

    }

    /**
     * 点击每一个item时返回item中的日期
     * 
     * @param position
     * @return
     */
    public String getDateByClickItem(int position) {
        return dayNumber[position];
    }

    /**
     * 在点击gridView时，得到这个月中第一天的位置
     * 
     * @return
     */
    public int getStartPositon() {
        return dayOfWeek + 7;
    }

    /**
     * 在点击gridView时，得到这个月中最后一天的位置
     * 
     * @return
     */
    public int getEndPosition() {
        return (dayOfWeek + daysOfMonth + 7) - 1;
    }

    public String getShowYear() {
        return showYear;
    }

    public void setShowYear(String showYear) {
        this.showYear = showYear;
    }

    public String getShowMonth() {
        return showMonth;
    }

    public void setShowMonth(String showMonth) {
        this.showMonth = showMonth;
    }

    public String getAnimalsYear() {
        return animalsYear;
    }

    public void setAnimalsYear(String animalsYear) {
        this.animalsYear = animalsYear;
    }

    public String getLeapMonth() {
        return leapMonth;
    }

    public void setLeapMonth(String leapMonth) {
        this.leapMonth = leapMonth;
    }

    public String getCyclical() {
        return cyclical;
    }

    public void setCyclical(String cyclical) {
        this.cyclical = cyclical;
    }

    /**
     * @param position
     * 设置点击的日期的颜色位置
     */
    public void setColorDataPosition(int position) {
        if (position >= dayOfWeek && position < daysOfMonth + dayOfWeek) {
            colorDataPosition = position;
            notifyDataSetChanged();
        }
    }
}

6）重头戏还是这个MyCalendarView.java，毕竟，你其他的东西都是打辅助的，到后面，大家要用的还不是这个类。

MyCalendarView.java

package com.example.nanchen.calendarviewdemo.view;

import android.app.Activity;
import android.content.Context;
import android.graphics.Color;
import android.graphics.drawable.ColorDrawable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.Display;
import android.view.GestureDetector;
import android.view.GestureDetector.SimpleOnGestureListener;
import android.view.Gravity;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.WindowManager;
import android.view.animation.AnimationUtils;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.GridView;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.ViewFlipper;

import com.example.nanchen.calendarviewdemo.R;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;


/**
 * 自定义的日历控件
 *
 * @author nanchen
 * @date   2016-08-11 09:44:27
 */
public class MyCalendarView extends LinearLayout implements OnClickListener {

    private final String TAG = MyCalendarView.class.getSimpleName();
    private int year_c = 0;// 今天的年份
    private int month_c = 0;// 今天的月份
    private int day_c = 0;// 今天的日期
    private String currentDate = "";//当前日期
    private Context mContext;
    private TextView currentMonth;// 显示日期
    private ImageView prevMonth;// 去上一个月
    private ImageView nextMonth;// 去下一个月
    private int gvFlag = 0;
    private GestureDetector gestureDetector = null;//用户手势检测
    private CalendarAdapter adapter = null;//适配器
    private ViewFlipper flipper = null;
    private GridView gridView = null;
    private static int jumpMonth = 0; // 每次滑动，增加或减去一个月,默认为0（即显示当前月）
    private static int jumpYear = 0; // 滑动跨越一年，则增加或者减去一年,默认为0(即当前年)
    private ClickDataListener clickDataListener;

    public MyCalendarView(Context context) {
        this(context, null);
    }

    public MyCalendarView(Context context, AttributeSet attrs) {
        super(context, attrs);
        mContext = context;
        initView();
    }

    /**
     * 初始化布局
     */
    private void initView() {
        //加载布局，一个头布局，一个横向的星期布局，下面一个ViewFlipper用于滑动
        View view = View.inflate(mContext, R.layout.calen_calendar, this);
        currentMonth = (TextView) view.findViewById(R.id.currentMonth);
        prevMonth = (ImageView) view.findViewById(R.id.prevMonth);
        nextMonth = (ImageView) view.findViewById(R.id.nextMonth);
        setListener();
        setCurrentDay();
        gestureDetector = new GestureDetector(mContext, new MyGestureListener());
        flipper = (ViewFlipper) findViewById(R.id.flipper);
        flipper.removeAllViews();
        adapter = new CalendarAdapter(mContext, getResources(), jumpMonth,
                jumpYear, year_c, month_c, day_c);
        addGridView();
        gridView.setAdapter(adapter);
        flipper.addView(gridView, 0);
        addTextToTopTextView(currentMonth);
    }

    private void setListener() {
        prevMonth.setOnClickListener(this);
        nextMonth.setOnClickListener(this);

    }

    public void setClickDataListener(ClickDataListener clickDataListener) {
        this.clickDataListener = clickDataListener;
    }

    private void setCurrentDay() {
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat(FormatDate.DATE_FORMAT, Locale.CHINA);
        currentDate = sdf.format(date); // 当期日期
        year_c = Integer.parseInt(currentDate.split("-")[0]);
        month_c = Integer.parseInt(currentDate.split("-")[1]);
        day_c = Integer.parseInt(currentDate.split("-")[2]);
    }

    /**
     * 移动到下一个月
     * 
     * @param gvFlag
     */
    private void enterNextMonth(int gvFlag) {
        addGridView(); // 添加一个gridView
        jumpMonth++; // 下一个月
        adapter = new CalendarAdapter(mContext, this.getResources(), jumpMonth,
                jumpYear, year_c, month_c, day_c);
        gridView.setAdapter(adapter);
        addTextToTopTextView(currentMonth); // 移动到下一月后，将当月显示在头标题中
        gvFlag++;
        flipper.addView(gridView, gvFlag);
        flipper.setInAnimation(AnimationUtils.loadAnimation(mContext,
                R.anim.push_left_in));
        flipper.setOutAnimation(AnimationUtils.loadAnimation(mContext,
                R.anim.push_left_out));
        flipper.showNext();
        flipper.removeViewAt(0);
    }

    /**
     * 移动到上一个月
     * 
     * @param gvFlag
     */
    private void enterPrevMonth(int gvFlag) {
        addGridView(); // 添加一个gridView
        jumpMonth--; // 上一个月

        adapter = new CalendarAdapter(mContext, this.getResources(), jumpMonth,
                jumpYear, year_c, month_c, day_c);
        gridView.setAdapter(adapter);
        gvFlag++;
        addTextToTopTextView(currentMonth); // 移动到上一月后，将当月显示在头标题中
        flipper.addView(gridView, gvFlag);

        flipper.setInAnimation(AnimationUtils.loadAnimation(mContext,
                R.anim.push_right_in));
        flipper.setOutAnimation(AnimationUtils.loadAnimation(mContext,
                R.anim.push_right_out));
        flipper.showPrevious();
        flipper.removeViewAt(0);
    }

    /**
     * 添加头部的年份 闰哪月等信息
     * 
     * @param view
     */
    private void addTextToTopTextView(TextView view) {
        StringBuffer textDate = new StringBuffer();
        // draw = getResources().getDrawable(R.drawable.top_day);
        // view.setBackgroundDrawable(draw);
        textDate.append(adapter.getShowYear()).append("年")
                .append(adapter.getShowMonth()).append("月").append("\t");
        view.setText(textDate);
    }

    private void addGridView() {
        LayoutParams params = new LayoutParams(
                LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
        // 取得屏幕的宽度和高度
        WindowManager windowManager = ((Activity) mContext).getWindowManager();
        Display display = windowManager.getDefaultDisplay();
        int Width = display.getWidth();
        int Height = display.getHeight();

        gridView = new GridView(mContext);
        gridView.setNumColumns(7);
        gridView.setColumnWidth(40);
        // gridView.setStretchMode(GridView.STRETCH_COLUMN_WIDTH);
        if (Width == 720 && Height == 1280) {
            gridView.setColumnWidth(40);
        }
        gridView.setGravity(Gravity.CENTER_VERTICAL);
        gridView.setSelector(new ColorDrawable(Color.TRANSPARENT));
        // 去除gridView边框
        gridView.setVerticalSpacing(0);
        gridView.setHorizontalSpacing(0);
        gridView.setOnTouchListener(new OnTouchListener() {
            // 将gridview中的触摸事件回传给gestureDetector

            public boolean onTouch(View v, MotionEvent event) {
                // TODO Auto-generated method stub
                return gestureDetector.onTouchEvent(event);
            }
        });

        gridView.setOnItemClickListener(new OnItemClickListener() {

            @Override
            public void onItemClick(AdapterView<?> arg0, View arg1,
                    int position, long arg3) {
                // TODO Auto-generated method stub
                // 点击任何一个item，得到这个item的日期(排除点击的是周日到周六(点击不响应))
                int startPosition = adapter.getStartPositon();
                int endPosition = adapter.getEndPosition();
                if (startPosition <= position + 7
                        && position <= endPosition - 7) {
                    int scheduleDay = Integer.parseInt(adapter.getDateByClickItem(position)
                            .split("\\.")[0]); // 这一天的阳历
                    int scheduleYear = Integer.parseInt(adapter.getShowYear());
                    int scheduleMonth = Integer.parseInt(adapter.getShowMonth());
                    ((CalendarAdapter) arg0.getAdapter())
                            .setColorDataPosition(position);
                    if (clickDataListener != null) {
                        clickDataListener.onClickData(scheduleYear,
                                scheduleMonth, scheduleDay);
                    }
                }
            }
        });
        gridView.setLayoutParams(params);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
        case R.id.nextMonth: // 下一个月
            enterNextMonth(gvFlag);
            Log.d(TAG, "gvFlag=" + gvFlag);
            break;
        case R.id.prevMonth: // 上一个月
            enterPrevMonth(gvFlag);
            break;

        }

    }

    private static class MyGestureListener extends SimpleOnGestureListener {
        private MyCalendarView calendarView;

        @Override
        public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
                float velocityY) {
            int gvFlag = 0; // 每次添加gridview到viewflipper中时给的标记
            if (e1.getX() - e2.getX() > 120) {
                // 像左滑动
                calendarView.enterNextMonth(gvFlag);
                return true;
            } else if (e1.getX() - e2.getX() < -120) {
                // 向右滑动
                calendarView.enterPrevMonth(gvFlag);
                return true;
            }
            return false;
        }
    }
}

这个，这个类没啥难的吧？看不懂？就跟一般的Activity处理一样，绑定布局，设置监听，做一些交互。

额，对，昨天写这个的时候搞得太复杂太复杂了。今天楼主全部放到xml文件中去了啦啦啦。

而且上面的布局和周几都不用刷新的，这不，直接放在Xml中定死就可以了嘛。

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal" >

        <ImageView
            android:id="@+id/prevMonth"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_gravity="center"
            android:layout_weight="1"
            android:src="@drawable/pre_month_selector" />

        <TextView
            android:id="@+id/currentMonth"
            android:layout_width="0dp"
            android:layout_height="35dp"
            android:layout_weight="3"
            android:gravity="center"
            android:text="2016年8月"
            android:textColor="#177ed6"
            android:textSize="18dp" />

        <ImageView
            android:id="@+id/nextMonth"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_gravity="center"
            android:layout_weight="1"
            android:src="@drawable/next_month_selector" />
    </LinearLayout>


    <!--周几的布局-->
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="20dp"
        android:background="#ffffffff" >

        <TextView
            style="@style/weekName"
            android:text="日"
            android:textColor="#177ed6" />

        <TextView
            style="@style/weekName"
            android:text="一" />

        <TextView
            style="@style/weekName"
            android:text="二" />

        <TextView
            style="@style/weekName"
            android:text="三" />

        <TextView
            style="@style/weekName"
            android:text="四" />

        <TextView
            style="@style/weekName"
            android:text="五" />

        <TextView
            style="@style/weekName"
            android:text="六"
            android:textColor="#177ed6" />
    </LinearLayout>

    <View
        android:layout_width="match_parent"
        android:layout_height="1dp"
        android:background="#ff8091a8" />

    <ViewFlipper
        android:id="@+id/flipper"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />
</LinearLayout>

XML文件够简单吧~上部一个简单的title布局，中间一个水平的线性布局用于显示周几，下面一个ViewFlipper用于左右滑动。

额，两个Selector

pre_month_selector.xml

<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">

    <item android:state_pressed="true" android:drawable="@drawable/triangle06_pressed"/>
    <item android:state_pressed="false" android:drawable="@drawable/triangle06"/>

</selector>

next_month_selector.xml

<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">

    <item android:state_pressed="true" android:drawable="@drawable/triangle05_pressed"/>
    <item android:state_pressed="false" android:drawable="@drawable/triangle05"/>

</selector>

7）使用，MainActivity.java

package com.example.nanchen.calendarviewdemo;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.widget.Toast;

import com.example.nanchen.calendarviewdemo.view.MyCalendarView;
import com.example.nanchen.calendarviewdemo.view.ClickDataListener;

import java.util.Locale;

/**
 * @author nanchen
 * @date   2016-08-11 10:48:21
 */
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        MyCalendarView myCalendarView = (MyCalendarView) findViewById(R.id.main_calendar);
        myCalendarView.setClickDataListener(new ClickDataListener() {
            @Override
            public void onClickData(int year, int month, int day) {
                String date = String.format(Locale.CHINA,"%04d年%02d月%02d日",year,month,day);
                Toast.makeText(MainActivity.this,date,Toast.LENGTH_SHORT).show();
            }
        });
    }
}

布局文件

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.example.nanchen.calendarviewdemo.MainActivity">

    <com.example.nanchen.calendarviewdemo.view.MyCalendarView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:id="@+id/main_calendar"/>
</LinearLayout>

 

更多详情源码请上github：https://github.com/nanchen2251/MyCalendarViewNewDemo

 

额，差不多啦，转载的小伙伴别忘了附上本文地址:http://www.cnblogs.com/liushilin/p/5763717.html

还是欢迎大家抨击，点赞，分享~你们的支持和打击是小主进步的源泉~