java基础之九

一、java.lang包   不需要用import导入，直接使用
   1.java.lang.StringBuilder    ----是非线程安全的，并发处理，性能稍快。（StringBuffer）是线程安全的，同步处理，性能稍慢
     包括的普通方法: 引用.方法名  访问
     StringBuilder append(char c/char[] c/int i/boolean b/double d/float f/long l/String str/StringBuilder&StringBuffer b/object o)    
     StringBuilder append(char[] c,int offset,int len)     末尾追加;                                                      
     StringBuilder insert(int index,String str)            在index位置插入str;(可以在index位置上插入的根append基本一样，除去StringBuilder&StringBuffer b/object o)
     StringBuilder replace(int start,int end,String str)   将位置[start,end)之间的字符串替换成str;
     StringBuilder delete(int start,int end)               删除位置为[start,end)之间的元素;
     StringBuilder reverse()                               反转字符;
   2.java.lang.String
     包括的普通方法：引用.方法名  访问
     int length()  获取字符串长度;
     int indexOf(String str)                获取str在当前字符串中的位置  没有返回-1
     int indexOf(char c)                    获取字符c在当前字符串中的位置  没有返回-1     
     int indexOf(char c,int start)          从start位置开始查找，当前字符串中字符c的位置   没有返回-1
     int indexOf(String str,int start)      从start位置开始查找，当前字符串中str的位置   没有返回-1
     int lastIndexOf(String str)            str在当前字符串中最后一次出现的位置   没有返回-1
     int lastIndexOf(char c)                字符c在当前字符串中最后一次出现的位置   没有返回-1
     int lastIndexOf(String str,int start)  从[0-start]位置范围内查找str在当前字符串中最后一次出现的位置   没有返回-1
     int lastIndexOf(char c,int start)      从[0-start]位置范围内查找字符c在当前字符串中最后一次出现的位置   没有返回-1
     String substring(int start,int end)    获取当前字符中[start,end)范围内的字符串
     String substring(int start)            从start位置截取到末尾
     String trim()                          去除字符串两边的空白字符
     char charAt(int index)                 获取当前字符中指定index上的字符
     String toUpperCase()                   将当前字符串中的英文转换为全大写
     String toLowerCase()                   将当前字符串中的英文转换为全小写
     boolean startsWith(String str)         查看当前字符串是否以指定字符串str开始
     boolean endsWith(String str)           查看当前字符串是否以指定字符串str结尾
     包括的静态方法：类名.方法名  访问
     valueOf(int/byte/char c/short/long/double/float/boolean f)   将其他类型转换为字符串，常用的是将基本数据类型转换为字符串 
     包括正则表达式方法：引用.方法名
     ?:表示0个或1个
     *:表示0个或任意多个
     +:表示1个或任意多个
     boolean matches(String regex)                 使用给定的正则表达式regex来验证当前字符串是否满足格式要求，满足则返回true 
     String[] split(String regex)                  将当前字符串按照满足给定正则表达式regex的部分进行拆分，返回所有被拆分的部分
     String replaceAll(String regex,String str)    将当前字符串中满足正则表达式的部分替换为给定的字符串str
   3.java.lang.Number:    抽象类，是Integer/Long/Double/Short/Byte/Float类的父类
     Number类中提供了这6这类之间相互转换的普通方法
     a.java.lang.Integer/Long/Double/Short/Byte/Float         互转
       double doubleValue()
       int intValue()
       long longValue()
       short shortValue()
       byte byteValue()
       float floatValue()
       常量：求这6种数据类型的最大值最小值   类名.常量名  访问
       int/long/double/short/byte/float MAX_VALUE
       int/long/double/short/byte/float MIN_VALUE
       静态方法：将字符串转换为对应的基本类型值   类名.方法名  访问
       int parseInt(String str)    包装类Integer中的方法，用于将字符串str转换成int型，str包含的必须是整型数字  否则运行报错
       byte parseByte(String str)  包装类Byte中的方法，用于将字符串str转换成byte型，str包含的必须是整型数字且不能超过byte范围，否则运行报错
       short parseShort(String str)包装类Short中的方法，用于将字符串str转换成short型，str包含的必须是整型数字且不能超过short范围,否则运行报错
       long parseLong(String str)  包装类Long中的方法，用于将字符串str转换成long型，str包含的必须是整型数字  否则运行报错
       float parseFloat(String str) 包装类Float中的方法，用于将字符串str转换成float型,str包含的必须是整数、小数，否则运行报错
       double parseDouble(String str) 包装类Double中的方法，用于将字符串str转换成double型,str包含的必须是整数、小数，否则运行报错
     b.静态方法：用于将8种基本类型转换为包装类
       Double valueOf(double i)         Double dou = Double.valueOf(12.25);        也称装箱：可简写为Double dou = 12.25;
       Integer valueOf(int i)           如果传小数进去，会将小数部分舍去
       ...
       拆箱：int i = new Integer(23).intValue();可简写为int i = new Integer(1)


