6.常用API

    char c = '中';//单字符 多字节
    syso((int)c);       //20013
    syso("中".hashCode());   //20013
    syso(Arrays.toString(s.getBytes()));//GBK 2个元素的数组[-42, -48]  UTF8 3个元素的数组[-28, -72, -83]
​
    char c = 'a';//单字符 单字节
    syso((int)c);           //97
    syso("a".hashCode());   //97
    syso(Arrays.toString("a".getBytes()));//[97]
​
单字节单字符  
    //（数字 英文 英文标点符号）
字符串的哈希值             字符串的字节值                         字符的ASCII值       三者相同
"a".hashCode()          Arrays.toString("a".getBytes())     (int)'a'
                        //[97]
  
多字节单字符  
    //（一个汉字 一个中文标点符号）
字符串的哈希值             字符串的字节值                         字符的ASCII值
"中".hashCode()         Arrays.toString("中".getBytes()))    (int)'中'
    //20013             //[-42,-48]                         //20013
  
  
多字节多字符  以下为utf-8编码集
        String s2 = "中国";
        System.out.println(s2.hashCode());//642672
        System.out.println((int)'中');//20013
        System.out.println((int)'国');//22269
        System.out.println(Arrays.toString(s2.getBytes()));//[-28, -72, -83, -27, -101, -67]

String str = "ab";  
String str1 = "ab";
syso(str==str1) //true
  
  
String str = "a"+"b";
String str1 = "ab";
syso(str==str1);    //true
  
