java常用类

包装类

包装类是针对八种基本定义类型相应的引用类型——包装类

该类的特点： 调用类中的方法

基本数据类型	包装类
boolean	Boolean
int	Integer
char	Character
short	Short
long	Long
float	Float
double	Double
byte	Byte

装箱和拆箱

JDK5 前的手动拆装箱 装箱： 基本类型 ==》 包装类型 ，反之拆箱

JDK5之后有自动的

自动装箱的底层调用的是 valueOf方法，不如 INteger.ValueOf（）

拆箱是： .类型Value（）方法

     //手动装箱
        int a = 100;
        Integer integer = new Integer(a);//过时
        Integer integer1 = Integer.valueOf(a);//常用

        //手动拆箱
        int i = integer.intValue();

        //jdk5 之后，就可以自动进行拆装箱
        int n1 = 100;
        //自动装箱
        Integer integer2 = n1 ;//底层使用的额仍然是 new 一个Integer Integer.valueOf(n1)
        //自动拆箱
        int n2 = integer2; //底层使用的还是integer.intValue();

问题

Object obj1 = true? new Integer(1) : new Double(2.0);//三元运算符:【sh]一真大师
System.out.println(obj1);//输出什么？？？？？
//输出1.0  因为：三元运算符是一个整体。后边的Double会提高精度

包装类转String

Integer i = 100;
//方式一
String str1 = i +"" //i 仍然是Integer ，不是真正的转型
//方式二
    String str = i.toString();
//方式三
    String str2 = String.valueOf(i);

//=======String > INteger
String str3 = "13245";
Integer i1 = Integer.parseInt(str3);
Integer i2 = new  Integer(str3);

String

String用于保存字符串，字符串的字符使用的是Unicode字符编码，b字符（不区分中文）占两个字节

构造方法：

String sr1 = new String();
String sr2 = new String(String sdd);
String s3 = new String(char[] a);
String s4 = new String(char[] a,int startIndex,int count);

刨析String创建刨析

方式一 ： String str = “sdsdd”； 方式二： new(使用构造器)

刨析：

方式一，是先看常量池中看有没有 数据空间，如果有就直接指向，没有的话在创建

方式二，是在堆中创建新的数据空间，然后看常量池中是否有这个数据，有的话就指向，没有的话就创建

String 的特性

String 类中的底层存储是一个 final char[] sds 该数组，被final修饰，是不可变的。

字符串是不可变的，一个字符串对象一旦被分配，其内容是不可变的

String在常量池中的对象，只会创建，或者存在，不会出现重写，覆盖的情况

面试问题

String常用方法

String 是保存字符串常量的，每次进行更新都需要重新开辟空间，效率很低

StringBuffer（多线程）

基本介绍

代表可变的字符序列，可以对字符串进行增删

StringBuffer是一个容器 ，存放的值是在堆中

构造器

//构造器的使用
        StringBuffer stringBuffer1 = new StringBuffer();
        //通过给一个String创建一个StringBuffer
        StringBuffer stringBuffer = new StringBuffer("sdadv");

        //通过构造器直接知道 数组的大小
        StringBuilder stringBuilder = new StringBuilder(15);

String —> StringBuffer

        //String >>>StringBuffer
        //方法一： 这种方式返回的才是StringBuffer,对String本身没影响
        String str = "sdad";
        StringBuffer stringBuffer2 = new StringBuffer(str);
        //方法二:使用append方法
        StringBuffer stringBuffer3 = new StringBuffer();
         stringBuffer3 = stringBuffer3.append(str);

StringBuffer >>>String

     //StringBuffer >>> String
        StringBuffer sbuff = new StringBuffer("你好");
        //方法一
        String s = sbuff.toString();
        //使用构造器
        String s1 = new String(sbuff);

StringBuffer方法

StringBuffer练习

StringBuilder（非线程安全）

特点：

单线程优先

可串行化（对象可以网络传输，可以保存到文件）

类不可以被继承

数据存放位置： 父类源码的 char[] value ，因此字符序列存放在堆中

一个可变的字符序列 ，此类提供一个与StringBuffer兼容的API，但不保证同步，该类被设计用作StringBuffer 的建议替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer 要快。

在StringBuilder上的主要操作时append和insert方法，可重载这些方法，

在接受任意类型的数据。

String StringBuffer StringBuilder比较

1. StringBuffer 和StringBuilder 很相似，都是可变的字符序列，而且方法也一样
2. String: 不可变的字符序列，效率低，但是复用率高
3. StringBuffer :增删效率高，线程安全
4. StringBuilder: 效率最高，线程不安全，可保存到文件，支持网络传输

String注意说明：如果我们对String做大量的修改，不要用String

效率：

StringBuilder>>>>StringBuffer>>>String

应用场景