二、java.util包
   1.java.util.Date
     包括的普通方法(未过时的)：引用.方法名  访问
     long getTime()                                获取Date内部维护的long值(从1970年1月1日00:00:00到表示的时间点之间所经过的毫秒数) 
     void setTime(long time)                       表示Date内部维护的long（毫秒）以后time毫秒的时间点     
   2.java.util.Calendar  
     包括的普通方法：
     Date getTime()                                将自身表示的日期时间以一个Date对象形式返回
     void setTime(Date date)                       使得当前Calendar表示给定Date所表示的日期
     void set(int field,int value)                 对指定的时间分量field(年月日，时分秒，周几)设置指定的值value
     int get(int field)                            获取指定的时间分量field的值
     int getActualMaximum(int field)               一般用来获取某月某年有多少天
     void add(int field,int value)                 给指定的时间分量field累加给定的值value
     包括的静态方法：
     Calendar getInstance()                        获取回来的实现类表示当前系统时间      (Calendar calendar = Calendar.getInstance()) 
   3.java.util.Collection     接口
     包括的普通方法：
     boolean add(E e)                              向集合当中添加一个元素，当成功添加则返回true   添加的元素默认在最后位置
     int size()                                    当前集合的元素个数
     boolean isEmpty()                             判断集合是否不包含任何元素   不包含任何元素则返回true
     void clear()                                  清空当前集合
     boolean contains(E e)                         判断集合是否包含指定元素      包含则返回true
     boolean remove(E e)                           删除集合中指定的元素     成功删除返回true
     boolean addAll(Collection c)                  将给定集合c中的元素添加到当前集合中，当前集合元素发生了变化则返回true
     boolean containsAll(Collection c)             判断当前集合是否包含给定集合中的所有元素   包含则返回true
     boolean removeAll(Collection c)               将当前集合中与给定集合c中相同的元素删除  删除后当前集合元素发生了变化则返回true
*    T[] toArray(T[] a);                           将集合转换成数组（String[] arr = c.toArray(new String[]{})）长度可以填也不可以不填  
     Object[] toArray();                           将集合转换成数组
     Iterator iterator()                           用来遍历集合的所有元素
   4.java.util.Iterator       迭代器，目前学习的三个方法用于遍历集合的所有元素
     普通方法：
     boolean hasNext()                             问   通过迭代器判断集合是否还有元素可以遍历
     E next()                                      取   返回获取到的元素
     void remove()                                 删   删除next()获取到的元素
   5.java.util.List      继承Connection的接口
     提供了一些独有的普通方法，可以通过下标对集合进行操作
     E get(int index)                              获取指定位置上的元素  
     E set(int index,E e)                          替换元素操作：将给定的元素设置到指定位置上，返回值为原位置上的元素
     void add(int index,E e)       重载方法        在指定位置上插入给定的元素，原位置及后续元素顺序向后移动
     E remove(int index)           重载方法        删除指定位置上的元素，返回值为被删除的元素
     List subList(int start,int end)               获取当前集合中指定范围内的元素，返回一个子集
   6.java.util.Arrays
     静态方法：
