JAVASE 【Java基础六之常用类1】

m0_54668939

于 2023-04-29 01:00:00 发布

阅读量100

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/m0_54668939/article/details/126051717

版权

文章目录

JAVASE 【Java基础六之常用类1】

JAVASE 【Java基础六之常用类1】

1. API的概念

应用程序编程接口 : 每一个技术,官方都会定义出许多的功能,开发人员可以直接拿来使用(拿来主义). API可以理解为Sun公司已经开发好的类和方法. API文档就是我们开发的帮手

2. Object类

Object类 : 所有类的父类,一切类都直接或者是间接继承Object. Object类中的所有功能,子类都可以使用.福利 :

class XX {} //自己的构造方法,继承下来11个方法

Object类定义在了java.lang包, lang包是核心包,此包中的任何类,在使用的时候不需要import 导入

2.1、Object类的本地方法

本地方法 : 方法的定义上使用关键字,是修饰符 native ,这个方法就是本地方法.

本地方法的特点 :

方法没有方法体
方法是C++语言编写的,Sun公司不开源
方法运行的时候,是一个独立的内存 (本地方法栈)
作用 : 凡是遇到本地方法,方法的作用是和本机的操作系统交互的

2.2、Object类的方法toString()

自己定义类Person类,默认的继承Object,Object类定义定义了方法 :

public String toString(); //结果是字符串,就是对象内地地址

输出语句中System.out.println(对象) 调用对象的toString()

System.out.println(对象) == System.out.println(对象.toString())

toString方法的结果,和开发没有任何的关系. 我们需要的是重写父类的方法toStirng(),建立我们对象自己的字符串表现形式

[1] 2.2.1 重写父类的方法toString()

public class Person {
    private String name;
    private int age;
    public Person(){}
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 重写了父类的方法toString()
     * 返回字符串
     * @return
     * 重写方法目标 : 方法中,返回类中成员变量的值
     */
    public String toString(){
        return name + "::" + age;
    }
}

2.3、Object类的方法equals()

Java技术认为任何对象都具备比较性,Object类定义了方法equals(),作用就是用来比较对象的.方法结果是boolean值,对象相等就是true

自己进行了对象的比较

 boolean b = p1.equals(p2); // false 对象不相等

Object类的方法源码equals

public boolean equals(Object obj){
    return this == obj ;
}

引用数据类型 == 就是比较对象的地址是不是相同的
Object类的方法 equals默认比较对象的内存地址

思考 : 对象的地址有可比性吗北京海淀区中关村南大街1号, 北京昌平区北大产业园路2号. 不能比较对象的地址,我们要重写equals方法,建立我们对象Person自己的比较形式

public class Person {
    private String name;
    private int age;
    public Person(){}

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    /**
     * 重写equals,建立Person对象自己的比较方式
     * 比较对象的age年龄,年龄相同返回true
     */

    public boolean equals(Object obj){
        //健壮性判断,如果obj对象的值是null,比较的另一个对象不存在
        if (obj == null){
            return false;
        }
        //判断this和参数obj是不是一个对象 "p1" 如果是,返回true
        //怎么确定this和obj是不是一个对象,内地地址要是一样
        if ( this == obj ) {
            return true;
        }
        //比较对象的年龄,this和obj
        //obj向下转型为Person,安全性判断
        if (obj instanceof  Person) {//obj是Person对象
            Person p = (Person) obj;
            return this.age == p.age;
        }
        //不是Person,没有可比性
        return false;
    }
}

3.String字符串类

字符串对象,程序中定义""都是字符串对象,这个对象的使用频率最高.

字符串类 java.lang.String类,继承Object类,实现了三个接口.

程序中只要你写 “里面任意” 都是String类的对象.

字符串对象是常量,一旦创建不能修改.

3.1 字符串对象创建

public static void main(String[] args) {
    //字符串创建,2个方式
    //直接=创建
    String s = "abc";
    //使用构造方法创建
    String str = new String("aa");
}

直接 = 创建方式,代码少,书写简单,推荐使用
new String() 使用了构造方法的创建形式,代码大,不推荐使用

3.2 字符串的实现原理

字符串这个数据类,在Java中是不存在的,字符串的实现原理是用char[]数组表示.

“abc”,使用数组char[] ch = {‘a’,‘b’,‘c’} ;来表示.

JDK9版本之后,节约内存,char数组改变为了byte数组

JDK8版本以前都是char数组

private final char value[]; //JDK中String类的源码

数组的前面的修饰符final, 最终的数组,数组一旦建立,数组的地址就被锁死(常量)使用常量的原因,为了线程安全

3.3 字符串创建对象的区别

String str = "abc"; 
String str = new String("abc");

public class StringTest {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = new String("abc");
        System.out.println(s1 == s2); //false

        System.out.println("==========");
        /**
         *  s3 = hello 内存中出现String对象,里面是char数组
         *  s3保存的是String对象
         *
         *  s4 = "hello" 和s3中的字符串在内存中的数组表现是一样的
         *  共用
         *  s3的内存地址,赋值给s4
         */
        String s3 = "hello";
        String s4 = "hello";
        System.out.println(s3 == s4); //true

        System.out.println("========");

        String s5 = "how";
        String s6 = "you";

