Java之常用类

常用类以及后面高级特性:集合框架,多线程,io流,网络编程,反射等等都是使用jdk提供API

API:Application Programming Interface:应用程序接口文档

Object类

需要将重点的类的重点功能--记住

举例:String类的拆分/将字符串转换成字符数组等等

java.lang.Object类:所有的类父类(包括自定义的类)

重点功能:

public final Class getClass():获取正在运行的类; (返回字节码文件对象) (跟后面反射有关系)

getClass()方法

在Java中获取一个类的字节码文件对象的方式有几种?
          有三种:
                 #1)public final Class getClass():获取正在运行的类;  (返回字节码文件对象)
                  2)在Java中任意类型的class属性   举例: Class c = 类名.class
                  3)Class类提供的一个静态方法
                  public static Class forName(String classPathName) :参数为当前类的全限定名称

代码实现:

public class ObjectDemo {
    public static void main(String[] args) throws ClassNotFoundException {


        //创建两个学生对象
        Student s1 = new Student() ;
        Student s2 = new Student() ;

        //public final Class getClass():获取正在运行的类;  (返回字节码文件对象)
        Class c1 = s1.getClass() ;
        System.out.println(c1) ;//class com.qf.object_01.Student  (class标记类  包名.类名-->类的全限定名称)
        Class c2 = s2.getClass() ;
        System.out.println(c2) ;
        System.out.println(c1==c2) ;//true:s1和s2都是com.qf.object_01.Student:类就加载一次,对象可以不断new!
        System.out.println("------------------------------------------") ;
        //在Java中任意类型的class属性:也可以获取到一个类的字节码文件!
        Class c3= Student.class ;
        System.out.println(c3) ;
        System.out.println(c3==c2);
        System.out.println("-----------------------------------------") ;
        //第三种获取字节码文件方式:Java提供Class类---跟反射相关的-提供静态功能-->返回值是它自己本身
        //public static Class forName(String className) throws ClassNotFoundException
        //这个方法在使用过程中,可能出现类找不到异常,谁调用这个方法,必须对这个异常处理---给上面抛出
        //这个方法的参数需要传递的是当前类的"全限定名称"
        //Class c4 = Class.forName("Student") ;//这里必须是全限定名称
        Class c4 = Class.forName("com.qf.object_01.Student") ;
        System.out.println(c4) ;
        System.out.println(c4==c3);
    }
}

toString()方法

public String toString():返回对象的字符串表示形式。

结果应该是一个简明扼要的表达，容易让人阅读。 建议所有子类覆盖此方法(否则,打印出来的是地址值!)

public int hashCode():返回对象的哈希码值,不同的对象,它的哈希码值不同

(理解为 "地址值",它不是实际意义的地址值----通过哈希算法算出来的)

	alt+ins---->toString:重写Object的toString方法

代码实现:

public class ObjectDemo {

    public static void main(String[] args) {
       // System.out.println("helloworld".hashCode());
        // System.out.println("hello".hashCode());

        //通过有参方法来创建Teacher类对象
        Teacher t = new Teacher("高圆圆",44) ;
        System.out.println(t) ;//直接输出对象名等价于---Object类的toString()
        System.out.println(t.toString());
        System.out.println("---------------------------------------");
        //Class c = t.getClass() ;
        //System.out.println(c) ;//class com.qf.object_02.Teacher --->Class类的ublic String getName() :获取类的全限定名称
        //String name = c.getName();
        //System.out.println(name);
       // int i = t.hashCode();
        //System.out.println(i);

        //Integer.toHexString(整数类型):将整数类型---转成十六进制数据,并且以字符串形式体现
        /*String str = Integer.toHexString(t.hashCode());
        System.out.println(name+"@"+str) */;

        //上面代码没有意义,建议所有子类都覆盖这个方法:



    }
}

任何类都继承Object类---toString方法源码

public String toString() {

return getClass().getName() + "@" + Integer.toHexString(hashCode());

//return this.getClass().getName() +"@" +Integer.Integer.toHexString(this.hashCode())

}

equals方法

==和equals的区别?

==连接的是两个基本数据类型:比较的数据值是否相同

而如果引用类型,比较的是引用类型的地址值是否相等!

equals:Object的equals方法默认比较的是两个对象的地址值相同,

如果你要比较成员信息的内容是否相同,必须重写Object的equals方法以及hashCode,重写之后比较的是内容是否相同(成员信息)

equals重写之后,是比较里面的每一个成员信息是否一样,如果都一样;

还有比较两个成员对应的hashCode是否一样,如果一样,是同一个人!

代码实现:

public class ObjectDemo3 {
    public static void main(String[] args) {

        int a  = 20 ;
        int b = 20 ;
        System.out.println(a==b) ;//连
        System.out.println("---------------------------------------------------") ;
        Student s1 = new Student() ;
        Student s2 = new Student() ;
        System.out.println(s1==s2) ;
        System.out.println("----------------------------------------------------") ;
        Student s3 = new Student("高圆圆",33) ;
        Student s4 = new Student("高圆圆",33) ;
        System.out.println(s3 == s4);//false
        // public boolean equals(Object obj)指示一些其他对象是否相等。
        //idea生成了equals和hashCode
        System.out.println(s3.equals(s4));
     }
}

clone()方法

	Object的克隆方法:创建并返回此对象的"副本"----前提是自定义的类型必须实现Cloneable接口,否则无法克隆!
	protected Object clone() throws CloneNotSupportedException

public class ObjectDemo4 {
    public static void main(String[] args) throws CloneNotSupportedException {

        //创建一个学生对象
        //没有学习克隆之前
        Student s1 = new Student() ;
        s1.name = "高圆圆" ;
        s1.age = 44 ;
        System.out.println(s1);
        System.out.println("---------------------------") ;
        //定义一个Student类型的变量s2,将s1赋值给s2
        Student s2 = s1 ; //将堆内存地址值给它
        System.out.println(s2) ;

        System.out.println("------------使用Object类的clone方法------------------") ;
        //s1.clone() ;//次对象的类必须实现接口Cloneable ,才能进行克隆!
        //可以克隆了,实现接口了
        //protected Object clone() throws CloneNotSupportedException
        Object o = s1.clone(); // 相当于向上转型:

        //将强转为子类型:向下转型
        Student s3 = (Student) o;
        System.out.println(s3);
    }
}

如果一个接口没有成员变量,连成员方法都没有,将这类接口称为"标记接口"
 	Cloneable接口:某个类如果能够实现这个接口,那么这个类对象就可以克隆!
 	Object类的clone方法里面被 native:本地方法---非Java语言实现
      protected native Object clone() throws CloneNotSupportedException;
      JNI:Java Native Interface:Java本地接口---通过java语言调用底层语言C

finalize()方法-垃圾回收法

Object类的垃圾回收方法
protected void finalize()throws Throwable--跟gc垃圾回收器有关系
当jvm开启垃圾回收器的时候,就会回收堆内存中没有更多引用的对象(new 出来的东西)

当前垃圾回收器开始运行,会调用Object类的finalize()方法,来回收对象,子类重写了,会调用子类的finalize方法

public class ObjectDemo5 {
    public static void main(String[] args) {

        //创建一个人类
        Person p = new Person("高圆圆",44) ;
        System.out.println(p) ;
        System.out.println("--------------------------") ;
        p = null ; //堆内存没有东西了

        //System类--->public static void gc()运行垃圾回收器
        // 手动开启垃圾回收器 (java语言中自动回收)---jvm垃圾回收--是一个线程(垃圾回收线程)
        System.gc();
    }
}

Object的finalize方法的原码:
 protected void finalize() throws Throwable { }

Scanner类

java.util.Scanner:文本扫描器(键盘录入数据的)
   构造方法:
       public Scanner(InputStream source):
           创建一个文本扫描器对象,里面参数是字节输入流,读取键盘录入的一些数据
 
  成员方法:
 
   获取功能:除过不能录入char类型之外.都可以录入!
       int nextInt():录入int类型
       String next():录入字符串
       String nextLine():录入一行字符串
       ....
   判断功能
          boolean hasNextXXX()方法:判断下一个录入的是为XXX类型
 
 
          细节:
            如果先录入int,在录入String,在录入String(使用String nextLine())---String的值会被漏掉;
           解决方案:
                   1)使用String  next():录入单个字符串(推荐)
                   2)在使用nextLine()之前,重新创建一个新的Scanner对象;

String类

String类:代表字符串,是一个常量,创建之后,其值不能更改!
       举例:
               String s = "abc" ;  格式 开发中定义字符串就这个格式!
  字符串的底层就是一个字符数组组成!char[]--->String
 
  构造方法:
       public String():创建字符串对象
       public String(String original):将指定的字符串传进去,构造一个字符串对象
       public String(char[] value):将字符串数组---构造成String
       public String(char[] value,int offset,int count):将一部分字符数组转换成String
       public String(byte[] bytes)将字节数组---构造成String
       public String(byte[] bytes, int offset,int length):将一部分字节数组---构造成String
 
       如果存在类型转换问题:
               已知char[]--->String  public String(char[] value)
               已知byte[]--->String  public String(byte[] bytes)
 
        如果仅仅表示定义一个String对象---推荐的格式
               String 变量名 = "字符串常量" ;