*    List<T> asList(T[] array)                     将数组装换成集合
     String toString(T[] array)                    将数组转换成字符串
三、java.text包
   1.java.text.SimpleDateFormat    
     SimpleDateFormat可以根据指定的日期格式，将String与Date互换  
     包括的普通方法：  引用.方法名  访问
     String format(Date date)                      将Date按照SimpleDateFormat构造器中指定的日期格式转换为String
     Date parse(String str)                        将String按照SimpleDateFormat构造器中指定的日期格式转换为Date


1.数组和ArrayList的区别：
  数组底层其实就是一组相同类型的数据
  ArrayList不仅包含数组还包含通用算法
  
2.什么是二进制
  计数规则：逢2进1
  数字：0 1
  权：256 128 64 32 16 8 4 2 1
  基数：2
  因为2进制（10进制）可以进行计数（加法），所以支持任何的数学运算。
  1).为什么要使用2进制？
    采用2进制作为计算机的计数规则，可以实现更加低廉的制造成本。


   **？计算机内部处理是2进制的，编程语言将10进制转换为2进制交给计算机处理，编程语言给使用者留下的错觉：计算机能够直接处理10进制
   int i= 56;//从控制台输入的其实是文本信息（字符串）int i = Integer.parseInt()将字符串转换为整型数据类型
   //中间用包装类进行运算
   System.out.println(i);//56  //Integer.toString()十进制输出;


3.16进制
  16进制是2进制的简写形式！
  因为：2进制书写非常麻烦，不便，故使用16进制简写就方便了很多
  16进制的一位数，可以对应简写2进制4位数，这样就可以大大简化2进制的书写


  16进制的计数规则：逢16进1  
                    数字：0 1 2 3 4 5 6 7 8 9 a b c d e f 
   权：256 16 1 （16^2  16^1  16^0）
   基数：16 
   0100 0001 --->    41
   1100 0010 --->    c2
   1010 1110 --->    ae           ------>a*16^1+14*16^0=174
   int i = 0xae;//0xae就是10101110的缩写（十进制174）
4.补码：
  1).计算机以补码的形式保存所有的整数。
  是一种算法，已经被封装为方法
  为啥需要补码：究其根本，还是为了节约成本，省钱


  补码的最大值（max）:
        int max = 0x7fffffff;//2147483647
System.out.println(Integer.toBinaryString(max));//111 1111 1111 1111 1111 1111 1111 1111
  补码的最小值（min）:                                   7    f    f    f    f    f    f    f
        int min = 0x80000000;//-2147483648
System.out.println(Integer.toBinaryString(max));//1000 0000 0000 0000 0000 0000 0000 0000 
                                                   8    0    0    0    0    0    0    0
  -1的二进制代码：-1 = ~1+1
    11111111 11111111 11111111 11111111


  3).溢出：溢出结果不是随机数
     a.正数溢出的结果可能是负数或正数
     b.n=(max+1)*2+n
     c.min=max+1  max = min-1
                   -n-1 = ~n;
   补码的对称现象：-n=~n+1(不适用于最小值)：~是指0变1 1变0，包括符号位 


   在java内存中byte、short根本不存在，穿着int马甲当int算，内存中只有int


>>>逻辑右移位运算
       规则：将数据的每个位向右移动
       n:00000000 00000000 00000000 00110010   50 
       m=n>>>1
       m:000000000 00000000 00000000 0011001   25 = 50/2^1
       m=n>>>3
       m:000000000 00000000 00000000 0000110   6   (50/2^3=6.25 舍小数点并取小为6)
<<左移位运算
       n:00000000 00000000 00000000 00110010  50
       m=n<<1
       m:00000000 00000000 00000000 01100100  100   50*2^1
       m=n<<3
       m:00000000 00000000 00000001 10010000  400   50*2^3
   引子：移位运算的数学意义
         在2进制中数据向左移动一次，原数据*2
   经典题目：
         如何优化将n*8运算？（n<<3）