        String s7 = "howyou";
        /**
         *   s7 == (s5+s6)   s5和s6是变量
         *   变量在编译的时候,javac不确定变量的计算结果是什么
         *   运行的时候,JVM会为 s5+s6的结果,新开内存空间
         */
        System.out.println(s7 == (s5+s6)); //false

        System.out.println("============");

        /**
         *  "how"+"you" 是常量,值在编译期间就已经确定
         *  运行,不会建立新的内存空间
         */
        System.out.println(s7 == ("how"+"you"));// true

        String s8 = "a"+"b"+"c";

    }

    public static void print(){
        //字符串的不变
        //abc内存是不会改变
        String s = "abc";
        System.out.println(s);
        //变量s,指向了新的字符串对象
        s = "bbc";
        System.out.println(s);
    }
}

3.4 String类的构造方法

讲过字符编码, ASCII, 小写字母a的值97

String(byte[] b) 字节数组转成字符串,使用平台的默认字符集
String(byte[] b,int off,int len) 字节数组转成字符串,使用平台的默认字符集,参数off数组的开始索引,len要转的个数
String(byte[] b,int off,int,len,String,charsetName) 字节数组转成字符串,使用平台的默认字符集,参数off数组的开始索引,len要转的个数,charsetName参数是你自己可以指定编码表

public class StringTest {
    public static void main(String[] args) throws UnsupportedEncodingException {
        stringConsByte3();
    }

    //String类构造方法相关,和字节,汉字相关
    public static void stringConsByte3() throws UnsupportedEncodingException {
        // String(byte[] bytes)通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
        //平台是操作系统, 默认字符集是GBK
        //强制指定为GBK编码
        byte[] bytes ={-28, -67, -96, -27};
        String str = new String(bytes,"gbk");
        System.out.println(str);
    }

    //String类构造方法相关,和字节,汉字相关
    public static void stringConsByte2(){
        // String(byte[] bytes)通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
        //平台是操作系统, 默认字符集是GBK
        //IDEA 启动的时候,为JVM添加启动参数,默认字符集改成UTF-8

        byte[] bytes ={-28, -67, -96, -27, -91, -67}; // 6字节的数组,转为字符串后是2个汉字
        String str = new String(bytes);
        System.out.println(str);
    }

    //String类构造方法相关,和字节
    public static void stringConsByte(){
       // String(byte[] bytes)通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
        //平台是操作系统, 默认字符集是GBK
        byte[] bytes = {97,98,99,100};
        String str = new String(bytes);
        System.out.println(str);

        //数组的一部分转成字符串
        String str1 = new String(bytes,1,2);//从1索引开始,要2个
        System.out.println(str1);
    }
}

String(char[] b) 字节数组转成字符串

String(char[] b,int off,int,len) 字节数组转成字符串,参数off数组的开始索引,len要转的个数

//String类的构造方法,new String(char[])
public static void stringConsChar(){
    char[] ch = {'a','b','c','d','e'};
    //构造方法,数组转成字符串
    String s = new String(ch);
    System.out.println(s);

    //构造方法,数组转成字符串,转一部分
    String s1 = new String(ch,1,3);//从1索引开始,转3个
    System.out.println(s1);
}

3.5 String类的常用方法

String类的判断类型的方法, 返回都是布尔类型

boolean equals(Object obj) 字符串之间的比较,两个字符串相同,返回true
boolean equalsIgnoreCase(String str ) 字符串之间的比较,两个字符串相同,返回true,忽略大小写
boolean startWith(String str)判断字符串是否以另一个字符串开头,是开头就返回true
boolean endsWith(String str)判断字符串是否以另一个字符串结尾,是结尾就返回true
boolean contains(String str) 判断字符串中是否包含另一个字符串,完全包含返回true
boolean isEmpty()判断字符串的长度是不是0,如果是0返回true

public static void  stringMethod(){
        //boolean equals(Object obj) 字符串之间的比较,两个字符串相同,返回true
        //String类继承Object,重写父类方法,比较的是字符串的实际内容
        String s1 = new String("abc");
        String s2 = new String("abc");
        boolean b = s1.equals(s2);
        System.out.println(b);

        System.out.println("====================");
        //boolean equalsIgnoreCase(String str ) 字符串之间的比较,两个字符串相同,返回true,忽略大小写
        b = "abcdef".equalsIgnoreCase("ABCDEF");
        System.out.println(b);
        System.out.println("=============");
        //boolean startWith(String str)判断字符串是否以另一个字符串开头,是开头就返回true
        b = "HelloWorld.Java".startsWith("Hello");

        System.out.println(b);
        b = "HelloWorld.Java".endsWith(".Java");
        System.out.println("=============");
        System.out.println(b);

        //boolean contains(String str) 判断字符串中是否包含另一个字符串,完全包含返回true
       b = "how are you".contains("are  ");
        System.out.println("=============");
        System.out.println(b);

        //boolean isEmpty()判断字符串的长度是不是0,如果是0返回true
        b = "".isEmpty();
        System.out.println("=============");
        System.out.println(b);
    }

String类的获取方法,返回值不一定