面试题:
        s1和s2有什么区别?
         String s1 = "hello" ;
         String s2 = new String("hello") ;
 
     第一个格式:
           创建一个对象,直接在常量池中创建;
      第二个格式:
           需要在堆内存开辟空间,而且指向常量池地址:内存创建了两个对象!
 
    两个都是创建字符串实例,但是推荐第一种,从内存角度考虑,消耗内存资源不严重!

/**
 *看程序,写结结果
 *
 * 考点:
 *      ==和equals的区别:
 *
 *      ==:连接的是两个引用类型的数据,比较的是两个对象的地址是否相同
 *      Object的equals():默认比较的是两个对象的地址值是否相同,子类重写了equals(),就比较两个对象的内容是否相同
 *
 *      
 *
 */
public class StringDemo3 {
    public static void main(String[] args) {

        String s1 = "hello" ;
        String s2 = "world" ;
        String s3 = "helloworld" ;
        System.out.println((s1+s2)==s3) ;
        System.out.println((s1+s2).equals(s3)) ;//String类重写了Object的equals方法,只管字符串内容是否一样
        System.out.println("----------------------------") ;
        System.out.println(("hello"+"world")==s3) ;//常量先相加,然后常量池中找,存在返回地址;否则常量池开空间
        System.out.println(("hello"+"world").equals(s3)) ;//比较内容是否相同
    }
}

字符串常量相加:

先相加,然后看结果,是否在常量池中,如果有,直接返回值地址;否则开空间

字符变量相加:

先在常量池开辟空间,然后在操作;

String类中常用的获取功能:

       1)public char charAt(int index) 获取指定索引值对应的字符
       2)public int length()  :字符串特有功能:获取字符串长度
 
       3)public String concat(String str):拼接功能 将指定的字符串拼接到该字符串末尾,获取新的字符串
 
       4)public int indexOf(String str)返回指定字符串第一次出现索引值
       public int lastIndexOf(String str):返回指定子字符串最后一次出现的索引值
 
 
       5)public String[] split(String regex):字符串拆分功能
 
       6)截取功能
               public String substring(int beginIndex,int endIndex)
               从指定位置开始,截取到endIndex-1处结束,包前不包后
               public String substring(int beginIndex)
              从指定位置开始默认截取到末尾!

String类的常用的转换功能:

       public byte[] getBytes(): 将字符串转换成字节数组 (编码过程:将能看懂的东西--->变成看不懂的!)
                           (使用平台默认字符集)
 
       public char[] toCharArray()  :将字符串转换成字符数组  (使用居多)
 
       public static String valueOf(常见的基本类型int/long/double/float/boolean/Object):
           String的万能方法:将上面的常用类型--转换成String
 
       public String toUpperCase():将指定字符串转换成大写
       public String toLowerCase():将指定字符串转换成小写

例1:

import java.util.Scanner;

/**
 * 需求:
 *      键盘录入一个字符串,将字符串的第一个字符转换成小写,其余字符转换成大写(不考虑特殊字符)
 *      举例:
 *              "Helloworld"---->"hELLOWORLD"
 *
 *      分析:
 *              1)创建键盘录入对象
 *              2)将字符串的第一个字符,截取出来 substring(0,1)--->将截取后的字符---转换成大写
 *              3)从第二个字符开始,截取出来 substring(1)--->将截取后的字符串---转换小写
 *              4)将2)和4)拼接----concat(指定的字符串)
 *
 *
 *
 */
public class StringTest {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;

        //提示并录入字符串
        System.out.println("请输入一个字符串:") ;
        String line = sc.nextLine() ;

        /*//1)先将line的第一个字符截取出来
        String s1 = line.substring(0,1) ;
        //2)将s1--->转换成大写
        String s2 = s1.toUpperCase() ;

        //3)将line字符串 从第二个字符开始截取出来
        String s3 = line.substring(1) ;
        //4)将s3-->转换成小写
        String s4 = s3.toLowerCase() ;

        //5)将s2和s4拼接---String的concat拼接功能
        String result = s2.concat(s4) */;
       // System.out.println(result) ;

        //一步走 :链式编程
        String result = line.substring(0,1).toUpperCase().concat(line.substring(1).toLowerCase()) ;
        System.out.println(result);
        System.out.println("--------------------------------------");

        //调用方法
        String result2 = getStr(line) ;
        System.out.println(result2);
    }
    public static String getStr(String s){
        return
                s.substring(0,1).toUpperCase().concat(s.substring(1).toLowerCase()) ;
    }

}