>>数学右移位运算
     运算规则：当正数情况下，左侧补0
               当负数情况下，左侧补1，保持符号不变
       n:11111111 11111111 11111111 11101110   -18
       m=n>>>2                                                      m=n>>2
       m:00111111 11111111 11111111 11111011   1073741819           m:11111111 11111111 11111111 11111011   -5 (-18/2^2=4.5,取小为-5)
& 与运算
     规则：将两个数按位对齐进行与（相当于乘）运算。
     n = 01101101 01101101 01101101 11100101 
     m = 00000000 00000000 00000000 11111111
    n&m= 00000000 00000000 00000000 11100101 与n的低八位相同，这是掩码运算
    掩码运算：两重意义
      1.用于将数据的一部分截取出来
      2.掩码运算时2整次幂余数：%2: &0x1; %4: &0x3; %8: &0x7; %16: &0xf   记住是2的整次幂
        举例说明：0000 % 4 = 00 -> 0000 & 0011 = 00
                  0001 % 4 = 01 -> 0001 & 0011 = 01
 0010 % 4 = 10 -> 0010 & 0011 = 10
 0011 % 4 = 11    ...
 0100 % 4 = 00
 0101 % 4 = 01
 ...
       面试题：如何优化n%8?(答案：n&0x7)
    掩码运算的用途：
      n =  01101101 01100100 11000011 00010001
      b1 = 00000000 00000000 00000000 01101101
      b2 = 00000000 00000000 00000000 01100100
      b3 = 00000000 00000000 00000000 11000011
      b4 = 00000000 00000000 00000000 00010001
      b1 = (n>>>24) & 0xff
      b2 = (n>>>16) & 0xff
      b3 = (n>>>8)  & 0xff
      b4 = (n>>>0)  & 0xff
    合并b1,b2,b3,b4,为一个int
    int n = (b1<<24) + (b2<<16) + (b3<<8) + b4)
            (b1<<24) | (b2<<16) | (b3<<8) | b4
| 或运算
    运算规则：两个数按位对齐进行或（相当于加法，但不进位）运算
           1 | 1 = 1
  1 | 0 = 1
  0 | 1 = 1
  0 | 0 = 0

#### IO   java.io.*;
## File 文件的创建、删除、改名、列目录，属性等  实现了Serializable和Comparable接口
## RandomAccessFile （随机访问文件）
   # void write(int b) 向文件中写出一个byte
   # int  read()       从文件中读取一个byte
   # void write(byte[] buf)向文件中写一批byte
   # int  read(byte[] data) 从文件中读取一批数据，返回实际读取的字节数int len
   # void writeInt(int b)   一次性写入4个字节  (writeLong() 一次性写入8个字节)
   # int  readInt()         一次性读取4个字节  (readLong() 一次性读取8个字节)
   # 将字符串序列化为byte数据的方法：byte[] buf = str.getBytes(String charsetName);
   # 字符串反序列化：String str = new String(byte[] data,int offset,int len,String charsetName)         --offset和len可以不写
   -其构造方法： 
        --RandomAccessFile(File file,"r")    只读模式
        --RandomAccessFile(File file,"rw")   读写模式
   RandomAccessFile总结：
 1.可以操作文件内容
 2.可以任意移动文件指针，读写文件---可以从文件的任意位置开始读写
 3.每次读写1个byte
 4.提供了基本数据类型的读写方法
   -基本类型读写的底层：每次读写1个byte
          缺点：没有提供更复杂数据的读写方法
## IO流（Stream）
    流是一套API（非常多），提供了各种数据类型的读写API！
    流是一套可扩展的API，通过扩展的API支持了各种类型数据的读写！
    按照流是否直接与特定的地方（如磁盘、内存、设备等）相连，可以分别为节点流（低级流）和处理流（高级流、过滤流、扩展流）
        节点流---从特定的数据源开始读写数据，只提供最基本的byte读写方法，功能简单。
  -低级流，只能按照byte访问，不方便
  -FileInputStream    文件输入流
  -FileOutputStream   文件输出流
  -System.in          控制台输入流 
  -System.out         控制台输出流
  -网络流
