Java常用类总结和异常的分类

一,Arrays工具类的使用

Arrays.toString(a);  帮助我们打印数组a的内容 
Arrays.sort(a);      排序
Arrays.binarySearch(a,30); 在a数组中查找30的索引，不存在返回-1

二，多维数组

int[][]  a=new int[3][];   //数组a在栈内存存a的首地址，指向堆内存中数据的地址，数据的地址指向堆内存中数据

三，数组存储表格数据

Object[] a={2019001,"李静"，"女"} ； //编译器会自动把基本数据类型包装成对象放入object
Object[] b={2019002,"小明"，"未知"} ；
Object[][] tableData = new  Object[2][];
tableData[0]= a;
tableData[0]= b;

四，冒泡排序（比较大小换顺序）
五，二分法查找

public class TestArrays {                 //返回要查找的值的索引
    public static void main(String[] args){
        int[] a={100, 20, 30,45,60};
        Arrays.sort(a);
        int value=100;//要查找的值

        System.out.println(MbinarySearch(a,value));
    }
      public  static  int MbinarySearch(int[] a,int value) {
            int low = 0;
            int high = a.length - 1;
            while (low <= high) {
                int mid = (low + high) / 2;
                if (value == a[mid]) return mid;
                else if (value > a[mid]) low = mid + 1;
                else high = mid - 1;
            }
            return -1;
        }
}

六，包装类
基本数据类型不是对象，也就是使用int、double、boolean等定义的变量、常量。基本数据类型没有可调用的方法。

基本数据类型                  包装类
byte
boolean
short
char                       Character
int                        Integer
long
float
double

