11. Java常用类

1. Scanner类

1.1 基本语法

java.util.Scanner 是 Java5 的新特征，我们可以通过 Scanner 类来获取用户的输入。

Scanner s = new Scanner(System.in);

1.2 next方法

import java.util.Scanner; 

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
    // 从键盘接收数据  

    //next方式接收字符串
        System.out.println("next方式接收：");
        // 判断是否还有输入
        if(scan.hasNext()){
          String str1 = scan.next();
          System.out.println("输入的数据为："+str1);
        }  

    }
}

输出结果：

$ javac ScannerDemo.java
$ java ScannerDemo
next方式接收：
rimi com
输入的数据为：rimi

可以看到 com 字符串并未输出

1.3 nextLine方法

import java.util.Scanner; 

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
    // 从键盘接收数据  

    //nextLine方式接收字符串
        System.out.println("nextLine方式接收：");
        // 判断是否还有输入
        if(scan.hasNextLine()){
          String str2 = scan.nextLine();
          System.out.println("输入的数据为："+str2);
        }  

    }
}

执行以上程序输出结果为：

$ javac ScannerDemo.java
$ java ScannerDemo
nextLine方式接收：
rimi com
输入的数据为：rimi com

可以看到 com 字符串输出。

1.4 next与nextLine()的区别

next():

1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
4、next() 不能得到带有空格的字符串。

nextLine()：

1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。

1.5 使用Scanner输入多种数据类型

如果要输入 int 或 float 类型的数据，在 Scanner 类中也有支持，但是在输入之前最好先使用 hasNextXxx() 方法进行验证，再使用 nextXxx() 来读取

import java.util.Scanner;  

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
    // 从键盘接收数据
        int i = 0 ;
        float f = 0.0f ;
        System.out.print("输入整数：");
        if(scan.hasNextInt()){
      // 判断输入的是否是整数
            i = scan.nextInt() ;
      // 接收整数
            System.out.println("整数数据：" + i) ;
        }else{
      // 输入错误的信息
            System.out.println("输入的不是整数！") ;
        }
        System.out.print("输入小数：");
        if(scan.hasNextFloat()){
      // 判断输入的是否是小数
            f = scan.nextFloat() ;
      // 接收小数
            System.out.println("小数数据：" + f) ;
        }else{
      // 输入错误的信息
            System.out.println("输入的不是小数！") ;
        }
    }
}

输出结果：

$ javac ScannerDemo.java
$ java ScannerDemo
输入整数：12
整数数据：12
输入小数：1.2
小数数据：1.2

1.6 练习

1. 请输入需要累加的整数，直到输入 0 结束累加。

---

2. Number和Math类

2.1 什么是包装类

一般地，当需要使用数字的时候，我们通常使用内置数据类型，如：byte、int、long、double 等

int a = 5000;
float b = 13.65f;
byte c = 0x4a;

然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。

所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。

这种由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类。相似的，编译器也可以把一个对象拆箱为内置类型。Number 类属于 java.lang 包。

public class Test{

   public static void main(String args[]){
      Integer x = 5;
      x =  x + 10;
      System.out.println(x);
   }
}

当 x 被赋为整型值时，由于x是一个对象，所以编译器要对x进行装箱。然后，为了使x能进行加运算，所以要对x进行拆箱。

关于拆箱封箱

/**
*
* java中的自动装箱与拆箱
* 简单一点说，装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。
*/
public class NumberDemo {
    public static void main(String[] args) {
        /*
        Integer i1 = 128;  // 装箱，相当于 Integer.valueOf(128);
        int t = i1; //相当于 i1.intValue() 拆箱
        System.out.println(t);
        */

        /*
        对于–128到127（默认是127）之间的值,被装箱后，会被放在内存里进行重用
        但是如果超出了这个值,系统会重新new 一个对象
        */
        Integer i1 = 200;
        Integer i2 = 200;

        /*
        注意 == 与 equals的区别
        == 它比较的是对象的地址
        equlas 比较的是对象的内容
        */
        if(i1==i2) {
            System.out.println("true");
        } else {
            System.out.println("false");
        }
    }
}

2.2 Math类

Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。

Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

