实用类

枚举

jdk5.1开始引入了一种新的类型，枚举。是由一组固定的常量组成的类型，使用enum关键自定义。
语法：

访问修饰符 enum 枚举名{
    常量1[,常量2...[;]//必须以;结尾
    //其他成员(包括构造方法必须位于枚举常量后面）
}

public enum Test {
    Male,Female;//必须要加;
}

应用：

public class WeekDemo {
    public enum Week {
        MON,TUE,WED,THU,FRI,SAT,SUN;    
    }
    public void doWhat(Week day){
        switch (day){
        case MON:
        case TUE:
        case WED:
        case THU:
        case FRI:
            System.out.println("今天周五！");
            break;
        case SAT:
            System.out.println("今天周六！");
            break;
        case SUN:
            System.out.println("今天周日！");
            break;
        default:System.out.println("输入有误");
        }   
    }
    public static void main(String[] args) {
        WeekDemo wd=new WeekDemo();
        wd.doWhat(Week.FRI);//结果输出：今天周五！
        Week sun=Week.SUN;//另一种赋值方式
        wd.doWhat(sun);//结果输出：今天周日！
    }
}

优点：1使得代码更容易维护，有助于确保为变量指定合法的期望的值（必须指定枚举里的常量，否则报错）2更易输入，只需要输入枚举名.常量值即可3.代码更清晰，允许使用描述性的名称表示数据，使用时直观方便。

---

包装类

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)，有些地方也翻译为外覆类或数据类型类。

包装类均位于java.lang包，包装类和基本数据类型的对应关系如下表所示：

注意：char和Character，其他类型的包装类都是直接首字母大写。String不是基本数据类型。

记忆：

对于包装类说，这些类的用途主要包含两种：
a、作为和基本数据类型对应的类类型存在，方便涉及到对象的操作。
b、包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。

为什么要用到包装类：
Java是一个面相对象的编程语言，基本类型并不具有对象的性质，为了让基本类型也具有对象的特征，就出现了包装类型（如我们在使用集合类型Collection时就一定要使用包装类型而非基本类型），它相当于将基本类型“包装起来”，使得它具有了对象的性质，并且为其添加了属性和方法，丰富了基本类型的操作。

public class Test {

    public static void main(String[] args) {
        int a=0;
        String b=a;//错误，不能强转
        Integer i=0;
        String s=i.toString();//可以通过Integer独有的toString来转换
    }

}

包装类有三个作用：一个实现基本类型之间的转换 ，二是便于函数传值 ，三就是在一些地方要用到Object的时候方便将基本数据类型装换。

注意：基本数据类型不存在null值，一经初始化，就被赋予另外的默认值. 但包装类是存在null值的，只做初始化而不赋值，那它就是个null。例如int默认值0，Integer默认值是null。

JDK1.5版本后不需要编码实现基本数据类型和包装类之间的转换，编译器会自动完成。

Integer i=9;
int a=i;

---

Math类常用方法

public class Main {  

    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        System.out.println(Math.E);//比任何其他值都更接近 e（即自然对数的底数）的 double 值。  
        System.out.println(Math.PI);//比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值。  
        /* 
         * 1.abs绝对值函数 
         * 对各种数据类型求绝对值 
         */  
        System.out.println(Math.abs(-10));//输出10  

        /* 
         * 2.三角函数与反三角函数 
         * cos求余弦 
         * sin求正弦 
         * tan求正切 
         * acos求反余弦 
         * asin求反正弦 
         * atan求反正切 
         * atan2(y,x)求向量(x,y)与x轴夹角 
         */  
        System.out.println(Math.acos(-1.0));//输出圆周率3.14...  
        System.out.println(Math.atan2(1.0, 1.0));//输出 π/4 的小数值  

        /* 
         * 3.开根号 
         * cbrt(x)开立方 
         * sqrt(x)开平方 
         * hypot(x,y)求sqrt(x*x+y*y)在求两点间距离时有用sqrt((x1-x2)^2+(y1-y2)^2) 
         */  
        System.out.println(Math.sqrt(4.0));//输出2.0  
        System.out.println(Math.cbrt(8.0));//输出2.0  
        System.out.println(Math.hypot(3.0, 4.0));//输出5.0  

