java基础——常用类

XZY-SUNSHINE

已于 2022-10-27 20:45:32 修改

阅读量450

点赞数

分类专栏： java基础文章标签： java

于 2022-10-23 14:44:07 首次发布

本文链接：https://blog.csdn.net/qq_52117201/article/details/127474579

版权

java基础专栏收录该内容

31 篇文章 1 订阅

订阅专栏

包装类

分类

在这里插入图片描述

类结构

在这里插入图片描述

说明：

实现了Serallizable接口说明此类可以串行化，实现网络传输

实现了Compareable接口说明此类实例可以相互比较大小

包装类和基本数据类型的相互转换

package wrap;

public class change {
    public static void main(String[] args) {
        //    包装类和基本数据类型的转换以int->integer为例
        int n1=100;
//    jdk5以前是手动装箱和手动拆箱
        //手动装箱
        Integer n2=Integer.valueOf(n1);
        //第二种手动装箱形式
        Integer n3=new Integer(n1);
        //手动拆箱
        int n4= n2.intValue();

        //jdk5以后就可以自动装箱和自动拆箱,底层执行的代码和手动装拆和手动拆箱的代码一样
        //自动装箱
        Integer n5=n1;
//        自动拆箱
        int n6=n5;
        
    }

}

测试题

package wrap;

public class wrap01_work {
    public static void main(String[] args) {
//        下面的代码是否正确.
//        正确
        Double d = 100d;
        Float f = 1.5f;
//        如下两个题目输出结果相同吗?各是什么?
//        不相同，obj1是1.0，obj2是1
//        因为obj1赋值式子中最高精度是double所以是1.0
        Object obj1 = true?new Integer(1):new Double(2.0);
        System.out.println(obj1);//什么?
        Object obj2;
        if(true) {
            obj2 = new Integer(1);
        } else {
            obj2 = new Double(2.0);
            System.out.println(obj2);//输出什么?
        }
    }
}

包装类和string的相互转换

package wrap;

public class wrap_stringchange {
    public static void main(String[] args) {
        int n1=100;
        //以Integer转换为string为例

//        Integer->string
        //方式一
        String n2=n1+"";
        //方式二
        String n3=String.valueOf(n1);
        //方式三
        String n4=n2.toString();
        
        //string->Integer
        String n5="123";
//        方式一
        Integer n6=Integer.parseInt(n5);
        //方式二
        Integer n7=new Integer(n5);
    }
}

Integer和Character类常用的方法

System.out.println(Integer.MIN_VALUE);//返回最小值
System.out.println(Integer.MAX_VALUE);//返回最大值
System.out.println(Character.isDigit('a'));//判断是不是数字
System.out.println(Character.isLetter( 'a' ));//判断是不是字母
System.out.println(Character.isUpperCase( 'a'));//判断是不是大写
System.out.println(Character.isLowerCase( 'a'));//判断是不是小写
System.out.println(Character.isWhitespace( 'a' ));//判断是不是空格
System.out.println(Character.toUpperCase( 'a'));//转成大写
System.out.println(Character.toLowerCase( 'A'));//转成小写

测试题

        //第一题
            Integer i = new Integer(1);
            Integer j = new Integer(1);
            System.out.println(i==j);//false;因为；两个对象不同，所以地址值不一样

            Integer m = 1;
            Integer n = 1;
            System.out.println(m==n);//true;
//看下面源码如果赋值-128~127直接返回，不是的话就创建对象实例
        //        public static Integer valueOf(int i) {
//            if (i >= Integer.IntegerCache.low && i <= Integer.IntegerCache.high)
//                return Integer.IntegerCache.cache[i + (-Integer.IntegerCache.low)];
//            return new Integer(i);
//        }
            Integer x = 128;
            Integer y = 128;
            System.out.println(x==y);//false;看上面原码

        //第二题

        //示例一
        Integer i1=new Integer( 127 );
        Integer i2=new Integer( 127 );
        System.out.println(i1==i2);//false
        //示例二
        Integer i3=new Integer( 128);
        Integer i4=new Integer( 128 );
        System.out.println(i3==i4);//false
        //示例三
        Integer i5=127;
        Integer i6=127;
        System.out.println(i5==i6);//true
        //示例四
        Integer i7=128;
        Integer i8=128;
        System.out.println(i7==i8);//false
        //示例五
        Integer i9=127;
        Integer i10=new Integer(127);
        System.out.println(i9==i10);//false
        //示例六
        Integer i11=127;
        int i12=127;
        System.out.println(i11==i12);//true；和基本数据类型比较就是数值是否相同
        //示例七
        Integer i13=128;
        int i14=128;
        System.out.println(i13==i14);//true；和基本数据类型比较就是数值是否相同

String类