public class Test {
    public static void main (String []args)
    {
        System.out.println("90 度的正弦值：" + Math.sin(Math.PI/2));
        System.out.println("0度的余弦值：" + Math.cos(0));
        System.out.println("60度的正切值：" + Math.tan(Math.PI/3));
        System.out.println("1的反正切值： " + Math.atan(1));
        System.out.println("π/2的角度值：" + Math.toDegrees(Math.PI/2));
        System.out.println(Math.PI);
    }
}

结果如下：

90 度的正弦值：1.0
0度的余弦值：1.0
60度的正切值：1.7320508075688767
1的反正切值： 0.7853981633974483
π/2的角度值：90.0
3.141592653589793

2.3 number和Math类的方法

1   xxxValue()
将 Number 对象转换为xxx数据类型的值并返回。
2   compareTo()
将number对象与参数比较。
3   equals()
判断number对象是否与参数相等。
4   valueOf()
返回一个 Number 对象指定的内置数据类型
5   toString()
以字符串形式返回值。
6   parseInt()
将字符串解析为int类型。
7   abs()
返回参数的绝对值。
8   ceil()
对整形变量向左取整，返回类型为double型。
9   floor()
对整型变量向右取整。返回类型为double类型。
10  rint()
返回与参数最接近的整数。返回类型为double。
11  round()
返回一个最接近的int、long型值。
12  min()
返回两个参数中的最小值。
13  max()
返回两个参数中的最大值。
14  exp()
返回自然数底数e的参数次方。
15  log()
返回参数的自然数底数的对数值。
16  pow()
返回第一个参数的第二个参数次方。
17  sqrt()
求参数的算术平方根。
18  sin()
求指定double类型参数的正弦值。
19  cos()
求指定double类型参数的余弦值。
20  tan()
求指定double类型参数的正切值。
21  asin()
求指定double类型参数的反正弦值。
22  acos()
求指定double类型参数的反余弦值。
23  atan()
求指定double类型参数的反正切值。
24  atan2()
将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。
25  toDegrees()
将参数转化为角度。
26  toRadians()
将角度转换为弧度。
27  random()
返回一个随机数。

举例

    /**
     * abs求绝对值
     */
    System.out.println(Math.abs(-10.4));    //10.4
    System.out.println(Math.abs(10.1));     //10.1  

    /**
     * ceil天花板的意思，就是返回大的值，注意一些特殊值
     */
    System.out.println(Math.ceil(-10.1));   //-10.0
    System.out.println(Math.ceil(10.7));    //11.0
    System.out.println(Math.ceil(-0.7));    //-0.0
    System.out.println(Math.ceil(0.0));     //0.0
    System.out.println(Math.ceil(-0.0));    //-0.0  

    /**
     * floor地板的意思，就是返回小的值
     */
    System.out.println(Math.floor(-10.1));  //-11.0
    System.out.println(Math.floor(10.7));   //10.0
    System.out.println(Math.floor(-0.7));   //-1.0
    System.out.println(Math.floor(0.0));    //0.0
    System.out.println(Math.floor(-0.0));   //-0.0  

    /**
     * max 两个中返回大的值,min和它相反，就不举例了
     */
    System.out.println(Math.max(-10.1, -10));   //-10.0
    System.out.println(Math.max(10.7, 10));     //10.7
    System.out.println(Math.max(0.0, -0.0));    //0.0  

    /**
     * random 取得一个大于或者等于0.0小于不等于1.0的随机数
     */
    System.out.println(Math.random());  //0.08417657924317234
    System.out.println(Math.random());  //0.43527904004403717  

    /**
     * rint 四舍五入，返回double值
     * 注意.5的时候会取偶数
     */
    System.out.println(Math.rint(10.1));    //10.0
    System.out.println(Math.rint(10.7));    //11.0
    System.out.println(Math.rint(11.5));    //12.0
    System.out.println(Math.rint(10.5));    //10.0
    System.out.println(Math.rint(10.51));   //11.0
    System.out.println(Math.rint(-10.5));   //-10.0
    System.out.println(Math.rint(-11.5));   //-12.0
    System.out.println(Math.rint(-10.51));  //-11.0
    System.out.println(Math.rint(-10.6));   //-11.0
    System.out.println(Math.rint(-10.2));   //-10.0  

    /**
     * round 四舍五入，float时返回int值，double时返回long值
     */
    System.out.println(Math.round(10.1));   //10
    System.out.println(Math.round(10.7));   //11
    System.out.println(Math.round(10.5));   //11
    System.out.println(Math.round(10.51));  //11
    System.out.println(Math.round(-10.5));  //-10
    System.out.println(Math.round(-10.51)); //-11
    System.out.println(Math.round(-10.6));  //-11
    System.out.println(Math.round(-10.2));  //-10

