Character:

package Chapter9;

public class CustomCharacter {
    public static void main(String[] args) {

        char ch = 'a';

        char uniChar = '\u039A';

        char[] charArray = {'a', 'b'};

        Character character = new Character('x');

        System.out.println("访问\"菜鸟教程\"");

        /*isLetter()-是否是一个字母*/
        /*isDigit()-是否是一个数字字符*/
        /*isWhitespace()-是否是一个空格*/
        /*isUpperCase()-是否是大写字母*/
        /*isLowerCase()-是否是小写字母*/
        /*toUpperCase()-指定字母的大写形式*/
        /*toLowerCase()-指定字母的小写形式*/
        /*toString()-返回字符的字符串形式，字符串的长度仅为1*/
    }
}

String:

package Chapter10;

public class CustomString {

    public static void main(String[] args) {

        char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};
        String helloString = new String(helloArray);
        System.out.println( helloString );

        String site = "www.runoob.com";
        int len = site.length();
        System.out.println( "菜鸟教程网址长度 : " + len );

        String string1 = "菜鸟教程网址：";
        System.out.println("1、" + string1 + "www.runoob.com");

        String fs;
        double floatVar = (float) 2.0;
        int intVar = 2;
        String stringVar = "asd";

        fs = String.format("浮点型变量的的值为 " +
                "%f, 整型变量的值为 " +
                " %d, 字符串变量的值为 " +
                " %s", floatVar, intVar, stringVar);

        System.out.println(fs);


//         String 类支持的方法 http://www.runoob.com/manual/jdk1.6/java/lang/String.html

        /*char charAt(int index)-返回指定索引处的 char 值。*/
        /*int compareTo(Object o)-把这个字符串和另一个对象比较。*/
        /*  int compareTo(String anotherString)-按字典顺序比较两个字符串。*/
        /*int compareToIgnoreCase(String str)-按字典顺序比较两个字符串，不考虑大小写。*/
        /*String concat(String str)-将指定字符串连接到此字符串的结尾。*/
        /*boolean contentEquals(StringBuffer sb)-当且仅当字符串与指定的StringButter有相同顺序的字符时候返回真。*/
        /*  static String copyValueOf(char[] data)-返回指定数组中表示该字符序列的 String。*/

        /*static String copyValueOf(char[] data, int offset, int count)-返回指定数组中表示该字符序列的 String。*/
        /*  boolean endsWith(String suffix)-测试此字符串是否以指定的后缀结束。*/
        /*boolean equals(Object anObject)-将此字符串与指定的对象比较。*/
        /*  boolean equalsIgnoreCase(String anotherString)-将此 String 与另一个 String 比较，不考虑大小写。*/
        /*  byte[] getBytes()-使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
            byte[] getBytes(String charsetName)-使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
            void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)-将字符从此字符串复制到目标字符数组。*/
        /*int hashCode()-返回此字符串的哈希码。*/

        /*  int indexOf(int ch)-返回指定字符在此字符串中第一次出现处的索引。
            int indexOf(int ch, int fromIndex)-返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
            int indexOf(String str)-返回指定子字符串在此字符串中第一次出现处的索引。
            int indexOf(String str, int fromIndex)-返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。*/


        /*  String intern()-返回字符串对象的规范化表示形式。
            int lastIndexOf(int ch)-返回指定字符在此字符串中最后一次出现处的索引。
            int lastIndexOf(int ch, int fromIndex)-返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
            int lastIndexOf(String str)-返回指定子字符串在此字符串中最右边出现处的索引。
            int lastIndexOf(String str, int fromIndex)-返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
            */

        /*  int length()-返回此字符串的长度。*/


        /*
        boolean matches(String regex)-告知此字符串是否匹配给定的正则表达式。
        boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)-测试两个字符串区域是否相等。
        boolean regionMatches(int toffset, String other, int ooffset, int len)-测试两个字符串区域是否相等。
        String replace(char oldChar, char newChar)-返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
        String replaceAll(String regex, String replacement-使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
        String replaceFirst(String regex, String replacement)-使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
        String[] split(String regex)-根据给定正则表达式的匹配拆分此字符串。
        String[] split(String regex, int limit)-根据匹配给定的正则表达式来拆分此字符串。
        boolean startsWith(String prefix)-测试此字符串是否以指定的前缀开始。
        boolean startsWith(String prefix, int toffset)-测试此字符串从指定索引开始的子字符串是否以指定前缀开始。*/