String类是保存字符串常量的。每次更新都需要重新开辟空间，效率较低,因此java设计者还提供了StringBuilder 和 StringBuffer 来增强String的功能,并提高效率。

类结构

在这里插入图片描述

构造方法

直接赋值String s =字符串;

执行过程：先从常量池查看是否有"hsp”数据空间，如果有，直接指向;如果没有则重新创建，然后指向。S最终指向的是常量池的空间地址
调用构造器 String s2 =new String(字符串);

执行过程：先在堆中创建空间，里面维护了value属性，指向常量池的hsp空间。如果常量池没有"hsp"，重新创建,如果有，直接通过value指向。最终指向的是堆中的空间地址。

介绍

String对象用于保存字符串，也就是一组字符序列
字符串常量对象是用双引号括起的字符序列。例如:“你好”、“12.97”、"boy"等
字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节。
String类实现了

接口 Serializable 【String 可以串行化:可以在网络传输】

接口Comparable [String 对象可以比较大小]
String是final类，不能被其他的类继承
string有属性 private final char value[];用于存放字符串内容一定要注意:value是一个final类型，地址不可以修改(需要功力)
重要规则，String c1 = “ab” + “cd”;常量相加,看的是池。String c1 =+b;变量相加,是在堆中

关于String类特性的测试题

package wrap;

public class String01 {
    public static void main(String[] args) {
        //第一题
        String a= "abc";
        String b = "abc";
        System.out.println(a.equals(b));//True
        System.out.println(a==b);//True
        //第二题
        String a ="hsp";
        String b =new String("hsp");
        System.out.println(a.equals(b));//true
        System.out.println(a==b);//false
        //b.intern()方法最终返回的是常量池的地址(对象)
        System.out.println(a==b.intern());//true
        System.out.println(b==b.intern());//false
        //第三题
        String s1 = "hspedu";
        String s2 ="java";
        String s4 = "java";
        String s3 = new String("java");
        System.out.println(s2==s3);//false
        System.out.println(s2==s4);//true
        System.out.println(s2.equals(s3));//true
        System.out.println(s1==s2);//false
        //第四题
        Person p1 = new Person();
        p1.name = "hspedu";
        Person p2 = new Person();
        p2.name = "hspedu";
        System.out.println(p1.name.equals(p2.name));//true
        System.out.println(p1.name==p2.name);//true
        System.out.println(p1.name=="hspedu");//true
        String s1 = new String("bcde");
        String s2 = new String("bcde");
        System.out.println(s1==s2);//fasle
        //第五题：以下语句创建了几个对象?画出内存布局图。
        //创建了两个对象
        String s1 = "hello";
        s1="haha";
        //第六题：创建了几个对象：
        //错误想法：创建了三个对象
        //解答：解释器会直接创建helloabc对象
        String a= "hello" +"abc";
        //第七题：创建了几个对象?画出内存图?
        //解答：创建了三个对象，但是创建c对象的时候不是和上一题一样直接指向常量池的
        //流程：
        	//1.先创建一个StringBuilder sb = StringBuilder()
        	//2.然后执行sb.append("hello");
			//3.sb.append("abc");
			//4.String c= sb.toString(
			//5.最后其实是 c指向堆中的对象(String) value[] -> 池中“"helloabc"，具体看图
        String a = "hello";
        String b ="abc";
		String c=a+b;
        //第八题
        String s1 = "hspedu";
        String s2 = "java";
        String s5 = "hspedujava";
        String s6 =(s1+s2).intern();
        System.out.println(s5==s6);//true
        System.out.println(s5.equals(s6));//true
        //第九题
        String str = new String("hsp");
        final char[] ch ={'j','a','v','a'};
        str = "java";
        ch[0]='h';
        System.out.print(str + " and ");
        System.out.println(ch);//java and hava
    }
}
class Person{
    String name;
}

第五题内存布局图

在这里插入图片描述

第七题内存布局图

在这里插入图片描述

常见的方法

equals //区分大小写，判断内容是否相等
equalslgnoreCasel //忽略大小写的判断内容是否相等
length / /获取字符的个数，字符串的长度
indexOf //获取字符在字符串中第1次出现的索引,索引从O开始,如果找不到,返回-1
lastIndexOf //获取字符在字符串中最后1次出现的索引,索引从0开始,如找不到,返回-1
substring //截取指定范围的子串
trim //去前后空格
charAt :获取某索引处的字符,注意不能使用Str[index]这种方式.
toUppercase ：将字符串转换为大写
toLowercase ：将字符串转换为小写
concat ：拼接字符串
replace 替换字符串中的字符，s1.replace()返回的结果是替换过后的，对s1没有任何影响
split 分割字符串，有特殊字符，需要加上转义符 \
compareTo //比较两个字符串的大小
toCharArray //转换成字符数组
format //格式字符串，

练习实例

package wrap;

