03.java面向对象-常用类

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量385 收藏 1
点赞数
分类专栏： java面向对象高级部分补充 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54915265/article/details/134501923
版权

03.java面向对象-常用类

01. 包装类

1. 包装类的分类 Wrapper

  1. 针对八种基本数据类型相应的应用类型-包装类
  2. 有了类的特点，就可以调用类中的方法
    | 基本数据类型 | 包装类 |
    | ------------ | ----------- |
    | boolean | Boolean |
    | char | Character |
    | byte | Byte |
    | short | Short |
    | int | Integer |
    | long | Long |
    | float | Float |
    | double | Double |
public class WrapperType {
    public static void main(String[] args) {
        //Boolean
        //char -- Character
        //byte -- Byte
        //short -- Short
        //int -- Integer
        //long -- Long
        //float -- Float
        //double -- double
    }
}

2. 包装类和基本数据的转换

演示包装类和基本数据的转换

  1. jdk5 前手动装箱和拆箱的方式，装箱：基本类型-包装类型，反之拆箱
  2. jdk5 以后的自动装箱和拆箱方式
  3. 自动装箱底层调用的是valueOf方法，比如Integer.valueOf()
  4. **备注：**包装类主要用于将基本数据类型转换为对象（装箱）以及将对象转换为基本数据类型（拆箱）。
  5. 其他包装类的用法类似
public class Integer01 {
    public static void main(String[] args) {
        //1. jdk前是手动装箱和拆箱
        //手动装箱
        int n1 = 100;
        Integer integer = new Integer(n1);
        Integer integer1 = Integer.valueOf(n1);
        //手动拆箱
        int i = integer.intValue();
        //2. jdk5 就可以自动装箱
        int n2 = 200;
        //自动装箱 int -> Integer
        Integer integer2 = n2;//底层使用的是 Integer.valueOf(n2)
        //自动拆箱
        int n3 = integer2;//底层使用的是 Integer intValue()方法
    }
}

3. 包装类型和String类型的相互转换

1. 案例演示 以Integer和String装换为例，其他类似：
public class WrapperVSString {
    public static void main(String[] args) {
        //1. 包装类(Integer --> String)
        Integer i = 100;//自动装箱
        //方式1 对于原类型没有影响
        String str = i + "";
        //方式2 使用toString方法
        String str2 = i.toString();
        //方式3
        String str3 = String.valueOf(i);

        //2. String --> 包装类(Integer)
        String str4 = "1234";
        Integer i2 = Integer.parseInt(str4);//自动装箱
        //方式2
        Integer i3 = new Integer(str4); 

    }
}

4. Integer和Character类的常用方法

public class WrapperMethod {
	public static void main(String[] args) {
		System.out.println(Integer.MIN_VALUE); //返回最小值
		System.out.println(Integer.MAX_VALUE);//返回最大值
        
		System.out.println(Character.isDigit('a'));//判断是不是数字
		System.out.println(Character.isLetter('a'));//判断是不是字母
		System.out.println(Character.isUpperCase('a'));//判断是不是大写
		System.out.println(Character.isLowerCase('a'));//判断是不是小写
		System.out.println(Character.isWhitespace('a'));//判断是不是空格
        
		System.out.println(Character.toUpperCase('a'));//转成大写
		System.out.println(Character.toLowerCase('A'));//转成小写
	}
}

02. String类

1. String类的理解和创建对象

  1. String 对象用于保存字符串，也就是一组字符序列
  2. 字符串常量对象是用双引号引起的字符序列。例如：“你好”、“1.343”、“boy”等
  3. 字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节
  4. String类常用构造器：
    String s1 = new String();
    String s2 = new String(String original);
    String s3 = new String (char[] a);
    String S4 = new String(char[], int startIndex, int count);
  5. String类实现了Serializable接口，说明String 可以串行化
  6. String类实现了Comparable接口，说明String类可以进行比较
  7. String 是final类，不能被其他类继承
  8. String 有属性 private final char value[]; 用于存放字符串内容
  9. 重点：value是一个final类型，不可以修改（指的 不是是值不能修改，而是地址不能被修改）

2. 两种创建String对象的区别

方式一：直接赋值String s = “yzj”;
方式二：调用构造器 String s2 = new String(“yzj”);

  1. 方式一：先从常量池查看是否有“yzj”数据空间，如果有直接指向；如果没有则重新创建，然后指向。s最终指向的是常量池的空间地址
  2. 方式二：先从对中创建空间，里面维护了value属性，指向常量池的yzj空间。如果常量池中没有“yzj”，重新创建，如果有直接通过value指向。最终指向的是堆中的空间地址。

02. String类的常见方法

1. 说明

​ String类是保存字符串常量。每次更新都需要开辟空间，效率较低，因此java设计者还提供了StringBuilder 和 StringBuffer 来增强String的功能，并提高效率

2. String类常见方法一览

  1. equals：区分大小写，判断内容是否相等
  2. equalsIgnoreCase：忽略大小写判断内容是否相等
  3. length：获取字符的个数，字符串的长度
  4. indexOf：获取字符在在字符串中第一次出现的索引，索引从零开始，如果找不到，返回-1
  5. lastiIndexOf：获取字符在字符串中最后一次的索引，索引从零开始，如果找不到，返回-1
  6. substring：获取指定范围的字符串
  7. trim：去掉前后空格
  8. charAt：获取某处索引外的字符，注意不能使用Str[index] 这种方式
    String str = “hello”
    str[0] 错误的
    str.charAt(0) => h 正确
/**
 * String 常用方法
 **/
