Java面向对象【常用类】

進擊的小鹿

已于 2022-08-20 21:16:40 修改

阅读量1.6k

点赞数 4

分类专栏： Java入门文章标签： java 算法数据结构

于 2022-08-20 16:51:31 首次发布

本文链接：https://blog.csdn.net/weixin_62584200/article/details/126441640

版权

Java入门专栏收录该内容

12 篇文章 3 订阅

订阅专栏

包装类Wrapper

针对八种数据类型相应引用类型

基本数据类型	包装类
boolean	Boolean
char	Character
byte	Byte(父类Number)
short	Short(父类Number)
int	Integer(父类Number)
long	Long(父类Number)
float	Float(父类Number)
double	Double(父类Number)

包装类和基本数据的转换

jdk5之前是手动装箱和拆箱
- 装箱：基本类型->包装类型，反之拆箱
jkd5之后自动装箱和拆箱
自动装箱底层调用的是valueOf方法

代码

package com.xiaolin.wrapper;

/**
 * @author 林小鹿
 * @version 1.0
 */
public class Integer01 {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        // jdk5前是手动装箱和拆箱
        // 手动装箱 int->Integer
        int n1 = 100;
        Integer integer = new Integer(n1);
        // 或者
        Integer integer1 = Integer.valueOf(n1);

        // 手动拆箱 Integer->int
        int i = integer.intValue();

        // jdk5后，就可以自动装箱和拆箱
        // int->Integer
        int n2 = 200;
        Integer integer2 = n2;  // 底层使用的是 Integer.valueOf(n2)

        // 自动拆箱 Integer->int
        int n3 = integer2;  // 底层使用的是 valueOf()方法
    }
}

String类

内含有不可变序列final value[]数组

String 对象用于保存字符串，即是一组字符序列
字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节
String类中有很多构造器构成了重载
String类实现了接口 Serializable [可以窜行化：可以在网络传输]
String类实现了接口 Comparable [String 对象可以比较大小]
String 是final 类，不能被其他的类继承
String 有属性 private final char value[]; 用于存放字符串内容
value 是一个final类型，不可修改（地址不可修改）（注意）

两种创建String对象区别

①：直接复制String s = “linxiaolu”

②：调用构造器 String s2 = new String(“linxiaolu”)

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

重要规则：

String c1 = “a” + “b”;常量相加，看的是池
String c1 = a + b;变量相加，是在堆中

String类的常见方法

equals：区分大小写，判断内容是否相等
equalsIgnoreCase：忽略大小写的判断内容是否相等
length：获取字符的个数，字符串的长度
indexOf：获取字符在字符串中第1次出现的索引，索引从0开始如果找不到，返回-1
lastIndexOf：获取字符在字符串中最后1次出现的索引，索引从0开始，如找不到，返回-1
substring：截取指定范围的子串
trim：去前后空格
charAt：获取某索引处的字符，注意不能使用String[index]这种方式获取下标下的元素
toUpperCase：字符串转大写
toLowerCase：字符串转小写
concat：拼接字符串
- concat（）方法首先获取拼接字符串的长度，判断这个字符串长度是否为0（判断这个用来拼接的字符串是不是空串），如果是就返回原来的字符串（等于没有拼接）；否则就获取源字符串的长度，创建一个新的char[]字符数组，这个字符数组的长度是拼接字符串的长度与源字符串的长度之和，通过Arrays类的copyOf方法复制源数组，然后通过getChars方法将拼接字符串拼接到源字符串中，然后将新串返回。
replace：替换字符串中的字符
split：分割字符串，对于某些分割的字符，则需要转义符
compareTo：比较两个字符串的大写
toCharArray：转换成字符数组
format：格式化字符串，%s 字符串；%c 字符；%d 整型；%.2f 浮点型

String的增强类StringBuffer类

代表可变字符序列，可以对字符串内容进行增删
很多方法与String相同，但StringBuffer是可变长度
是一个容器

StringBufferVS String

String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率较低 // private final char value[];
StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer都更新实际上可以更新内容，不用每次更新地址，效率较高 (不用每次都创建新对象) // char[] value;

StringBuffer与String相互转换

package com.xiaolin.stringbuffer;