public class string_method {
    public static void main(String[] args) {
        //1。equals前面已经讲过了。比较内容是否相同，区分大小写
        String str1 = "hello";
        String str2 ="Hello" ;
        System.out.println(str1.equals(str2));
        //2.equalsIgnoreCase 忽略大小写的判断内容是否相等
         String username = "johN" ;
        if("john ".equalsIgnoreCase(username)){
            System.out.println( "Success ! ");
        }else{
            System.out.println("Failure! ");
        }
        //3.length 获取字符的个数，字符串的长度
        System.out.println("hsp".length());
        //4.indexOf 获取字符在字符串对象中第一次出现的索引，索引从0开始，如果找不到，返回-1
        String s1 = "wertenweg";
        int index = s1.indexOf( 'w');
        System.out.println(index);// 0
        // 5.lastIndex0f 获取字符在字符串中最后一次出现的索引，索引从0开始,如果找不到,返回-1
        s1 = "wer@terwe@g@";
        index = s1.lastIndexOf('@');
        System.out.println(index);//11
        // 6.substring截取指定范围的子串
         String name = "hello,张三";
        //下面name.substring(6）从索引6开始截取后面所有的内容
        System.out.println(name.substring(6));
        //name.substring(0,5)表示从索引0开始截取,截取到5-1位置
        System.out.println(name.substring(0,5));
        //7.toUpperCase转换成大写
        String s = "heLLo";
        System.out.println(s.toUpperCase());//HELLO
        //8.toLowerCase
        System.out.println(s.toLowerCase());//hello
        //9.concat拼接字符串
        String s2="宝玉";
        s1 = s2.concat("林黛玉").concat("薛宝钗").concat( "together");
        System.out.println(s1);//宝玉林黛玉薛宝骊together
        // 10.replace 替换字符串中的字符
        s1 ="宝玉 and林黛玉林黛玉林黛玉";
        //在s1中，将所有的林黛玉替换成薛宝钗
        s1 = s1.replace("林黛玉","薛宝钗");
        System.out.println(s1);//宝玉and薛宝骊薛宝钗薛宝骊
        // 11.split分割字符串，对于某些分割字符，我们需要转义比如   │   \等
        String poem ="锄禾日当午，汗滴禾下土,谁知盘中餐，粒粒皆辛苦";
        // 1.以，为标准对 poem进行分割，返回一个数组
        // 2.在对字符串进行分割时，如果有特殊字符，需要加入―转义符 \
        String[] split = poem.split("，");
        poem = "E: \\aaa\\bbb" ;
        split =poem.split("MNN");
//        String[] split = poem.split("\\\\");
//        String[] split = poem.split("\\");
        System.out.println("==分割后内容=== ");
        for (int i = 0; i< split.length; i++) {
            System.out.println(split[i]);
        }
        // 12.toCharArray 转换成字符数组
        s = "happy" ;
        char[] chs = s.toCharArray();
        for (int i = 0; i< chs.length; i++) {
            System.out.println(chs[i]);
        }
        // 13.compareTo比较两个字符串的大小，如果前者大，则返回正数，
        // 后者大，则返回负数，如果相等,返回0
        String a1="jchn";
        String b1="jabk";
        System.out.println(a1.compareTo(b1));//返回值是'c' - 'a' = 2的值
//        14.format格式字符串
        /*占位符有:
         *%S字符串%c字符%d 整型%.2f 浮点型*
         */
        String name1 = "john";
        int age = 10;
        double score = 98.3/3;
        char gender = '男';
//将所有的信息都拼接在一个字符串。
        String info =
                "我的姓名是" + name1 +"年龄是" +age + "，成绩是"
                        +score +"性别是" + gender + "希望大家喜欢我！";
        System.out.println(info);
        //1.%s , %d , %.2f %c称为占位符
        //2.这些占位符由后面变量来替换
        //3.%s 表示后面由字符串来替换
        //4.%d是整数来替换
        //5．%.2f 表示使用小数来替换，替换后，只会保留小数点两位
        //6．%c使用char类型来替换
        String info2 = String .format("我的姓名是%s年龄是%d，成绩是%.2f性别是%c.希望大家喜欢我! ",name,age,score,gender);
        System.out.println(info2);
    }
}

StringBuffer类

基本介绍

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

类结构

在这里插入图片描述

String Vs StringBuffer