扩展流---必须依赖低级流（包含节点流），过滤流不能单独工作，它在低级流的基础之上扩展了丰富的数据读写功能。功能复杂，使用方便。
  
  1. 字节流是从两个抽象类扩展的：
     -InputStream   字节输入流 (单向的，无法调指针)
         -int read()                读取一个字节，返回的int值“低8位”有效，若返回值为-1，则表示EOF（文件末尾）
-int read(byte[] buf)      尝试最多读取给定数组length个字节并存入该数组，返回值为实际读取到的字节量，若返回值为-1，则表示EOF（文件末尾）
     -OutputStream  字节输出流 (单向的，无法调指针)
         -void write(int b)         写出一个字节，写的是给定int的“低8位”
-void write(byte[] buff);  将给定字节数组中的所有字节全部写出
    # 文件流FileInputStream/FileOutputStream 
       是低级流，以文件作为数据源读写数据，只提供简单byte读写功能，很少直接使用
       文件输出流提供了两种构造方法：
       FileOutputStream (String filename,boolean append) ---如果为true,每运行一次程序就会在文件原有内容的基础上继续写出
       FileOutputStream (String filename)    
    # 缓冲流BufferedInputStream/BufferedOutputStream     ---提高IO性能
       是高级流，必须依赖低级流（低级流作为构造器参数）提供了自动化缓冲区管理，
          使用缓冲流可以提高软件的IO性能。不会改变原有的软件逻辑。在以后工作中，在***读写文件时***都会加上缓冲流提高性能。
-void flush() 清空缓冲区，将缓冲区中的数据强制写出
    # 对象流ObjectInputStream/ObjectOutputStream         ---对象读写
       是高级流
       ObjectInputStream:----Object readObject();
       ObjectOutputStream:---void writeObject(Object obj)


  2. 字符流                                              ---扩展了字符编码  
     字符流的父类：---是以字符char为单位读写数据，一次处理一个Unicode。其底层仍是基本的字节流
     -Reader   字符输入流
         -int read()            读取一个字符，返回的int值“低16位”有效
-int read(char[] arr)  从该流中读取一个字符数组的length的字符并存入该数组，返回值为实际读取到的字符量
     -Writer   字符输出流
         -void write(int c)          写出一个字符，写的是给定int的“低16位”表示的字符
-void write(char[] arr)     将给定数组中的所有字符写出
-void write(String str)     将给定的字符串写出
-void write(char[] arr,int offset,int len)  将给定数组中从offset处开始连续的len个字符写出
      字符流是高级流，必须依赖低级的byte流，字符流封装了字符的编码和解码功能，能够将字符数据编码序列化为byte写到低级流中，或将byte字符数据
      解码为字符数据。
    # 字符转换流InputStreamReader/OutputStreamWriter       ---扩展了字符编码  
       是高级流。
       构造方法：
         -InputStreamReader(InputStream in) 根据系统默认字符集创建ISR   （以后工作中少用，不利于java程序的跨平台运行）
         -InputStreamReader(InputStream in,String charsetName) 基于字节输入流及给定字符集创建ISR
-OutputStreamWriter(InputStream in,String charsetName) 基于字节输出流及给定字符集创建OSR
-OutputStreamWriter(InputStream in) 根据系统默认字符集创建OSR   （以后工作中少用，不利于java程序的跨平台运行） 


        UTF-8：变成编码，是目前国际化最优编码：支持10W以上的字符集
      缺点：中文占三字节（英文占1个字节），因为需要标识，故造成了空间浪费
        GBK ：中国本地化最优编码，2w多中英文字符集（只支持中文英文）
      中文2字节，英文1字节，中英文混合最节省    


    # 缓冲字符流PrintWriter/BufferedReader   ---用这个流是就不要用字节流中的缓冲流了
       是高级流。
       PrintWriter（缓冲字符输出流）依赖于字符转换输出流（文本输出流）OutputStreamWriter
         -void print(int i/char c/char[] arr/boolean b/double d/float f/long l/String str)     