public class StringMethod {
    public static void main(String[] args) {
        //1. equals 前面已经讲过了. 比较内容是否相同，区分大小写
        String str1 = "hello";
        String str2 = "Hello";
        System.out.println(str1.equals(str2));//
        // 2.equalsIgnoreCase 忽略大小写的判断内容是否相等
        String username = "johN";
        if ("john".equalsIgnoreCase(username)) {
            System.out.println("Success!");
        } else {
            System.out.println("Failure!");
        }
        // 3.length 获取字符的个数，字符串的长度
        System.out.println("你是谁".length());
        // 4.indexOf 获取字符在字符串对象中第一次出现的索引，索引从 0 开始，如果找不到，返回-1
        String s1 = "wer@terwe@g";
        int index = s1.indexOf('@');
        System.out.println(index);// 3
        System.out.println("weIndex=" + s1.indexOf("we"));//0
        // 5.lastIndexOf 获取字符在字符串中最后一次出现的索引，索引从 0 开始，如果找不到，返回-1
        s1 = "wer@terwe@g@";
        index = s1.lastIndexOf('@');
        System.out.println(index);//11
        System.out.println("ter 的位置=" + s1.lastIndexOf("ter"));//4
        // 6.substring 截取指定范围的子串
        String name = "hello,张三";
        //下面 name.substring(6) 从索引 6 开始截取后面所有的内容
        System.out.println(name.substring(6));//截取后面的字符
        //name.substring(2,5)表示从索引 0 开始截取，截取到索引 5-1=4 位置
        System.out.println(name.substring(2, 5));//llo
    }
}

3. String类常见方法一览2

  1. toUpperCase：转换成大写
  2. toLowerCase：转换成小写
  3. concat：拼接字符
  4. replace：替换字符串中的字符
  5. split：分割字符串中的字符，对于某些分割字符，我们需要转义比如| \\等
    案例：String poem = “锄禾日当午，汗滴禾下土，谁知盘中餐，粒粒皆辛苦”; 和文件路径
  6. compareTo：比较两个字符串的大小
  7. toCharArray：转换成字符数组
  8. format：格式字符串，%s字符串 %c字符 %d 整型 %.2f 浮点型
    案例将一个人的信息格式化输出
public class StringMethod02 {
    public static void main(String[] args) {
        // 1.toUpperCase 转换成大写
        String s = "heLLo";
        System.out.println(s.toUpperCase());//HELLO
        // 2.toLowerCase
        System.out.println(s.toLowerCase());//hello
        // 3.concat 拼接字符串
        String s1 = "宝玉";
        s1 = s1.concat("林黛玉").concat("薛宝钗").concat("together");
        System.out.println(s1);//宝玉林黛玉薛宝钗 together
        // 4.replace 替换字符串中的字符
        s1 = "宝玉 and 林黛玉 林黛玉 林黛玉";
        //在 s1 中，将 所有的 林黛玉 替换成薛宝钗
        //s1.replace() 方法执行后，返回的结果才是替换过的. // 注意对 s1 没有任何影响
        String s11 = s1.replace("宝玉", "jack");
        System.out.println(s1);//宝玉 and 林黛玉 林黛玉 林黛玉
        System.out.println(s11);//jack and 林黛玉 林黛玉 林黛玉
        // 5.split 分割字符串, 对于某些分割字符，我们需要 转义比如 | \\等
        String poem = "锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
            // 1. 以 , 为标准对 poem 进行分割 , 返回一个数组
            // 2. 在对字符串进行分割时，如果有特殊字符，需要加入 转义符 \
        String[] split = poem.split(",");
        poem = "E:\\aaa\\bbb";
        split = poem.split("\\\\");
        System.out.println("==分割后内容===");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }

        // 6.toCharArray 转换成字符数组
        s = "happy";
        char[] chs = s.toCharArray();
        for (int i = 0; i < chs.length; i++) {
            System.out.println(chs[i]);
        }
        // 7.compareTo 比较两个字符串的大小，如果前者大，
        // 则返回正数，后者大，则返回负数，如果相等，返回 0
        // (1) 如果长度相同，并且每个字符也相同，就返回 0
        // (2) 如果长度相同或者不相同，但是在进行比较时，可以区分大小
        // 就返回 if (c1 != c2) {
        // return c1 - c2;
        // }
        // (3) 如果前面的部分都相同，就返回 str1.len - str2.len
        String a = "jcck";
        String b = "jack";
        System.out.println(a.compareTo(b)); // 返回值是 'c' - 'a' = 2 的值

        // 8.format 格式字符串
        /* 占位符有:
         * %s 字符串 %c 字符 %d 整型 %.2f 浮点型
         *
         */
        String name = "john";
        int age = 10;
        double score = 56.857;
        char gender = '男';

        //将所有的信息都拼接在一个字符串.
        String info = "我的姓名是" + name + "年龄是" + age + ",成绩是" + score + "性别是" + gender + "。希望大家喜欢我！";
        System.out.println(info);
        //1. %s , %d , %.2f %c 称为占位符
        //2. 这些占位符由后面变量来替换
        //3. %s 表示后面由 字符串来替换
        //4. %d 是整数来替换
        //5. %.2f 表示使用小数来替换，替换后，只会保留小数点两位, 并且进行四舍五入的处理
        //6. %c 使用 char 类型来替换
        String formatStr = "我的姓名是%s 年龄是%d，成绩是%.2f 性别是%c.希望大家喜欢我！";
        String info2 = String.format(formatStr, name, age, score, gender);
        System.out.println("info2=" + info2);
    }
}

03. StringBuffer类

1. 基本介绍

  1. java.lang.StringBuffer代表可变字符序列，可以对字符串内容进行增删
  2. 很多方法与String相同，但StringBuffer是可变长度的。
  3. StringBuffer是一个容器
  4. 线程安全：StringBuffer 是线程安全的，这意味着多个线程可以同时操作同一个