/**
 * @author 林小鹿
 * @version 1.0
 */
public class StringBuffer02 {
    public static void main(String[] args) {
        // String-->StringBuffer
        String str = "hello sw";

        // 方法① 使用构造器
        StringBuffer stringBuffer = new StringBuffer(str);

        // 方法② 使用append方法
        StringBuffer stringBuffer1 = new StringBuffer();
        stringBuffer1 = stringBuffer1.append(str);

        // StringBuffer-->String
        StringBuffer stringBuffer2 = new StringBuffer("xialu");
        // 方式① 使用toString方法
        String s = stringBuffer2.toString();

        // 方式② 使用构造器
        String s1 = new String(stringBuffer2);
        
    }
}

StringBuffer常用方法

增 append
删 delete(start,end)
改 replace(start,end,string) // 将start—end 间的内容替换掉，不包含end
查 indexOf // 查找子窜在字符串第1此出现的索引，如果找不到返回-1
插 insert
获取长度 length

StringBuilder类

一个可变的字符序列，此类提供一个与StringBuffer 兼容的 API ，但不保证同步（StringBuilder 存在线程安全问题）。该类被设计用作StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候。通常情况，单线程建议优先采用该类，它比StringBuffer要快

结论

如果字符串存在大量的修改操作，一般使用StringBuffer 或StringBuilder
如果字符串存在大量的修改操作，并在单线程的情况，使用StringBuilder
如果字符串卒中大量的修改操作，并在多线程的情况，使用StringBuffer
如果我们字符串很少修改，被多个对象引用，使用String，比如配置信息等

Math类

执行基本数学运算的方法
在a~b之间取随机数
- (int)(a + Math.random() * (b - a + 1))

Arrays类

Arrays.toString(arr)
sort排序
binarySearch 通过二分搜索法进行查找，要求必须排好序
- int index = Arrays.binarySearch(arr, 3);

sort定制排序

通过传入一个接口 Comparator 实现定制排序

Integer[] arr = {1, -2, 10, 8};
        // 定制排序
        // 传入参数，（1）排序数组arr；（2）实现了Comparator接口的匿名内部类，要求实现compare方法
Arrays.sort(arr, new Comparator(){
            @Override
            public int compare(Object o1, Object o2) {
                Integer o11 = (Integer) o1;
                Integer o22 = (Integer) o2;

                return o22 -o11;
            }
        });

练习题代码–接口编程+动态绑定+定制化排序

package com.xiaolin;

import java.util.Arrays;
import java.util.Comparator;

/**
 * @author 林小鹿
 * @version 1.0
 * 练习题--接口编程+动态绑定+定制化排序
 */
public class Array01 {
    public static void main(String[] args) {

        Book[] books = new Book[4];
        books[0] = new Book("红楼梦", 100);
        books[1] = new Book("誓死", 90);
        books[2] = new Book("文艺青年", 5);
        books[3] = new Book("JAVA从入门到入土", 300);

        // 按price从大到小
//        Arrays.sort(books, new Comparator() {
//            @Override
//            public int compare(Object o1, Object o2) {
//                Book book1 = (Book) o1;
//                Book book2 = (Book) o2;
//                double priceVal =  book2.getPrice() - book1.getPrice();
//                // 进行了一个转换
//                if (priceVal > 0) {
//                    return 1;
//                }else if (priceVal < 0) {
//                    return -1;
//                }else {
//                    return 0;
//                }
//            }
//        });

        // 按照书名长度从大到小排序
        Arrays.sort(books, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Book book1 = (Book) o1;
                Book book2 = (Book) o2;
                return book2.getName().length() - book1.getName().length();
            }
        });

        System.out.println(Arrays.toString(books));

        // 定制化排序测试---动态绑定+定制化排序
        Integer[] arr = {56, -1, 34, -7, 16};
        Book.bubble(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer o11 = (Integer) o1;
                Integer o22 = (Integer) o2;
                return o22 - o11;
            }
        });
        System.out.println(Arrays.toString(arr));
    }
}

class Book {
    private String name;
    private double price;

