Java第十二课_常用类

基本数据类

package com.msr.lesson01;

import org.junit.Test;
// 测试单元 JUnit 4.12 : 测试时无需使用main函数. 在@Test中不需要main函数, 且函数可以一个个测.
//     注意 : 被测试函数不能有返回值也不能有形参,并且必须 public 修饰

public class Practice {

    @Test
    public void m1(){
        /*
            Number : 是六个数值型类型的父类,要求子类有相互转换的功能.

            封装类/包装类
                byte    Byte
                short   Short
                int     Integer
                long    Long
                float   Float
                double  Double
                boolean Boolean
                char    Character

            通用功能 :
                1.对应的基本数据类型 和 引用数据类型之间的转换
                2.负责 基本数据类型 和 String 之间的转换
         */
        // 1.对应的基本数据类型 和 引用数据类型之间的转换
        // int ---> Integer, 自动完成
        // 手动装箱
        Integer integer1 = Integer.valueOf(3306);// 引用类型.valueOf(基础类型)
        // 自动装箱
        integer1 = 3306;
        print(123);

        // Integer  -->  int
        // 手动拆箱
        int num = integer1.intValue();// 引用类型.***Value()
        // 自动拆箱
        num = integer1;

        // 2.负责 基本数据类型 和 String 之间的转换
        // *** ---> String
        String s = Integer.toString(8080);// 引用类型.toString(基础类型)

        // String  --->  ***
        // static int	parseInt​(String s)	默认十进制
        int i = Integer.parseInt("456");// 引用类型.parse***("")

        // static Integer	valueOf​(String s)
        Float aFloat = Float.valueOf("3.14");// 引用类型.valueOf("")

        // Integer类 :
        // 十进制 --->  其他进制
        // static String	toBinaryString​(int i)
        // static String	toHexString​(int i)
        // static String	toOctalString​(int i)
        String s1 = Integer.toBinaryString(3306);
        System.out.println("s1 = " + s1);
        String s2 = Integer.toOctalString(3306);
        System.out.println("s2 = " + s2);
        String s3 = Integer.toHexString(3306);
        System.out.println("s3 = " + s3);

        // static String	toString​(int i, int radix)
        System.out.println(Integer.toString(3306,2));
        System.out.println(Integer.toString(3306,8));
        System.out.println(Integer.toString(3306,10));
        System.out.println(Integer.toString(3306,16));

        // 其他进制 ---> 十进制
        // static Integer	valueOf​(String s, int radix)
        System.out.println(Integer.valueOf("110011101010", 2));
        System.out.println(Integer.valueOf("6352", 8));
        System.out.println(Integer.valueOf("cea", 16));
        // static int	parseInt​(String s, int radix)
        int i1 = Integer.parseInt("110011101010", 2);
        System.out.println("i1 = " + i1);
        System.out.println(Integer.parseInt("cea",16));

        // 数值型的极值 :
        System.out.println(Double.MAX_VALUE);
        System.out.println(Float.MIN_VALUE);
    }

    public static void print(Object o){
        System.out.println("o = " + o);
    }

    @Test
    public void m2(){
        // Integer 带有缓冲区 : -128 ~ 127的数值直接有, 且指向同一个地址. 但是使用new创建, 或者是其他数值时, 依然是在堆内存开辟新空间.
        Integer integer1 = 127;// Integer integer1 = new Integer(127) ;
        Integer integer2 = 127;
        Integer integer3 = new Integer(0);
        Integer integer4 = -129;
        Integer integer5 = -129;
        System.out.println(integer1 == integer2);// true
        System.out.println(integer1 == integer3);// false
        System.out.println(integer4 == integer5);// false

        // 只有七个基本数据类型可以进行计算
        Integer a = 10;
        int num = 11;
        num += a;// a ---> int  ;  num = num + a
    }
}

String类