public class StringBuffer01 {
    public static void main(String[] args) {
        //1. StringBuffer 的直接父类 是 AbstractStringBuilder
        //2. StringBuffer 实现了Serializable ，即StringBuffer的对象可以串行化
        //串行化：可以通过网络传输
        //3. 在父类中，AbstractStringBuffer 有属性 char[] value，不是final
        // 该value 数组存放 字符串内容引出存放在堆中的
        //4. StringBuffer 是一个final类，不能被继承
        StringBuffer stringBuffer = new StringBuffer();
    }
}

2. String和StringBuffer的区别

  1. String保存的是字符常量，里面的值不能改，每次String类的更新实际上就是更改地址，效率较低//private final char value[];
  2. StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用更新地址，效率较高//char[] value; 这个放在堆里
public class StringBuffer01 {
    public static void main(String[] args) {
        //1. StringBuffer 的直接父类 是 AbstractStringBuilder
        //2. StringBuffer 实现了Serializable ，即StringBuffer的对象可以串行化
        //串行化：可以通过网络传输
        //3. 在父类中，AbstractStringBuffer 有属性 char[] value，不是final
        // 该value 数组存放 字符串内容引出存放在堆中的
        //4. StringBuffer 是一个final类，不能被继承
        //5. 因为StringBuffer字符内容是存在插入[] value, 所有在变化【增加/删除】
        //不用每次都更换地址（即不是每次都是创建新的对象），所以他的效率高于String
        StringBuffer stringBuffer = new StringBuffer();
    }
}

3. StringBuffer的构造器

  1. StringBuffer()：构造一个其中不带字符的字符串缓冲区，器初始容量为16个字符
  2. StringBuffer(charSequence seq) ：public java.lang.StringBuilder(Charquence seq)构造一个字符串缓冲区，它包含指定的CharSequence相同的字符
  3. StringBuffer(int capacity) ：构造一个不带字符，但具有指定初始容量的字符串缓冲区，即对char[] 大小进行指定
  4. StringBuffer(String str)：构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容
public class StringBuffer02 {
    public static void main(String[] args) {
        //1. 创建一个大小为16 的 char[],用于存放字符内容
        StringBuffer stringBuffer = new StringBuffer();
        //2. 通过构造器指定 char[] 的容量
        StringBuffer stringBuffer1 = new StringBuffer(100);
        //3. 通过给一个String 创建StringBuffer, char[] 大小就是 hello.length() = 16
        StringBuffer hello = new StringBuffer("hello");
    }
}

4.String和StringBuffer相互转换

  1. 开发中经常会将String和StringBuffer进行相互转换
案例：
public class StringAndStringBuffer {
    public static void main(String[] args) {
        // 1. String -> StringBuffer
        String str = "hello";
        //方式1 使用构造器
        //注意:返回的才是StringBuffer对象， 对str本身没有影响
        StringBuffer stringBuffer = new StringBuffer(str);
        //方式2 使用append方法
        StringBuffer stringBuffer1 = new StringBuffer();
        
        //2. StringBuffer -> String
        StringBuffer stringBuffer3 = new StringBuffer("hello");
        //方式1 使用StringBuffer提供的toString方法
        String s = stringBuffer3.toString();
        
        //方式 使用构造器
        String s1 = new String(stringBuffer3);
    }
}

4. StringBuffer类常见方法

  1. append：增
  2. delete(start,end)：删
  3. replace(start, end, string)：改 //将start----end 之间的内容替换掉，不含end
  4. indexOf //查找子串在字符串第一次出现的索引，如果找不到返回-1
  5. insert：插 insert
  6. length：获取长度
public class StringBufferMethod {
    public static void main(String[] args) {
        StringBuffer s = new StringBuffer("hello");
        //增
        s.append(',');// "hello,"
        s.append("张三丰");//"hello,张三丰"
        s.append("赵敏").append(100).append(true).append(10.5);//"hello,张三丰赵敏 100true10.5"
        System.out.println(s);//"hello,张三丰赵敏 100true10.5"
        //删
        /*
         * 删除索引为>=start && <end 处的字符
         * 解读: 删除 11~14 的字符 [11, 14)
         */
        s.delete(11, 14);
        System.out.println(s);//"hello,张三丰赵敏 true10.5"
        //改
        //使用 周芷若 替换 索引 9-11 的字符 [9,11)
        s.replace(9, 11, "周芷若");
        System.out.println(s);//"hello,张三丰周芷若 true10.5"
        //查找指定的子串在字符串第一次出现的索引，如果找不到返回-1
        int indexOf = s.indexOf("张三丰");
        System.out.println(indexOf);//6

        //插
        //在索引为 9 的位置插入 "赵敏",原来索引为 9 的内容自动后移
        s.insert(9, "赵敏");
        System.out.println(s);//"hello,张三丰赵敏周芷若 true10.5"
        //长度
        System.out.println(s.length());//22
        System.out.println(s);
    }
}

04. StringBuilder类

1. 基本介绍

  1. 一个可变的字符序列。此类提供一个能与StringBuffer兼容的API，但不保证同步（StringBuilder 不是线程安全）。该类被设计用作StringBuffer的一个建议替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer要快。
  2. 在StringBuilder上的主要操作是append和insert方法，可重载这些方法，以接收任意类型的数据。
