Unit 9 Java常用类

于 2023-04-29 13:35:56 发布
阅读量57 收藏
点赞数
分类专栏： Java基础 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63954541/article/details/130440058
版权

1 字符串相关的类

1）相关描述

在这里插入图片描述

​ String: 字符串，使用一对" "引起来表示。

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

2.String 实现了 Serializable 接口：表示字符串是支持序列化的。
实现了 Comparable 接口：表示 String 可以比较大小。

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

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

体现：1）当对字符串重新赋值时，需要重写指定区域赋值，不能使用原有的 value 进行赋值。

​ 2）当对现有的字符串连接操作时，也需要重写指定内存区域赋值，不能使用原有的 value 进行赋值。

​ 3）当调用 String 的 replace( ) 方法修改指定字符或字符串时，也需要重写指定内存区域赋值，不能使用原有的 value 进行赋值。

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

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

2）String对象的创建

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public class StringTest {
    /*
    结论：
    1. 常量与常量的拼接结果在常量池中。且常量池中不会存在相同内容的常量。
    2. 只要其中有一个是变量，结果就在堆中。
     */
    @Test
    public void test3(){
        String s1 = "javaEE";
        String s2 = "hadoop";

        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";
        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;

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

        String s8 = s5.intern();//返回值得到的s8使用的常量值中已经存在的"javaEEhadoop"
        System.out.println(s3 == s8);//true
    }

    /*
    String的实例化方式：
    方式一：通过字面量定义的方式
    方式二：通过new + 构造器的方式

    面试题：String s = new String("abc");方式创建对象，在内存中创建了几个对象？
            两个：一个是堆空间new结构，另一个是char[] 对应的常量池中的数据：“abc”
     */
    @Test
    public void test2(){
        //通过字面量定义的方式：此时的s1和s2的数据javaEE声明在方法区中的字符串常量池中
        String s1 = "javaEE";
        String s2 = "javaEE";

        //通过new + 构造器的方式：此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。
        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

    }

    @Test
    public void test1(){
        String s1 = "abc";//字面量的定义方式
        String s2 = "abc";
//        s1 = "hello";

        System.out.println(s1 == s2);//比较s1和s2的地址值

        System.out.println(s1);//hello
        System.out.println(s2);//abc

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

        String s3 = "abc";
        s3 += "def";
        System.out.println(s3);//abcdef
        System.out.println(s2);

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

        String s4 = "abc";
        String s5 = s4.replace('a','m');
        System.out.println(s4);
        System.out.println(s5);
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

复习：1.String与基本数据类型、包装类之间的转换。

/**
String--->基本数据类型、包装类：调用包装类的静态方法：parseXxx(str)
基本数据类型、包装类--->String：调用String重载的valueOf(xxx)
*/
@Test
public void test1(){
	String str1 ="123";
	int num = Integer.parseInt(str1);

	String str2 = String.valueOf(num);//"123"
	String str3 = num + "";//"123"

2.String 与 char[ ] 之间的转换

/**
String--->char[]: 调用String的toCharArray() 
char[]--->String: 调用String的构造器
*/
@Test
public void test2(){
	String str1 = "abc123";

	char[] charArray = str1.toCharArray();
	for(int i = 0;i < charArray.length;i++){
		System.out.println(charArray[i]);
	}

	char[] arr = new char[]{'h','e','l','l','o'};
	String str2 = new String(arr);
	System.out.println(str2);
}

3.String 与 byte[ ] 之间的转换

/**
编码：String ---> byte[]：调用String的getBytes()
解码：byte[] ---> String：调用String的构造器

编码：字符串 ---> 字节（看得懂 ---> 看不懂的二进制数据）
解码：编码的逆过程：字节 ---> 字符串（看不懂的二进制数据--->看得懂）

说明：解码时，要求解码时使用的字符集必须与编码时使用的字符集一致，否则会出现乱码。
	*/
@Test
public void test3(){
	String str1 = "abc123";
	byte[] bytes = str1.getBytes();//使用默认的字符集进行转换
	System.out.println(Arrays.toString(bytes));

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

	Stringstr2 = newString(bytes);//用默认的字符集进行解码
	System.out.println(str2);
}

4.String StringBuffer StringBuilder

/**
	String、StringBuffer、StringBuilder三者的异同？
	String：不可变的字符序列；底层用char[]存储
	StringBuffer：可变的字符序列；线程安全的，效率低；底层用char[]存储
	StringBuilder：可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层用char[]存储
*/
//源码分析：
	String str = new String();//char[] value = new char[0];
	String str1 = new String("abc");//char[] value = new char[]{'a','b','c'};
	
	StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度为16的char型数组
	sb1.append('a');//value[0] = 'a';
	sb1.append('b');//value[1] = 'b';
	
	StringBuffer sb2 = new StringBuffer("abc");//char[] value = new char["abc".length() + 16];
	
/**	问题一：System.out.println(sb2.length());//3,abc三个，不是16
	问题二：扩容问题：如果要添加的数据底层数组盛不下了，那就需要扩容底层数组
	默认情况下，扩容为原来容量的2倍+2，同时将原有数组中的元素复制到新的数组中。
	
	指导意义：开发中建议大家使用：StringBuffer(int capacity)或StringBuilder(int capacity)
*/

在这里插入图片描述

总结:

增：append(xxx)

删：delete(intstart,intend)

改：setCharAt(intn,charch)/replace(intstart.intend,Stringstr)

查：charAt(intn)

插：insert(intoffset,xxx)

长度：length()

遍历：for()+charAt()/toString()

对比String、StringBuffer、StringBuilder三者的效率

从高到低排序：StringBuilder > StringBuffer > String

2 JDK8之前的日期和时间API

在这里插入图片描述
在这里插入图片描述

java.util.Date类

​ |—java.sql.Date类

1.两个构造器的使用

​ >构造器一：Date( ):创建一个对应当前时间的 Date 对象

​ >构造器二：创建指定毫秒数的 Date 对象

2.两个方法的使用

​ >toString( ):显示当前的年、月、日、时、分、秒

​ >getTime( ):获取当前 Date 对象对应的时间戳

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

​ >如何实例化

​ >如何将 java.util.Date 对象转换为 java.sql.Date 对象

	@Test
	public void test2(){
		//构造器一：Date():创建一个对应当前时间的Date对象
		Date date1 = new Date();
		System.out.println(date1.toString());//MonMay0222:09:22CST2022

		System.out.println(date1.getTime());//1651500562821

		//构造器二：创建指定毫秒数的Date对象
		Date date2 = new Date(1651500562821L);
		System.out.println(date2);

		//创建java.sql.Date对象
		java.sql.Date date3 = new java.sql.Date(1651500562821L);
		System.out.println(date3);

		//如何将java.util.Date对象转换为java.sql.Date对象
		//情况一：
		//Date date4 = new java.sql.Date(1651500562821L);
		//java.sql.Datedate5 = (java.sql.Date)date4;
		//情况二：
		Date date6 = new Date();
		java.sql.Date date7 = new java.sql.Date(date6.getTime());
	}
	@Test
	public void test1(){
		long time = System.currentTimeMillis();
		//返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差
		//称为时间戳
		System.out.println(time);
	}

有两道相关的算法题目：

/**
 * 将一个字符串进行反转。将字符串中指定部分进行反转
 *
 * 方式一：转换为 char[]
 * @author lystart
 * @creat ${TEAR}--05--03 ${time}
 */
public class StringDemo {
    //方式一：转换为 char[]
    public String reverse(String str,int startIndex,int endIndex){
        char[] arr = str.toCharArray();
        for(int x = startIndex,y = endIndex;x < y;x++,y--){
            char temp = arr[x];
            arr[x] = arr[y];
            arr[y] = temp;
        }
        return new String(arr);
    }

    //方式二：使用String的拼接
    public String reverse1(String str,int startIndex,int endIndex){
        //第一部分
        String reverseStr = str.substring(0,startIndex);
        //第二部分
        for(int i = endIndex;i >= startIndex;i--){
            reverseStr += str.charAt(i);
        }
        //第三部分
        reverseStr += str.substring(endIndex + 1);

        return reverseStr;

    }

    //方式三：使用StringBuffer/StringBuffer替换String
    public String reverse2(String str,int startIndex,int endIndex){
        StringBuilder builder = new StringBuilder(str.length());

        //第一部分
        builder.append(str.substring(0,startIndex));
        //第二部分
        for(int i = endIndex;i >= startIndex;i--){

            builder.append(str.charAt(i));
        }
        //第三部分
        builder.append(str.substring(endIndex + 1));

        return builder.toString();
    }

    public void testReverse(){
        String str = "abcdefg";
        String reverse = reverse2(str,2,4);
        System.out.println(reverse);
    }
}

public class StringDemo1 {
    /*
    获取一个字符串在另一个字符串中出现的次数
     */
    public int getCount(String mainStr,String subStr){
        int mainLength = mainStr.length();
        int subLength = subStr.length();
        int count = 0;
        int index = 0;
        if(mainLength >= subLength){
            //方式一
//            while((index = mainStr.indexOf(subStr)) != -1){
//                count++;
//                mainStr = mainStr.substring(index + subStr.length());
//            }
            //方式二：对方式一的改进
            while ((index = mainStr.indexOf(subStr,index)) != -1){
                count++;
                index += subLength;
            }
        }
        return count;
    }
    @Test
    public void testGetCount(){
        String mainStr = "abkkcadkabkebfkaabkskab";
        String subStr = "ab";
        int count = getCount(mainStr,subStr);
        System.out.println(count);
    }
}

在这里插入图片描述

JDK8之前的日期时间的API测试

​ 1.System 类中 currentTimeMillis( );

​ 2.java.util.Date 和子类 java.sql.Date

​ 3.SimpleDateFormat

​ 4.Calender

SimpleDateFormat 的使用：SimpleDateFormat 对日期 Date 类的格式化和解析

​ 1.两个操作：

​ 1.1格式化：日期—>字符串

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

​ 2.SimpleDateFormat 的实例化

	@Test
	public void testSimpleDateFormat() throws ParseException {
	//实例化SimpleDateFormat:使用默认的构造器
		SimpleDateFormat sdf = new SimpleDateFormat();

	//格式化：日期--->字符串
		Date date = new Date();
		System.out.println(date);

		String format = sdf.format(date);
		System.out.println(format);

	//解析：格式化的逆过程，字符串--->日期
		String str = "22-5-4下午9:55";
		Date date1 = sdf.parse(str);
		System.out.println(date1);

		System.out.println("******************");
		//***************************

		//使用指定的方式进行格式化和解析：调用带参的构造器

		//SimpleDateFormatsdf1=newSimpleDateFormat("yyyyy.MMMMM.ddGGGhh:mmaaa");
		SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-ddhh:mm:ss");
		String format1 = sdf1.format(date);
		System.out.println(format1);

		//解析:要求字符串必须符合SimpleDateFormat识别的格式（通过构造器参数体现）。
		//否则抛异常
		Date date2 = sdf1.parse("2022-05-0410:05:53");
		System.out.println(date2);
	}

在这里插入图片描述

Calender 日历类的使用

	@Test
	public void testCalender(){
		//1.实例化
		//方式一：创建其子类(GregarianCalender)的对象
		//方式二：调用静态方法getInstance()
		Calendar calendar = Calendar.getInstance();
		//System.out.println(calendar.getClass());

		//2.常用方法
		//get()
		int days = calendar.get(Calendar.DAY_OF_MONTH);
		System.out.println(days);
		System.out.println(calendar.get(Calendar.DAY_OF_YEAR));

		//set()
		calendar.set(Calendar.DAY_OF_MONTH,22);
		days = calendar.get(Calendar.DAY_OF_MONTH);
		System.out.println(days);

		//add()
		calendar.add(Calendar.DAY_OF_MONTH,3);
		//calendar.add(Calendar.DAY_OF_MONTH,-3);没有减，就加上一个负的
		days = calendar.get(Calendar.DAY_OF_MONTH);
		System.out.println(days);

		//getTime():日历类--->date
		Date date = calendar.getTime();
		System.out.println(date);

		//setTime():Date--->日历类
		Date date1 = new Date();
		calendar.setTime(date1);
		days = calendar.get(Calendar.DAY_OF_MONTH);
		System.out.println(days);
	}

3 JDK8中的新日期时间API

可变性：像日期时间这样的类应该是不可变的

偏移性：Date 中的年份是从1900开始的，而月份都从0开始

格式化：格式化只对 Date 有用，Calendar 则不行

此外，它们也不是线程安全的；不能处理闰秒等

//LocalDate、LocalTime、LocalDateTime的使用说明
	//1.LocalDateTime相较于LocalDate、LocalTime。使用频率要高
	//代码见day04 java包的JDK8DateTimeTest.java
	public void test1(){
		LocalDate localDate = LocalDate.now();
		LocalTime localTime = LocalTime.now();
		LocalDateTime localDateTime = LocalDateTime.now();
	
		System.out.println(localDate);
		System.out.println(localTime);
		System.out.println(localDateTime);
	
		//of():设置指定的年、月、日、时、分、秒。没有偏移量
		LocalDateTime localDateTime1 = LocalDateTime.of(2020,10,6,13,23,42);
		System.out.println(localDateTime1);
	
		//getXxx()
		System.out.println(localDateTime.getDayOfMonth());
		System.out.println(localDateTime.getDayOfWeek());
		System.out.println(localDateTime.getMonth());
		System.out.println(localDateTime.getMonthValue());
		System.out.println(localDateTime.getMinute());
	
		//体现不可变性
		LocalDate localDate1 = localDate.withDayOfMonth(22);
		System.out.println(localDate1);
		System.out.println(localDate);
	}

在这里插入图片描述

2.瞬时：instant

// Instant：时间线上的一个瞬时点。这可能被用来记录应用程序中的事件时间戳。
//关注里面的方法
	public void test2(){
		//now():获取本初子午线对应的标准时间
		Instant instant = Instant.now();
		System.out.println(instant);//2022-08-16T13:39:25.566Z
	
		//添加时间的偏移量
		OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
		System.out.println(offsetDateTime);
	
		//获取自1970年1月1日0时0分0秒（UTC）开始的毫秒数
		long milli = instant.toEpochMilli();
		System.out.println(milli);
	
		//ofEpochMilli():通过给定的毫秒数。获取Instant实例--->Date类的getTime()方法
		Instant instant1 = Instant.ofEpochMilli(15504);
		System.out.println(instant1);
	}

在这里插入图片描述

3.格式化与解析日期或时间

在这里插入图片描述

public void test3(){
	//方式一：预定义的标准格式ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
	DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
	//格式化
	LocalDateTime localDateTime = LocalDateTime.now();
	String str1 = formatter.format(localDateTime);
	System.out.println(localDateTime);
	System.out.println(str1);//2022-08-16T21:59:39.908

	//解析：字符串--->日期
	formatter.parse("2022-08-16T21:59:39.908");

	//方式二：
	//本地化相关的格式。如：ofLocallizedDateTime(FormatSystle.LONG)
	//FormatSystle.LONG/FormatStyle.MEDIUM/FormatStyle.SHORT：适用于LocalDateTime
	DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
	//格式化
	String str2 = formatter1.format(localDateTime);
	System.out.println(str2);

	DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL);
	String str3 = formatter2.format(LocalDate.now());
	System.out.println(str3);

	//方式三：自定义的格式。如：ofPattern("yyyy-MM-ddhh:mm:ssE")
	DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-ddhh:mm:ssE");
	//格式化：日期--->字符串
	String str4 = formatter3.format(LocalDateTime.now());
	System.out.println(str4);

	//解析：字符串--->日期
	TemporalAccessor accessor = formatter3.parse("2022-08-1622:15:40");
	System.out.println(accessor);
}

4 Java比较器

一、说明：Java 中的对象，正常情况下，只能进行比较：== 或 ！=。不能使用 > 或 < 的，但是在

​ 开发场景中，我们需要对多个对象进行排序。

​ 如何实现？使用两个接口中的任何一个：Comparable 或 Comparator

二、Comparable 接口的使用

​ Comparable 接口的使用举例：自然排序

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

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

​ 3.重写 compareTo(obj) 的规则：

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

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

​ 如果当前对象 this 等于形参对象 obj，则返回零。

4.对于自定义类来说，如果需要排序，我们可以让自定义类实现 Comparable接口，重写 compareTo(obj)方法。

​ 在 compareTo(obj) 方法中指明如何排序

在这里插入图片描述

5 System类

在这里插入图片描述

在这里插入图片描述

6 Math类

在这里插入图片描述

7 BigInteger与BigDecimal类

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

南方有嘉木_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值