public class Practice02 {
    @Test
    public void m1(){
        /*
            字符串 :
                可变字符串/字符串缓冲区 : StringBuffer / StringBuilder
                不可变字符串 : String
         */
        // String类表示字符串。
        // Java程序中的所有字符串文字，如“abc”，都是作为此类的实例实现的。
        // 字符串是常量；
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1 == s2);// 字符串都是先在方法区创建字符,再把地址赋给变量.同一字符串地址值一致
        String s3 = new String("abc");// 使用new关键字创建时,是在堆内存创建, 将地址值存放在方法区, 再赋给变量(栈内存)
        System.out.println(s1 == s3);
        // 它们的值在创建后不能更改, 但是变量可以指向新字符串
        s1 = "xyz";
        // 字符串缓冲区支持可变字符串。
        // 因为String对象是不可变的，所以它们可以共享。

        s1 = "a";// 1 : 方法区里创建"a"
        s2 = "x" + "y";// 3 : 方法区里"x","y","xy"各一个
        s3 = new String("z");// 2 : 堆内存"z",方法区里存地址.
    }

    @Test
    public void m2() throws UnsupportedEncodingException {
        //  String类常见的操作：
        String s = "abcdEFG";
        //  1. 获取：
        //   		1.1  字符串中的包含的字符数，也就是字符串的长度：
        //   			int length():获取长度
        System.out.println(s.length());
        //   		1.2  根据位置获取位置上某个字符：
        //   			char charAt(int index) :找返回值为char的方法
        System.out.println(s.charAt(3));
        //   		1.3 根据字符获取该字符在字符中的位置：(总共八个方法)
        //   			int indexOf(int ch):返回的是ch在字符串中第一次出现的位置
        //   			int indexOf(int ch,int fromIndex):从formIndex指定位置开始，获取ch在字符串中第一次出现的位置
        //   			int indexOf(String str):返回的是str在字符串中第一次出现的位置
        //   			int indexOf(String str,int fromIndex):从formIndex指定位置开始，获取str在字符串中第一次出现的位置
        //
        //   			int lastIndexOf(int ch) :倒着找,但是位置值不变
        System.out.println(s.indexOf('E'));
        //   2. 判断
        //   		2.1 字符串是否包含某一个子串
        //   			boolean contains(str) ;
        //   			特殊之处：indexOf(str):可以索引第一次出现个位置，如果返回-1，表示str不在字符串中。
        //   				所以可以用于判断是否包含。
        //   				if(str.indexOf("aa") != -1)
        //   				而且可以用于获取位置
        System.out.println(s.contains("E"));
        //   		2.2字符串是否有内容
        //   			boolean isEmpty():原理就是判断长度是否为零；""
        //   		2.3字符串是否以指定内容开头
        //   			boolean startsWith(str) ;
        //   		2.4字符串是否是以指定内容结束
        //   			boolean endsWith(str) ;
        //   		2.5判断字符串内容是否相同。复写了Object类中equals方法。
        //   			boolean equals(str) ;
        //   		2.6判断内容是否相同，并忽略大小写。原理： 全部转换成大写或小写再比较
        //   			boolean equalsIgnoreCase(str) ;
        System.out.println(s.equalsIgnoreCase("abcdefg"));
        //   3. 转换
        //   		3.1 将字符数组转成字符串
        //   			构造函数：	String(char[])
        //   					String(char[],offset,count):将字符数组中的一部分转成字符串
        char[] a = new char[]{'a','b','c','d','e'};
        System.out.println(new String(a, 1, 3));// 从1开始,一共3个
        //   			静态方法：
        //   					static String copyValueOf(char[]) ;
        //   					static String copyValueOf(char[] data,int offset,int count) ;
        //  					static String valueOf(char[]) ;
        //  		3.2 将字符串转成字符数组
        //  					char[] toCharArray() :
        for (char c : s.toCharArray()) {
            System.out.println(c);
        }
        //  		3.3 将字节数组转成字符串
        //  					String(byte[])
        //  					String(byte[],offset,count):将字符数组的一部分转成字符串
        //  		3.4 将字符串转成字节数组
        //  					byte[] getBytes() ;
        byte[] bytes;

        bytes = "华夏ABC".getBytes();// 默认utf-8 : 一个汉字 三个字节  一个字母  一个字节
        System.out.println(Arrays.toString(bytes));

        // UnsupportedEncodingException : 不支持的编码格式异常
        bytes = "华夏ABC".getBytes("GBK");// GBK : 一个汉字 两个字节  一个字母  一个字节
        System.out.println(Arrays.toString(bytes));

        bytes = "华夏ABC".getBytes("UTF-16be");// UTF-16be : 一个汉字 两个字节  一个字母  两个字节
        System.out.println(Arrays.toString(bytes));
        //  		3.5 将基本数据类型转成字符串
        //  			static String valueOf(int)
        //  			static String valueOf(double)
        //
        //  			3+"";//就是String.valueOf(3) ;//专业写法
        //
        //  		特殊： 字符串和字节数组在转换过程中，是可以指定编码表的。
        //  4. 替换
        //  		String replace(oldchar,newchar) ;
        System.out.println(s.replace('a','A'));
        //  5. 切割：
        //  		String[] split(regex) ;
        String[] split =s.split("d");
        System.out.println(Arrays.toString(split));
        Arrays.stream(split).forEach(System.out::println);
        //  6. 子串。获取字符串的一部分
        //  		String substring(begin) ;
        //  		String substring(begin,end) ;
        System.out.println(s.substring(3));
        System.out.println(s.substring(3,4));// Java中参数是两个索引值时,通常包含头不包含尾
        //  7. 转换，去除空格，比较
        //  		7.1 将字符串转成大写或小写
        //  			String toUpperCase() ;
        //  			String toLowerCase() ;
        System.out.println(s.toUpperCase());
        //  		7.2 将字符串两端的空格都去除
        //  			String trim() ;
        //  		7.3 对两个字符串进行自然顺序的比较
        // 			int compareTo(string) ;
        System.out.println("aaa".compareTo("abc"));// -1 比abc在前一位
        System.out.println("abc".compareTo("abc"));// 0
        System.out.println("abc".compareTo("aaa"));// 1 比aaa在后一位
    }
}