public class StringBuilder01 {
    public static void main(String[] args) {
        //1. StringBuilder 继承 AbstractStringBuilder类
        //2. 实现了Serializable，说明StringBuilder对象是可以串行化的（对象可以进行网络传输）
        //3. StringBuilder 是final类，不可以被继承
        //4. StringBuilder 对象字符序列任然是存放在其父类 AbstractStringBuilder的 char[] value
        //5. StringBuilder 的方法，没有做互斥的处理，即没有synchronized关键字，因此在单线程的情况下使用
        StringBuilder stringBuilder = new StringBuilder();

    }
}

2. StringBuilder和StringBuffer的比较

  1. StringBuilder和StringBuffer非常类似，均可以代表可变的字符序列，而且方法也一样
  2. String：不可变字符序列效率低，但是复用率高
  3. StringBuffer：可变字符序列、效率较高（增删）、线程安全
  4. StringBuilder：可变字符序列，效率最高、线程不安全

3. String使用注意事项

​ String s = “a”; //创建了一个字符串
​ s += “b”; //实际上原来的"a"字符串对象已经丢弃了，现在又产生一个字符串 s +“b”(也就是ab)。如果多次知悉丁这些改变串内容的操作，就会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序性能。 结论：如果我们要对String进行大量修改就不要用String

05. Math类

1. 基本介绍

​ Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数

2. 方法一览（均为静态方法）

abs(double a)返回double的绝对值
abs(float a)返回float的绝对值
abs(int a)返回int的绝对值
abs(long a)返回long的绝对值
acos(double a)返回一个值的反余弦，返回的角度在0.0 到 pi之间
asin(double a)返回一个值的反正弦，返回的角度范围在-pi/2 到 pi/2之间
atan(double a)返回一个值的反正切，返回的角度范围在-pi/2 到 pi/2之间
atan2(double y, double x)将矩形坐标(x, y) 转换成极坐标(r, theta), 返回所得角theta
cbrt(double a)返回double值的立方根

3. 举例演示 Math 类常见的方法

  1. abs 绝对值
  2. pow 求幂
  3. ceil 向上取整
  4. floor 向下取整
  5. round 四舍五入
  6. sqrt 求开方
  7. random 求随机数 //思考：请写出获取 a-b之间的一个随机整数，a,b均为整数
  8. max 求两个数的最大值
  9. min 求两个数的最小值
/**
 * 讲解常用的Math类
 **/
public class Math01 {
    public static void main(String[] args) {
        //看看 Math 常用的方法(静态方法)
        //1.abs 绝对值
        int abs = Math.abs(-9);
        System.out.println(abs);//9

        //2.pow 求幂
        double pow = Math.pow(2, 4);//2 的 4 次方
        System.out.println(pow);//16
        //3.ceil 向上取整,返回>=该参数的最小整数(转成 double);
        double ceil = Math.ceil(3.9);
        System.out.println(ceil);//4.0
        //4.floor 向下取整，返回<=该参数的最大整数(转成 double)
        double floor = Math.floor(4.9);
        System.out.println(floor);//4.0
        //5.round 四舍五入 Math.floor(该参数+0.5)
        long round = Math.round(5.51);
        System.out.println(round);//6
        //6.sqrt 求开方
        double sqrt = Math.sqrt(9.0);
        System.out.println(sqrt);//3.0
        //7.random 求随机数
        // random 返回的是 0 <= x < 1 之间的一个随机小数
        // 思考：请写出获取 a-b 之间的一个随机整数,a,b 均为整数 ，比如 a = 2, b=7
        // 即返回一个数 x 2 <= x <= 7
        //  Math.random() * (b-a) 返回的就是 0 <= 数 <= b-a
        // (1) (int)(a) <= x <= (int)(a + Math.random() * (b-a +1) )
        // (2) 使用具体的数给小伙伴介绍 a = 2 b = 7
        // (int)(a + Math.random() * (b-a +1) ) = (int)( 2 + Math.random()*6)
        // Math.random()*6 返回的是 0 <= x < 6 小数
        // 2 + Math.random()*6 返回的就是 2<= x < 8 小
        // (int)(2 + Math.random()*6) = 2 <= x <= 7
        // (3) 公式就是 (int)(a + Math.random() * (b-a +1) )
        for(int i = 0; i < 100; i++) {
            System.out.println((int)(2 + Math.random() * (7 - 2 + 1)));
        }
        //max , min 返回最大值和最小值
        int min = Math.min(1, 9);
        int max = Math.max(45, 90);
        System.out.println("min=" + min);
        System.out.println("max=" + max);
    }
}

06. Arrays类

​ Arrays里面包含了一系列静态方法，用于管理或操作数组（比如排序和搜索）

  1. toString 返回数组的字符形式
    Arrays.toString(arr)
  2. sort 排序(自然排序和定制排序) Integer arr[] = {1, -1, 7, 0, 89};
  3. binarySearch 通过二分法进行查找，要求必须排好序
    int index =Arrays.binarySearch(arr,3);
  4. copyOf 数组元素复制
    Integer[] newArr = Arrays.copyOf(arr, arr.length);
  5. fill 数组元素的填充
    Integer[] num = new Integer[] {9, 3, 2};
  6. equals 比较两个数组元素内容是否完全一致
    boolean equals = Arrays.equals(arr, arr2);
  7. asList 将一组值，转换成list
    List<Integer> asList = Arrays.asLis{2, 3, 4, 5, 1};