String str = new String("aa");
String str1 = str;  //共享地址
syso(str==str1);    //true
​
final String s = "a";
String str = s+"ab";        //如果时常量的连接  是纯粹的值拼接
String str1 = "aab";
syso(str==str1);    //true
​
​
​
//以下三种情况 有地址信息存在
String str = new String("ab");
String str1 = "ab";
syso(str==str1);    //false
​
String str = input.next();//输入一个b  有地址产生
String str1 = "b";
syso(str==str1);    //false
​
String s = "a";
String str = s+"ab";        //有变量的连接  有地址产生
String str1 = "aab";
syso(str==str1);    //false

    主要是进行字符串的数据分析，java对此作了相应的改进。
 *  | 需要转译符 \\|
 *  ( 需要转译符 \\( 
 *  a:表示匹配字母a
 *  \\匹配转义字符\
 *  \\t匹配转义字符\t
 *  \\n匹配转义字符\n
     *      \\*
   
 *  
 *  [a,b,c]                 可能是a 可能是b 可能是c
 *  [^a,b,c]                不是a,b,c中任意一个
 *  [a-z,A-Z]               全部子母中的任意一个
 *  [0-9]                   全部数字中的任意一个    
 *  (xxx|xx|xxx)            三选一
 *  
 *  .                       表示任意一位字符
 *  \d                      等同于.[0-9]
 *  \D                      等同于.[^0-9]
 *  \w                      .[a-zA-Z0-9]
 *  \W                      .[^a-zA-Z0-9]
 *  
 *  ?       0次或1次       {0,1}
 *  *       0次 1次 或多次   {0,}
 *  +       1次或多次       {1,}
 *  {n}     出现n次
 *  {n,}    n次以上
 *  {n,m}   n次到m次

//      String regex = "\\d{6,}";
//      String pwd = "123456678";
//      System.out.println(pwd.matches(regex));
​
        // 数字 字母(多个) @ 数字 字母（多个） . com con cn
        String regex1 = "[0-9,a-z,A-Z]+@[0-9,a-z,A-Z]+\\.(com|cn|con)";
        Strint regex2 = "\\w+@\\w+\\.(com|con|cn)";
        String s = "DFG@dfg.con";
        System.out.println(s.matches(regex1));
      
      
//      String r = "\\d{4}-\\d{7}";
//      String zj = "1234-1234567";
//      System.out.println(zj.matches(r));
​
1900-1999.1-12.1-30
​
//注意中括号和大括号之间的空格
String reg = "19[0-9][0-9]\\.([1-9]|1[0-2])\\.([1-9]|1[0-9]|2[0-9]|30)";
​
\\w+@\\w+\\.\\w+
邮箱  @ . 有且只有一个@ 和. @在.前面 不能以.结尾   例如   safWE1324@aFSdH23f.sdfRW123

        Date d1 = new Date();
      
        int year = d1.getYear();
        int month = d1.getMonth();
        int date = d1.getDate();
        int hours = d1.getHours();
        int minutes = d1.getMinutes();
        int seconds = d1.getSeconds();
      
        int day = d1.getDay();
        System.out.println((year+1900)+"年"+(month+1)+"月"+date+"日"+" "+hours+":"+minutes+":"+seconds+" 星期"+day);
  
        //1.设定标准
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss 周u");
      
        //2.使用标准
        String format = sdf.format(d1);
        System.out.println(format);
​
        //2.准备字符串
        String str = "1999-4-3 17:22:15 周3";//ParseException
      
        //3.调用方法 转回Date类型
        Date d2 = sdf.parse(str);   //该方法需要抛出一个ParseException异常
        System.out.println(d2);

        LocalDate ld = LocalDate.now();// 获取对象
      
        ld = ld.of(1999, 5, 12);
        System.out.println(ld);
​
        System.out.println(ld.getDayOfMonth());
        System.out.println(ld.getMonthValue());
        System.out.println(ld.getYear());
​
        LocalTime lt = LocalTime.now();
        lt = lt.of(20, 22, 12);
        System.out.println(lt);
​
​
        //Date使用的是  SimpleDateFormat 格式.format(Date日期)
        DateTimeFormatter dtf1 = DateTimeFormatter.ofPattern("HH时mm分ss秒");
        String times = lt.format(dtf1); //时间对象.方法（格式作为参数）
        System.out.println(times);
​
      
//      System.out.println();
//      // 将LocalDate对象 转为字符串
//      // 1.定义格式
//      DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 E");
//      // 2.使用格式 
//      String str = ld.format(dtf);
//      System.out.println(str);
              
        System.out.println();
        String str1 = "1997-07-01";// 必须4位 2位 2位 只能-//DateTimeParseException
        LocalDate newld = LocalDate.parse(str1); // 不是用定义的规则 直接通过本类静态方法
        System.out.println(newld);
​
        String str2 = "20:07:18";   //2位:2位:2位
        LocalTime lt1 = LocalTime.parse(str2);
        System.out.println(lt1);
​
        String s3 = "2020-01-20T08:19:22";
        LocalDateTime ldt1 = LocalDateTime.parse(s3);
        System.out.println(ldt1);

        double num = Math.random();
      
        System.out.println(num);
      
        int l = (int)(num*10);
        System.out.println(l/3);
      
        System.out.println(Math.ceil(-5.9));//向大取整
      
        System.out.println(Math.floor(-5.01));//向小取整
​
​
        System.out.println(Math.round(5.5));//四舍五入
      
        System.out.println(Math.round(-5.5));//负数  五舍六入
      
        int r = 3;
        double s = Math.PI*Math.pow(r, 2);
        System.out.println(s);
      
        System.out.println(Math.sqrt(10));

        DecimalFormat df = new DecimalFormat("#.###");  //0.00
      
        String str = df.format(8.3456789);
      
        System.out.println(str);//8.346
      
      
        DecimalFormat df1 = new DecimalFormat("#.##%");
      
        String str1 = df1.format(8.3456789);
      
        System.out.println(str1);   //834.57%

	String str = "345";
	int num = Integer.parseInt(str);
	syso(num);	//整数类型 345

		int num = 10;
		Integer i = new Integer(num);	//装箱
		System.out.println(i);
	
		int nums = i.intValue(); 		//拆箱
		System.out.println(nums);
	
		Integer i2 = num;	//自动装箱
		int num2 = i2;		//自动拆箱

	String str = "555";
	int num = Integer.parseInt(str);//NumberFormatException

	ArrayList names = new ArrayList();	//默认都是Object类型

	names.add("张三");
	names.add(123);
	names.add(true);

	ArrayList<String> names = new ArrayList<String>();	//使用包装类来约束类型
	ArrayList<Integer> ages = new ArrayList<Integer>();

	18.没有方法可以调用 因为默认int
    Integer i = 18;
	i.使用方法

public class Pet{

    public void show(){

    }
    public void show1() throws Exception{

    }
}
public class Cat extends Pet{
    //重写父类的show()
    public void show() throws NullPointerException,IndexOutOfBoundsException,ArrayIndexOutOfBoundsException{
        //子类随便抛出运行时异常 父类该方法 无需操作
        //通过throws 抛出的异常 不分先后顺序
    }

    //重写父类的show1()
    public void show1() throws ParseException{
        //子类抛出了编译期异常 则要求 父类（接口类）的该方法要抛出相同或者更高级的异常
    }

    public void show2(){

        try{
            //可能出现运行时异常的代码 绝对不会出现ParseException
        }catch(StringIndexOutOfBoundsException e){
            //子类异常放前面
        }catch(IndexOutOfBoundsException e){
            //父类异常放后面
        }catch(ParseException e){//报错
            //不能随便catch编译期异常 必须是try内部的代码有可能触发这个编译期异常 才能catch
        }catch(Exception e){

        }
    }

    public void show3(){
        try{
            String str = null;
            syso(str.length());	//NullPointerException
        }catch(ParseException e){	//报错
            //如果try内的代码 并没有可能出现该编译期异常 则不能catch该异常
        }
    }
}

public class Util{

    public void start() throws ParseException,Exception{

        Cat cat = new Cat();
        cat.show();//该方法抛出的都是运行时异常 因此 调用时可不做操作

        cat.show1();//该方法抛出了编译期异常ParseException  则调用这个方法的方法 也就是start()必须抛出一样 或者更高级的父类异常   或者 直接使用try catch处理掉 则start()也可以不做抛出

    }

}

 1.throws 只是为了绕过虚拟机的编译检查（并没有解决掉该异常）
		场景：只能用在绝对不会触发的编译期异常
		功能：向后抛出异常 将异常的处理时机滞后
		语法特点：
     		1.可以向后抛出任何多个异常(运行时 编译期 都可)   
     		2.没有子父类顺序要求 
     		3.后期调用该抛出编译期异常的方法 的方法也必须抛出一样或更高级的编译期异常
			4.对于编译期异常 如果子类重写方法抛出了编译期异常 则父类原始方法必须抛出相同或更高级编译期异常
		  
 2.try catch  真正的处理掉异常 代码可以继续向下执行
		 场景：只要有可能触发 
		 功能：解决掉异常 给与友好提示 程序继续执行
		 语法特点：
            1.尝试执行try模块内的代码(应该将怀疑会报错的代码放在其中) 
			2.如果没有报错 跳过以下所有catch 向后执行
			3.如果报错 则创建这个异常类的对象 
				去依次匹配后续的catch 进入对应的catch模块执行
				没有匹配的catch 直接报错 程序终止
			4.执行完毕后 会跳出try catch模块 继续执行代码后续业务
			5.对于编译期异常 try中有可能出现 才允许catch
			6.后续catch模块中的异常 必须从小到大排列

public class LoginException extends RuntimeException / Exception{ 
    public LoginException(String message){
        super(message);
    }
}

	//测试类
	String name = "李四";
	String pwd = "123";
	if(!name.equals("张三")||!pwd.equals("123")){
        //通过if找到抛出异常的时机
        try{
            //触发异常
            String str = null;
            syso(str.length());//会去查找空指针异常

            throw new LoginException("用户名或密码有误");
        }catch(NullPointerException e){
            syso("没有对象");
        }catch(LoginException e){
            syso(e.getMessage());
        }catch(Exception e){
            syso("父类异常放最后");
        }

    }
	syso("后续业务");