int length() 返回字符串长度,字符串中字符的个数
char charAt(int index) 返回指定索引上的单个字符
int indexOf(String str) 返回指定的字符串,在当前字符串中第一次出现的索引
int lastIndexOf(String str) 返回指定的字符串,在当前字符串中最后一次出现的索引
String substring(int start,int end)截取字符串,参数表示开始索引和结束索引,包含开头索引,不包含结束索引

  /**
     * String类的获取方法
     */
    public static void stringMethod2(){
        //int length() 返回字符串长度,字符串中字符的个数
        int length = "abcdef".length();
        System.out.println("length = " + length);

        //char charAt(int index) 返回指定索引上的单个字符
        char ch = "abcdef".charAt(3);
        System.out.println("ch = " + ch);

        //int indexOf(String str) 返回指定的字符串,在当前字符串中第一次出现的索引
        //找不到指定的字符串,返回-1  负数不能作为索引出现
        int index = "how do you do".indexOf(" ");
        System.out.println("index = " + index);

        //int lastIndexOf(String str) 返回指定的字符串,在当前字符串中最后一次出现的索引
        index = "how do you do".lastIndexOf(" ");
        System.out.println("index = " + index);

        //String substring(int start,int end)截取字符串,参数表示开始索引和结束索引,
        // 包含开头索引,不包含结束索引
        String str = "HelloWorld";
        str =  str.substring(2,6);// 返回新的字符串
        System.out.println("str = " + str);

        //substring具有重载写法
        String str1 = "你好我好大家好";
        str1 = str1.substring(3);//从3索引开始,截取到最后
        System.out.println("str1 = " + str1);
    }

String类的转换方法

String toLowerCase() 字符串中的所有内容转成小写
String toUpperCase() 字符串中的所有内容转成大写
char[] toCharArray() 字符串转成字符数组
byte[] getBytes() 字符串转成字节数组 (查询编码表),平台默认字符集
byte[] getBytes(String charsetName) 字符串转成字节数组 (查询编码表),指定编码表
static String valueOf(任意类型参数) 参数转成字符串对象

   /**
     * String类的转换方法
     */
    public static void stringMethod3() throws UnsupportedEncodingException {
        //- String toLowerCase() 字符串中的所有内容转成小写
        // - String toUpperCase() 字符串中的所有内容转成大写
        String str = "abCDefGHJktyM";
        String lower = str.toLowerCase();
        String upper = str.toUpperCase();
        System.out.println("lower = " + lower);
        System.out.println("upper = " + upper);

        //char[] toCharArray() 字符串转成字符数组
        char[] ch = str.toCharArray();
        System.out.println(ch);

        //byte[]  getBytes() 字符串转成字节数组 (查询编码表),平台默认字符集
        String s = "呵呵你好";
        byte[] bytes = s.getBytes("gbk");
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }

       // static String valueOf(任意类型参数) 参数转成字符串对象
        int i = 1;
        String strI = String.valueOf(i);
        System.out.println(strI+1);
    }

String类的比较方法

int compareTo(String str) 字符串之间的比较,谁大谁小,按照字典顺序(自然顺序)

 /**
     * String类的字符串的比较方法,字典顺序
     */
    public static void stringMethod4() throws UnsupportedEncodingException {
        //int compareTo(String str) 字符串之间的比较,谁大谁小,按照字典顺序(自然顺序)
        String str1 = "bcm";
        String str2 = "baz";
        //对象str1调用方法compareTo,参数传递str2
        /**
         *  返回值是int
         *  返回的是 负数,调用者小
         *  返回的是 正数,调用者大
         *  返回是0  一样大
         */
        int i = str1.compareTo(str2);
        System.out.println("i = " + i);
    }

String类的方法去空格,替换,切割

String trim() 去掉字符串两边空格,中间空格不去掉
String replace(String oldString,String newString)替换字符串
String[] split(“规则字符串”) 对字符串进行切割

    /**
     * String类的方法 去空格,替换,切割
     */
    public static void stringMethod5() throws UnsupportedEncodingException {
        //String trim() 去掉字符串两边空格,中间空格不去掉
        String str = "  abc  def       ";
        System.out.println(str);
        str = str.trim();
        System.out.println("str = " + str);

        //String[] split("规则字符串") 对字符串进行切割
        String splitStr = "aa,bb,cc,dd,ee"; // 逗号,进行切割
        String[] strs = splitStr.split(",");
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }

        //String replace(String oldString,String newString)替换字符串
        String repStr = "how do you do";
        repStr = repStr.replace("o","N");
        System.out.println("repStr = " + repStr);
    }

String类正则表达式相关的功能

正则表达式 : 专门用于处理字符串的技术 (正则大神)

字符类 :
- [abc] 字符串的这个位置只能是abc
- [^abc] 字符串的这个位置不能是abc
- [a-zA-Z] 字符串的这个位置必须是字母,52个
- [^a-zA-Z] 字符串的这个位置必须不能是字母,52个
数字类:
- [0-9] 字符串的这个位置只能是数字
- [^0-9] 字符串的这个位置不能是数字
- [\d] 等同于 [0-9]
- [\D] 等同于 [^0-9]
预定义字符 :
- . 匹配所有的字符
- [\d] 等同于 [0-9]
- [\D] 等同于 [^0-9]
- [\w] 文字字符,包含数字,字母,下划线 [a-zA-Z0-9_]
- [\W] 文字字符,不能包含数字,字母,下划线 [^a-zA-Z0-9_]
数量词 :
- X{m} X这个字符只能出现m次 a{3}
- X{m,} X这个字符至少出现m次
- X{m,n} X这个字符至少出现m次,不超过n次
- X? X这个字符出现一次,或者一次也没有
- X* X这个字符出现零次或者多次
- X+ X这个字符出现至少一次