public class ArraysMethod01 {
    public static void main(String[] args) {

//        Integer[] integers = {1, 20, 90};
//        //以前我们遍历数组用for循环
//        //Arrays类提供了一个toString方法，显示数组
//        System.out.println(Arrays.toString(integers));

        //演示sort方法的使用
        Integer[] arr = {1, -1, 7, 0, 89};
        //进行排序
        //1. 可以直接进行冒泡排序，这事也可以使用Arrays提供的sort方法排序
        //2. 因为数组是引用类型，所以通过sort排序，会直接影响到 实参 arr
        //3. sort重载的，也可以通过传入一个接口 Comparator 实现一个定制排序
        //4.  调用定制排序时，传入两个参数（1）排序的数组 arr
        // (2) 实现了Comparator接口的匿名内部类，要求实现 compare方法
        //5. 先演示效果
        //6. 体现了接口编程的方式，看源码
        //源码分析 1）Arrays.sort(arr, new Comparator()
        //(2) 最终到 TimSort 类的 private static <T> void binarySort(T[] a, int lo, int hi, int start, // Comparator<? super T> c)()
        //(3) 执行到 binarySort 方法的代码, 会根据动态绑定机制 c.compare()执行我们传入的
        // 匿名内部类的 compare ()
        // while (left < right) {
        // int mid = (left + right) >>> 1;
        // if (c.compare(pivot, a[mid]) < 0)
        // right = mid;
        // else
        // left = mid + 1;
        // }
        (4) new Comparator() {
         @Override
         public int compare(Object o1, Object o2) {
         Integer i1 = (Integer) o1;
         Integer i2 = (Integer) o2;
         return i2 - i1;
         }
         }
        (5) public int compare(Object o1, Object o2) 返回的值>0 还是 <0
         会影响整个排序结果, 这就充分体现了 接口编程+动态绑定+匿名内部类的综合使用
         将来的底层框架和源码的使用方式，会非常常见

        //默认排序
        Arrays.sort(arr);
        System.out.println("排序后-----------");
        System.out.println(Arrays.toString(arr));
        //定制排序
        Arrays.sort(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer i1 = (Integer) o1;
                Integer i2 = (Integer) o2;
                return i2 - i1;
            }
        });
    }
}

补充：

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

        int[] arr = {1, -1, 8, 0, 20};