---

3. Character类

3.1 Character类的用法

Character 类用于对单个字符进行操作。

Character 类在对象中包装一个基本类型 char 的值

// 单个字符
char ch = 'a';

// Unicode 字符表示形式
char uniChar = '\u039A'; 

// 字符数组
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };

// 包装类 Character
Character ch = new Character('a');

在某些情况下，Java编译器会自动创建一个Character对象。

例如，将一个char类型的参数传递给需要一个Character类型参数的方法时，那么编译器会自动地将char类型参数转换为Character对象。 这种特征称为装箱，反过来称为拆箱。

public static void main(String[] args) {
    // 原始字符 'a' 装箱到 Character 对象 character 中
    Character character = 'a';
    // 原始字符 'x' 用 test 方法装箱
    // 返回拆箱的值到 ch
    char ch = test('x');
}
public static char test(Character c) {
    return c;
}

3.2 转义序列

前面有反斜杠（\）的字符代表转义字符，它对编译器来说是有特殊含义的。

\t  在文中该处插入一个tab键
\b  在文中该处插入一个后退键
\n  在文中该处换行
\r  在文中该处插入回车
\f  在文中该处插入换页符
\'  在文中该处插入单引号
\"  在文中该处插入双引号
\\  在文中该处插入反斜杠

3.3 Character类的方法

1   isLetter()  是否是一个字母
2   isDigit()   是否是一个数字字符
3   isWhitespace()  是否是一个空格
4   isUpperCase()   是否是大写字母
5   isLowerCase()   是否是小写字母
6   toUpperCase()   指定字母的大写形式
7   toLowerCase()   指定字母的小写形式
8   toString()  返回字符的字符串形式，字符串的长度仅为1

---

4. String类

字符串广泛应用 在Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。

4.1 创建字符串

创建字符串最简单的方式如下:

String greeting = "睿峰科技";

在代码中遇到字符串常量时，这里的值是 "睿峰科技""，编译器会使用该值创建一个 String 对象。 和其它对象一样，可以使用关键字和构造方法来创建 String 对象。 String 类有 11 种构造方法，这些方法提供不同的参数来初始化字符串，比如提供一个字符数组参数:

public class StringDemo{
   public static void main(String args[]){
      char[] nameArray = { 'r', 'i', 'm', 'i'};
      String nameString = new String(nameArray);
      System.out.println(nameString);
   }
}

注意:String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了。

如果需要对字符串做很多修改，那么应该选择使用 StringBuffer & StringBuilder 类。

String 类是不可改变的解析，例如：

String s = "Google";
System.out.println("s = " + s);

s = "Rimi";
System.out.println("s = " + s);

结果为：

Google
Rimi

从结果上看是改变了，但为什么门说String对象是不可变的呢？

原因在于实例中的 s 只是一个 String 对象的引用，并不是对象本身，当执行 s = "Rimi"; 创建了一个新的对象 "Rimi"，而原来的 "Google" 还存在于内存中。

4.2 字符串长度

用于获取有关对象的信息的方法称为访问器方法。

String 类的一个访问器方法是 length() 方法，它返回字符串对象包含的字符数。

public class StringDemo {
    public static void main(String args[]) {
        String site = "www.rimiedu.com";
        int len = site.length();
        System.out.println( "睿峰教育网址长度 : " + len );
   }
}

4.3 连接字符串

String 类提供了连接两个字符串的方法：

string1.concat(string2);

更常用的是使用'+'操作符来连接字符串，如：

"Hello," + " rimi" + "!"

4.4 常用String类方法