字符串缓冲区

    public static void main(String[] args) {
        /*
            字符串缓冲区 :
                StringBuffer : 线程安全的可变字符序列。字符串缓冲区类似于字符串，但可以修改。在任何时间点，它都包含一些特定的字符序列，但序列的长度和内容可以通过某些方法调用来更改。
                StringBuilder :  线程不安全的可变字符序列。多线程时不好处理多个同时的修改请求. 用于 单线程 ;
         */

        StringBuilder stringBuilder = new StringBuilder("abcdefg");
        // 查
        System.out.println(stringBuilder);
        // int	capacity() 获取理论容量
        // int	length()  获取实际容量
        System.out.println("stringBuilder.capacity() = " + stringBuilder.capacity());
        System.out.println("stringBuilder.length() = " + stringBuilder.length());

        // char	charAt​(int index) 获取指定的索引值对应的字符
        System.out.println(stringBuilder.charAt(stringBuilder.length() - 1));
        // int	indexOf​(String str) 获取指定字符的索引值
        // int	indexOf​(String str, int fromIndex)
        System.out.println("stringBuilder.indexOf(\"j\") = " + stringBuilder.indexOf("j"));
        // int	lastIndexOf​(String str)
        // int	lastIndexOf​(String str, int fromIndex)
        System.out.println(stringBuilder.lastIndexOf("j"));

        // 增
        // StringBuilder	append​(boolean b)
        stringBuilder.append(123)
                .append(true)
                .append("abc")
                .append(3.14)
                .append('a')
                .append(new Object());
        System.out.println(stringBuilder);

        // 删
        // StringBuilder	delete​(int start, int end)	从start索引值开始,删除到 end 索引值
        // StringBuilder	deleteCharAt​(int index)  删除指定索引值对应的字符
        stringBuilder.delete(1, 4);
        // void	trimToSize() 尝试减少空间容量 : 释放多余空间, 让capacity空间和length长度一致
        stringBuilder.trimToSize();
        System.out.println(stringBuilder);
        System.out.println("stringBuilder.capacity() = " + stringBuilder.capacity());
        System.out.println("stringBuilder.length() = " + stringBuilder.length());

        // 改
        // StringBuilder	insert​(int offset, boolean b) 在指定位置插入元素
        stringBuilder.insert(stringBuilder.length() - 1, "xyz");
        System.out.println(stringBuilder);
        // StringBuilder	replace​(int start, int end, String str)	 替换
        stringBuilder.replace(10, stringBuilder.length(), "hello");
        System.out.println(stringBuilder);
        // StringBuilder	reverse() 反转
        System.out.println(stringBuilder.reverse());

        // void	setCharAt​(int index, char ch) 改变对应索引值上的值
        stringBuilder.setCharAt(3, 'Y');
        System.out.println(stringBuilder);

        // void	setLength​(int newLength)
        System.out.println("stringBuilder.capacity() = " + stringBuilder.capacity());
        System.out.println("stringBuilder.length() = " + stringBuilder.length());
        stringBuilder.setLength(8);
        System.out.println(stringBuilder);
        System.out.println("stringBuilder.capacity() = " + stringBuilder.capacity());
        System.out.println("stringBuilder.length() = " + stringBuilder.length());
        // String	substring​(int start)
        // String	substring​(int start, int end)
        System.out.println(stringBuilder.substring(1, 3));
    }

