Java学习笔记——常用类

字符串相关的类：String及常用方法、StringBuffer、StringBuilder

jdk8之前的日期时间API：System静态方法、Date类、Calender类、SimpleDateFormat类

jdk8中新日期时间API：

Java比较器：Comparable接口、Comparator接口

System类

Math类

BigInteger与BigDecimal

字符串相关的类 String类的概述

String：字符串，使用一对“”引起来表示

1.String声明为final的，不可被继承

2.String实现了Serializable接口：表示字符串是支持序列化的

​ 实现了Comparable接口：表示String可以比较大小

3.String内部定义了final char[] value用于存储字符串数据

4.String：代表不可变的字符序列。简称：不可变性

​ 体现：当对字符串重新赋值时/对现有字符串进行连接操作时/当调用String的replace()方法修改指定字符或者字符串时，需要重写指定内存区域赋值，不能使用原有value进行赋值

5.通过字面量的方式给一个字符串赋值（区别于new），此时的字符串值声明在字符串常量池中

6.字符串常量池中不会存储相同内容的字符串的

String不同实例化方式的对比

String的实例化方式

方式一：通过字面量定义的方式

方式二：通过new+构造器的方式

public class StringTest {
    public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1 == s2);//false
        System.out.println(s1.equals(s2));//true
//虽然对象所指的堆内存中的地址不一样，但是String类型的字面量定义都是在方法区的常量池中创建了相同的值
        Person p1 = new Person("Tom",13);
        Person p2 = new Person("Tom",13);
        System.out.println(p1 == p2);//false
        System.out.println(p1.name==p2.name);//true
    }
}

String不同拼接操作的对比

1.常量与常量的拼接结果在常量池，且常量池中不会存在相同内容的常量

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

3.如果拼接的结果调用intern()方法，返回值就在常量池中

public class StringTest {
    public static void main(String[] args) {
        String s1 = "hellojava";
        String s2 = "hello";
        String s3 = "java";
        String s4 = "hello"+"java";
        String s5 = "hello" + s3;
        String s6 = s2 + "java";
        String s7 = s2 + s3;

        System.out.println(s1 == s4);//true
        System.out.println(s1 == s5);//false
        System.out.println(s1 == s7);//false

        String s8 = s7.intern();
        System.out.println(s1 == s8);//true
    }
}

String的常用方法

public class StringMethodTest {
    public static void main(String[] args) {
        String s1 = "helloworld";
        String s2 = "";
        String s3 = " ";
//        String s2 = new String("hello");
        System.out.println(s1.length());
        System.out.println(s1.charAt(4));
        System.out.println(s1.isEmpty());
        System.out.println(s2.isEmpty());
        System.out.println(s3.isEmpty());
        System.out.println(s1.toUpperCase());
        String s4 = " hello world  ";
        System.out.println(s4.trim());
        String s5 = " Hello World  ";
        System.out.println(s4.equalsIgnoreCase(s5));
        System.out.println(s1.concat(s4));
        System.out.println(s1.compareTo(s2));//涉及到字符串排序
        String s6 = "java上课内容";
        System.out.println(s6.substring(4));
        System.out.println(s6.substring(4, 7));//含左不含右
    }

}

String与基本数据类型、包装类之间的转换

String ——>基本数据类型、包装类：parseXxx(str)

基本数据类型、包装类——>String：valueOf(xxx)

package a01;


public class Test1 {

	public static void main(String[] args) {
		String s1 = "123";
		int num = Integer.parseInt(s1);
		String s2 = String.valueOf(num);
		System.out.println(num);
		System.out.println(s2);
	}
}

String和char[]之间的转换

String——>char[]：调用String中的toCharArray()

char[]——>String：调用string构造器

package com.yan.Test;

public class Test3 {
	public static void main(String[] args) {
		String str1 = "abc123";
		char[] c1 = str1.toCharArray();
		for (int i = 0; i < c1.length; i++) {
			System.out.println(c1[i]);
		}
		char[] c2 = new char[] {'h','e','l','l','o'};
		String str2 = new String(c2);
		System.out.println(str2);
	}
}

String和byte[]之间的转换

编码：字符串——>字节

String——>byte[]：调用String的getBytes()

解码：字节——>字符串

byte[]——>String：调用String构造器

说明：解码时所使用的编码集必须与编码时的编码集一致，否则会出现乱码

package com.yan.Test;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class Test4 {
	public static void main(String[] args) throws UnsupportedEncodingException {
		String str1 = "abc中国";
		byte[] b1 = str1.getBytes();
		System.out.println(Arrays.toString(b1));
		byte[] b2 = str1.getBytes("utf-8");
		System.out.println(Arrays.toString(b2));
		String str2 = new String(b1);
		System.out.println(str2);
		String str3 = new String(b2);
		System.out.println(str3);
	}
}

String、StringBuilder、StringBuffer的区别

	String	StringBuilder	StringBuffer
是否为可变的字符序列	不可变	可变	可变
底层存储	char[]	char[]	char[]
		JDK5.0新增，线程不安全，效率高	线程安全，效率低

String str1 = new String();//char[] value = new char[0]
String str2 = new String("abc");//char[] value = new char[]{'a','b','c'}

StringBuffer sb1 = new StringBuffer();//char[] value = new char[16]底层创建一个长度为16的数组
sb1.append('a');//value[0] = 'a';
sb1.append('b');//value[1] = 'b';

问题一：System.out.println(sb1.length());//3问题二：扩容问题：如果要添加的数据底层数组盛不下了，就需要扩容底层的数组。默认情况下，扩容为原来容量的2倍+2，同时将原有数组中的元素复制到新的数组中 StringBuffer的常用方法