1.字符串比较

compareTo
compareToIgnoreCase(//忽略大小写)

2.查找字符串最后一次出现的位置

lastIndexOf

3.截取字符串出现

substring

4.字符串替换

replace
replaceFirst
replaceAll

5.字符串反转

StringBuffer

6.字符串查找

indexOf

7.字符串分割

split

8.字符串小写转大写

toUpperCase

9.测试两个字符串区域是否相等

//参数说明：自己的起始位置，比较的 String, 比较的 String 的起始位置，比较长度。
regionMatches(11, second_str, 12, 9);
regionMatches(true, 11, second_str, 12, 9); //第一个参数 true 表示忽略大小写区别

10.字符串性能比较测试

System.currentTimeMillis(); //利用获取时间戳进行比较
//第一种创建形式
String s1 = "hello";
//第二种创建形式
String s2 = new String("hello");

11.字符串优化

1. 直接使用字符串
     String str  = "123";
     String str1 = "123";
2. 使用 new 关键字
     String str2 = new String("123");

字符串优化处理

12.连接字符串

字符串连接 - 使用 + 操作符

字符串连接 - 使用 StringBuffer/StringBuilder

StringBuffer
代码示例：
   StringBuilder sb = new StringBuilder ( "" );
        for ( int i= 0 ;i< 10 ;i++){
               sb.append(String.valueOf(i));
               System.out.println(sb+",");
               }

---

5. StringBuffer/StringBuilder类

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。

由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

public class Test{
  public static void main(String args[]){
    StringBuffer sBuffer = new StringBuffer("睿峰官网：");
    sBuffer.append("www");
    sBuffer.append(".rimi");
    sBuffer.append(".com");
    System.out.println(sBuffer);
  }
}

StringBuffer方法：

1   public StringBuffer append(String s)    将指定的字符串追加到此字符序列。
2   public StringBuffer reverse()    将此字符序列用其反转形式取代。
3   public delete(int start, int end)   移除此序列的子字符串中的字符。
4   public insert(int offset, int i)    将 int 参数的字符串表示形式插入此序列中。
5   replace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。

Java 中 StringBuffer 和 String 是有一定的区别的

首先，String 是被 final 修饰的，他的长度是不可变的，就算调用 String 的 concat 方法，那也是把字符串拼接起来并重新创建一个对象，把拼接后的 String 的值赋给新创建的对象，

而 StringBuffer 的长度是可变的，调用StringBuffer 的 append 方法，来改变 StringBuffer 的长度，并且，相比较于 StringBuffer，String 一旦发生长度变化，是非常耗费内存的！

---

5. 数组类

java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

具有以下功能：

• 给数组赋值：通过 fill 方法。
• 对数组排序：通过 sort 方法,按升序。
• 比较数组：通过 equals 方法比较数组中元素值是否相等。
• 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

常用方法：

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

---

6. 时间日期

java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象。

第一个构造函数使用当前日期和时间来初始化对象。

Date( )

第二个构造函数接收一个参数，该参数是从1970年1月1日起的毫秒数。

Date(long millisec)

6.1 常用Date方法

1   boolean after(Date date)
若当调用此方法的Date对象在指定日期之后返回true,否则返回false。
2   boolean before(Date date)
若当调用此方法的Date对象在指定日期之前返回true,否则返回false。
3   Object clone( )
返回此对象的副本。
4   int compareTo(Date date)
比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。
5   int compareTo(Object obj)
若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。
6   boolean equals(Object date)
当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。
7   long getTime( )
返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
8   int hashCode( )
 返回此对象的哈希码值。
9   void setTime(long time)
用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
10  String toString( )
转换Date对象为String表示形式，并返回该字符串。

6.2 获取当前时间

Java中获取当前日期和时间很简单，使用 Date 对象的 toString() 方法来打印当前日期和时间

import java.util.Date;

public class DateDemo {
   public static void main(String args[]) {
       // 初始化 Date 对象
       Date date = new Date();

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

6.3 日期比较

Java使用以下三种方法来比较两个日期：

• 使用 getTime() 方法获取两个日期（自1970年1月1日经历的毫秒数值），然后比较这两个值。
• 使用方法 before()，after() 和 equals()。例如，一个月的12号比18号早，则 new Date(99, 2, 12).before(new Date (99, 2, 18)) 返回true。
• 使用 compareTo() 方法，它是由 Comparable 接口定义的，Date 类实现了这个接口。

6.4 使用 SimpleDateFormat 格式化日期

SimpleDateFormat 是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat 允许你选择任何用户自定义日期时间格式来运行

import java.util.*;
import java.text.*;

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

      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));
   }
}

