Java常用类及使用方法

String s1 = "javaEE";
String s2 = "javaEE";
String s3 = new String("javaEE");
String s4 = new String("javaEE");
System.out.println(s1 == s2);//true
System.out.println(s1 == s3);//false
System.out.println(s1 == s4);//false
System.out.println(s3 == s4);//false

如上代码所示，String通过字面量定义的变量位于字符串常量池中，通过new+构造器会在内存中创建两个对象：堆中的new，char[]对应的常量池数据。用以下的宋老师的图例看会更加清楚：

4.字符串拼接后的内存解析

String s1 = "hello";
String s2 = "world";
String s3 = "hello" + "world";
String s4 = s1 + "world";
String s5 = s1 + s2;
String s6 = (s1 + s2).intern();
System.out.println(s3 == s4);//false
System.out.println(s3 == s5);//false
System.out.println(s3 == s6);//false
System.out.println(s4 == s5);//true

1.常量与常量的拼接在常量池中；

2.但只要其中一个为变量，结果就在堆中；

3.若使用intern()方法，则返回值在常量池中；

6.String中的常用方法

1.length()，字符串长度

2.charAt(),返回某索引出的字符

3.isEmpty，是否是空的

4.toLowerCase()，转换为小写

5.toUpperCase(),转换为大写

6.trim(),忽略字符串头部或尾部的空格

7.equalIgnoreCase (),忽略大小写比较

8.concat (),相当于+

9.compareTo (),比较两个字符串大小，负数就是当前数小，涉及到字符串排序

10.substring (),返回一个新字符串，从输入索引开始截取，若输入两个索引，那就是左闭右开的区间

11.endWith (),是否以指定后缀结束

12.startWith (),是否以指定后缀开始，区分大小写，返回布尔类型

13.contains(),当前字符串是否包含形参字符串

14.indexOf(),找到形参出现的第一个索引

15.LastIndexOf (),从后往前找形参出现的第一个索引；找不到就返回默认初始化值减一：-1

16.replace (),将所有旧字符串转换为新字符串

17.match (),确定此字符串是否匹配给定的正则表达式

18.split (),根据正则表达式拆分字符串

7.什么时候indexOf (str)和LastIndexOf (str)返回值相同

答：存在唯一的str或者不存在该str

8.String和其他结构之间的转换

1.与包装类，基本数据类型转换

String转换为包装类：Integer.parseInt(str)；

包装类转换为String：String.valueOf(i1)

Integer i1 = 123;
String s1 = "123";
Integer i2 = Integer.parseInt(s1);
String s2 = String.valueOf(i1);

2.与char[ ]转换

String转换为char[ ]：调用toCharArray()

char[ ]转换为String：用String构造器,把char[ ]放进去

char[] char1 = new char[]{'a','b','c'};
String s1 = "abc";
char[] char2 = s1.toCharArray();
String s2 = new String(char1);

3.与byte[ ]转换

String转换为byte[ ]（编码）：调用String的getBytes()方法

byte[ ]转换为String（解码）：调用String构造器

byte[] byte1 = new byte[]{1,2,3};
String s1 = "123";
byte[] byte2 = s1.getBytes();
String s2 = new String(byte1);

若：byte转换为字符串会出现乱码，是因为编码集与解码集不一致。

其中,编码就是将字符串转换为计算机底层的二进制字节;解码就是将字节转换为字符串。

9.String,StringBuffer,StringBuilder的异同

相同点

底层都使用char[ ]存储

不同点

String:不可变的字符序列

StringBuffer:可变的字符序列；线程安全的，效率低

StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高

效率对比：StringBuilder>StringBuffer>>String

10.StringBuffer的常用方法

1.增：append(),添加字符

2.删：delete (),删除指定位置内容

3.改：replace (),替换指定位置str

4.插：insert (),在指定位置插入xxx

5.反：reverse (),将字符序列反转

setCharAt (),修改一个字符

6.查：charAt (),查询指定索引字符

7.遍历：toString ()

11.String,StringBuffer,StringBuilder的相互转换

1.String转换为StringBuffer,StringBuilder

调用StringBuffer,StringBuilder构造器

2.StringBuffer,StringBuilder转换为String

调用String构造器

2.日期类

1.jdk8之前的日期和时间API

1.system.currentTimeMills()

返回一个毫秒的时间差，通常称为时间戳，同1970.1.1.0:0:0对比

long timeMillis = System.currentTimeMillis();

2.Date类的使用

1.两个包

Java.until.Date

Java.sql.Date：对应数据库中的日期类型