//Integer类的使用，其他类似
//基本数据类型转换成包装对象
integer a= new integer(3);
integer b= integer.valueOf(30);
//包装类对象转换成基本数据类型
int c=b.intValue();
double d=b.doubleValue();
//在进行运算时，也可以进行拆箱
Integer i = 10;
System.out.println(i++);
//把字符串转换成包装类对象
integer a=new integer(“9999”）
//包装类对象转换为字符串
string b=a.toString();//""+a

七，自动装箱和拆箱

//Java中基础数据类型与它们的包装类进行运算时，编译器会自动帮我们进行转换，转换过程对程序员是透明的，这就是装箱和拆箱，装箱和拆箱可以让我们的代码更简洁易懂
//创建缓存了[-128,127]之间的数字的数组，当我们调用Valueof()时检查大小，如果不在范围内则创建新的integer对象
 Integer a=234;//自动装箱 编译器integer a= integer.valueOf(234);
 int b=a;  //自动拆箱 编译器 int b=a.intValue(); 

八，String类

string是不可变字符序列   其核心数组被final修饰
比较用equals
StringBuilder（线程不安全效率高，一般用它）,StringBuffer（线程安全，效率低）都是可变字符序列

九，StringBuilder和StringBuffer用法 //可变字符序列

public static void main(String[] args){
       StringBuilder sb=new StringBuilder();            //循环累加字符串避免使用string造成程序崩溃
       for(int i=0;i<26;i++) {
            char temp =(char)('a'+i);
           sb.append(temp);                          //给数组后继续累加字符序列
       }
        System.out.println(sb);
    }

十，Data时间类

 public static void main(String[] args){
        Date a = new Date();      //获得当前时间
        System.out.println(a);
    }
    
 long now= System.currentTimeMillis();//获得当前时刻毫秒数 ，“时刻数值”

十一，DateFormat抽象类和SimpleDateFormat实现类的使用

      public static void main(String[] args) throws ParseException {
      //把对象按照“格式字符串指定的格式”转成相应的字符串
        DateFormat df = new SimpleDateFormat("yyyy-mm-dd hh:mm:ss");//抽象类不能被new
        String str = df.format(new Date(40000000));
        System.out.println(str);

        //把字符串按照“格式字符串指定的格式”转成相应的时间对象
        DateFormat df2 = new SimpleDateFormat("yyyy年mm月dd日 hh时mm分ss秒");
        Date date = df2.parse("1983年05月10日 10时35分23秒");
        System.out.println(date);
       }      
        运行结果：1970-06-01 07:06:40  
                 Mon Jan 10 10:35:23 CST 1983

十二，Calenda（抽象类）和GregorianCalendar的使用

public static void main(String[] args) throws ParseException {
        //获得日期的相关元素
        Calendar calendar = new GregorianCalendar(2999,10,9,22,10,50);
        int month = calendar.get(Calendar.YEAR);
        int weekday= calendar.get(Calendar.DAY_OF_WEEK);//星期几
        System.out.println(month);//0-11对应月份
        System.out.println(weekday);

        //设置日期的相关元素
        Calendar c2 = new GregorianCalendar();
        c2.set(Calendar.YEAR,8012);
        System.out.println(c2);

        //日期的计算
        Calendar  c3 = new GregorianCalendar();
        c3.add(Calendar.DATE,100);
        System.out.println(c3);

        //日期对象和时间对象的转化
        Date d4= c3.getTime();
        Calendar  c4 = new GregorianCalendar();
        c4.setTime(new Date());
        System.out.println(c4);
    }

十三，可视化日历程序

public class TestCalendar {
 public  static void main(String[] args) throws ParseException {
     System.out.println("请输入日期（格式：2019-9-11）");
     Scanner scanner = new Scanner(System.in);   
     String str = scanner.nextLine();
        
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd");//格式字符串
        Date date = df.parse(str);//生成时间对象
        Calendar c= new GregorianCalendar();
        c.setTime(date);
       int day =c.get(Calendar.DAY_OF_MONTH);
       int days=c.getActualMaximum(Calendar.DATE);

        System.out.println("日\t一\t二\t三\t四\t五\t六");
        c.set(Calendar.DAY_OF_MONTH,1);

        for(int i=0;i<c.get(Calendar.DAY_OF_WEEK)-1;i++){
            System.out.print("\t");
        }

        for(int i=1;i<=days;i++){
            if(day == c.get(Calendar.DAY_OF_MONTH)){
                System.out.print(c.get(Calendar.DAY_OF_MONTH)+"*\t");
            }
            else   System.out.print(c.get(Calendar.DAY_OF_MONTH)+"\t");

            if(c.get(Calendar.DAY_OF_WEEK)==Calendar.SATURDAY){
                System.out.println();
            }
            c.add(Calendar.DAY_OF_MONTH,1);
        }
   }
}

十四，函数math,random常用方法
Math类的常用方法：
1. abs 绝对值
2. acos,asin,atan,cos,sin,tan 三角函数
3. sqrt 平方根
4. pow(double a, double b) a的b次幂
5. max(double a, double b) 取大值
6. min(double a, double b) 取小值
7. ceil(double a) 大于a的最小整数
8. floor(double a) 小于a的最大整数
9. random() 返回 0.0 到 1.0 的随机数
10. long round(double a) double型的数据a转换为long型(四舍五入)
11. toDegrees(double angrad) 弧度->角度
12. toRadians(double angdeg) 角度->弧度

RANDOM类的常用方法：

public class TestRandom {
    public static void main(String[] args) {
        Random rand = new Random();
        //随机生成[0,1)之间的double类型的数据
        System.out.println(rand.nextDouble());
        //随机生成int类型允许范围之内的整型数据
        System.out.println(rand.nextInt());
        //随机生成[0,1)之间的float类型的数据
        System.out.println(rand.nextFloat());
        //随机生成false或者true
        System.out.println(rand.nextBoolean());
        //随机生成[0,10)之间的int类型的数据
        System.out.print(rand.nextInt(10));
        //随机生成[20,30)之间的int类型的数据
        System.out.print(20 + rand.nextInt(10));
        //随机生成[20,30)之间的int类型的数据（此种方法计算较为复杂）
        System.out.print(20 + (int) (rand.nextDouble() * 10));
    }

十五、File类
1、File类的常见构造方法：public File(String pathname)
以pathname为路径创建File对象，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储
注意：构造函数只是创建一个File实例，并没有以文件做读取等操作，因此路径即使是错误的，也可以创建实例不报错
2、通过File对象可以访问文件的属性：

public class TestFile2 {
    public static void main(String[] args) throws Exception {
        File f = new File("d:/b.txt");
        System.out.println("File是否存在："+f.exists());
        System.out.println("File是否是目录："+f.isDirectory());
        System.out.println("File是否是文件："+f.isFile());
        System.out.println("File最后修改时间："+new Date(f.lastModified()));
        System.out.println("File的大小："+f.length());
        System.out.println("File的文件名："+f.getName());
        System.out.println("File的目录路径："+f.getPath());
    }
}

可参考CSDN File类
十六、枚举
（所有的枚举类型隐性地继承自 java.lang.Enum。枚举实质上还是类!而每个被枚举的成员实质就是一个枚举类型的实例，他们默认都是public static final修饰的。可以直接通过枚举类型名使用它们。）
枚举类型的定义包括枚举声明和枚举体格式如下：

enum  枚举名 {
      枚举体（常量列表）
}

枚举的使用

import java.util.Random;
public class TestEnum {
    public static void main(String[] args) {
        // 枚举遍历
        for (Week k : Week.values()) {
            System.out.println(k);
        }
        // switch语句中使用枚举
        int a = new Random().nextInt(4); // 生成0，1，2，3的随机数
        switch (Season.values()[a]) {
        case SPRING:
            System.out.println("春天");
            break;
        case SUMMER:
            System.out.println("夏天");
            break;
        case AUTUMN:
            System.out.println("秋天");
            break;
        case WINDTER:
            System.out.println("冬天");
            break;
        }
    }
}
/**季节*/
enum Season {
    SPRING, SUMMER, AUTUMN, WINDTER
}
/**星期*/
enum Week {
    星期一, 星期二, 星期三, 星期四, 星期五, 星期六, 星期日
}

十七、异常机制（搬）
1、简介
程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常。 异常发生时，是任程序自生自灭，立刻退出终止，还是输出错误给用户？或者用C语言风格：用函数返回值作为执行状态？。

Java提供了更加优秀的解决办法：异常处理机制。

2、Java异常的分类和类结构图
Java标准裤内建了一些通用的异常，这些类以Throwable为顶层父类。

Throwable又派生出Error类和Exception类。

错误：Error类以及他的子类的实例，代表了JVM本身的错误。错误不能被程序员通过代码处理，Error很少出现。因此，程序员应该关注Exception为父类的分支下的各种异常类。

异常：Exception以及他的子类，代表程序运行时发送的各种不期望发生的事件。可以被Java异常处理机制使用，是异常处理的核心。

总体上我们根据Javac对异常的处理要求，将异常类分为2类。

非检查异常（unckecked exception）：Error 和 RuntimeException 以及他们的子类。javac在编译时，不会提示和发现这样的异常，不要求在程序处理这些异常。所以如果愿意，我们可以编写代码处理（使用try…catch…finally）这样的异常，也可以不处理。对于这些异常，我们应该修正代码，而不是去通过异常处理器处理 。这样的异常发生的原因多半是代码写的有问题。如除0错误ArithmeticException，错误的强制类型转换错误ClassCastException，数组索引越界ArrayIndexOutOfBoundsException，使用了空对象NullPointerException等等。

检查异常（checked exception）：除了Error 和 RuntimeException的其它异常。javac强制要求程序员为这样的异常做预备处理工作（使用try…catch…finally或者throws）。在方法中要么用try-catch语句捕获它并处理，要么用throws子句声明抛出它，否则编译不会通过。这样的异常一般是由程序的运行环境导致的。因为程序可能被运行在各种未知的环境下，而程序员无法干预用户如何使用他编写的程序，于是程序员就应该为这样的异常时刻准备着。 如SQLException , IOException,ClassNotFoundException 等。

需要明确的是：检查和非检查是对于javac来说的，这样就很好理解和区分了。