例2:

/**
 * 需求:
 *           已知数组静态初始化的
 *            int[] arr  = {24,57,69,13,98} ;
 *            定义功能,将数组转换成String --->把数组遍历出来--->每一个元素拼接成String
 *                    [元素1, 元素2, 元素3, ....] (不允许使用Arrays工具类的toString(数组对象))
 */
public class StringTest2 {
    public static void main(String[] args) {
          //已知数组
        int[] arr  = {24,57,69,13,98} ;
        //调用将数组转换String的方法
        String result = arrayToString(arr) ;
        System.out.println(result) ;
    }
    //将转换成String
    public static String arrayToString(int[] array){
        //定义一个最终结果变量
        String s = "" ;
        s += "[" ;//或者使用字符串的concat功能
        //遍历数组
        for(int  x = 0 ; x < array.length ; x++){
            if(x==array.length-1){
                //最后一个元素
                s+=array[x] +"]" ;
            }else{
                //中间元素
                s+= array[x] +", ";
            }
        }
        return s ;
    }

}

String类判断功能以及其他功能:

       public boolean contains(String str):判断大串中是否包指定的子字符串
       public boolean equals(Object anObject)):比较两个字符串内容是否相同
       public boolean equalsIgnoreCase(String anotherString)):忽略大小写比较
       public boolean startsWith(String prefix):字符串是否以指定的前缀开头
       public boolean endsWith(String str):字符串是否以指定的后缀结尾
 
  其他功能:
       public String replace(char oldChar,char newChar)替换功能:使用指定的新的字符替换以前的字符
       public String trim():删除前后两端空格
 
               应用场景:trim():  使用io(intput输入 Output输出)流进行 读写复制(文件内容在网络中传输)
    文件内容前后有一些空字符出现,获取到文件内容之后,先去trim()去除两端空格

面试题

/**
 * 面试题:
 * String s1 = "hello" ;
 * String s2 = "hel" ;
 * 这个两个字符串按照字典顺序比较结果是怎么计算的?
 *
 * --->两个字符串--->底层是以字符数组存储-获取字符数组长度,获取长度的最小值
 * 使用最小值作为 while循环条件, 如果没有取到最小值,一直循环,
 *          循环逻辑:
 *                 通过获取两个字符数组的每一个字符,如果都相同,最终临界条件达到 ,两个字符数组长度相减
 *
 *              如果获取到字符,如果两个字符不相等,直接是两个字符---对应的ASCII码表的值相减---直接得到字典顺序的值!
 */
public class StringTest {
    public static void main(String[] args) {
        String s1 = "hello" ;
        String s2 = "hel" ;
        //public int compareTo(String another)
        System.out.println(s1.compareTo(s2)) ;
        System.out.println("-----------------------------") ;
        String s3 = "abc" ;
        int i = s1.compareTo(s3);
        System.out.println(i);
    }



}

class Demo{
    private final void m1(){

    }
}

StringBuffer类

	StringBuffer:字符串缓冲区,线程安全的,支持可变的字符序列!
	 什么叫线程安全----->后面讲的多线程
 	线程安全----> 意味"同步"---->执行效率低!---"银行类的网站!"
 	线程不安全---->意味"不同步"---->执行效率高!----"论坛的网站!"---不安全--->"锁机制"来解决线程安全问题(多线程)

StringBuffer和StringBuilder的区别?

StringBuffer和StringBuilder的区别?
        这两个类都是字符串缓冲区,都支持可变的字符序列,(都有相同的功能)
        前者:使用在多线程环境里面,能够保证线程安全----意味着同步----->执行效率低
        后者:是StringBuffer的简易替换,用于在单线程环境中,线程不安全---不同步---执行效率高!
        单线程使用StringBuilder:效率高(速度快)
 
 构造方法
       public StringBuffer():无参构造方法,里面空的字符序列,初始容量16个字符(默认容量足够大)  -
       public StringBuffer(String str):将字符串构造为StringBuffer类型,容量是大小:当前的里面的字符串长度+16
       前两个构造方法使用居多!
       public StringBuffer(int capacity):创建一个字符串缓冲区,指定容量大小
  获取字符串缓冲区的长度 ---int length()
  获取字符串缓冲区的容量---int capacity()

StringBuffer的添加/删除的功能