正则表达式的匹配功能,String类的方法matches()

/**
     *  检查邮箱
     *  规则 :
     * @ 前面 : 可以是数组,字母,混合,_  位数放下
     * @ 后面 : 数组,字母  sina qq 126 1393 yahoo gmail 位数放下
     * . 固定 : com  cn org  edu gov 字母  位数放下
     */
public static void stringMethod2(){
    String email = "shihehe@sina.com";
    String reg = "[\\w]+@[a-z0-9]+(\\.[a-z]+)+";
    boolean b = email.matches(reg);
    System.out.println(b);

}
/**
     *  正则表达式检查手机号是否合法
     *  开头必须是1,长度固定11
     *  第二位3 4 5 6 7 8 9
     *  第三位 必须是都是数字
     */
public static void stringMethod(){
    String tel = "13800138000";
    //定义正则的规则,也是字符串
    String regex = "1[3459678][0-9]{9}";
    //正则规则,和字符串校验
    //String类的方法 matches()
    boolean b = tel.matches(regex);
    System.out.println(b);
}

String类的方法split

   public static void stringMethod3(){
        String str = "as123d387654w5465fasfr234567sa";
        String[] strings = str.split("\\d+");
        for (int i = 0; i < strings.length; i++) {
            System.out.println(strings[i]);
        }
        System.out.println("================");
        String ip = "192.....168.....35.121";
        String[] ipArray = ip.split("\\.+");
        for (int i = 0; i < ipArray.length; i++) {
            System.out.println(ipArray[i]);
        }
    }

String类的方法replaceAll

 public static void stringMethod4(){
        String str = "as123d387654w5465fasfr234567sa";
        //字符串中的所有数组,换成#
        String repString = str.replaceAll("\\d+","#");
        System.out.println(repString);

        String first =  str.replaceFirst("\\d+","#");
        System.out.println(first);
    }

4. StringBuilder

StringBuilder是字符串对象的缓冲区对象, 缓冲区(出现目的,为了高效)提供String类的效率.

String str = "a"; //字符数组
String str2 = "b";//字符数组
String str3 = str + str2;//字符数组

4.1 StringBuilder类的实现原理

一个可变的字符序列,字符序列就是字符数组

String 类中 : private final char[] value;
StringBuilder : char[] value;

字符序列是数组,Java数组的是定长的,一旦创建,长度固定!

创建对象的时候,StringBuilder中的数组的初始化长度为16个字符

StringBuilder自动的进行数组的扩容,新数组实现,原来数组的中元素复制到新的数组.

结论 : 无论怎么做字符串的操作,StringBuilder内部永远只有一个数组

StringBuilder类是线程不安全的类,运行速度快 , 推荐使用StringBuilder

StringBuffer是线程安全的类,运行速度慢,多线程的程序,使用

两个类的构造方法,和其他的方法,一模一样.

4.2、 StringBuilder类的常用方法

StringBuilder append(任意类型) 参数追加成字符串,无论参数写的是什么,变成字符串.相当于是字符串里面的 + 运算

public static void builderAppend(){
    StringBuilder builder = new StringBuilder();
    //方法append追加字符串
    builder.append(100);
    builder.append(5.8);
    builder.append(true);
    System.out.println("builder = " + builder);
}

方法调用链, 链式编程 :

链式编程 : 保证一个方法的返回值是一个对象,再使用这个对象调用的调用方法 :对象.方法().方法().方法()......

public static void builderAppend2(){
    StringBuilder builder = new StringBuilder();
    //方法append() 返回值是StringBuilder
    //return this 返回值是this (谁调用,我是谁)
    builder.append("hehe").append(false).append(1.5).append(1); //执行的结果,是builder对象,继续使用builder对象调用方法
    System.out.println("builder = " + builder);
}

StringBuilder insert(int 索引, 任意类型) 可以将任意类型的参数,插入到字符串缓冲区,指定索引.

/**
     * StringBuilder类的方法insert,指定位置,插入元素
     */
public static void builderInsert(){
    StringBuilder builder = new StringBuilder();
    builder.append("bcdef");
    //指定的索引上,添加字符串,原有字符,顺延
    builder.insert(2,"QQ");
    System.out.println("builder = " + builder);
}

StringBuilder类的其它方法
- int length() 返回字符串缓冲区的长度
- StringBuilder delete(int start,int end)删除缓冲区中的字符,包含开头索引,不包含结束索引
- void setCharAt(int 索引,char ch)修改指定元素上的字符
- StringBuilder reverse() 翻转字符串

4.3、 StringBuilder对象和String对象的互转

String对象转成StringBuilder对象 String --> StringBuilder
- StringBuilder类的构造方法 StringBuilder(String str)
- append方法 append(String str)

  /**
     * String -> StringBuilder
     */
    public static void stringToStringBuilder(){
        //构造方法
        StringBuilder builder = new StringBuilder("abc");
        //对象的方法append
        builder.append("hello");
    }

StringBuilder对象转成String对象 StringBuilder ->String
- StringBuilder的方法toString()
- String类的构造方法

    /**
     *  StringBuilder -> String
     */
    public static void stringBuilderToString(){
        StringBuilder builder = new StringBuilder();
        builder.append("我是字符串的缓冲区");
        //builder对象转成String对象,调用builder对象的方法 toString()
        String str = builder.toString();
        System.out.println(str);

        //String类的构造方法
        String s = new String(builder);
        System.out.println(s);
   }