        /* 
         * 4.最值 
         * max(a,b)求最大值 
         * min(a,b)求最小值 
         */  
        System.out.println(Math.max(1, 2));//输出2  
        System.out.println(Math.min(1.9, -0.2));//输出-0.2  
        /* 
         * 5.对数 
         * log(a) a的自然对数(底数是e) 
         * log10(a) a 的底数为10的对数 
         * log1p(a) a+1的自然对数 
         * 值得注意的是，前面其他函数都有重载，对数运算的函数只能传double型数据并返回double型数据 
         */  
        System.out.println(Math.log(Math.E));//输出1.0  
        System.out.println(Math.log10(10));//输出1.0  
        System.out.println(Math.log1p(Math.E-1.0));//输出1.0  
        /* 
         * 6.幂 
         * exp(x) 返回e^x的值 
         * expm1(x) 返回e^x - 1的值 
         * pow(x,y) 返回x^y的值 
         * 这里可用的数据类型也只有double型 
         */  
        System.out.println(Math.exp(2));//输出E^2的值  
        System.out.println(Math.pow(2.0, 3.0));//输出8.0  

        /* 
         * 7.随机数 
         * random()返回[0.0,1.0)之间的double值 
         * 这个产生的随机数其实可以通过*x控制 
         * 比如(int)(random*100)后可以得到[0,100)之间的整数 
         */  
        System.out.println((int)(Math.random()*100));//输出[0,100)间的随机数  

        /* 
         * 8.转换 
         * toDegrees(a) 弧度换角度 
         * toRadians(a) 角度换弧度 
         */  
        System.out.println(Math.toDegrees(Math.PI));//输出180.0  
        System.out.println(Math.toRadians(180));//输出 π 的值  
        /* 
         * 9.其他 
         */  

        //copySign(x,y) 返回 用y的符号取代x的符号后新的x值  
        System.out.println(Math.copySign(-1.0, 2.0));//输出1.0  
        System.out.println(Math.copySign(2.0, -1.0));//输出-2.0  

        //ceil(a) 返回大于a的第一个整数所对应的浮点数(值是整的，类型是浮点型)  
        //可以通过强制转换将类型换成整型  
        System.out.println(Math.ceil(1.3443));//输出2.0  
        System.out.println((int)Math.ceil(1.3443));//输出2  

        //floor(a) 返回小于a的第一个整数所对应的浮点数(值是整的，类型是浮点型)  
        System.out.println(Math.floor(1.3443));//输出1.0  

        //rint(a) 返回最接近a的整数的double值  
        System.out.println(Math.rint(1.2));//输出1.0  
        System.out.println(Math.rint(1.8));//输出2.0  


        //nextAfter(a,b) 返回(a,b)或(b,a)间与a相邻的浮点数 b可以比a小  
        System.out.println(Math.nextAfter(1.2, 2.7));//输出1.2000000000000002  
        System.out.println(Math.nextAfter(1.2, -1));//输出1.1999999999999997    
        //所以这里的b是控制条件  

        //nextUp(a) 返回比a大一点点的浮点数  
        System.out.println(Math.nextUp(1.2));//输出1.2000000000000002  

        //nextDown(a) 返回比a小一点点的浮点数  
        System.out.println(Math.nextDown(1.2));//输出1.1999999999999997     
    }  
}  

常用方法：
1.Math.abs(double a)返回绝对值
2.Math.max(double a,double b)返回最大值
3.Math.random()返回一个double值，范围在[0.0,1.0]之间。

---

String类方法

public class Main {  

    public static void main(String[] args) {  
       String a="ssde到底";
       System.out.println(a.length());//获取字符串长度：6
       //==和equals判断相等的比较
       //==判断的是两个对象在内存中的地址，也就是判断是否是同一个对象，equals判断的是两个对象的值是否一致。
       //==与equals的主要区别是：==常用于比较原生类型，而equals()方法用于检查对象的相等性。
       String b=new String("hh");
       String c=new String("hh");
       if(b==c){
           System.out.println("==判断有效");
       }
       else{
           System.out.println("==判断无效");//地址不同，故b==c不成立
       }
       if(b.equals(c)){
           System.out.println("equals判断有效");
       }
       else{
           System.out.println("equals判断无效");//值相同，故b.equals(c)成立
       }
       //没有使用new创建新的对象，此时两字符串的指向的地址和值都相同
       String d="s";
       String e="s";
       if(d==e){
           System.out.println("==判断有效");//输出
       }
       else{
           System.out.println("==判断无效");
       }
       if(d.equals(e)){
           System.out.println("equals判断有效");//输出
       }
       else{
           System.out.println("equals判断无效");
       }
       //忽略大小写 
       String f="KiM";
       if(f.equalsIgnoreCase("kim")){
           System.out.println("equalsIgnoreCase忽略大小写");
       }
        //大小写转换
       System.out.println("大写"+f.toUpperCase()+"小写"+f.toLowerCase());
       //字符串连接
       System.out.println(f.concat(a));
        //String的提取和查询
       String g="sde131回火";
       System.out.println("搜索第一个出现的字符int类型的ch（ascII码）或者String："+g.indexOf(100)+","+g.indexOf("回"));//-1表示不存在
       System.out.println("搜索最后一个出现的字符int类型的ch（ascII码）或者String:"+g.lastIndexOf("1"));
       System.out.println("提取从索引位置index开始的字符串:"+g.substring(3));//131回火
       System.out.println("提取从索引位置之间的字符串:"+g.substring(3,5));//13
       //返回一个前后不含任何空格的字符串副本(注意，中间的空格不能去除)
       String h=" sde131回     火    ";
       System.out.println(h);//" sde131回     火    "
       System.out.println(h.trim());//"sde131回     火"
       //字符串拆分
       String abc="a,b,c,e";
       String[] j=abc.split(",",3);//遇到,进行拆分,后面的数字3表示拆分次数,结果是字符串数组
       for(String t:j){
       System.out.println(t);//结果依次输出：a  b  c,e
       }
    }  
}  