    public Book(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
    // 定制化冒泡排序
    public static void bubble(Integer[] arr, Comparator c) {
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                // 数组排序由c.compare(arr[j], arr[j+ 1 ])返回的值决定
                if (c.compare(arr[j], arr[j+ 1 ]) > 0) {
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
    
}

System类

exit：退出当前程序
arraycopy：复制数组元素，比较适合底层调用
currentTimeMillens：返回当前时间距离1970-1-1 的毫秒数
gc：运行垃圾回收机制

BigInteger和BigDecimal类

底层把数据当作字符串进行处理，可接收一个字符串

BigInteger适合保存比较大的整形
BigDecimal适合保存精度更高的浮点型（小数）

常见方法

add()：加
subtract()：减
multiply()：乘
divide()：除（BigDecimal在除法时可能会抛出无限不循环小数的错误，可以通过 RoundingMode.CEILING参数保留分子的小数点位数）

第一代日期类 Data类

代码

package com.xiaolu.data;

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

/**
 * @author 林小鹿
 * @version 1.0
 */
public class Date01 {

    public static void main(String[] args) throws ParseException {
        Date d1 = new Date(); // 获取当前系统时间
        System.out.println("当前日期=" + d1);

        // 通过指定毫秒数得到时间
        Date d2 = new Date(9234567);
        System.out.println("d2="+d2);


        // 创建 SimpleDateFormat 对象，可以对日期格式化，格式是规定的，不可乱写
        SimpleDateFormat sdf = new SimpleDateFormat("yyy年MM月dd日 hh:mm:ss E");
        String format = sdf.format(d1);  // format：将日期转换成指定格式的字符串
        System.out.println("当前日期="+format);

        // 可以把一个格式化的String 转成对应的 Date
        // 在把String转换成Date时，使用的 sdf 格式需要和你给的String的格式保持一致，否则会抛出转换异常
        String s = "1996年01月01日 10:20:30 星期一";
        Date parse = sdf.parse(s); // 存在转化异常，通过Alt+enter 抛出异常
        System.out.println("parse="+parse);

    }
}

第二代日期类 Calendar(日历)类

代码

package com.xiaolu.data;

import java.util.Calendar;

/**
 * @author 林小鹿
 * @version 1.0
 */
public class Calendar_ {

    public static void main(String[] args) {
        // 1、Calendar是一个抽象类，并且构造器是private
        // 2、可以通过 getInstance() 来获取
        // 3、Calendar没有提供对应的格式化的类，需要自己组合输出
        // 4、如果需要输出24小时制，只需要吧Calendar.HOUR 改成 Calendar.HOUR_OF_DAY
        Calendar c = Calendar.getInstance();
        System.out.println("c=" + c);

        // 获取日历对象的某个日历字段
        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));


    }
}

第三代日期类

前面两代日期类存在不足

Calendar存在的问题

可变性：像日期和时间类应该是不可变的
偏移性：Date中的年份是从1900开始的，而月份都是从0开始
格式化：格式化只对Date有用
它们也不是线程安全，不能处理闰年秒等问题（每隔2天，多出1s）

三代日期类(JDK8加入)

LocalDate(日期/年月日)
LocalTIME(时间/时分秒)
LocalDateTime(日期时间)

格式化日期类 DateTimeFormatter类

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

代码

package com.xiaolu.data;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

/**
 * @author 林小鹿
 * @version 1.0
 */
public class LocalDate_ {

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

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


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

    }
}

Instant时间戳

类似于Date，提供了一系列和Date类转换的方式

Instant ===> Date
- Date date = Date.from(instant);
Date===>Instant
- Instant now = Instant.now();

代码

// 通过 静态方法 now() 获取表示当前时间戳的对象
Instant now = Instant.now();
System.out.println(now);
// 通过 from 可以把 Instant转成 Date
Date date = Date.from(now);
// 通过 date的toInstant() 可以把date 转成Instant对象
Instant instant = date.toInstant();

其他对象方法

// 提供 plus 和 minus方法可以对当前时间进行加或者减
// 890天后
LocalDateTime localDateTime = ldt.plusDays(890);
System.out.println("890天后=" + dateTimeFormatter.format(localDateTime));

// 在345分钟前是什么时候
LocalDateTime localDateTime1 = ldt.minusMinutes(345);
System.out.println("345分钟前=" + dateTimeFormatter.format(localDateTime1));