String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率较低//private final char valuell;
StringBuffer保存的是字符串变量,里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用更新地址,效率较高/char[ value;1/这个放在堆.

构造方法

stringBuffer()构造一个其中不带字符的字符串缓冲区，其初始容量为16个字符。
stringBuffer(CharSequence seq)构造一个字符串缓冲区，它包含与指定的charSequence相同的字符。
StringBuffer(int capacity) 构造一个不带字符，但具有指定初始容量的字符串缓冲区。即对char[]大小进行指定
StringBuffer(String str)构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。大小为，字符串长度+16

String和StringBuffer相互转换

package wrap;

public class StringBuffer01{
    public static void main(String[] args) {
        //String-->StringBuffer
        String s= "hello";
        //方式1:
        //返回的才是StringBuffer对象，对str本身没有影响
        StringBuffer b1=new StringBuffer(s);
        //方式2:
        StringBuffer b2 = new StringBuffer();
        b2.append(s);
        //StringBuffer->String
        //方式1:
        String s2 = b1.toString();
        //方式2:
        String s3 = new String(b1);
    }
}

常用的方法

package wrap;

public class StringBuffer02 {
    public static void main(String[] args) {
        StringBuffer s = new StringBuffer("hello");
        //增
        s.append('.');
        s.append("张三丰");
        s.append("赵敏").append(100).append(true).append(10.5);
        System.out.println(s);//hello,张三丰赵敏100true10.5
        // 删
        /*
        删除索引为>=start && <end处的字符
        解读:删除11~14的字符[11，14)
        */
        s.delete(11,14);
        System.out.println(s);
        //改
        s.replace(9,11,"周芷若");
        System.out.println(s);
        //查找指定的子串在字符串第一次出现的索引，如果找不到返回-1
        int indexOf = s.indexOf("张三丰");
        System.out.println(indexOf);
        //hello.张三丰周芷若true10.5
        s.insert(9,"赵敏");
        System.out.println(s);
        //长度
        System.out.println(s.length());
        System.out.println(s);
    }
}

练习题

package wrap;

public class StringBufferwork01 {
    public static void main(String[] args) {
        //第一题：看下面的代码输出什么?为什么?
        String str = null;
        StringBuffer sb = new StringBuffer();
        sb.append(str);
        System.out.println(sb.length());//4 -> 解读：sb.append(str)底层调用的是 AbstractStringBuilder的 appendNull，赋值为4，内容为null
        System.out.println(sb);//null
        StringBuffer sb1 = new StringBuffer(str);
        System.out.println(sb1);//报错 -> 解读：StringBuffer sb1 = new StringBuffer(str)的底层源码super(str.length0 + 16);
        //第二题：输入商品名称和商品价格，要求打印效果示例，使用前面学习的方法完成:
        // 商品名  商品价格
        //  手机  123,564.59
        //要求:价格的小数点前面每三位用逗号隔开，在输出。
        //思路分析
        //1。定义一个Scanner对象，接收用户输入的价格(String)
        //2．希望使用到StringBuffer的 insert ，需要将String 转成StringBuffer
        //3.然后使用相关方法进行字符串的处理
        //代码实现
        Scanner input=new Scanner(System.in);
        System.out.print("请输入商品的名字：");
        String name=input.next();
        System.out.print("情输入商品的价格：");
        StringBuffer price=new StringBuffer(input.next());
        if (price.lastIndexOf(".")>0) {
            for (int i = price.lastIndexOf(".") - 3; i > 0; i -= 3) {
                price.insert(i, ",");
            }
        }else{
            for (int i = price.length() - 3; i > 0; i -= 3) {
                price.insert(i, ",");
            }
        }
        System.out.println("商品\t商品名\n"+name+"\t"+price);
    }
}

StringBuilder类

基本介绍

一个可变的字符序列。此类提供一个与 StringBuffer 兼容的API,但不保证同步(StringBuilder不是线程安全)。该类被设计用作 StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能,建议优先采用该类因为在大多数实现中，它比 StringBuffer 要快。
在StringBuilder上的主要操作是 append 和 insert方法,可重载这些方法,以接受任意类型的数据。

常用方法

StringBuilder 和 StringBuffer 均代表可变的字符序列，方法是一样的，所以使用和StringBuffer一样.

知识点总结

StringBuilder继承 AbstractStringBuilder类
实现了Serializable ，说明StringBuilder对象是可以串行化(对象可以网络传输,可以保存到文件)StringBuilder是final类，不能被继承
StringBuilder对象字符序列仍然是存放在其父类AbstractStringBuilder的 char[] value;因此，字符序列是堆中
StringBuilder 的方法，没有做互斥的处理,即没有synchronized关键字,因此在单线程的情况下使用StringBuilder

String,StringBuffer 和StringBuilder的比较

StringBuilder 和 StringBuffer非常类似，均代表可变的字符序列，而且方法也一样
String:不可变字符序列,效率低,但是复用率高。
StringBuffer:可变字符序列、效率较高(增删)、线程安全
StringBuilder:可变字符序列、效率最高、线程不安全
String使用注意说明:
1. string s=“a”;//创建了一个字符串
2. s += “b”;//实际上原来的"a"字符串对象已经丢弃了，现在又产生了一个字符串s+“b”(也就是"ab”)。如果多次执行这些改变串内容的操作,会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能=>结论:如果我们对String 做大量修改,不要使用String
效率:StringBuilder > StringBuffer > String

String,StringBuffer和StringBuilder的选择

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

Math类

基本介绍

Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。math类的方法一般都为静态方法，直接调用即可。

常用方法

package wrap;

public class math01 {
    public static void main(String[] args) {
        //1.abs 绝对值
        int abs = Math.abs(-9);
        System.out.println(abs);
        //2.pow求幂
        double pow = Math.pow(2,4);//2的4次方
        // System.out.println(pow); //16
        //3.ceil向上取整,返回>=该参数的最小整数(double);
        double ceil = Math.ceil(-3.0001);
        System.out.println(ceil);
        //4.floor向下取整，返回<=该参数的最大整数(double);
        double floor = Math.floor(-4.999);
        System.out.println(floor);
        //5.round 四舍五入 Math.floor(该参数+0.5)
        long round = Math.round(-5.001);
        System.out.println(round);
        //6.sqrt求开方
        double sqrt = Math.sqrt(-9.0);
        System.out.println(sqrt);
        //7.random返回的是0<= x<1之间的一个随机小数
        //思考:请写出获取 a-b之间的一个随机整数,a, b均为整数，比如 a = 2，b=7
        // 即返回一个数x2 <= x <= 7
        //老韩解读
        //      (1)(int)(a) <= x <= (int)(a + Math.random() * (b-a +1) )
        int a=1,b=2;
        for(int i = 0; i< 10; i++) {
            System.out.println((int)(a+ Math.random()*(b-a +1)));
        }
    }
}

Arrays类

Arrays里面包含了一系列静态方法，用于管理或操作数组(比如排序和搜索)。

常用方法

package wrap;

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

public class Arrays01 {
    public static void main(String[] args) {
        Integer[] integers = {1,20,90};//遍历数组
        for(int i = 0; i< integers.length; i++) {
            System.out.println(integers[i]);
        }
        //直接使用Arrays.toString方法，显示数组
        System.out.println(Arrays.toString(integers));
        //演示sort方法的使用
        Integer arr[]={-1,7,0,89};//进行排序
        //1．可以直接使用冒泡排序，也可以直接使用Arrays提供的sort方法排序
        //2．因为数组是引用类型，所以通过sort排序后，会直接影响到实参arr
        // 3. sort重载的，也可以通过传入一个接口 Comparator实现定制排序
        //4．调用定制排序时，传入两个参数
            // (1)排序的数组arr
            //(2〕实现了Comparator接口的匿名内部类，要求实现compare方法
        //5先演示效果，再解释
        //6原码分析
        //(1)Arrays.sort(arr, new Comparator(
        //(2）最终到 TimSort类的 private static <T> void binarySort(T[] a, int lo
                //Comparator<? super T> c))
        //(3）执行到 binarySort方法的代码，会根据动态绑定机制c.compare()执行我们传入
        //      匿名内部类的 compare (
        //while (left < right) {
        //                  int mid = (left + right) >>> 1;
        //                  if (c.compare(pivot,a[mid])<0)
        //                      right = mid;
        //                  else
        //                      left = mid + 1;
        //                  }
        //(4)public int compare(0bject o1,0bject o2)返回的值>0还是<O会影响整个排序结果
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return 0;
            }
        });
        //binarySearch通过二分搜索法进行查找，要求必须排好
        //1．使用binarySearch二叉查找
        //2．要求该数组是有序的．如果该数组是无序的，不能使用binarySearch
        //3.如果数组中不存在该元素,就返回return -(low +1) low指的是应该在的位置
        Integer[] arr1 = {12,90,123,567};
        int index = Arrays.binarySearch(arr1,12);
        System.out.println( "index=" + index) ;
        //copyOf数组元素的复制=
        //1．从arr数组中，拷贝arr.length个元素到newArr数组中
        // 2．如果拷贝的长度> arr.length就在新数组的后面增加null
        // 3．如果拷贝长度<0就抛出异常NegativeArraySizeException
         Integer[] newArr = Arrays.copyOf(arr1,arr1.length);
        System.out.println("==拷贝执行完毕后==");
        System.out.println(Arrays.toString(newArr));
        //fill填充数组
        Integer[] num = new Integer[]{9,3,2};
        //1．使用99去填充num数组，可以理解成是替换原理的元素
        Arrays.fill(num,99);
        System.out.println("==num数组填充后==");
        System.out.println(Arrays.toString(num));
        //equals比较两个数组元素内容是否完全一致
         Integer[] arr2 = {1,2,90,123};
        //1．如果arr 和arr2数组的元素一样，则方法true;
        // 2。如果不是完全一样，就返回 false
        boolean equals = Arrays.equals(arr,arr2);
        System.out.println("equals=" +equals);
        //1. asList方法，会将(2,3,4,5,6,1)数据转成一个List集合
        //2．返回的 asList 编译类型List(接口)
        //3. asList运行类型java.util.Array#ArrayList
        List asList = Arrays.asList(2,3,4,5,6,1);
        System.out.println("asList=" +asList);
        System.out.println("asList的运行类型" +asList.getClass());
    }
}

