8.3笔记

复习{
  常用类: 
       Object: 
            new Object();
            clone(); 返回一个对象的 副本
                实现Cloneable接口， 重写clone方法
            equals(); 用来比较两个对象 是否相等
                 == ,如果想要比较两个Person ，
                 必须重写Object类的equals方法，
                 如果补充写 就会调用父类的方法，==
            finalize(); 垃圾回收机制，GC  JVM
            toString(); 打印对象的内存地址，我们要重写
                      toString按照自己的格式
       String类: 
           new String();      this.value = "".value
            new String(String str);
            new String(byte[] b,String charsetName);
            
            charAt(int index); 返回指定索引位置的 char值
            concat(); 完成两个字符串的拼接
            contains(); 判断 当前字符串是否包含指定字符
            compareTo(); 比较两个字符串的大小
                 1   0  -1
            endsWith();
            startsWith();
            getBytes("UTF-8"); 将字符串变成字节数组
            toCharArray(); 把一个字符串变成char数组
            String s = subString(); 截取
                        subString(int fromIndex,int endIndex); 
            String[] str = split(); 分割
            indexOf(); 返回指定字符在字符串中 的位置
            
            String s = "Hello";
            str.indexOf(这里不是下标，是字符的值);
            replace(String oldStr, String newStr);
            replaceAll(String oldStr,String newStr);
            trim(); 
            isEmpty(); 判断是否是一个空字符串
            toLowerCase();
            toUpperCase();
            valueOf(); 
================================================== =================
String 是final修饰的 ， 不可改变类
StringBuffer: 也是final修饰的，但是有 toStringCache 的缓存去 是 字符的缓冲区
     private transient char[] toStringCache;
StringBuilder: 字符串的缓冲区

StringBuffer是线程安全的，性能慢;
            线程同步
StringBuilder是线程不安全的， 性能快;            
            线程异步
            
是可以变的字符序列，是线程安全的， 与String功能都是用来操作字符串的
               
   new StringBuffer();  
        super(16); 实际上调用的是 父类的构造器，
            父类的构造器，new char[16];
            str.length() + 16;
            
   append(); 向 一个字符缓冲区 追加  支持 链式编程
   capacity(); 返回的是 底层 char数组的长度
   length(); 返回char数组中的 有效字符个数
   charAt(int index); 返回指定索引出的字符
   delete(1, 3); 根据索引删除，保留未删除字符，包含头，不包含尾
   indexOf(String str)           
   indexOf(String str,int fromIndex);         
   insert(int offset, Object b); 向指定字符串中插入指定字符
   lastIndexOf(String str);返回指定字符串最后出现的下标
   lastIndexOf(String str,int fromIndex);  返回指定字符串在的位置，从指定位置查找
   replace(int start, int end, String str)             
   reverse(); 字符串反转输出            
   substring(int start)
   substring(int start,int end);                     
   toString();         

StringBuilder 类的结构，功能都与 StringBuffer相同，唯一不同的
方法上 没有synchronized 修饰，属于线程不安全的;

String,StringBuffer,StringBuilder的区别?

1.String类 是final修饰的 不可改变类，
   可以使用 + 进行 字符串拼接，但这样会很消耗空间
   每次在拼接时，都会开辟新的空间来存储字符串，
 
2.StringBuffer被称为字符串缓冲区，是可变的字符序列，
   没次在append 拼接新字符串时，都是在同一个中 操作;
   有默认空间，16，空间会自动扩容 ， 是线程安全的
    有synchronized 修饰， 性能慢;  
   
3.StringBuilder与StringBuffer同理，都是字符串的缓冲区，
 是可变字符序列，.... 唯一不同的是线程不安全的 ，没有synchronized 
   关键字修饰， 性能快
=====================================================
包装类:
  byte,short,int ,long ,float ,double, char,boolean
  Byte,Short,Integer,Long ,Float,Double,Character,Boolean
  
oop 都倾向于操作 对象 ， 引用  
  所以 java中所有的原生数据类型，都对应的 
 设计了一个 类 
  
 为什么要有包装类，因为java是纯面向对象的编程语言，操作对象是最方便的，
 随意将所有的原生数据类型 都 对应的 设计了一个 包装类;
 
Integer:  
   Integer中 包装了一个 int 类型的值
   其中还提供了一些方法，将 int 转换为String ，String转换为int 的方法
   
   new Integer(int value);
   new Integer(String value);
   
   static compare(int x, int y); 比较两个数 ，如果x < y  -1 , x == y 0 , x > y 1
   
      对象.compareTo(对象);  返回的还是 -1， 0 ， 1
   decode(String value); 将一个字符串转换为 数字
   intValue(); 将一个Integer对象 转换为 int原生类型
   max(int a, int b); 返回两个数字的最大值
   min(int a , int b);  返回两个数的最小值
   parseInt(String s); 把 一个字符串转换为 int 类型数字
   
*** Integer.toBinaryString(6); 将一个10进制转换为 2进制显示
   sum(int a, int b); 求两个数的和
   valueOf(); 将int ， String 转换为 Integer
   
   自动拆装包:
        将原生 数据类型 int 赋值给 Integer 这个过程就是 装包
        将Integer类型转换为 int 就是拆包 ， 这个过程都是自动的，不用纠结了
 例如:    int a  = 3; 
         Integer b = a;
         int c = b;
=====================================================
日期类: 
     java.util.Date;  代表系统时间
       |-- java.sql.Date;  数据库时间
       
     构造器: 
          new Date();  
          new Date(long 毫秒值);
          
           getTime(); 返回当前系统的 毫秒值
           
        过时了: 从1900 年算 向后  
          getYear();
          getMonth(); 

为了强制区分两个Date对象是不同包的:          
java.util.Date date1 = new java.util.Date();
java.sql.Date date2 = new java.sql.Date(); 
 
     java.sql.Date
      构造器:
              new Date(long date);一定是 跟 java.util.Date连用
               

      方法: 
          valueOf(String s);  
            toString(); 将日期 以字符串的形式 打印输出
            
 SimpleDateFormate:  是用来辅助 java.util.Date的
    
     构造器: new SimpleDateFormate(String pattern); pattern 日期格式
     
     方法:String  format(Date date); 将一个Date类型的 对象，转换为 String 类型输出
                parse(String date); 将一个字符串类型的日期格式，转换为Date类型
==========================================================================
Time:
  new Time(long time);
  
  打印输出的是 当前系统的 时分秒;

Timestamp:
    代表时间，是java.sql下的
  new Timestamp(long time);
====================================================
Math: 代表数学类
   abs(); 返回绝对值
   max(Object a, Object b); 返回两个数的最大值
   min(Object a, Object b); 返回两个数字的最小值
   pow(Object a, Object b); 将第一个参数的值返回到第二个参数的幂。 
   sqrt(double a); 平方根
   random(); 返回的是 0-1之间的随机数
   
Random: 随机数类
    nextInt(int bound); 入参是边界值

 例如: 
Random r = new Random();
//让你随机出一个1-10的值     10就是边界值  +1偏量值
//10 - 20 
int nextInt = r.nextInt(11)+10;
System.out.println(nextInt);   

Scanner: 
   new Scanner(InputStream source); 字节流
     例如: new Scanner(System.in);
     
   方法: 
        nextInt(); 返回控制台输入的int 类型的值
        next(); 按空格截取输入的内容
        nextLine();  都是返回控制台输入的 String 的字符串
        
        
   

                
                
                
                
                
                    
                               

}