使用原则：
如果字符串存在大量的修改，一般使用 StringBuffer / StringBuilder
如果字符串存在修改，并在单线程的情况下，使用StringBuilder 如果字符串存在大量修改，并在多线程的情况，使用 StringBuffer
如果我们字符串修改小，被多个对象使用，使用该String，比如配置信息

Math

Math类用于使用对数值的计算，且都是静态方法，可以直接使用

常用方法

Date,Calendar,LocalDate…

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

SimpleDateFormat ： 格式和解析日期类 它允许进行格式化和规范化

练习

Date date = new Date();

        System.out.println(date);
        //可以使用 SimpleDateformat格式化Date
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd  hh:mm:ss E");
        System.out.println(simpleDateFormat.format(date));
        //可以把一个格式化的String转化成Date类型
        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss E");
        String sdate = "2022年2月5日 0:12:00 星期二";
        Date format = null;
        try {
            format = simpleDateFormat1.parse(sdate);
        } catch (ParseException e) {
           // e.printStackTrace();
            System.out.println(e.getMessage());
        }
        System.out.println("format = "+format);

练习

  //Calendar学习
    public static void CalendarTest() {
//Calendar是一个抽象类，很多属性都是私有的，但可以使用getInstance方法调用
        Calendar instance = Calendar.getInstance();
        System.out.println(instance);
        //获取日历对象的某个日历字段
        System.out.println("年   :  " + instance.get(Calendar.YEAR));
        System.out.println("月   :  " + (instance.get(Calendar.MONTH) + 1));
        System.out.println("日   :  " + instance.get(Calendar.DAY_OF_MONTH));
        System.out.println("时   :  " + instance.get(Calendar.HOUR));
        //24小时制的
        System.out.println("24时   :  " + instance.get(Calendar.HOUR_OF_DAY));
        System.out.println("分   :  " + instance.get(Calendar.MINUTE));
        System.out.println("秒   :  " + instance.get(Calendar.SECOND));
        System.out.println("星期   :  " + instance.get(Calendar.DAY_OF_WEEK_IN_MONTH));

        //Calender没有专门的格式化方法，所以需要程序员自己组合显示


    }

出现多代日期类的原因

   //第三代日期类练习
    public static void LocalTimeTest() {

        //通过该.now（）返回LocalDateTime
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);
        System.out.println(now.getYear());
        System.out.println(now.getMonthValue());
        System.out.println(now.getDayOfMonth());
        System.out.println(now.getHour());
        System.out.println(now.getMinute());
        System.out.println(now.getSecond());
        //...如果只获取年月日
        LocalDate now1 = LocalDate.now();
        System.out.println(now.getYear());
        //只获取时分秒
        LocalTime now2 = LocalTime.now();
        System.out.println(now2.getHour());

        //DateTimeFormatter格式日期类，用于对其的格式化
        LocalDateTime now3 = LocalDateTime.now();
        //关于DateTimeFormatter的各个参数
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH小时mm分钟ss秒");
        String format = dtf.format(now3);
        System.out.println(format);


    }

      //Instant时间戳
        Instant now4 = Instant.now();
        Date from = Date.from(now4);

        /*
        * instant ---> Date
        * Date date = Date.from(instant);
        * date -->instant
        * Instant instant = date.toInstant();
        *
        *
        * MonthDay类：检查重复时间
        * 是否是润年
        * 增加日期的某个部分
        * 使用plus方法测试增加时间后是什么时间
        * 使用minus方法测试查看一年前和一年后的日期
        * */

System

Arrays

可直接使用

常用方法

定制排序： 接口编程 + 动态绑定 +匿名内部类的综合使用

自定义定制排序

//        bubble01(arr, new Comparator() {
//            @Override
//            public int compare(Object o1, Object o2) {
//                int n1 = (Integer) o1;
//                int n2 = (Integer) o2;
//                return n1 - n2;
//            }
//        });
    //结合冒泡 + 定制
    public static void bubble01(int[] arg, Comparator c) {
        for (int i = 0; i < arg.length - 1; i++) {
            for (int j = 0; j < arg.length - 1 - i; j++) {
                //从大到小
                if (c.compare(arg[j], arg[j + 1]) > 0) {
                    arg[j] = arg[j] + arg[j + 1];
                    arg[j + 1] = arg[j] - arg[j + 1];
                    arg[j] = arg[j] - arg[j + 1];
                }
            }

        }
    }

BigInteger（大数） BigDecimal(精度高的)

 //BigInteger练习
 /*   public  请添加图片描述teger.subtract(new BigInteger("546545646465464"));
        System.out.println(subtract);


    }*/
    //BigDecimal
    public static void BigIDecimalTest() {
        //使用同上
        BigDecimal bigDecimal = new BigDecimal("13213.89416519156156");

    }