//        bubble01(arr);
        bubble02(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                int i1 = (Integer) o1;
                int i2 = (Integer) o2;
                return i2 - i1;
            }
        });
        System.out.println("=========排序后的结果============");
        System.out.println(Arrays.toString(arr));
        //使用冒泡完成排序
    }
    public static void bubble01(int[] arr) {
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j+1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    //结合冒泡 + 定制
    public static void bubble02(int arr[], Comparator c) {
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (c.compare(arr[j], arr[j + 1])> 0) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}


import java.util.Arrays;
import java.util.List;

public class ArraysMethod02 {
    public static void main(String[] args) {
        Integer[] arr = {1, 2, 34, 545, 2344};
        //binarySearch 通过二分法进行查找，要求必须排好序
        //int index =Arrays.binarySearch(arr,3);
        //1. 使用binarySearch 二叉查找
        //2. 要求数组是要许的，如果该数组是无序的，不能使用binarySearch
        //3. 查找数组中的数字,返回下标索引
        //4. 如果数组中不存在这个元素，就返回-(low + 1) low是基于你这个数字大小原本它该在的索引位置，例如35 它在数组中不存在在的话应该在第4位
        int index = Arrays.binarySearch(arr, 5641);
        System.out.println("index = " + index);

        //copyOf 数组元素的复制
        //1. 从arr数组中，拷贝arr.length个元素到 newArr数组中
        //2. 如果拷贝长度 > arr.length 就在新数组后面增加 null
        //3. 如果拷贝长度 < 0 就抛出异常
        //4. 该方法底层使用的 System.arraycopy()
        Integer[] newArr = Arrays.copyOf(arr, arr.length);
        System.out.println("拷贝完成后");
        System.out.println(Arrays.toString(newArr));

        //fill 数组填充
        Integer[] num = {1, 2, 3};
        System.out.println(Arrays.toString(num));
        Arrays.fill(num, 34);
        //1. 使用34 替换所有的元素
        System.out.println(Arrays.toString(num));

        //equals 比较两个数组元素内容是否完全一致
        Integer[] arr2 = {1, 2, 34, 456};
        boolean equals = Arrays.equals(arr, arr2);
        System.out.println(equals);//false

        //asList 将一组值，转换成list
        //1. asList 方法，会将 (2,3,4,5,6,1)数据转成一个 List 集合
        //2. 返回的 asList 编译类型 List(接口)
        //3. asList 运行类型 java.util.Arrays#ArrayList, 是 Arrays 类的
        // 静态内部类 private static class ArrayList<E> extends AbstractList<E>
        // implements RandomAccess, java.io.Serializable
        List<Integer> asList = Arrays.asList(2, 3, 4, 5, 6, 1);
        System.out.println(asList);
    }
}

07. System类

1. System类常见方法和案例

  1. exit退出当前程序
  2. arraycopy：复制数组元素，比较适合底层调用，一般使用Arrays.copyOf完成数组复制
    int[] src = {1, 2, 3};
    int[] dest = new int[3];
    System.arraycopy(src, 0, dest, 0, 3);
  3. currentTimeMillens: 返回当前时间距离 1970-1-1的毫秒数
  4. gc：运行垃圾回收机制
import java.util.Arrays;

public class System_ {
    public static void main(String[] args) {
//        //1. exit结束程序
//        System.out.println("ok1");
//        //2. 0 表示一个状态，正常的状态
//        System.exit(0);
//        System.out.println("ok2");

        //1.arraycopy：复制数组元素，比较适合底层调用，一般使用Arrays.copyOf完成数组复制
        int[] src = {1, 2, 3};
        int[] dest = new int[3];//dest:当前是0, 0, 0
        //2. 搞清这五个参数
//     * @param src the source array.   源数组
//     * @param srcPos starting position in the source array.   代表从源数组的那个索引开始拷贝
//     * @param dest the destination array.     目标数组，即把源数组的数据拷贝到那个数组
//     * @param destPos starting position in the destination data.  把源数组的数据拷贝到 目标数组的那个索引
//     * @param length the number of array elements to be copied.   从源数组拷贝多少个元素到目标数组
        System.arraycopy(src, 0, dest, 0, 3);
        System.out.println("dest = " + Arrays.toString(dest));

        //currentTimeMillens: 返回当前时间距离 1970-1-1的毫秒数
        System.out.println(System.currentTimeMillis());
    }
}

08. BigInteger和BigDecimal类

1. BigInteger和BigDecimal介绍

  1. BigInterger适合保存较大的整型
  2. BigDecimal适合保存精度更高的浮点型（小数）

2. BigInteger和BigDecimal常见方法

  1. add 加
  2. subtract 减
  3. multiply 乘
  4. divide 除
1. BigInteger
import java.math.BigInteger;
/**
 * BigInteger类
 **/
public class BigInteger_ {
    public static void main(String[] args) {
        //当我们在编程中，需要处理很大的整数，long不够用
//        long l = 654564564546546; //整数过大

        BigInteger bigInteger = new BigInteger("9999999999999999999999");
        BigInteger bigInteger1 = new BigInteger("111");
        System.out.println(bigInteger);

        //1. 在对 BigInteger进行加减乘除的时候，需使用对应的方法，不能直接+ - * /
        //2. 在进行运算的时候需要一个BigInteger变量
        BigInteger add = bigInteger.add(bigInteger1);
        System.out.println(add);
        BigInteger subtract = bigInteger.subtract(bigInteger1);
        System.out.println(subtract);
        BigInteger multiply = bigInteger.multiply(bigInteger1);
        System.out.println(multiply);
        BigInteger divide = bigInteger.divide(bigInteger1);
        System.out.println(divide);
    }
}
2.BigDecimal
import java.math.BigDecimal;

/**
 * BigDecimal类
 **/
public class BigDecimal_ {
    public static void main(String[] args) {
        //使用一个精度很高的数时，double就会进行缩减，不够用
        //可以使用Decimal

//        double d1 = 1999.111111111111111111111111111112222;
//        System.out.println(d1);
        BigDecimal bigDecimal = new BigDecimal("1999.1111111111111111113246333");
        BigDecimal decimal = new BigDecimal("1.22");
        System.out.println(bigDecimal);

        //1. 如果对 BigDecimal进行运算，需要使用对应的方法
        //加减时必须要创建一个需要操作的BigDecimal
        BigDecimal add = bigDecimal.add(decimal);
        BigDecimal subtract = bigDecimal.subtract(decimal);
        BigDecimal multiply = bigDecimal.multiply(decimal);
//        BigDecimal divide = bigDecimal.divide(decimal);//注意有时候会除不净，抛出异常

        System.out.println(add + " " + subtract + " " + multiply + " ");
        //在调用divide方法时，指定精度即可
        //如果有无限循环小数，就会保留分子精度
        System.out.println(bigDecimal.divide(decimal, BigDecimal.ROUND_CEILING));

    }
}

09.日期类[知道怎么查，会用即可，不用每个方法都背]

1. 第一代日期类

  1. Date：精确到毫秒，代表特定的瞬间
  2. SimpleDateFormat：格式化和解析日期的具体类。它允许进行格式化（日期 - 文本）、解析（文本 - 日期）和规范化。
字母日期或时间元素表示示例
GEra标识符TextAD
y年Year1994: 96
M年中的月份MonthJuly; Jul; 07
w年中的周数Number27
W月份中的周数Number2
D年中的天数Number189
d月份中的天数Number10
F月份中的星期Number2
E星期中的天数TextTuesday; Tus
aAm/pm标记TextPM
H一天中的小时数（0-23）Number0
k一天中的小时数（1-24）Number24
Kam/pm中的小时数（0-11）Number0
ham/pm中的小时数（1-12）Number12
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Date01 {
    public static void main(String[] args) throws ParseException {
        //
        //1. 获取当前系统时间
        //2. 这里的 Date 类是在 java.util 包
        //3. 默认输出的日期格式是国外的方式, 因此通常需要对格式进行转换
        Date d1 = new Date(); //获取当前系统时间
        System.out.println("当前日期=" + d1);
        Date d2 = new Date(9234567); //通过指定毫秒数得到时间
        System.out.println("d2=" + d2); //获取某个时间对应的毫秒数
        //
        //
        //1. 创建 SimpleDateFormat 对象，可以指定相应的格式
        //2. 这里的格式使用的字母是规定好，不能乱写
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy 年 MM 月 dd 日 hh:mm:ss E");
        String format = sdf.format(d1); // format:将日期转换成指定格式的字符串
        System.out.println("当前日期=" + format);
        //
        //1. 可以把一个格式化的 String 转成对应的 Date
        //2. 得到 Date 仍然在输出时，还是按照国外的形式，如果希望指定格式输出，需要转换
        //3. 在把 String -> Date ， 使用的 sdf 格式需要和你给的 String 的格式一样，否则会抛出转换异常
        String s = "1996 年 01 月 01 日 10:20:30 星期一";
        Date parse = sdf.parse(s);
        System.out.println("parse=" + sdf.format(parse));
    }
}

2. 第二代时期类

  1. 第二代日期类，主要就是Calendar类（日历）
    public abstract class Calender extends Object implements Serializable,Cloneable,Comparable<Calendar>
  2. Calendar类是一个抽象类，它为特定瞬间与一组诸如 YEAR, MONTH, DAT_OF_MONTH, HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下日期的日期）提供一些方法
import java.util.Calendar;

/**
 * 第二代日期类
 **/
public class Calendar_ {
    public static void main(String[] args) {
        //Calendar
        //1. Calendar是一个抽象类，并且构造器是private
        //2. 可以通过getInstance() 来获取案例
        //3. 提供大量的方法和字段提供给程序员
        //4. Calendar 没有提供对应的格式化的类，因此需要程序员自己组合来输出(灵活)
        //5. 如果我们需要按照 24 小时进制来获取时间， Calendar.HOUR ==改成=> Calendar.HOUR_OF_DAY
        Calendar c = Calendar.getInstance(); //创建日历类对象//比较简单，自由
        System.out.println("c=" + c);
        //2.获取日历对象的某个日历字段
        System.out.println("年：" + c.get(Calendar.YEAR));
        // 这里为什么要 + 1, 因为 Calendar 返回月时候，是按照 0 开始编号
        System.out.println("月：" + (c.get(Calendar.MONTH) + 1));
        System.out.println("日：" + c.get(Calendar.DAY_OF_MONTH));
        System.out.println("小时：" + c.get(Calendar.HOUR));
        System.out.println("分钟：" + c.get(Calendar.MINUTE));
        System.out.println("秒：" + c.get(Calendar.SECOND));
        //Calender 没有专门的格式化方法，所以需要程序员自己来组合显示
        System.out.println(c.get(Calendar.YEAR) + "-" + (c.get(Calendar.MONTH) + 1) + "-" +
                c.get(Calendar.DAY_OF_MONTH) +
                " " + c.get(Calendar.HOUR_OF_DAY) + ":" + c.get(Calendar.MINUTE) + ":" + c.get(Calendar.SECOND) );
    }
}

3. 第三代日期类

1. 前面两代日期类的不足分析

​ JDK1.0中包含了一个java.util.Date类, 但是它的大多数方法已经在JDK1.1 中引入Calendar类之后被弃用了.而Calendar也存在问题是:

  1. 可变性: 像日期和时间这样的类应该是不可变的
  2. 偏移性: Date中的年份是从1900开始的,而月份是从0开始的
  3. 格式化: 格式化只对Date有用,Calendar则不行
  4. 此外,他还不是线程安全的;不能处理闰秒等(每隔2天，多出1s)
2. 第三代日期类常见方法
  1. LocalDate(日期/年月日)、LocalTime(时间/时分秒)、LocalDateTime(日期时间/年月日时分秒) JDK8加入
  2. LocalDate只包含时间，可以获取时间字段
  3. LocalDateTimes包含日期+时间，可以获取日期和时间字段
3. DateTimeFormatter格式日期类

​ 类似于SimpleDateFormatter

​ DateTimeFormatter dtf = DateTimeFormatter.ofPattern(格式);
​ String str = dtf.format(日期对象)；

综合案例:
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

/**
 * 第三代日期类
 **/
public class LocalDate_ {
    public static void main(String[] args) {
        //1. 使用now() 返回表示当前日期的对象
        LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt);

        //2. 使用DateTimeFormatter对象来进行格式化
        //3. 创建DateTimeFormatter对象
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年 MM月dd日 HH小时mm分钟ss秒");
        String format = dtf.format(ldt);
        System.out.println(format);

        System.out.println("年" + ldt.getYear());
        System.out.println("月" + ldt.getMonth());
        System.out.println("日" + ldt.getDayOfMonth());
        System.out.println("时" + ldt.getHour());
        System.out.println("分" + ldt.getMinute());
        System.out.println("秒" + ldt.getSecond());

        LocalDate now = LocalDate.now();//可获取年月日
        LocalTime now1 = LocalTime.now();//可获取时分秒
        
    }
}
4. Instant时间戳
  1. 类似于Date
    提供一系列和Date类转换方式
    Instant -> Date:
    Date date = Date.from(instant);
    Date -> Instant:
    Instant Instant = date.toInstant();