StringBuffer的添加/删除的功能
  添加:
       public StringBuffer append(任意java类型) 可以将任意类型的元素添加(在末尾追加)到字符串缓冲区中,返回值是字符串缓冲区本身

     public StringBuffer insert(int offset,任意java类型):在指定位置处的序列前面插入新的序列
  删除:
          public StringBuffer deleteCharAt(int index):在指定位置处删除指定的字符,返回字符串缓冲区本身
          public StringBuffer delete(int start,int end):从指定位置start处开始到end-1处的字符序列删除,
                          返回值字符串缓冲区本身

   开发中使用居多:追加功能以及删除 deletCharAt(int  index)使用居多

StringBuffer的特有功能-字符串缓冲区反转功能:

     public StringBuffer reverse() :字符串缓冲区反转功能,将字符串缓冲区中所有的字符序列反转!

例:

 *需求:
 *      键盘录入一个字符串,将字符串反转
 *
 *    方式1:不让你使用StringBuffer的特有功能,让你使用String
 *       1)将录入的字符串---->转换成字符数组
 *       2)定义一个String s = "" ;
 *       3)将字符数组倒着遍历
 *       for(int i = 字符数组.length-1;i>0 ;i --){
 *           s += 字符数组[i] ;
 *
 *       }
 *       4)返回结果变量s
public class StringBufferDemo3 {
    public static void main(String[] args) {

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;

        //提示并录入数据
        System.out.println("请输入一个字符串:" ) ;
        String line = sc.nextLine() ;

        //调用一个功能完成
        String result = reverse(line);
        System.out.println(result) ;
        System.out.println("---------------------------------------") ;
        String result2 = reverse2(line);
        System.out.println(result2);
    }

    //方式2:使用StringBuffer的反转功能
    public static String reverse2(String s){
       /*StringBuffer sb = new StringBuffer() ;
       sb.append(s) ;
       return sb.reverse().toString() ;*/

         return new StringBuffer(s).reverse().toString() ;
    }


    public static String reverse(String s){
        //定义一个空字符串
        String result = "" ;
        //将s字符串-->转换功能  --->字符数组
        char[] chs = s.toCharArray();
        for(int x = chs.length-1 ; x >= 0 ; x--){
            result += chs[x] ;
        }
        return  result ;
    }
}

StringBuffer其他功能-替换功能:

      替换功能
      
 public StringBuffer replace(int start,int end,String str)
 使用指定的字符串str从指定位置开始到end-1处进行替换,返回该字符串缓冲区本身
 public String substring(int start):从指定位置开始截取,默认截取到末尾,返回被截取后的字符串
 public String substring(int start,int end):从指定位置开始截取到指定位置end-1处,返回被截取后的字符串

//String<---->StringBuffer相互转换  (重点)

public class StringBufferTest {
    public static void main(String[] args) {

        //String---->StringBuffer
        String s = "hello" ;
       // StringBuffer sb = s ;

        //方式1)可以通过StringBuffer的有参构造方法
        //StringBuffer(String str)
        //创建一个字符串缓冲
        StringBuffer sb = new StringBuffer(s) ;
        System.out.println(sb) ;

        System.out.println("-------------------------") ;
        //方式2:通过StringBuffer的无参构造方法+append(String str)
        StringBuffer sb2  = new StringBuffer() ;
        sb2.append(s) ;
        System.out.println(sb2);


        System.out.println("---------------StringBuffer-->String------------------");
        //有一个字符串缓冲区--->里面存在字符序列
        StringBuffer buffer = new StringBuffer("100") ;
        //方式1) -->public String toString()
        String str = buffer.toString();
        System.out.println(str) ;
        System.out.println("----------------------------------------") ;
        //方式2:String类的构造方法
        //public String(StringBuffer buffer)
        String str2 = new String(buffer)  ;
        System.out.println(str2) ;


    }
}

String和StringBuffer的区别?

String特点:字符串是一个常量,一旦被创建,其值不能被更改

String作为形式参数,形参的改变不会影响实际参数;

而除过String这个引用类型之外,形式参数的改变直接影响实际参数!

StringBuffer特点:

字符串缓冲区支持可变的字符串,线程安全,执行效率低!

Integer类

功能:十进制转换成对应的进制的方法(静态方法)

拆箱和装箱:

四类八种的基本数据类型都会自动提升 对应的引用类型              jdk5以后新特性:自动拆装箱

           拆箱:
                  这些包装类类型--->降为 基本类型
           装箱:
                  就是基本类型--->提升  对应的引用类型

              基本类型                       引用类型的默认值null
                  byte                        Byte
                  short                       Short
                  int                         Integer(特殊)
                  long                        Long

                  float                       Float
                  double                      Double

                  char                        Character(特殊)

                  boolean                     Boolean
                  
      这些四类八种中的基本数据类型可以String进行相互转换的---->中间桥梁 ---->对应的基本类型的包装类类型!
      String-->Integer--->int
          "100"  --->100

       String--Long-->long



       Integer和Character涉及相关功能