2.两个构造器

无参构造器Date()：创建一个当前时间Date

Date(时间戳)：创建指定毫秒数的Date

3.两个方法

toString();返回当前年月日时分秒

getTime():获取当前Date对象的毫秒数

4.util下的date和sql下date转换

将util下date.getTime()放入sql下date构造器即可

代码示例：

//关于日期的API---> Date()方法；
//两种：java.util.Date/java.sql.Date
//每一种都有两个构造器
//两种方法：toString()：返回当前日期的时分秒；getTime():获取当前对象的毫秒值 
@Test
    public void test(){
        //1.Java.util.Date方法
        Date date = new Date();
        //获取当前日期的时分秒
        System.out.println(date.toString());
        //获取当前日期的毫秒数
        System.out.println(date.getTime());

        System.out.println("------------------------------------");
        Date date1 = new Date(1234325214214l);
        java.sql.Date date7 = new java.sql.Date(date1.getTime());
        System.out.println(date7);
        System.out.println(date1.toString());
        System.out.println(date1.getTime());

        System.out.println("-------------------------------------");
        //2.java.sql.Date方法
        java.sql.Date date2 = new java.sql.Date(System.currentTimeMillis());
//        java.sql.Date date3 = new java.sql.Date();
        String s = date2.toString();
        System.out.println(s);
        long time = date2.getTime();
        System.out.println(time);

        System.out.println("---------------------------------------");
        //3.二者之间的转换：靠java.util.Date的有参构造器，形参为毫秒值
        Date date3 = new Date(date2.getTime());
        System.out.println(date3);
        java.sql.Date date4 = new java.sql.Date(date3.getTime());
        System.out.println(date4);

    }

3.SimpleDateFormat的使用

1.作用

对日期Date类的格式化和解析

2.格式化与解析

格式化：format()方法:将Date对象格式化为字符串

解析：parse()方法：将字符串解析为Date对象

SimpleDateFormat s = new SimpleDateFormat();
Date date = new Date();
//格式化：转化为字符串
String s1 = s.format(date);
System.out.println(s1);
//解析：转化为Date
Date date1 = s.parse(s1);
System.out.println(date1);

3.SimpleDateFormat的实例化

1.使用无参构造器造对象，使用format()方法将Date对象转换为字符串；使用pasre方法将字符串转换为日期

2.使用固定格式的有参构造器(常用)


 public void test1() throws ParseException {
        //第一种方式实例化
        SimpleDateFormat s = new SimpleDateFormat();
        Date date = new Date();
        System.out.println(date);
        //格式化：转化为字符串
        String s1 = s.format(date);
        System.out.println(s1);
        //解析：转化为Date
        Date date1 = s.parse(s1);
        System.out.println(date1);
        
        System.out.println("-------------------------------------------------------");
        //2.第二种方式实例化(更常用)
        SimpleDateFormat ss = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        Date date2 = new Date();
        System.out.println(date2);
        String s2 = ss.format(date2);
        System.out.println(s2);
        Date date3 = ss.parse(s2);
        System.out.println(date3);
    }

3.解析时，字符串必须满足SimpleDateFormat格式，构造器形参格式，否则异常。

2.jdk8中日期时间API

1.获取当前日期

LocalDate、LocalTime、LocalDateTime

实例化：LocalTime.now()方法

2.设置指定的年月日时分秒

LocalTime.of()方法

3.获取年月日，getXxx()

4.不可变性：设置年月日,withDayofMonth

5.添加：plusMonths()

6.减：minusDay();

        //1.获取当前日期
        LocalDate l = LocalDate.now();
        System.out.println(l);
        LocalTime l1 = LocalTime.now();
        System.out.println(l1);
        LocalDateTime l2 = LocalDateTime.now();
        System.out.println(l2);

        //2.设置指定的日期
        LocalTime l3 = LocalTime.of(5, 8);
        System.out.println(l3);

        //3.获取年月日
        int dayOfMonth = l.getDayOfMonth();
        System.out.println(dayOfMonth);

        //4.不可变性
        LocalDate localDate = l.withDayOfMonth(2);
        System.out.println(dayOfMonth);
        System.out.println(localDate.getDayOfMonth());

        //5.添加
        LocalDate l5 = l.plusDays(5);
        System.out.println(l);//不可变性
        System.out.println(l5);//24

        //6.减
        LocalDate localDate1 = l.minusDays(5);
        System.out.println(l);
        System.out.println(localDate1);//14

3.Calender类的使用：抽象类

1.实例化