import java.time.Instant;
import java.util.Date;

/**
 * Instant时间戳
 **/
public class Instant_ {
    public static void main(String[] args) {

        //1. 通过静态方法 now() 获取当前时间戳对象
        Instant now = Instant.now();
        System.out.println(now);
        //2. 通过from 可以把 Instant 转成 Date
        Date date = Date.from(now);
        //3. 通过 date的toInstant() 可以把date 转成Instant对象
        Instant instant = date.toInstant();
    }
}
5. 第三代日期类更多方法
  1. LocalDateTime类
  2. MonthDay类:检查重复事件
  3. 是否是闰年
  4. 增加日期的某个部分
  5. 使用plus方法测试增加时间的某个部分
  6. 使用minus方法测试查看一年前和一年后的日期
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

/**
 * 第三代日期类
 **/
public class LocalDate_ {
    public static void main(String[] args) {
        //1. 使用now() 返回表示当前日期的对象
        LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt);

        //2. 使用DateTimeFormatter对象来进行格式化
        //3. 创建DateTimeFormatter对象
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年 MM月dd日 HH小时mm分钟ss秒");
        String format = dtf.format(ldt);
        System.out.println(format);

        System.out.println("年" + ldt.getYear());
        System.out.println("月" + ldt.getMonth());
        System.out.println("日" + ldt.getDayOfMonth());
        System.out.println("时" + ldt.getHour());
        System.out.println("分" + ldt.getMinute());
        System.out.println("秒" + ldt.getSecond());

        LocalDate now = LocalDate.now();//可获取年月日
        LocalTime now1 = LocalTime.now();//可获取时分秒