这一行代码确立了转换的格式，其中 yyyy 是完整的公元年，MM 是月份，dd 是日期，HH:mm:ss 是时、分、秒。

注意:有的格式大写，有的格式小写，例如 MM 是月份，mm 是分；HH 是 24 小时制，而 hh 是 12 小时制。

6.5 日期和时间的格式化编码

时间模式字符串用来指定时间格式。在此模式中，所有的 ASCII 字母被保留为模式字母，定义如下：

G   纪元标记    AD
y   四位年份    2001
M   月份  July or 07
d   一个月的日期  10
h    A.M./P.M. (1~12)格式小时   12
H   一天中的小时 (0~23)   22
m   分钟数 30
s   秒数  55
S   毫秒数 234
E   星期几 Tuesday
D   一年中的日子  360
F   一个月中第几周的周几  2 (second Wed. in July)
w   一年中第几周  40
W   一个月中第几周 1
a   A.M./P.M. 标记    PM
k   一天中的小时(1~24)    24
K    A.M./P.M. (0~11)格式小时   10
z   时区  Eastern Standard Time
'   文字定界符   Delimiter
"   单引号 `

6.6 测量时间

System.currentTimeMillis(); //获取当前时间戳

import java.util.*;

public class DiffDemo {

   public static void main(String args[]) {
      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!");
      }
   }
}

---

6.7 Calendar类

我们现在已经能够格式化并创建一个日期对象了，但是我们如何才能设置和获取日期数据的特定部分呢，比如说小时，日，或者分钟? 我们又如何在日期的这些部分加上或者减去值呢? 答案是使用Calendar 类。

Calendar类的功能要比Date类强大很多，而且在实现方式上也比Date类要复杂一些。

Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。

6.7.1 创建Calendar类对象

1. 创建一个代表系统当前日期的Calendar对象

   Calendar c = Calendar.getInstance();//默认是当前日期

2. 创建一个指定日期的Calendar对象

   使用Calendar类代表特定的时间，需要首先创建一个Calendar的对象，然后再设定该对象中的年月日参数来完成。

   //创建一个代表2009年6月12日的Calendar对象
   Calendar c1 = Calendar.getInstance();
   c1.set(2009, 6 - 1, 12);
   

6.7.2 Calendar类对象字段

Calendar类中用一下这些常量表示不同的意义，jdk内的很多类其实都是采用的这种思想

Calendar.YEAR   年份
Calendar.MONTH  月份
Calendar.DATE   日期
Calendar.DAY_OF_MONTH   日期，和上面的字段意义完全相同
Calendar.HOUR   12小时制的小时
Calendar.HOUR_OF_DAY    24小时制的小时
Calendar.MINUTE 分钟
Calendar.SECOND 秒
Calendar.DAY_OF_WEEK    星期几

6.7.3 Calendar类对象的获取

Calendar c1 = Calendar.getInstance();
// 获得年份
int year = c1.get(Calendar.YEAR);
// 获得月份
int month = c1.get(Calendar.MONTH) + 1;
// 获得日期
int date = 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);

*:first-child {
margin-top: 0 !important;
}

body>*:last-child {
margin-bottom: 0 !important;
}

/* BLOCKS
=============================================================================*/

p, blockquote, ul, ol, dl, table, pre {
margin: 15px 0;
}

/* HEADERS
=============================================================================*/

h1, h2, h3, h4, h5, h6 {
margin: 20px 0 10px;
padding: 0;
font-weight: bold;
-webkit-font-smoothing: antialiased;
}

h1 tt, h1 code, h2 tt, h2 code, h3 tt, h3 code, h4 tt, h4 code, h5 tt, h5 code, h6 tt, h6 code {
font-size: inherit;
}