Calender类是一个抽象类，无法实例化，通常使用Calendar.getInstance()方法来造对象。

2.常用方法

get():get(Calendar.DAY_OF_MONTH)

set():set(Calendar.DAY_OF_MONTH,22)

add():add(Calendar.DAY_OF_MONTH,3)

getTime():getTime();日历类转为Date对象

setTime():setTime();Date对象转为日历类

代码示例：

        //使用Calendar.getInstance方法创建Calendar对象
        Calendar c = Calendar.getInstance();
        Date date1 = c.getTime();
        System.out.println(date1);
        //Calendar的常用方法get():获取当前日期的信息
        int s1 = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(s1);
        int s2 = c.get(Calendar.DAY_OF_WEEK);
        System.out.println(s2);
        int s3 = c.get(Calendar.DAY_OF_YEAR);
        System.out.println(s3);
        int s4 = c.get(Calendar.HOUR_OF_DAY);
        System.out.println(s4);


        //Calendar的常用方法set():设置当前日期信息
        //注意：此时set()方法为一个void方法，因此直接将Calendar对象本身改了
        c.set(Calendar.DAY_OF_MONTH,2);

        int i = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(i);

        //add()
        c.add(Calendar.DAY_OF_MONTH,4);
        int i1 = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(i1);

        //getTime():将Calendar对象-->Date对象
        Date time = c.getTime();
        System.out.println(time);

        //setTime():将Date对象-->日历类对象
        Date date = new Date();
        c.setTime(date);
        int i3 = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(i3);

4.instant

1.instant.now()方法：按照格林威治时间算的，会少八小时

2.添加时间偏移量：atOffset();

3.获取相应的毫秒数：instant.toEpochMilli

4.有参构造器：Instant.ofEpochMilli()

    @Test
    public void test1(){
        Instant i1 = Instant.now();
        System.out.println(i1);

        OffsetDateTime i2 = i1.atOffset(ZoneOffset.ofHours(8));
        System.out.println(i2);

        //获取相应instant对象的毫秒数
        long l = i1.toEpochMilli();
        System.out.println(l);

        //有参构造器（同之前一样，都是将毫秒数放入，转换为日期）
        Instant i3 = Instant.ofEpochMilli(l);
        System.out.println(i3);
    }

5.DateTimeFormatter的使用

1.自定义格式：DateTimeFormatter.ofPattern()

    @Test
    public void test(){
        DateTimeFormatter d = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        LocalDateTime l = LocalDateTime.now();
        System.out.println(l);
        //格式化：LocalDate --> 字符串
        String s = d.format(l);
        System.out.println(s);

        //解析：
        TemporalAccessor parse = d.parse(s);
        TemporalAccessor parse1 = d.parse("2023-02-19");
        System.out.println(parse);
        System.out.println(parse1);
    }

6.编码、解码、格式化、解析

编码:字符串>字节

解码: 字节 >字符串

格式化:日期 >字符串

解析:字符串 >日期

3.java比较器

1.对多个对象排序

java中的对象正常情况下只能使用:==,!=,但在开发中，我们需要对多个对象进行排序，就需要比较对象的大小。因此需要使用两种接口中的任何一个：comparable；comparator

2.Comparable接口的使用:自然排序(默认)

1.调用Arrays.sort(),Arrays.toString()即可

    //第一种方式：comparable--自然排序；按照默认从大到小进行比较 
    @Test
    public void test1(){
        String[] arr = new String[]{"AA","CC","DD","BB"};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

2.像String、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方法。

3.String、包装类排列都是从小到大排。

4.重写compareTo(obj)规则：大于-正整数，小于-负整数，等于-0。

    @Override
    public int compareTo(Object o) {
        if (o instanceof Person){
            Person p1 = (Person) o;
            if (this.getAge() > p1.getAge()){
                return 1;
            }else if (this.getAge() < p1.getAge()){
                return -1;
            }else{
                return -this.getName().compareTo(p1.getName());
            }
        }else{
            throw new RuntimeException("您输入的类型不一致！");
        }
    }

5.对于自定义类，如果要进行排序，可以让自定义类实现Comparable接口，重写compareTo(obj)方法，指明如何排序。

3.Comparator：定制排序

匿名实现Comparator方法即可

    //第二种方式：comparator--定制排序
    @Test
    public void test2(){
        String[] arr = new String[]{"AA","CC","DD","BB"};
        Arrays.sort(arr, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return -o1.compareTo(o2);
            }
        }
        );
        System.out.println(Arrays.toString(arr));
    }