        //提供 plus 和 minus方法可以对当前时间进行加或减
        //看看890天后是什么时候 把 年月日-时分秒输出
        LocalDateTime localDateTime = ldt.plusDays(890);
        System.out.println("890天后=" + dtf.format(localDateTime));
        //看看3456分钟前是是什么时候 把 年月日-时分秒 输出
        LocalDateTime localDateTime1 = ldt.minusMinutes(3456);
        System.out.println("3456分钟前=" + dtf.format(localDateTime1));

    }
}
绝世小帅
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
头歌--Java面向对象 - 常用类
m0_56638814的博客
04-26 8828
头歌--Java面向对象 - 常用类
《Java面向对象——常用类》
2301_78817487的博客
10-15 397
原文链接：https://blog.csdn.net/2303_78171667/article/details/133826186。// StringBuffer常见的方法(和String的方法大同小异，列举出几个不同的)// System.out.println(str);
Java面向对象：Java核心API、Java常用类
qq_43265673的博客
07-25 417
1、包装类 √2、String类 ★3、StringBuffer和StringBuilder类 ★4、Math类 5、System类6、Arrays类 ★7、BigInteger类和BigDecimal类8、Date日期类、Calendar日历类以及新的日期
Java面向对象——基础2 封装、继承、多态(1)
Y1567409的博客
04-16 951
学习视频：《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。**[外链图片转存中…(img-7wTR0Q6d-1713202180345)][外链图片转存中…(img-3Z9kGAeL-1713202180346)][外链图片转存中…(img-MOsrC8un-1713202180346)]
Java面向对象 - 常用类
ros275229的博客
04-09 398
Java面向对象---常用类
Java｜面向对象（中）-- 包装类
蓝夜城__
12-10 516
Java｜面向对象（中）-- 包装类。自动装箱，自动拆箱，包装类的缓存机制，包装类与基本数据类型的区别
Java常用类
zhouwenxing666的博客
05-25 1028
Java是面向对象的语言，但并不是“纯面向对象”的，因为我们经常用到的基本数据类型就不是对象。但我们在实际应用中经常需要将基本数据转化成对象，以便于操作。为了解决这个不足，Java在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为封装类(Wrapper Class)。8种基本数据类型，分别对应一个封装类。封装类均位于java.lang包基本数据类型封装类byteBytebooleanBooleanshortShortcharCharacter。
Java基础——常用类
qq_52793248的博客
06-14 1815
Java基础——常用类
Educoder题目：Java面向对象 - 常用类答案解析.md
11-15
Educoder题目：Java面向对象 - 常用类答案解析
Educoder题目：Java面向对象 - String类答案解析.md
11-09
Educoder题目：Java面向对象 - String类答案解析
JAVA面向对象设计和常用类 声音设备模拟
02-05
根据下图所描述的运输货物场景下的类的体系结构，请用面向对象的类、继承、接口等概念用JAVA程序实现该体系结构，并按如下要求编写主方法测试你的实现： （1）Soundable是一个接口，包含三个抽象方法：play()表示...
Java面向对象和工具类
06-26
java 面向对象的重难点知识以及常用的工具类的使用
Java常用类.xmind
07-16
导图包括一些java常用类知识汇总，包括字符串、日期API（包括jdk8.0之前 和 之后的）、Math类、BigInteger类、BigDecimal类
Educoder- 《JAVA从小白到大牛》（第二章）2-6 Java面向对象 - 常用类
weixin_45674170的博客
11-04 3881
提示：本文章为个人学习记录，仅供参考学习，禁止转载，支持交流与讨论。 文章目录第1关：Object类相关知识什么是Object类1.关于`toString()`方法**2.关于`equals()`方法**Java对象克隆编程要求测试说明参考答案第2关：JAVA基础类型包装类-练习参考答案第3关：String&StringBuilder&StringBuffer类-练习参考答案第4关：Random类相关知识Random类Random对象的生成Random类中的常用方法编程要求测试说明参考答案
Java面向对象基础--常用基础类
买米当卡的博客
11-26 3587
Java常用基础类 一、包装类 1、包装类的定义; 基本数据类型如int、float、double、boolean、char 等。基本数据类型是不具备对象的特性的，比如基本类型不能调用方法、功能简单。为了让基本数据类型也具备对象的特性，Java 为每个基本数据类型都提供了一个包装类，这样我们就可以像操作对象那样来操作基本数据类型。 2、对应关系 二、Integer整数类 部分代码如下： public class Test1 { public static void main(String[] a
进阶2 探索图形化编程：扩展图形组件与切片开发的魅力
优树搭的博客
05-30 1264
当这些切片成功地通过图形程序串联起来后，在后续进行程序升级或维护时，大家会惊喜地发现，图形程序就如同清晰的路标一般，可以非常便捷地通过图形程序准确地定位到相关切片，并对这些切片进行在线查看、编辑和执行等操作。而且，这些切片的代码长度通常不会太长，相比传统开发的代码，阅读起来要容易得多，这无疑会给系统后续的工作带来极大的便利。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 838
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1184
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 477
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
头歌Java面向对象 - 常用类
05-28
好的，我可以回答关于Java面向对象常用类的问题。Java中有很多常用类，其中一些包括： 1. String类：用于表示字符串，提供了很多字符串操作方法。 2. Math类：提供了很多数学操作方法，如求绝对值、平方根、三角函数等。 3. ArrayList类：实现了可变大小的数组，提供了很多操作数组的方法。 4. HashMap类：实现了哈希表，提供了快速查找和插入的功能。 5. Date类：用于表示日期和时间，提供了很多操作日期和时间的方法。 除此之外，还有很多其他的常用类，如Scanner、File、Random等，它们都提供了很多实用的操作方法。希望这些信息能够帮助你。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值