5.System类

System系统类 : 定义在java.lang包中

定义了大量常用的字段(成员变量)和方法,该类不能实例化对象,不能new,类中的成员全部是静态修饰,类名直接调用.

全部静态成员,无需对象创建,类名调用. 构造方法private修饰

5.1、 System类的方法

static long currentTimeMillis() 返回自1970年1月1日,午夜零时,到你程序运行的这个时刻,所经过的毫秒值 , 1000毫秒=1秒

/**
* static long currentTimeMillis()
* 返回自1970年1月1日,午夜零时,到你程序运行的这个时刻,所经过的毫秒值 ,
* 1000毫秒=1秒
*/
public static void systemCurrentTimeMillis(){
    long timeMillis = System.currentTimeMillis();
    System.out.println("timeMillis = " + timeMillis); 
}

static void arrayCopy( Object src,int srcPos,Object dest, int destPos,int length )复制数组的元素.
- src : 要赋值的数据源,源数组
- srcPos : 源数组的开始索引
- dest : 要复制的目标数组
- destPos : 目标数组的开始索引
- length : 要复制的元素个数

    public static void systemArraycopy(){
        int[] src = {1,3,5,7,9};
        int[] dest = {2,4,6,8,0};
        //数组元素的赋值 : src数组中的3,5 复制到dest数组中0索引开始
        System.arraycopy(src,1,dest,0,2);
        for(int x = 0 ;  x < src.length ;x++ ){
            System.out.println(dest[x]);
        }
    }

static Properties getProperties() 返回当前的操作系统属性

    /**
     *  static Properties getProperties() 返回当前的操作系统属性
     *  System.getProperty(String 键名)
     */
    public static void systemGetProperties(){
        Properties properties = System.getProperties();
        System.out.println(properties);
        String str = System.getProperty("os.name");
        System.out.println(str);
    }

6. Math类

static double PI 圆周率
static double E 自然数的底数
static int abs(int a) 返回参数的绝对值
static double ceil(double d)返回大于或者等于参数的最小整数
static double floor(double d)返回小于或者等于参数的最大整数
static long round(double d)对参数四舍五入
static double pow(double a,double b ) a的b次幂
static double random() 返回随机数 0.0-1.0之间
static double sqrt(double d)参数的平方根

public static void main(String[] args) {
// System.out.println("Math.PI = " + Math.PI);
//  System.out.println("Math.E = " + Math.E);

//static int abs(int a) 返回参数的绝对值
System.out.println(Math.abs(-6));

//static double ceil(double d)返回大于或者等于参数的最小整数
System.out.println(Math.ceil(12.3)); //向上取整数

//static double floor(double d)返回小于或者等于参数的最大整数
System.out.println("Math.floor(5.5) = " + Math.floor(5.5));//向下取整数

//static long round(double d)对参数四舍五入
long round = Math.round(5.5); //取整数部分  参数+0.5
System.out.println("round = " + round);

//static double pow(double a,double b ) a的b次幂
System.out.println("Math.pow(2,3) = " + Math.pow(2, 3));

//static double sqrt(double d)参数的平方根
System.out.println("Math.sqrt(4) = " + Math.sqrt(3));

// static double random() 返回随机数 0.0-1.0之间
for(int x = 0 ; x < 10 ; x++){
System.out.println(Math.random()); //伪随机数
}

}

7.Arrays工具类

java.util包中定义了类Arrays,数组操作的工具类.类不能创建对象,直接静态调用