练习题

package wrap;

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

public class arrays_work {
    public static void main(String[] args) {
//        案例:自定义Book类，里面包含name和price,按price排序(从大到小)。
//        要求使用两种方式排序，有一个 Book[]数组,里面有4个book对象.
//        使用前面学习过的传递实现Comparator接口匿名内部类,也称为定制排序。
//        可以按照price (1)从大到小(2)从小到大
//         (3)按照书名长度从大到小
        Book[] books = new Book[4];
        books[0] = new Book("红楼梦", 100);
        books[1] = new Book("金瓶梅新",90);
        books[2] = new Book("青年文摘20年", 5);
        books[3]= new Book("java从入门到放弃~",300);
//        按照price 从小到大
        Arrays.sort(books, new Comparator<Book>() {
            @Override
            public int compare(Book o1, Book o2) {
                Book book01=(Book)o1;
                Book book02=(Book)o2;
                double price=book01.price- book02.price;
                if (price>0){
                    return 1;
                }else if (price<0){
                    return -1;
                }else{
                    return 0;
                }
            }
        });
        System.out.println(Arrays.toString(books));
//        按照price从大到小
        Arrays.sort(books, new Comparator<Book>() {
            @Override
            public int compare(Book o1, Book o2) {
                Book book01=(Book)o1;
                Book book02=(Book)o2;
                double price=book01.price- book02.price;
                if (price>0){
                    return -1;
                }else if (price<0){
                    return 1;
                }else{
                    return 0;
                }
            }
        });
        System.out.println(Arrays.toString(books));
        //按照书名长度从大到小
        Arrays.sort(books, new Comparator<Book>() {
            @Override
            public int compare(Book o1, Book o2) {
                Book book01=(Book)o1;
                Book book02=(Book)o2;
                return book02.name.length()- book01.name.length();
            }
        });
        System.out.println(Arrays.toString(books));
    }
}
class Book{
    String name;
    double price;
    public Book(String name, double price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

System类

常见方法

package wrap;

import java.util.Arrays;

public class system01 {
    public static void main(String[] args) {
        //exit退出当前程序
        System.out. println("ok1");
        //1. exit(0)表示程序退出
        //2．0表示一个状态，正常的状态
         System.exit(0);
        System.out. println("ok1");
        //arraycopy :复制数组元素，比较适合底层调用，
        //一般使用Arrays.copyOf完成复制数组
        int[] src={1,2,3};
        int[] dest = new int[3];//dest当前是 {0,0,0}
        //1．主要是搞清楚这五个参数的含义
        //2.
//           源数组
//           *@param      src     the source array.
//           srcPos:从源数组的哪个索引位置开始拷贝
//           *@param      srcPos  starting position in the source array.
//           dest :目标数组，即把源数组的数据拷贝到哪个数组
//           *@param       dest    the destination array.
//           destPos:把源数组的数据拷贝到目标数组的哪个索引
//           *@param      destPos  starting position in the destination data.
//           length:从源数组拷贝多少个数据到目标数组
//          *@param       length    the number of array elements to be copied.
        System.arraycopy(src,0,dest,0,3);
        System.out.println("dest=" + Arrays.toString(dest));
        //currentTimeMillens:返回当前时间距离1970-1-1 的毫秒数
        System.out.println(System.currentTimeMillis());
    }
}

Biglnteger和BigDecimal类

应用场景:

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

使用说明

biginteger

package wrap;

import java.math.BigInteger;

public class biginteger01 {
    public static void main(String[] args) {
        ///当我们编程中，需要处理很大的整数，long 不够用
        // 可以使用BigInteger的类来搞定
//        long l = 23788888899999999999999999999l;//报错下面代码解决
//        System.out.println("l="+l);
        BigInteger bigInteger = new BigInteger("2378888889999999999999999999p");
        BigInteger bigInteger2 = new BigInteger("100");
        System.out.println(bigInteger);
        //1.在对 BigInteger进行加减乘除的时候，需要使用对应的方法，不能直接进行+– *///
        //2。可以创建一个要操作的 BigInteger 然后进行相应操作
        BigInteger add = bigInteger.add(bigInteger2);
        System.out.println(add);//加
        BigInteger subtract = bigInteger.subtract(bigInteger2);
        System.out.println(subtract);//减
        BigInteger multiply = bigInteger.multiply(bigInteger2);
        System.out.println(multiply);//乘
        BigInteger divide = bigInteger.divide(bigInteger2);
        System.out.println(divide);//除
    }
}

bigdecimal

package wrap;

import java.math.BigDecimal;

public class bigdecimal {
    public static void main(String[] args) {
        //当我们需要保存一个精度很高的数时，double不够用
        // 可以是 BigDecimal
        double d = 1999.111111311119999999999999999999999999999999999999999999999999999999999999999977788d;//不会报错，但是精度不够
        System.out.println(d);
        BigDecimal bigDecimal = new BigDecimal( "1999.111111111111111111111999999999999977788");
        BigDecimal bigDecimal2 = new BigDecimal( "1.1");
        System.out.println(bigDecimal);
        //1。如果对 BigDecimal进行运算，比如加减乘除，需要使用对应的方法
        // 2。创建一个需要操作的 BigDecimal然后调用相应的方法即可
        System.out.println(bigDecimal.add(bigDecimal));
        System.out.println(bigDecimal.subtract(bigDecimal2));
        System.out.println(bigDecimal.multiply(bigDecimal2));
        System.out.println(bigDecimal.divide(bigDecimal2));// 可能抛出异常ArithmeticException,因为除不尽，出现了无限循环小数
        // 在调用divide 方法时，指定精度即可。
        System.out.println(bigDecimal.divide(bigDecimal2,BigDecimal.ROUND_CEILING));
    }
}

日期类

第一代日期类：Date类

精确到毫秒，代表特定的瞬间

类结构

在这里插入图片描述

SimpleDateFormat

格式和解析日期的类SimpleDateFormat格式化和解析日期的具体类。它允许进行格式化(日期->文本)、解析(文本->日期)和规范化.

在这里插入图片描述

应用实例

package wrap;

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

public class Date01 {
    public static void main(String[] args) throws ParseException {

        Date d1 = new Date();//获取当前系统时间
        System.out.println("当前的日期是"+d1);
        //1．获取当前系统时间
        //2．这里的Date类是在java.util包
        //3．默认输出的日期格式是国外的方式，因此通常需要对格式进行转换
        Date d2 = new Date(9234567);//通过指定毫秒数得到时间
        System.out.println(d2.getTime());//获取某个时间对应的毫秒数
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss E");
        //1．创建SimpleDateFormat对象，可以指定相应的格式
        // 2．这里的格式使用的字母是规定好，不能乱写
        String format = sdf.format(d1); // format:将日期转换成指定格式的字符串
        System.out.println("当前的日期是"+format);
        //1．可以把一个格式化的String转成对应的Date
        String s = "1996年01月01日 10:20:30 星期一";
        Date parse = sdf.parse(s);//将异常抛出去即可
        System.out.println("日期"+parse);
    }
}

第二代日期类

calendar类

Calendar类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法,并为操作日历字段（例如获得下星期的日期)提供了一些方法。

类结构

在这里插入图片描述

应用实例

package wrap;

import java.util.Calendar;

public class calendar01 {
    public static void main(String[] args) {
        //1. Calendar是一个抽象类，并且构造器是private
        // 2．可以通过getInstance()来获取实例
        //3．提供大量的方法和字段提供给程序员
        Calendar c= Calendar.getInstance();//创建日历类对象,比较简单，自由
         System.out.println(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));
        //5．如果我们需要按照、24小时进制来获取时间，Calendar . HOUR-=改成=> Calendar .HOUR_OF_DAY
        System.out.println("小时:"+c.get(Calendar.HOUR));
        System.out.println("分钟:"+c.get(Calendar.MINUTE));
        System.out.println("秒:"+c.get(Calendar.SECOND));
        //Calender没有专门的格式化方法，所以需要程序员自己来组合显示
         System.out.println(c.get(Calendar.YEAR)+"年"+(c.get(Calendar.MONTH)+1)+"月"+c.get(Calendar.DAY_OF_MONTH)+"日");
    }
}