增

StringBuffer append(xxx)

删

StringBuffer delete(int start, int end)

改

StringBuffer replace(int start, int end, String str) / public void setCharAt(int n, char ch)

查

public char charAt(int n)

插

StringBuffer insert(int offset, xxx)

长度

length();

日期时间API

jdk8之前的日期时间API：System静态方法、Date类、Calender类、SimpleDateFormat类

System类中的currentTimeMillis()

Long timeLong = System.currentTimeMillis();
//返回当前时间与 1970年1月1日0时0分0秒之间以毫秒为单位的时间差
//称为时间戳
System.out.println(timeLong);

Date类的使用

java.util.Date类

​ |----java.sql.Date类

构造器

new Date()：创建一个对应当前时间的Date对象创建指定毫秒数的Date对象

方法

toString()getTime()

Date date1 = new Date();
System.out.println(date1.toString());//Wed Mar 16 08:48:15 CST 2022
System.out.println(date1.getTime());//1647391719892

Date date2 = new Date(156782425751L);
System.out.println(date2.toString());//Fri Dec 20 22:40:25 CST 1974

java.sql.Date对应数据库中的日期类型的变量

//将util下的Date转换为sql下的Date
Date date3 = new Date();
java.sql.Date date4 = new java.sql.Date(date3.getTime());
System.out.println(date4);

SimpleDateFormat 格式化：日期—>字符串 解析：格式化的逆过程 字符串—>日期

//1.格式化
	//1.1无参
SimpleDateFormat sdf1 = new SimpleDateFormat();
Date date = new Date();
String str1 = sdf1.format(date);
System.out.println(str1);//22-3-16 上午9:29
	//1.2带参
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
String str2 = sdf2.format(date);
System.out.println(str2);//2022-03-16 09:30:03
		
//2.解析
String str3 = "2022-03-16 09:30:03";
Date date3 = sdf2.parse(str3);
System.out.println(date3);//Wed Mar 16 09:30:03 CST 2022
		
Date date4 = sdf1.parse(str3);
System.out.println(date4);//抛异常

例题：渔夫三天打渔两天晒网

Calendar日历类 1.实例化

方式一：创建其子类GregorianCalendar的对象

方式二：调用其静态方法getInstance()

2.常用方法

Calendar calendar = Calendar.getInstance();
System.out.println(calendar);

//get()
int days = calendar.get(calendar.DAY_OF_MONTH);
System.out.println(days);

//set()
calendar.set(calendar.DAY_OF_WEEK, 5);
System.out.println(calendar.get(calendar.DAY_OF_WEEK));

//add()
calendar.add(calendar.DAY_OF_WEEK, 2);
System.out.println(calendar.get(calendar.DAY_OF_WEEK));

//getTime() 日历--->Date
Date date = calendar.getTime();
System.out.println(date);
		
//setTime() Date--->日历
Date date2 = new Date();
calendar.setTime(date2);
System.out.println(calendar);

LocalDate、LocalTime、LocalDateTime的使用 方法

// now()获取当前的日期、时间、日期＋时间
	LocalDateTime ldt1 = LocalDateTime.now();
	System.out.println(ldt1);
// of() 设置指定的年月日时分秒 没有偏移量
	LocalDateTime ldt2 = LocalDateTime.of(2022, 3, 16, 12, 56, 23);
	System.out.println(ldt2);
//getXxx() 获取相关的属性
// getDayOfMonth()/getDayOfYear()
	System.out.println(ldt2.getDayOfMonth());
//withXxx() 设置相关的属性
// withDayOfMonth()
	LocalDateTime ldt3 = ldt2.withDayOfMonth(14);
	System.out.println(ldt3);
//plusXxx() 添加
// plusDays()
	LocalDateTime ldt4 = ldt2.plusMonths(5);
	System.out.println(ldt4);

比较器 Comparable接口

自然排序

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

2.像String、包装类重写compareTo()方法以后，进行从小到大的排列

3.重写compareTo(obj)的规则

​ 如果当前对象this大于形参obj，则返回正整数

4.对于自定义类，如果需要排序，则实现Comparable接口，在compareTo(obj)方法中指明如何排序

Comparator接口

定制排序

1.元素的类型没有实现java.lang.Comparable接口又不方便修改代码或者实现了Comparable接口的排序规则不适合当前的操作，考虑Comparator的对象排序

2.重写compare(Object o1,Object o2)方法，比较o1和o2的大小

​ 如果方法返回正整数，o1大于o2

System类 Math类 BigInteger和BigDecimal类

位置： java.math包中
作用： 精确计算浮点数
创建方式： BigDecimal bd = new BigDecimal(“1.0”);
方法：
BigDecimal add(BigDecimal bd)
BigDecimal subtract(BigDecimal bd)
BigDecimal multiply(BigDecimal bd)
BigDecimal divide(BigDecimal bd)

[面试题]

String s = new String(“abc”);方式创建对象，在内存中创建了几个对象？

两个。一个是在堆空间中new结构，一个是char[]对应的常量池中的数据“abc”

String前面加上final，则该变量为常量

//①常量与常量的拼接结果在常量池，且常量池中不会存在相同内容的常量
//②只要其中一个是变量，结果就在堆中
public static void main(String[] args) {
  	String s1 = "javaEEhadoop";
  	String s2 = "javaEE";
  	String s3 = s2+"hadoop";
  	System.out.println(s1==s3);//false
  		
  	final String s4 = "javaEE";//此处s4为常量
  	String s5 = s4 + "hadoop";
  	System.out.println(s1==s5);//true
  }