public class IntegerDemo {
    public static void main(String[] args) {
        //public static String toOctalString(int i) 以字符串形式体现八进制
        //public static String toHexString(int i)  以字符串形式体现16进制
        //public static String toBinaryString(int i)以字符串形式体现的2进制
        System.out.println(Integer.toBinaryString(100));
        System.out.println(Integer.toOctalString(100));
        System.out.println(Integer.toHexString(100));
        System.out.println("-------------------------------------");
        //public static final int MAX_VALUE:常量:获取int的最大值
        //public static final int MIN_VALUE:常量:获取int的最小值
        System.out.println(Integer.MIN_VALUE) ;
        System.out.println(Integer.MAX_VALUE) ;

    }
}

Integer类表示包含int类型的值
 Integer类的构造方法:
      public Integer(int value):创建一个Integer实例,里面包含的int类型的值
      public Integer(String s) throws NumberFormatException: 将数字字符串转换成Integer的实例
              可能会出现数字格式化异常(字符串如果不是数字字符串,就会出现这个异常)

public class IntegerDemo2 {
    public static void main(String[] args) {
        //创建一个Integer实例
        //public Integer(int value):创建一个Integer实例,里面包含的int类型的值
        int a = 100 ;
        Integer i = new Integer(a) ;
        System.out.println(i) ;
        System.out.println("-----------------------------") ;
        // public Integer(String s) throws NumberFormatException:
        //Integer i2 = new Integer("hello") ;//NumberFormatException:数字格式化异常
        Integer i2 = new Integer("50") ;

        System.out.println(i2);


    }
}

int基本类型和引用String的相互转换 (重点)

int基本类型和引用String的相互转换  (重点)

 String---int:                int  变量名 = Integer.parseInt(已知的数字字符串) 推荐
 int---->String:            Integer类提供静态方法        String 变量名 = Integer.toString(int类型的值)

public class IntegerDemo4 {
    public static void main(String[] args) {

        //int---->String
        //方式1)比较简单
        int i = 100 ;
        String s = "" ;
        s += i ; //拼接符号 s = s+i
        System.out.println(s) ;//"100"
        System.out.println("-----------------------------------------") ;
        //方式2):int---->Integer----->String
        //int-->Integer
        //Integer integer = new Integer(i) ; //有参构造方法
        Integer integer = Integer.valueOf(i);
        //Integer--->String
        String str = integer.toString();
        System.out.println(str);

        System.out.println("----------------------------------------------") ;
        //方式3:Integer---->String
        //public static String toString(int i)
        String str2 = Integer.toString(i);
        System.out.println(str2);


        System.out.println("---------------------String-->Integer->int----------------------------") ;
        //推荐一步执行:
        //Integer类提供了静态方法
        //public static int parseInt(String s)throws NumberFormatException:要转的字符串必须为数字字符串

        //万能方法:String--->long  --->Long引用提供静态方法 public static long pasreLong(String str)
        //...
        String source = "1990" ;
        int value = Integer.parseInt(source);
        System.out.println(value) ;
        System.out.println("------------------------------------------");
        //分步执行
        //String--->Integer---->int
        //Integer(String str)
        Integer ii = new Integer(source) ;
        //Integer--->int     public int intValue() :
        int value2 = ii.intValue();
        System.out.println(value2) ;
    }
}

Integer是int类型的包装类类型,它里面的特点

Integer是int类型的包装类类型,它里面的特点

   Integer:
   将int类型赋值给Integer变量 这种格式,执行底层方式valueOf(int i)


   public static Integer valueOf(int i) {
          如果i的值在-128~127之间,直接从内部类--->IntegerCache缓存去中取数据
         if (i >= IntegerCache.low && i <= IntegerCache.high)
             return IntegerCache.cache[i + (-IntegerCache.low)]; //  cache属性:Integer cache[] 长度 =i+128
         return new Integer(i);   //如果上if不成立,重新开辟新的空间创建Integer实例
     }

Character类

char类型的包装类类型:Character
 构造方法:
      public Character(char value):包含char类型的值
 成员方法:
      判断功能:
          public static boolean isDigit(char ch):判断当前这个字符是否为数字
          public static boolean isLowerCase(char ch):判断当前这个字符是否小写
          public static boolean isUpperCase(char ch):判断当前这个字符是否大写

需求：键盘录入一个字符串,统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
    举例：
         "Hello123World"
 
      提示:统计字符定义三个统计变量,分别代表大写字母字符,小写字母字符,数字字符
            'A'-'Z' 大写
            'a'-'z' 小写
            '0'-'9' 数字
 