Arrays类的静态方法
- static void sort(数组) 对数组进行升序排列 (目前为止效率最快)
- static int binarySearch(数组,查找的关键字) 对数组进行二分搜索法
- static void fill(数组,填充的元素)
- static String toString(数组) 返回数组字符串表现形式
- static List asList(T…t) 元素转成List集合

    public static void main(String[] args) {
        int[] arr = {1,5,9,10,15,22,27,30};
        //arrayToString(arr);
       // arraySort(arr);
       // System.out.println(Arrays.toString(arr));

        int index = arrayBinarySearch(arr,5);
        System.out.println(index);

        arrayFill();
    }
    /**
     * fill填充数组
     */
    public static void arrayFill(){
        int[] arr = {1,2,3,4,5};
        Arrays.fill(arr,6);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * static int binarySearch(数组,查找的关键字) 对数组 进行二分搜索法
     * 返回元素在数组中出现的索引
     * 如果元素不存在,返回 (-插入点-1)
     * key : 放在数组中,保证有序的
     */
    public static int arrayBinarySearch(int[] arr,int key){
        int index = Arrays.binarySearch(arr, key);
        return index;
    }

    /**
     *  static void sort(数组) 对数组进行升序排列 (目前为止效率最快)
     */
    public static void arraySort(int[] arr){
        Arrays.sort(arr);
    }

    /**
     * static String toString(数组) 返回数组字符串表现形式
     * toString内部自动遍历数组
     */
    public static void arrayToString(int[] arr){
        String str =  Arrays.toString(arr);
        System.out.println(str);
    }

8. 大数运算

基本数据类型long ,double 都是有取值范围.遇到超过范围数据怎么办.引入了大数运算对象. 超过取出范围了,不能称为数字了,称为对象

java.math包 : BigInteger大整数, BigDecimal大浮点(高精度,不损失精度)

BigInteger类使用,计算超大整数的
- 构造方法直接new BigInteger(String str) 数字格式的字符串,长度任意
- BigInteger add(BigInteger b)计算两个BigInteger的数据求和
- BigInteger subtract(BigInteger b)计算两个BigInteger的数据求差
- BigInteger multiply(BigInteger b)计算两个BigInteger的数据求乘积
- BigInteger divide(BigInteger b)计算两个BigInteger的数据求商

public static void main(String[] args) {
        //创建大数据运算对象
        BigInteger b1 = new BigInteger("2345673456786554678996546754434343244568435678986");
        BigInteger b2 = new BigInteger("8765432345678987654323456787654");

        //b1+b2 求和
        BigInteger add = b1.add(b2);
        System.out.println("add = " + add);

        //b1 - b2 求差
        BigInteger subtract = b1.subtract(b2);
        System.out.println("subtract = " + subtract);

        //b1 * b2 求积
        BigInteger multiply = b1.multiply(b2);
        System.out.println("multiply = " + multiply);
        
        //b1 / b2 求商
        BigInteger divide = b1.divide(b2);
        System.out.println("divide = " + divide);
    }

BigDecimal 类使用,计算超大浮点数
- 构造方法,和BigInteger一样
- 方法 + - * 和BigInteger一样
- BigDecimal divide除法运算
- divide(BigDecimal big,int scalar,int round)方法有三个参数
  - big 被除数
  - scalar 保留几位
  - round 保留方式
- 保留方式 : 该类的静态成员变量
  - BigDecimal.ROUND_UP 向上+1
  - BigDecimal.ROUND_DOWN 直接舍去
  - BigDecimal.ROUND_HALF_UP 四舍五入

public static void main(String[] args) {
    BigDecimal b1 = new BigDecimal("3.55");
    BigDecimal b2 = new BigDecimal("2.12");
    /* System.out.println(b1.add(b2));
    System.out.println(b1.subtract(b2));
    System.out.println(b1.multiply(b2));*/

    //b1 / b2
    /**
    * 1.674528301886792
    * 除不尽,出现异常
    * 高精度运算,不能产生无序循环小数,无限不循环
    * 保留几位,怎么保留
    *
    * BigDecimal.ROUND_UP  向上+1
    * BigDecimal.ROUND_DOWN 直接舍去
    * BigDecimal.ROUND_HALF_UP 四舍五入
    */
    BigDecimal divide = b1.divide(b2,3,BigDecimal.ROUND_HALF_UP);
    System.out.println("divide = " + divide);
    }

9. 日期和日历类

9.1 Date

表示当前的日期对象,精确到毫秒值. java.util.Date类

构造方法
- 无参数构造方法 new Date()
- 有long型参数的构造方法 new Date(long 毫秒值)
Date类没有过时的方法
- long getTime() 返回当前日期对应的毫秒值
- void setTime(long 毫秒值) 日期设定到毫秒值上

    /**
     *  创建对象,使用有参数的构造方法
     */
    public static void date2(){
        Date date = new Date(0);
        System.out.println("date = " + date);
    }

    /**
     * 创建对象,使用无参数的构造方法
     */
    public static void date1(){
        Date date = new Date();
        //Tue Apr 13 10:33:40 CST 2021
        System.out.println("date = " + date);
    }
    /**
     *  getTime()
     *  setTime()
     */
    public static void date3(){
        Date date = new Date();
        //获取毫秒值
        long time = date.getTime();
        System.out.println(time);

        //设置日期
        date.setTime(0);
        System.out.println(date);
    }

9.2 Date类最重要内容

日期对象和毫秒值之间的相互转换
日期对象,转成毫秒值
- new Date().getTime()
- System.currentTimeMillis()
毫秒值转成日期对象
- new Date(毫秒值)
- new Date().setTime(毫秒值)

日期是特殊的数据,不能数学计算,但是毫秒值能!!

24*60*60*1000 一天的毫秒值

9.3 日历类 Calendar

日历类 : java.util.Calendar

日历字段 : 组成日历的每个部分,都称为日历字段 : 年,月,日,时分秒,星期

Calendar抽象类,不能建立对象,子类继承 : GregorianCalendar (格林威治)

[1] 获取Calendar类的对象

由于创建日历对象的过程非常的繁琐,考虑语言,时区… Sun公司工程师开发了一简单获取对象的方式,不要自己new

Calendar类定义了静态方法 : static Calendar getInstance() 返回的是Calendar 的子类的对象 GregorianCalendar

[2] 日历类的方法

int get(int field) 返回给定日历字段的值
- 日历中的任何数据,都是int类型
- 参数是具体的日历字段,传递年,月,日
- 日历字段的写法,看Calendar类的静态成员变量

   /**
     * Calendar类的方法get()
     * 获取日历字段
     */
    public static void calendarGet(Calendar calendar){
        //Calendar calendar =  Calendar.getInstance();//返回子类对象
       /* int year = calendar.get(Calendar.YEAR);
        System.out.println(year);*/
        System.out.println( calendar.get(Calendar.YEAR)+"年" + (calendar.get(Calendar.MONTH) +1)+"月" +
                calendar.get(Calendar.DAY_OF_MONTH)+"日" + calendar.get(Calendar.HOUR_OF_DAY)+"点" +
                calendar.get(Calendar.MINUTE)+"分"+calendar.get(Calendar.SECOND)+"秒");
    }

void set() 修改日历的值
- set(int field,int value)field要修改的字段,value具体的数据
- set(int,int,int) 传递年月日

/**
* Calendar类的方法set()
* 设置日历字段
*/
public static void calendarSet(){
    Calendar calendar = Calendar.getInstance() ; //和操作系统时间一样
    //自己设置日历,传递了年月日
    //calendar.set(2021,5,30);

    //设置某一个字段
    calendar.set(Calendar.DAY_OF_MONTH,30);
    //调用calendarGet,输出日历
    calendarGet(calendar);
}

add() 设置日历字段的偏移量
- add(int field,int value) field要修改的字段,value具体的数据

/**
     * Calendar类的方法add()
     * 设置日历字段的偏移量
     */
public static void calendarAdd(){
    Calendar calendar = Calendar.getInstance() ; //和操作系统时间一样
    //日历向后,偏移180天
    calendar.add(Calendar.DAY_OF_MONTH,180);
    calendarGet(calendar);
}

9.4 日期格式化

自定义日期的格式 : 自己的喜好,定义日期的格式

[1]DateFormat日期格式化

java.text.DateFormat : 类的作用是格式化日期的,但是抽象类不能建立对象,需要创建子类的对象, SimpleDateFormat

[2] SimpleDateFormat子类使用

构造方法: 带有String参数的构造方法
- 参数字符串 : 日期格式化后的样子
- 调用SimpleDateFormat类的父类方法format
- String format(Date date)传递日期对象,返回字符串

/**
* 日期格式化,自定义格式
*/
public static void format(){
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH点mm分ss秒");
    String str = sdf.format(new Date());
    System.out.println(str);
}

字符串转成日期对象
- SimpleDateFormat调用方法Date parse(String str)

    /**
     * 字符串转成日期对象
     */
    public static void parse() throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        /**
         *  dateString用户输入的日期
         *  转成Date对象
         *  前提 : 格式必须和SimpleDateFormat("格式一致")
         */
        String dateString = "2021-04-13";
        //sdf对象的方法parse
        Date date = sdf.parse(dateString);
        System.out.println("date = " + date);
    }