h1 {
font-size: 28px;
color: #000;
}

h2 {
font-size: 24px;
border-bottom: 1px solid #ccc;
color: #000;
}

h3 {
font-size: 18px;
}

h4 {
font-size: 16px;
}

h5 {
font-size: 14px;
}

h6 {
color: #777;
font-size: 14px;
}

body>h2:first-child, body>h1:first-child, body>h1:first-child+h2, body>h3:first-child, body>h4:first-child, body>h5:first-child, body>h6:first-child {
margin-top: 0;
padding-top: 0;
}

a:first-child h1, a:first-child h2, a:first-child h3, a:first-child h4, a:first-child h5, a:first-child h6 {
margin-top: 0;
padding-top: 0;
}

h1+p, h2+p, h3+p, h4+p, h5+p, h6+p {
margin-top: 10px;
}

/* LINKS
=============================================================================*/

a {
color: #4183C4;
text-decoration: none;
}

a:hover {
text-decoration: underline;
}

/* LISTS
=============================================================================*/

ul, ol {
padding-left: 30px;
}

ul li > :first-child,
ol li > :first-child,
ul li ul:first-of-type,
ol li ol:first-of-type,
ul li ol:first-of-type,
ol li ul:first-of-type {
margin-top: 0px;
}

ul ul, ul ol, ol ol, ol ul {
margin-bottom: 0;
}

dl {
padding: 0;
}

dl dt {
font-size: 14px;
font-weight: bold;
font-style: italic;
padding: 0;
margin: 15px 0 5px;
}

dl dt:first-child {
padding: 0;
}

dl dt>:first-child {
margin-top: 0px;
}

dl dt>:last-child {
margin-bottom: 0px;
}

dl dd {
margin: 0 0 15px;
padding: 0 15px;
}

dl dd>:first-child {
margin-top: 0px;
}

dl dd>:last-child {
margin-bottom: 0px;
}

/* CODE
=============================================================================*/

pre, code, tt {
font-size: 12px;
font-family: Consolas, "Liberation Mono", Courier, monospace;
}

code, tt {
margin: 0 0px;
padding: 0px 0px;
white-space: nowrap;
border: 1px solid #eaeaea;
background-color: #f8f8f8;
border-radius: 3px;
}

pre>code {
margin: 0;
padding: 0;
white-space: pre;
border: none;
background: transparent;
}

pre {
background-color: #f8f8f8;
border: 1px solid #ccc;
font-size: 13px;
line-height: 19px;
overflow: auto;
padding: 6px 10px;
border-radius: 3px;
}

pre code, pre tt {
background-color: transparent;
border: none;
}

kbd {
-moz-border-bottom-colors: none;
-moz-border-left-colors: none;
-moz-border-right-colors: none;
-moz-border-top-colors: none;
background-color: #DDDDDD;
background-image: linear-gradient(#F1F1F1, #DDDDDD);
background-repeat: repeat-x;
border-color: #DDDDDD #CCCCCC #CCCCCC #DDDDDD;
border-image: none;
border-radius: 2px 2px 2px 2px;
border-style: solid;
border-width: 1px;
font-family: "Helvetica Neue",Helvetica,Arial,sans-serif;
line-height: 10px;
padding: 1px 4px;
}

/* QUOTES
=============================================================================*/

blockquote {
border-left: 4px solid #DDD;
padding: 0 15px;
color: #777;
}

blockquote>:first-child {
margin-top: 0px;
}

blockquote>:last-child {
margin-bottom: 0px;
}

/* HORIZONTAL RULES
=============================================================================*/

hr {
clear: both;
margin: 15px 0;
height: 0px;
overflow: hidden;
border: none;
background: transparent;
border-bottom: 4px solid #ddd;
padding: 0;
}

/* TABLES
=============================================================================*/

table th {
font-weight: bold;
}

table th, table td {
border: 1px solid #ccc;
padding: 6px 13px;
}

table tr {
border-top: 1px solid #ccc;
background-color: #fff;
}

table tr:nth-child(2n) {
background-color: #f8f8f8;
}

/* IMAGES
=============================================================================*/

img {
max-width: 100%
}
-->