import java.util.Scanner;

public class CharacterTest {
    public static void main(String[] args) {
        //定义一个三个统计变量
        int upperCount = 0 ;
        int lowerCount = 0 ;
        int digitCount = 0 ;

        //键盘录入一个字符串
        Scanner sc= new Scanner(System.in) ;
        //提示并录入数据
        System.out.println("请您输入一个字符串:") ;
        String line = sc.nextLine() ;

        //选择核心代码--->快速抽取一个方法:ctrl+alt+M--->修改方法名即可!
        getCharCount(upperCount, lowerCount, digitCount, line);


    }

    private static void getCharCount(int upperCount, int lowerCount, int digitCount, String line) {
        //将字符串转换成字符数组
        char[] chs = line.toCharArray();
        //遍历字符数组
       /* for(int x = 0 ; x < chs.length ; x++){
            //获取每一个字符
            char ch = chs[x] ;
            //判断
            if(ch >= 'A' && ch <= 'Z'){
                //大写字母字符
                upperCount++;
            }else if(ch >='a' && ch <= 'z'){
                //小字母字符
                lowerCount++ ;
            }else{
                //数字字符
                digitCount++ ;
            }
        }*/
        //使用另一种方式
        for(int x = 0 ;  x < chs.length ; x++){
            char ch = chs[x] ;//获取字符
            //使用Character类提供的特有功能
            if(Character.isUpperCase(ch)){
                upperCount ++ ;
            }else if(Character.isLowerCase(ch)){
                lowerCount ++ ;
            }else if (Character.isDigit(ch)){
                digitCount++ ;
            }else{
                System.out.println("没有其他字符类型");
            }
        }


        System.out.println("大写字母字符共有:"+ upperCount +"个,小写字母有:"+ lowerCount +
                "个,数字字符有:"+ digitCount +"个");
    }
}

System类

java.lang.System:不能实例化:提供了静态字段(静态变量)
      public static final PrintStream out :标准 打印输出流
      public static final PrintStream err  标准错误输出流
      public static final InputStream in  标准输入流

System类常用的成员方法:

      public static long currentTimeMillis() 计算当前系统时间毫秒值  (很少单独用)
                      用来计算当前某个程序的时间复杂度(运行效率)

      public static void gc() 收到开启垃圾回收器   ---会调用finalize(),回收没有更多引用的对象
      public static void exit(int status): 参数为0:终止jvm
      public static void arraycopy(
                                 Object src,  //原对象
                                  int srcPos,   //原对象中的某个位置
                              Object dest,      //目标对象
                              int destPos,       //目标对象的某个位置
                              int length)      //指定的长度

Random类

java.util.Random:伪随机数生成器  可以产生随机数 比Math.random()麻烦
      两个构造方法:
              public Random() :无参构造方法(推荐)
              public Random(long seed):有参构造,创建一个指定long类型的变量的随机数生成器
      两个成员方法:
              public int nextInt(): 产生伪随机数在,取值是int类型 的范围内
              public int nextInt(int n):产生0-n之间的随机数(推荐)

Collection类

Collection:单例集合顶层次的根接口,不能new,没有直接子实现类,是通过它子接口的子实现类来实例化!
 泛型: 集合里面创建的时候,如果不带泛型可能程序安全问题;带了<>,模拟创建数组的时候,明确了数据类型!
 <E>:element
 <T>:Type
 <K>:Key键
 <V>:Value值

 基本功能:
      添加元素:
              boolean add(E e):添加元素
      删除:
              boolean remove(Object o):删除指定的元素
              void clear():暴力删除:清空集合
      判断:
              boolean contains(Object o):是否包含指定的元素
              boolean isEmpty():判断集合是否为空

Iterator<E> iterator():Collection专有迭代器(遍历集合) (过渡)

 Iterator迭代器接口:
      boolean hasNext(): 判断迭代器里面是否下一个可以遍历的元素
      E next():获取迭代器的下一个元素 (和迭代器中的类型一致)

        开发中---集合遍历---->都用jdk5以后新特性:增强for循环 代替上面迭代器

 // 需求:
 //       使用Collection<Student>存储5个学生对象,使用Iterator<E> iterator()进行遍历!
          
          public class CollectionDemo2 {
    public static void main(String[] args) {

        //使用Collection存储String字符串并进行遍历---使用Collection迭代器
        Collection<String> c = new ArrayList<>() ;

        //添加String
        c.add("android") ;
        c.add("JavaEE") ;
        c.add("mysql") ;
        c.add("hadoop") ;
        //c.add(100) ;

        //获取Collection的迭代器
        //Iterator<E> iterator()
        Iterator<String> it = c.iterator();
        //E next() //E---类型需要和泛型的类型一致的

        

        //while循环
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s+"---"+s.length());
        }

        
    }
}