10. JDK8新的时间日期对象

10.1 LocalDate 本地日期

获取该类的对象,静态方法
- static LocalDate now() 获取LocalDate的对象,跟随操作系统
- static LocalDate of() 获取LocalDate的对象,自己设置日期
  - of方法中传递年月日 of(int year,int month,int day)

/**
* LocalDate的静态方法获取对象
*/
public static void getInstance(){
    //静态方法now()
    LocalDate localDate = LocalDate.now();
    System.out.println("localDate = " + localDate);

    //静态方法of()设置日期
    LocalDate of =  LocalDate.of(2022,5,10);
    System.out.println("of = " + of);
}

获取日期字段的方法 : 名字是get开头
- int getYear() 获取年份
- int getDayOfMonth()返回月中的天数
- int getMonthValue() 返回月份

/**
* LocalDate类的方法 getXXX()获取日期字段
*/
public static void get(){
    LocalDate localDate = LocalDate.now();
    //获取年份
    int year = localDate.getYear();
    //获取月份
    int monthValue = localDate.getMonthValue();
    //获取天数
    int dayOfMonth = localDate.getDayOfMonth();
    System.out.println("year = " + year);
    System.out.println("monthValue = " + monthValue);
    System.out.println("dayOfMonth = " + dayOfMonth);
}

设置日期字段的方法 : 名字是with开头
- LocalDate withYear(int year)设置年份
- LocalDate withMonth(int month)设置月份
- LocalDate withDayOfMonth(int day)设置月中的天数
- LocalDate对象是不可比对象,设置方法with开头,返回新的LocalDate对象

/**
     * LocalDate类的方法 withXXX()设置日期字段
     */
public static void with(){
    LocalDate localDate = LocalDate.now();
    System.out.println("localDate = " + localDate);
    //设置年,月,日
    //方法调用链
    LocalDate newLocal = localDate.withYear(2025).withMonth(10).withDayOfMonth(25);
    System.out.println("newLocal = " + newLocal);
}

设置日期字段的偏移量, 方法名plus开头,向后偏移
设置日期字段的偏移量, 方法名minus开头,向前偏移

 /**
     * LocalDate类的方法 minusXXX()设置日期字段的偏移量,向前
     */
    public static void minus() {
        LocalDate localDate = LocalDate.now();
        //月份偏移10个月
        LocalDate minusMonths = localDate.minusMonths(10);
        System.out.println("minusMonths = " + minusMonths);
    }
    /**
     * LocalDate类的方法 plusXXX()设置日期字段的偏移量,向后
     */
    public static void plus(){
        LocalDate localDate = LocalDate.now();
        //月份偏移10个月
        LocalDate plusMonths = localDate.plusMonths(10);
        System.out.println("plusMonths = " + plusMonths);
    }

10.2 Period和Duration类

[1]Period 计算日期之间的偏差

static Period between(LocalDate d1,LocalDate d2)计算两个日期之间的差值.
- 计算出两个日期相差的天数,月数,年数