        /*
        CharSequence subSequence(int beginIndex, int endIndex)-返回一个新的字符序列，它是此序列的一个子序列。
        String substring(int beginIndex)-返回一个新的字符串，它是此字符串的一个子字符串。
        String substring(int beginIndex, int endIndex)-返回一个新字符串，它是此字符串的一个子字符串。
        char[] toCharArray()-将此字符串转换为一个新的字符数组。
        String toLowerCase()-使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
        String toLowerCase(Locale locale)-使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
        String toString()-返回此对象本身（它已经是一个字符串！）。
        String toUpperCase()-使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
        String toUpperCase(Locale locale)-使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
        String trim()-返回字符串的副本，忽略前导空白和尾部空白。
        static String valueOf(primitive data type x)-返回给定data type类型x参数的字符串表示形式。*/
    }
}

StringBuffer:

package Chapter11;

public class CustomStringBuffer {

    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer("菜鸟");
        buffer.append("aaaa");
        System.out.println(buffer);

        /*
        public StringBuffer append(String s)-将指定的字符串追加到此字符序列。

        public StringBuffer reverse()-将此字符序列用其反转形式取代。

        public delete(int start, int end)-移除此序列的子字符串中的字符。

        public insert(int offset, int i)-将 int 参数的字符串表示形式插入此序列中。

        replace(int start, int end, String str)-使用给定 String 中的字符替换此序列的子字符串中的字符。*/
    }
}

Array:

package Chapter12;

import java.lang.reflect.Array;
import java.util.Arrays;

public class CustomArray {

    public static void printArray(int[] arrayOne) {

        for (int i = 0;i < arrayOne.length; i++) {
            System.out.println(arrayOne[i] + "");
        }
    }

    public static int[] reverse(int[] list) {

        int[] result = new int[list.length];

        for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
            result[j] = list[i];
        }
        return result;
    }

    public static void main(String[] args) {
        double[] myList = {1.9, 2.9, 3.4, 3.5};

        // 打印所有数组元素
        for (int i = 0; i < myList.length; i++) {
            System.out.println(myList[i] + " ");
        }
        // 计算所有元素的总和
        double total = 0;
        for (int i = 0; i < myList.length; i++) {
            total += myList[i];
        }
        System.out.println("Total is " + total);
        // 查找最大元素
        double max = myList[0];
        for (int i = 1; i < myList.length; i++) {
            if (myList[i] > max) max = myList[i];
        }
        System.out.println("Max is " + max);

        // 打印所有数组元素
        for (double element: myList) {
            System.out.println(element);
        }





        int a[][] = new int[2][3];

        /*
        public static int binarySearch(Object[] a, Object key)-用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
        public static boolean equals(long[] a, long[] a2)-如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
        public static void fill(int[] a, int val)-将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
        public static void sort(Object[] a)-对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。*/

    }
}

Date Time

package Chapter13;

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

public class CustomDataAndTime {