Collection集合高级功能:

Object[] toArray():集合的传统方式遍历 将集合转换成对象数组(以后不会用的)

Calendar类-日历类

java.util.Calendar:日历类(抽象类)
  提供了获取年,年中的月,月中的日期,小时,小时分钟数,分钟中的秒数都可以获取到

  如果有一个类是抽象类,可以直接new子类,或者是它提供了一些静态方法---->
          完成了一些事情,创建子类对象,返回值是当前抽象类的本身

 成员方法:
      public static Calendar getInstance() 创建日历对象
      public int get(int field):通过日历对象获取日历中的字段值

                  参数:Calendar中提供的一些静态字段
                              public static final int YEAR:年份
                              public static final int DAY_OF_MONTH/public static final int DATE:月中的日期
                              public static final int MONTH:月份

      public abstract void add(int field,int amount):给指定的日历字段值添加或者减去时间偏移量

BigDecimal类-对小数进行精确计算

BigDecimal这个类是对小数可以进行精确计算的!
 构造方法:

      public BigDecimal(String val):将String类型数据构造成BigDecimal
          将double数据---使用"小数字符串"

  成员方法:
          public BigDecimal add(BigDecimal augend):求和
          public BigDecimal subtract(BigDecimal subtrahend):相减
          public BigDecimal divide(BigDecimal divisor):小数除法
          public BigDecimal divide(BigDecimal divisor,int roundingMode):除法,第二个参数舍入模式

                            BigDecimal提供的模式  public static final int ROUND_HALF_UP:四舍五入
                              ...
          public BigDecimal divide(BigDecimal divisor,
                          int scale,//保留几位小数
                          int roundingMode)     //舍入模式
          public BigDecimal multiply(BigDecimal multiplicand):乘法

Date类

	java.util.Date:表单特定的日期时间,还允许格式化和解析日期字符串
 		构造方法:
      		public Date():创建当前日期对象:获取当前系统日期时间
     		public Date(long date):里面传入long类型的时间毫秒值,获取的表示从标准基准时间（称为“时代”）即1970年1月1日00:00:00 GMT起的指定毫秒数
		成员方法:
      		public long getTime():将Date对象转换成long类型时间毫秒值
      		public void setTime(long time):设置日期时间,参数时间毫秒值
      
      
      
	java.util.Date重点如何和String日期文本相互转换!

 		他们之间要进行转换需要使用类DateFormat
		 DateFormat是日期/时间格式化子类的抽象类，它以语言无关的方式格式化和分析日期或时间
 		它具体的子类:SimpleDateFormat是一个具体的类,允许格式化（日期文本），解析（文本日期）

		构造方法:
 		     public SimpleDateFormat(String pattern):参数是日期模式         "yyyy-MM-dd"
   		   pattern的组成:
     		         y:表示年份中某个值----->yyyy 表示年 "1996/2023/..."
     		         M:表示年中的月份------>MM     表示月:七月-->"07" 十月 -->"10"
      		        d:表示月中的日期值----->dd   表示 "01","11","31"..
 		成员方法
     		 将Date---->String:格式化  public final String format(Date date)
     		 将String日期---->Date:解析

                              public Date parse(String source)throws ParseException

例:

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

/**
 * 键盘录入出生年月日,计算来到这个世界多少天了?
 *
 * 分析:
 *      1)键盘录入String dateStr = "1990-02-27"
 *      2)将dateStr日期字符串---->java.util.Date
 *      3)获取当前那个Date日期时间 毫秒值  long getTime()
 *      4)System提供了一个方法获取当前系统时间毫秒值
 *      5)时间差值---然后换算成天
 */
public class DateTest {
    public static void main(String[] args) throws ParseException {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;

        //提示并录入数据
        System.out.println("请输入您的出生年月日:" ) ;
        String dateStr = sc.nextLine() ;//yyyy年MM月dd日/yyyy-MM-dd

        //将dateStr---->java.util.Date
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd") ;
        Date date = sdf.parse(dateStr);

        //获取当前date所在时间毫秒值
        long oldTime = date.getTime();
        //获取当前系统时间毫秒值
        long nowTime = System.currentTimeMillis() ;

        long time = nowTime - oldTime ;


        System.out.println("您来到这个时间有:"+(time/1000/60/60/24)+"天");
    }
}