Math类(数学类)

    public static void main(String[] args) {
        // static double	abs​(double a) 绝对值
        System.out.println("Math.abs(-10/3) = " + Math.abs(-10 / 3));
        // static double	cbrt​(double a) 立方根
        System.out.println("Math.cbrt(8) = " + Math.cbrt(8));
        // static double	ceil​(double a) 天花板函数 / 向上取整
        System.out.println("Math.ceil(13.11) = " + Math.ceil(13.11));// 14
        System.out.println("Math.ceil(-13.11) = " + Math.ceil(-13.11));// -13
        // static double	floor​(double a) 地板函数 / 向下取整
        System.out.println("Math.floor(13.99) = " + Math.floor(13.99));// 13
        System.out.println("Math.floor(-13.99) = " + Math.floor(-13.99));// -14

        // static double	max​(double a, double b)
        // static float	max​(float a, float b)
        // static int	max​(int a, int b)
        // static long	max​(long a, long b)
        // static double	min​(double a, double b)
        // static float	min​(float a, float b)
        // static int	min​(int a, int b)
        // static long	min​(long a, long b)

        // static double	pow​(double a, double b)
        System.out.println(Math.pow(2,8));

        // static long	round​(double a)	 四舍五入
        // static int	round​(float a)
        System.out.println("Math.round(13.49999) = " + Math.round(13.49999));
        System.out.println("Math.round(13.555555) = " + Math.round(13.55555));

        // static double	sqrt​(double a) 平方根
        System.out.println("Math.sqrt(5) = " + Math.sqrt(5));

        // static double	random()
        // Random :
    }

Date类

    public static void main(String[] args) throws ParseException {
        // java.sql 用于和 数据库进行数据交换的包
        // java.util 工具包
        // java.util.Date : 类Date表示一个特定的时间瞬间，精度为毫秒。

        // 构造器
        // Date()
        // Date​(long date)

        // 方法
        Date date = new Date();
        int year = date.getYear();//当前年份 - 1900 不推荐使用的函数
        System.out.println("year = " + year);

        // boolean	after​(Date when)
        // boolean	before​(Date when)

        // Object	clone()

        // int	compareTo​(Date anotherDate)

        // boolean	equals​(Object obj)

        // static Date	from​(Instant instant)

        // Instant	toInstant()

        // long	getTime()

        // Date ---> String
        System.out.println(new Date());
        // DateFormat是日期/时间格式化子类的抽象类，它以独立于语言的方式格式化和解析日期或时间。
        // String	format​(Date date)
        DateFormat dateFormat = new SimpleDateFormat();
        String s = dateFormat.format(new Date());
        System.out.println(s);

        dateFormat = new SimpleDateFormat("yyyy.MMMMM.dd GGG hh:mm aaa");

        System.out.println(dateFormat.format(new Date()));

        dateFormat = new SimpleDateFormat("yyyy年MM月dd日 kk:mm:ss SSS");

        System.out.println(dateFormat.format(new Date()));

        System.out.println(new SimpleDateFormat("yyyy/MM/dd kk:mm:ss SSS").format(new Date()));

        // String --->  Date : 2023/12/18 17:46:46 273
        // Date	parse​(String source)
        // ParseException
        Date date1 = new SimpleDateFormat("yyyy/MM/dd kk:mm:ss SSS").parse("2023/12/18 17:46:46 273");
        System.out.println("date1 = " + date1);
    }