---

StringBuffer类和StringBulider类

StringBuffer类:
比String类更高效的存储字符串的一种引用数据类型，特别是在对字符串进行操作时效率更高。

常用方法：

public class Main {  

    public static void main(String[] args) {  
       StringBuffer sb=new StringBuffer("abc");
       //转化成string类型
       String a=sb.toString();
       int b=3;
       sb.append(b);//append连接字符串，可以将任意类型的参数追加到字符串后，而String只能追加字符串
       System.out.println(sb);//abc3
        //insert(位置,参数)将参数插到字符串指定位置并返回，参数可以是包括String的任意类型
       sb.insert(1, 333);
       System.out.println(sb);//a333bc3
    }  
}  

StringBulider
是一个可变的字符序列，比StringBuffer更快，方法与StringBuffer基本一致。

String,StringBuffer,StringBuilder三者区别：
1.String是不可变对象，每次对String类型进行改变时都会生成一个新的String对象，所以经常改变内容的字符串最好不要用String类型，会对性能产生影响。
2.StringBuffer字符串变量：是可变的字符串，每次对StringBuffer对象进行改变时，是对对象本身进行操作，不生成新对象，所以经常改变内容的字符串用StringBuffer类型
3.StringBuilder字符串变量：和StringBuffer差不多，但是StringBuffer是线程安全的，StringBuilder是单线程的，不提供同步，所以理论上效率更高。

---

日期时间类

Date类：
表示日期和时间，提供了一系列操作日期和时间的各组成部分的方法。

public class Main {  

    public static void main(String[] args) {  
      Date date=new Date();//使用系统当前时间创建日期对象
       System.out.println(date);//Wed Nov 01 14:26:03 CST 2017
    }  
}  

Calendar类：
也是来操作日期和时间的类，看做Date增强版，通过静态方法getInstance()获得Calander对象。
还提供了一些静态方法和字段来操作日历：

public class Main { 
    public static void main(String[] args) {  
      Calendar cl=Calendar.getInstance();//获取当前Calendar对象
      //注意，月份+1，星期-1
      System.out.println("今天是"+cl.get(Calendar.YEAR)+"年"+(cl.get(Calendar.MONTH)+1)+"月"+cl.get(Calendar.DAY_OF_MONTH)+"日星期"+(cl.get(Calendar.DAY_OF_WEEK)-1));
    }  
}  

DateFormat:常用其子类SimpleDateFormat进行日期格式转换

public class Main {  

    public static void main(String[] args) {  
     Date date=new Date();
     SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//格式要正确
     System.out.print(sdf.format(date));
    }  
}  

public class Test {

    public static void main(String[] args) throws ParseException {        
             Date date=new Date();
             String time="1922-12-12";
             SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");//格式要正确
             System.out.println(sdf.parse(time));//sdf.parse(String str)将字符串转换为日期
             System.out.println(sdf.format(sdf.parse(time)));//再进行日期格式转换
            } 
}

---

Random类：
Random（）//创建一个新的随机数生成器
nextInt()//返回一个伪随机数
nextInt(i)返回一个在0（包括），i（不包括）之间的伪随机数

public class Main {  

    public static void main(String[] args) {  
     Random r=new Random();
     System.out.println(r.nextInt());
     System.out.println(r.nextInt(20));
    }  
}