public static void between(){
    //获取2个对象,LocalDate
    LocalDate d1 = LocalDate.now(); // 2021-4-13
    LocalDate d2 = LocalDate.of(2022,4,13); // 2022-6-15
    //Period静态方法计算
    Period period = Period.between(d1, d2);
    //period非静态方法,获取计算的结果
    int years = period.getYears();
    System.out.println("相差的年:"+years);
    int months = period.getMonths();
    System.out.println("相差的月:"+months);
    int days = period.getDays();
    System.out.println("相差的天:"+days);
}

[2] Duration计算时间之间的偏差

static Period between(Temporal d1,Temporal d2)计算两个日期之间的差值.

 public static void between(){
        LocalDateTime d1 = LocalDateTime.now();
        LocalDateTime d2 = LocalDateTime.of(2021,5,13,15,32,20);
       // Duration静态方法进行计算对比
        Duration duration = Duration.between(d1, d2);
        // Duration类的对象,获取计算的结果
        long minutes = duration.toMinutes();
        System.out.println("相差分钟:" + minutes);

        long days = duration.toDays();
        System.out.println("相差天数:"+days);

        long millis = duration.toMillis();
        System.out.println("相差秒:" + millis);

        long hours = duration.toHours();
        System.out.println("相差小时:"+hours);
    }

[3] DateTimeFormatter

JDK8中的日期格式化对象 : java.time.format包

static DateTimeFormatter ofPattern(String str)自定义的格式
String format(TemporalAccessor t)日期或者时间的格式化
TemporalAccessor parse(String s)字符串解析为日期对象

/**
* 方法parse,字符串转日期
*/
public static void parse(){
    //静态方法,传递日期格式,返回本类的对象
    DateTimeFormatter dateTimeFormatter =
    DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    String str = "2021-04-13 15:55:55";
    //dateTimeFormatter调用方法parse转换
    //返回接口类型,接口是LocalDate,LocalDateTime 都实现了该接口
    TemporalAccessor temporalAccessor = dateTimeFormatter.parse(str);
    //System.out.println(temporalAccessor);
    LocalDateTime localDateTime = LocalDateTime.from(temporalAccessor);
    System.out.println(localDateTime);
}

/**
* 方法format格式化
*
*/
public static void format(){
    //静态方法,传递日期格式,返回本类的对象
    DateTimeFormatter dateTimeFormatter =
    DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    //dateTimeFormatter对象调用方法format
    String format = dateTimeFormatter.format(LocalDateTime.now());
    System.out.println(format);
}

11. 基本数据类型对象包装类

基本数据类型,一共有8种. 可以进行计算,但是功能上依然不够用,JDK提供了一套基本数据类型的包装类,功能增强,全部在lang包

基本数据类型	对应的包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

基本数据类型的包装类的最重要功能 : 实现类基本数据类型和String的互转

11.1 基本类型int变成Integer类的对象

Integer类的构造方法
- Integer(int a) int类型转成Integer对象
- Integer(String s)字符串转成Integer对象,字符串必须纯数字格式
- static Integer valueOf(int a) int类型转成Integer对象
- static Integer valueOf(String s) 字符串转成Integer对象,字符串必须纯数字格式

/**
* 创建Integer类的对象
* 构造方法,new
* static方法 valueOf
*/
public static void getInstance(){
    Integer i1 = new Integer(100);
    Integer i2 = new Integer("120");
    System.out.println(i1);
    System.out.println(i2);

    Integer i3 = Integer.valueOf(200);
    Integer i4 = Integer.valueOf("220");
    System.out.println(i3);
    System.out.println(i4);
}

11.2 String对象转成基本数据类型int

static int parseInt(String str) 参数字符串转成基本类型,字符串数字格式.
int intValue() Integer对象构造方法中的字符串,转成基本类型

/**
* 字符串转成基本类型int
* 静态方法parseInt()
* 非静态方法 intValue()
*/
public static void stringToInt(){
    int i = Integer.parseInt("100");
    System.out.println(i+1);

    Integer integer = new Integer("2");
    int j = integer.intValue();
    System.out.println(j+1);
}

11.3 自动装箱和拆箱

自动装箱 : 基本数据类型自动转成引用类型 int -> Integer
自动拆箱 : 引用类型自动转成基本数据类型 Integer ->int

public static void auto(){
    //自动装箱  int类型自动转成Integer对象
    //javac编译特效 Integer integer = Integer.valueOf(1000) 本质还是new Integer
    Integer integer = 1000;
    System.out.println(integer);

    //自动拆箱 Integer类型自动转成int类型
    //javac编译特点  integer + 1;  integer.intValue()返回int类型  + 1 = 1001
    //Integer integer2 = 1001 装箱
    Integer integer2 = integer + 1;
    System.out.println(integer2);
}

/**
* 自动装箱和拆箱中的问题
*/
public static void auto2(){
    Integer i1 = 1000; //new Integer(1000)
    Integer i2 = 1000; //new Integer(1000)
    System.out.println("i1==i2::" + (i1 == i2) ); // F
    System.out.println(i1.equals(i2)); // T

    System.out.println("=====忧郁的分割线======");

    Integer i3 = new Integer(1);
    Integer i4 = new Integer(1);
    System.out.println("i3==i4::"+(i3 == i4));// F
    System.out.println(i3.equals(i4)); // T

    System.out.println("=====忧郁的分割线======");

    Integer i5 = 127;
    Integer i6 = 127;
    System.out.println("i5==i6::"+(i5 == i6)); //true  数据不要超过byte
}