第三代日期类

Calendar问题分析

可变性:像日期和时间这样的类应该是不可变的。
偏移性:Date中的年份是从1900开始的,而月份都从0开始。格式化:格式化只对Date有用，Calendar则不行。
此外，它们也不是线程安全的;不能处理闰秒等(每隔2天,多出1s)。

Local类

LocalDate只包含日期，可以获取日期字段
LocalTime只包含时间,可以获取时间字段
LocalDateTime包含日期+时间，可以获取日期和时间字段

类结构

在这里插入图片描述

DateTimeFormatter类

格式日期类类似于SimpleDateFormat类

使用方法

DateTimeFormat dtf = DateTimeFormatter.ofPattern(格式);

String str = dtf.format(日期对象);

应用实例

package wrap;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class loacl {
    public static void main(String[] args) {
        //1。使用now()返回表示当前日期时间的对象
        LocalDateTime ldt = LocalDateTime.now();
        //LocalDate.now();
        // LocalTime.now()
        System.out.println(ldt);
        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());
        LocalDate now = LocalDate.now();//可以获取年月日
        LocalTime now2 = LocalTime.now();//获取到时分秒
    }
}

Instant时间戳

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

Instant—>Date:
Date date = Date.from(instant);
Date->Instant:
lnstant instant = date.tolnstant(;

应用实例

package wrap;

import java.time.Instant;
import java.util.Date;

public class instant {
    public static void main(String[] args) {
        //1.通过静态方法 now()获取表示当前时间藏的对象
        Instant now = Instant.now();
        System.out.println(now);
        //2．通过 from 可以把 Instant转成DateDate 
        Date date = Date.from(now);
        //3．通过 date的toInstant()可以把 date 转成Instant对象
        Instant instant = date.toInstant();
    }
}

练习题

package wrap;

public class wrapwork {
    public static void main(String[] args) {
     1.编程题
      (1)将字符串中指定部分进行反转。比如将"abcdef"反转为"aedcbf"
      (2)编写方法public static String reverse(String str, int start , int end）搞定
//        String str="abcdef";
//        str=reverse(str,0,2);
//        System.out.println(str);
     2.输入用户名、密码、邮箱，如果信息录入正确，则提示注册成功，否则生成异常对象
       要求:
//    //      (1)用户名长度为2或3或4
//    //      (2)密码的长度为6，要求全是数字'123456'
//    //      (3)邮箱中包含@和.并且@在.的前面isDigital
//        String secret="222222";
//        String box="sadas@sdfs.com";
//        str=checkinfo(str,secret,box);
//        System.out.println(str);
     3.编写java程序，输入形式为:
          Han Shun Ping的人名，以Ping,Han.S的形式打印 出来。
          其中.S是中间单词的首字母。
     (2)例如输入“Willian Jefferson Clinton”，输出形式为:
          Clinton,Willian .J
//        String name="Willian Jefferson Clinton";
//        printname(name);
    4.输入字符串，判断里面有多少个大写字母，多少个小写字母，多少个数字
//        numchar(name);
//     5.写出一下运行结果：
        String s1="abcedfsd";
        Animal a = new Animal(s1);
        Animal b = new Animal(s1);
        System.out.println(a==b);//false
        System.out.println(a.equals(b));//false
        System.out.println(a.name==b.name);//true
        String s4= new String("abcedfsd");
        String s5 = "abcedfsd";
        System.out.println(s1==s4);//false
        System.out.println(s4==s5);//false
        String t1 = "hello"+s1;
        String t2 = "helloabcedfsd";
        System.out.println(t1.intern()==t2);//true 解读：intern()方法最终返回的是常量池的地址(对象)
    }
    public static String reverse(String str, int start , int end){
        if (str==null||start<0||end<=start||end>=str.length()){
            System.out.println("输入格式有误,反转失败！");
            return str;
        }
        char[] list= str.toCharArray();
        char temp=' ';
        for (int i =start,j=end ; i!=j; i++,j--) {
            temp=list[i];
            list[i]=list[j];
            list[j]=temp;
        }
        return new String(list);
    }
    public static String checkinfo(String name,String  secret,String box){
        if (name==null||secret==null||box==null){
            return "输入信息不能为空！";
        }
        if (name.length()<2||name.length()>4){
            return "用户名长度为2-4!";
        }
        if (secret.length()!=6){
            return "密码的长度应设置为6位！";
        }
        for (int i = 0; i <secret.length() ; i++) {
            if (secret.charAt(i)>'9'||secret.charAt(i)<'0'){
                return "密码必须全部是数字！";
            }
        }
        int i=box.indexOf("@");
        int j=box.indexOf(".");
        if (i<0){
            return "邮箱中必须有@字符";
        }else if(j<0){
            return "邮箱中必须有 . 字符！";
        }else if (j<=i){
            return "@应该在.的前面";
        }
        return " 注册成功！";
    }
    public static void printname(String name){
        String[] names=name.split(" ");
        if (names.length!=3){
            System.out.println("输入格式有误！");
        }else{
            System.out.println(names[2]+","+names[0]+" ."+names[1].toUpperCase().charAt(0));
        }
    }
    public static void numchar(String str){
        int[] num=new int[3];
        for (int i = 0; i <str.length() ; i++) {
            if (str.charAt(i)>'0'&&str.charAt(i)<'9'){
                num[0]++;
            }else if (str.charAt(i)>'a'&&str.charAt(i)<'z'){
                num[1]++;
            }else if (str.charAt(i)>'A'&&str.charAt(i)<'Z'){
                num[2]++;
            }
        }
        System.out.println("数字的数量是"+num[0]+"\n小写字母的数量是"+num[1]+"\n大写字母的数量是"+num[2]);
    }
}
class Animal {
    String name;
    public Animal(String name){
        this.name= name;
    }
}