-void ptintln(int i/char c/char[] arr/boolean b/double d/float f/long l/String str)   写出并换行
        其构造方法：
-PrintWriter(File file)
-PrintWriter(String fileName) 
-PrintWriter(OutputStream out)
-PrintWriter(OutputStream out,boolean autoFlush)
         -PrintWriter(Writer out)    -------常用       ---不具有自动行刷新功能，加之其具有缓冲功能，所有在PW关闭时才会写出缓冲区中的内容
-PrintWriter(Writer out,boolean autoFlush)    ---不管用哪种构造器，但最终都会引用该构造器
 自动行刷新，就是调用println()方法执行结束以后，自动调用flush一次
       BufferedReader（缓冲字符输入流）依赖于字符转换输入流（文本输入流）InputStreamReader
         -String readLine()   连续读取一行字符串，直到读取到换行符位置，返回的字符串不包含换行符，如果返回null表示读取到文件的末尾
其构造方法：
-BufferedReader(Reader in)  ---意思是必须依赖与字符转换输入流InputStreamReader，字符转换输入流又必须依赖于一个低级流
#### 异常 --方法的意外（非正常）结果
  ## 意外结果返回方式
     1. 利用特殊值带回
        # read()当返回-1时是特殊情况
# readLine()当返回null是特殊情况
     2. 利用异常抛出
        Scanner nextInt() 输入错误抛出异常
  ## Java异常种类
    -Throwable类 可抛出的
        子类：
        -Error 错误，系统不可恢复错误 ---我们管不了，因为运行环境已经崩了
 -OutOfMemoryError 堆(heap)内存溢出错误
-Exception 例外，异常
 -IOException     
  使用IO流读写时会出现此异常，这是可检查异常，不捕获会报编译错误。
          -FileNotFoundException
  使用IO流读写文件时，这是可检查异常，不捕获会报编译错误。
 -RuntimeException:非检查异常
  ## 非检查异常RuntimeException
     java编译器不检查RuntimeException及其子类的异常处理规则。不报编译错误。
     -StringIndexOutOfBoundsException
      当使用String的charAt(int index)方法时，可能会出现此异常
     -NullPointerException 空指针异常： 
      当一个引用类型变量的值为null时，访问了它的属性或方法将出现空指针异常
     -IllegalArgumentExcption 不合法/不正确参数异常
     -InputMismatchException 输入不匹配异常
     Scanner in = new Scanner(System.in);
     int n = in.nextInt();
     如果输入的不是整数，就会报此异常。
     -ArrayIndexOutOfBoundsExcption 数组下标越界异常 
     -ClassCastException   强制类型转换异常（对象强制转换时出现）
     -NumberFormatException  NumberFormat异常（字符串转整数int a = Integer.parseInt(str)）
  ## 其他异常（可检查异常）：当调用有异常抛出的方法，必须处理异常，否则将出现编译错误！
     -ParseException
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    Date date = sdf.parse(str);
  ## try...catch
     程序一旦出现异常，java异常机制就去寻找catch语句。如果不使用catch处理，当前的线程也会停止。在程序中要合理使用catch处理异常
   # try...catch语法
     try{
        //可能有异常的代码段
     }catch(异常类型1 e){
        //当出现指定类型异常的时候执行的代码
//异常处理1
     }catch(异常类型2 e){                              ***catch中的异常类型必须由小到大排列，否则会出现编译错误
        //异常处理1
     }finally{
        //最终处理      ----无论程序是否有异常都会执行的代码
     }
  ## 异常总结
     1.需要根据软件的业务情况合理处理异常。
       -方法中能够处理的异常，就处理，如果不能处理的异常，一定抛出到调用者。
       -不能简单的抛弃异常。
     2.当抓到异常的时候，请务必输出***方法调用栈*** e.printStackTrace();
     3.throws  ---别乱用