    public static void main(String[] args) {

        // 初始化 Date 对象
        Date date = new Date();

        // 使用 toString() 函数显示日期时间
        System.out.println(date.toString());

        Date dNow = new Date( );
        SimpleDateFormat ft = new SimpleDateFormat("E yyyy.MM.dd 'at' hh:mm:ss a zzz");

        System.out.println("Current Date: " + ft.format(dNow));

        // 初始化 Date 对象
        Date dateNew = new Date();

        //c的使用
        System.out.printf("全部日期和时间信息：%tc%n",dateNew);
        //f的使用
        System.out.printf("年-月-日格式：%tF%n",dateNew);
        //d的使用
        System.out.printf("月/日/年格式：%tD%n",dateNew);
        //r的使用
        System.out.printf("HH:MM:SS PM格式（12时制）：%tr%n",dateNew);
        //t的使用
        System.out.printf("HH:MM:SS格式（24时制）：%tT%n",dateNew);
        //R的使用
        System.out.printf("HH:MM格式（24时制）：%tR%n",dateNew);

        // 初始化 Date 对象
        Date dateOne = new Date();

        // TODO: 如何定义
        // 使用toString()显示日期和时间
        System.out.printf("%1$s %2$tB %2$td, %2$tY%n",
                "Due date:", dateOne);

        // 显示格式化时间
        System.out.printf("%s %tB %<te, %<tY",
                "Due date:", date);

        //b的使用，月份简称
        String str=String.format(Locale.US,"英文月份简称：%tb",date);

        System.out.println(str);
        System.out.printf("本地月份简称：%tb%n",date);
        //B的使用，月份全称
        str=String.format(Locale.US,"英文月份全称：%tB",date);
        System.out.println(str);
        System.out.printf("本地月份全称：%tB%n",date);
        //a的使用，星期简称
        str=String.format(Locale.US,"英文星期的简称：%ta",date);
        System.out.println(str);
        //A的使用，星期全称
        System.out.printf("本地星期的简称：%tA%n",date);
        //C的使用，年前两位
        System.out.printf("年的前两位数字（不足两位前面补0）：%tC%n",date);
        //y的使用，年后两位
        System.out.printf("年的后两位数字（不足两位前面补0）：%ty%n",date);
        //j的使用，一年的天数
        System.out.printf("一年中的天数（即年的第几天）：%tj%n",date);
        //m的使用，月份
        System.out.printf("两位数字的月份（不足两位前面补0）：%tm%n",date);
        //d的使用，日（二位，不够补零）
        System.out.printf("两位数字的日（不足两位前面补0）：%td%n",date);
        //e的使用，日（一位不补零）
        System.out.printf("月份的日（前面不补0）：%te%n",date);


        SimpleDateFormat ftft = new SimpleDateFormat ("yyyy-MM-dd");

        String input = args.length == 0 ? "1818-11-11" : args[0];

        System.out.print(input + " Parses as ");

        Date t;

        try {
            t = ftft.parse(input);
            System.out.println(t);
        } catch (ParseException e) {
            System.out.println("Unparseable using " + ftft);
        }


        // Java 休眠(sleep)
        try {
            System.out.println(new Date( ) + "\n");
            Thread.sleep(1000*3);   // 休眠3秒
            System.out.println(new Date( ) + "\n");
        } catch (Exception e) {
            System.out.println("Got an exception!");
        }

        /*测量时间*/
        try {
            long start = System.currentTimeMillis( );
            System.out.println(new Date( ) + "\n");
            Thread.sleep(5*60*10);
            System.out.println(new Date( ) + "\n");
            long end = System.currentTimeMillis( );
            long diff = end - start;
            System.out.println("Difference is : " + diff);
        } catch (Exception e) {
            System.out.println("Got an exception!");
        }

        Calendar c1 = Calendar.getInstance();
        // 获得年份
        int year = c1.get(Calendar.YEAR);
        // 获得月份
        int month = c1.get(Calendar.MONTH) + 1;
        // 获得日期
        int dateTwo = c1.get(Calendar.DATE);
        // 获得小时
        int hour = c1.get(Calendar.HOUR_OF_DAY);
        // 获得分钟
        int minute = c1.get(Calendar.MINUTE);
        // 获得秒
        int second = c1.get(Calendar.SECOND);
        // 获得星期几（注意（这个与Date类是不同的）：1代表星期日、2代表星期1、3代表星期二，以此类推）
        int day = c1.get(Calendar.DAY_OF_WEEK);

        String months[] = {
                "Jan", "Feb", "Mar", "Apr",
                "May", "Jun", "Jul", "Aug",
                "Sep", "Oct", "Nov", "Dec"};

        int yearOne;
        // 初始化 Gregorian 日历
        // 使用当前时间和日期
        // 默认为本地时间和时区
        GregorianCalendar gcalendar = new GregorianCalendar();
        // 显示当前时间和日期的信息
        System.out.print("Date: ");
        System.out.print(months[gcalendar.get(Calendar.MONTH)]);
        System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");
        System.out.println(yearOne = gcalendar.get(Calendar.YEAR));
        System.out.print("Time: ");
        System.out.print(gcalendar.get(Calendar.HOUR) + ":");
        System.out.print(gcalendar.get(Calendar.MINUTE) + ":");
        System.out.println(gcalendar.get(Calendar.SECOND));

        // 测试当前年份是否为闰年
        if(gcalendar.isLeapYear(yearOne)) {
            System.out.println("当前年份是闰年");
        }
        else {
            System.out.println("当前年份不是闰年");
        }
    }
}