Java基础_常用类_18

最新推荐文章于 2022-12-16 08:40:12 发布

予生

最新推荐文章于 2022-12-16 08:40:12 发布

阅读量188

点赞数 1

分类专栏： Java从小白开始学习文章标签： java 字符串 string

本文链接：https://blog.csdn.net/qq_44173324/article/details/112573833

版权

Java从小白开始学习专栏收录该内容

28 篇文章 2 订阅

订阅专栏

包装类

什么是包装类：
以前定义变量，经常使用基本数据类型，
对于基本数据类型来说，它就是一个数，加点属性，加点方法，加点构造器，
将基本数据类型对应进行了一个封装，产生了一个新的类，—》包装类。
int,byte…—>基本数据类型
包装类—>引用数据类型
对应关系：
基本数据类型·············对应的包装类 ················继承关系
byte·······························Byte········- ····· ····Number—>Object
short····························· Short····················Number—>Object
int································ Integer······· ·····—>Number—>Object
long······························ Long·················—>Number—>Object
float·································Float ············· —>Number—>Object
double··························Double ·················—>Number—>Object
char ·····························Character ················Object
boolean····························Boolean···················Object
已经有基本数据类型了，为什么要封装为包装类？
（1）java语言面向对象的语言，最擅长的操作各种各样的类。
（2）以前学习装数据的—》数组，int[] String[] double[] Student[]
以后学习的装数据的—》集合，有一个特点，只能装引用数据类型的数据
是不是有了包装类以后就不用基本数据类型了？
`
不是。

Interger

在这里插入图片描述

public class InnerMethod {
    public static void main(String[] args) {
        //CompareTo
        Integer i = new Integer(6);
        Integer i2 = new Integer(12);
        System.out.println(i.compareTo(i2));
        /*public static int compare(int x, int y) {
            return (x < y) ? -1 : ((x == y) ? 0 : 1);
        }*/

        //equals
        //equals:Integer对Object中的equals方法进行了重写，比较的是底层封装的那个value的值。
        //Integer对象是通过new关键字创建的对象：
        Integer i3 = new Integer(12);
        Integer i4 = new Integer(12);
        System.out.println(i3 == i4);
        boolean flag =i3.equals(i4);
        System.out.println(flag);

        //Integer对象通过自动装箱来完成：
        Integer i5 = 130;
        Integer i6 = 130;
        System.out.println(i5.equals(i6));
        System.out.println(i5==i6);
        /*
        如果自动装箱值在-128~127之间，那么比较的就是具体的数值
        否在，比较的就是对象的地址
         */

        //intValue
        Integer i7 = 130;
        int i8 = i7.intValue();
        System.out.println(i8);

        //parseInt:String-->int
        int i1 = Integer.parseInt("8");
        System.out.println(i1);

        //toString:Integer-->String
        Integer i9 = 130;
        System.out.println(i9.toString());

    }
}

日期相关类

java.util.Date

public class Test {
    public static void main(String[] args) {
        Date d = new Date();
        System.out.println(d);
        System.out.println(d.toString());
        System.out.println(d.toGMTString());
        System.out.println(d.toLocaleString());

        System.out.println(d.getYear()+1900);
        System.out.println(d.getMonth()+1);

        System.out.println(d.getTime());
        System.out.println(System.currentTimeMillis());
        /*
        疑问：以后获取时间差使用getTime还是currentTimeMillis呢？
        答案：currentTimeMillis()--》因为这个方法是静态的，可以类名.方法名直接调用
        （2）public static native long currentTimeMillis();这是个本地方法；
        没有方法体，因为这个方法的具体实现不是通过java写的。
        （3）这个方法的作用：
        一般会去衡量一些算法所用的时间
         */
        long startTime = System.currentTimeMillis();
        for (int i=0;i<100000;i++){
            System.out.println(i);
        }
        long endTime = System.currentTimeMillis();
        System.out.println(endTime-startTime);
    }
}

以后获取时间差使用getTime还是currentTimeMillis呢？
答案：currentTimeMillis()–》因为这个方法是静态的，可以类名.方法名直接调用
public static native long currentTimeMillis();这是个本地方法；
没有方法体，因为这个方法的具体实现不是通过java写的。
这个方法的作用：
一般会去衡量一些算法所用的时间

java.sql.Date

关注valueOf这个方法

public class Test {
    public static void main(String[] args) {
        Date d = new Date(1592055964263L);
        System.out.println(d);
       
        java.util.Date date = new Date(1592055964263L);
        //util-->sql
        //方式一：向下转型
        Date date1 = (Date) date;
        //方式二：利用构造器
        Date date2 = new Date(date.getTime());

        //sql-->util
        java.util.Date date3 = d;

        //[3]String--->sql.Date:
        Date date4 =  Date.valueOf("2019-3-8");
    }
}

java.util.Date和java.sql.Date的区别
java.util.Date：年月日时分秒
java.sql.Date：年月日
java.sql.Date和java.util.Date的联系：
java.sql.Date(子类) extends java.util.Date （父类）

SimpleDateFormat

 关注parse和Format两个方法即可

public class Test {
    public static void main(String[] args) {
        //日期转换
        //SimpleDateFormat(子类)  entends DateFormat(父类)；
        DateFormat df = new SimpleDateFormat("yyyy\\MM\\dd HH:mm:ss");
        //String-->Date;
        try {
            Date d = df.parse("2019\\4\\6 12:23:54");
            System.out.println(d);//Sat Apr 06 12:23:54 CST 2019
        } catch (ParseException e) {
            e.printStackTrace();
        }
        //Date-->String;
        String format= df.format(new Date());
        System.out.println(format);//2021\01\14 10:40:10
        //下面几个date-->String的效果并不好
        Date date = new Date();
        System.out.println(date.toString());//Thu Jan 14 10:40:10 CST 2021
        System.out.println(date.getTime());//1610592010799
        System.out.println(date.toLocaleString());//2021-1-14 10:40:10,-->格式不能变，中间必须是横杠-，而Format的格式可以随意的变，如|，/,-,等等
    }
}

Calendar

public class InnerMethod {
    public static void main(String[] args) {
        //Calendar是一个抽象类，不可以直接创建对象
        //GregorianCalendar()子类 extends Calendar（父类是一个抽象类）
        Calendar ca = new GregorianCalendar();
        //这个也行
        Calendar ca2 = Calendar.getInstance();
        System.out.println(ca);

        //常用的方法
        System.out.println(ca.get(Calendar.YEAR));
        System.out.println(ca.get(Calendar.MONTH)+1);//月
        System.out.println(ca.get(Calendar.DATE));//日
        System.out.println(ca.get(Calendar.DAY_OF_WEEK));//一个星期的第几天
        System.out.println(ca.getActualMaximum(Calendar.DATE));//获取当月日期的最大天数
        System.out.println(ca.getActualMinimum(Calendar.DATE));//获取当月日期的最小天数

        //set方法
        ca.set(Calendar.YEAR,1999);
        ca.set(Calendar.MONTH,04);
        ca.set(Calendar.DATE,16);
        System.out.println(ca);

        //String-->Calendar
        //分解
        //String-->Java.sql.Date
        java.sql.Date date = java.sql.Date.valueOf("1999-04-16");
        //java.sql.date-->Calendar
        ca.setTime(date);
        System.out.println(ca);
    }
}

打印出日历

public class Test {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        System.out.print("请输入你想要查看的日期：（提示：请按照例如2012-5-6的格式书写）");
        String str = sc.next();
        //String-->Calendar
        java.sql.Date date = java.sql.Date.valueOf(str);
        Calendar ca = Calendar.getInstance();
        ca.setTime(date);

        //后续操作
        //星期提示
        System.out.println("日\t一\t二\t三\t四\t五\t六");
        //获取本月的最大天数
        int maxDay = ca.getActualMaximum(Calendar.DATE);
        //获取本月的日期中的日
        int nowDay = ca.get(Calendar.DATE);

        //将日期调为本月的1号
        ca.set(Calendar.DATE,1);
        //获取这个一号是本周的第几天：
        int num = ca.get(Calendar.DAY_OF_WEEK);
        /*System.out.println(num);*/

        //前面空出来的天数为：
        int day = num - 1;
        //引入计数器
        int count = 0;
        //在日期前的空格打出来

        for (int i = 1;i<=day;i++){
            System.out.print("\t");

        }
        //空出来的日子也要放入计数器：
        count = count+day;
        //遍历：从一号开始到maxDay号进行遍历
        for (int i=1;i<=maxDay;i++){
            if (i==nowDay){//如果遍历的i和当前日子一样的话，后面多拼一个*
                System.out.print(i+"*\t");
            }else{
                System.out.print(i+"\t");
            }
            count++;
            if(count%7 ==0){//当计数器的个数是7的倍数的时候，就换行操作
                System.out.println();
            }
        }
    }
}

LocalDate/LocalTime/LocalDateTime

public class Test {
    public static void main(String[] args) {
        //1.完成实例化
        //方法1：now（）;获取当前的日期；时间，日期加时间
        LocalDate localDate = LocalDate.now();
        System.out.println(localDate);
        LocalTime localTime = LocalTime.now();
        System.out.println(localTime);
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println(localDateTime);

        //2.of（）;
        LocalDate of = LocalDate.of(2020, 1, 14);
        System.out.println(of);
        LocalTime of1 = LocalTime.of(12, 58, 35);
        System.out.println(of1);
        LocalDateTime of2 = LocalDateTime.of(2020, 1, 14, 5, 32);
        System.out.println(of2);

        //LocalDate,localTime用的不如LocaldateTime多
        //下面讲解用localDateTime
        //get**方法
        System.out.println(localDateTime.getYear());//2021
        System.out.println(localDateTime.getMonth());//January
        System.out.println(localDateTime.getMonthValue());//1
        System.out.println(localDateTime.getDayOfMonth());//14
        System.out.println(localDateTime.getHour());//13
        System.out.println(localDateTime.getMinute());//6
        System.out.println(localDateTime.getSecond());//30

        //不是set方法，而是with
        //体会不可变性
        LocalDateTime localDateTime1 = localDateTime.withMonth(2);
        System.out.println(localDateTime);
        System.out.println(localDateTime1);

        //提供了加减操作
        //加
        LocalDateTime localDateTime2 = localDateTime.plusMonths(4);
        System.out.println(localDateTime);//2021-01-14T13:13:30.960
        System.out.println(localDateTime2);//2021-05-14T13:13:30.960
        //减
        LocalDateTime localDateTime3 = localDateTime.minusMonths(5);
        System.out.println(localDateTime);//2021-01-14T13:14:49.065
        System.out.println(localDateTime3);//2020-08-14T13:14:49.065


    }
}

DateTimeFormatter

public class DateTimeFormatterMethod {
    public static void main(String[] args) {
        //格式化类：DateTimeFormatter
        //方式一:预定义的标准格式。如:
        // ISO_LOCAL_DATE_TIME;
        // ISO_LOCAL_DATE;
        // IS0_LOCAL_TIME
        DateTimeFormatter df1 = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        //df1就可以帮我们完成LocalDateTime和String之间的相互转换：
        //LocalDateTime-->String:
        LocalDateTime now = LocalDateTime.now();
        String str = df1.format(now);
        System.out.println(str);//2021-01-14T13:22:13.99
        //String-->LocalDatetime
        TemporalAccessor parse = df1.parse("2021-01-14T13:22:13.99");
        System.out.println(parse);//{},ISO resolved to 2021-01-14T13:22:13.990

        //方法2：本地化相关格式如：ofLocalizeDateTime（）;
        //参数：FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT
        //FormatStyle.LONG :2020年6月15日 下午03时17分13秒
        //FormatStyle.MEDIUM: 2020-6-15 15:17:42
        //FormatStyle.SHORT:20-6-15 下午3:18
        DateTimeFormatter df2 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
        //LocalDateTime-->String
        LocalDateTime now1 = LocalDateTime.now();
        String str2 = df2.format(now1);
        System.out.println(str2);
        //String-->LocaldateTime
        TemporalAccessor parse1 = df2.parse("20-6-15 下午3:18");
        System.out.println(parse1);

        //方法3：自定义格式
        DateTimeFormatter df3 = DateTimeFormatter.ofPattern("yyyy--MM--ss hh:mm:ss");
        LocalDateTime-->String
        LocalDateTime now2 = LocalDateTime.now();
        String format = df3.format(now2);
        System.out.println(format);//2021-01-26 01:36:26
        //String-->LocaldateTime
        TemporalAccessor parse2 = df3.parse("2021--01--26 01:36:26");
        System.out.println(parse2);//{SecondOfMinute=26, HourOfAmPm=1, MilliOfSecond=0, NanoOfSecond=0, MicroOfSecond=0, MinuteOfHour=36, Year=2021, MonthOfYear=1},ISO


    }
}

Math

Math常用方法

import static java.lang.Math.*;//静态导入

public class Method {
    public static void main(String[] args) {
        //常用属性
        System.out.println(Math.PI);
        //常用方法
        System.out.println(Math.random());//随机数
        System.out.println(Math.abs(-80));//取绝对值
        System.out.println(Math.ceil(9.1));//10//相上取值
        System.out.println(Math.floor(9.1));//9//向下取值
        System.out.println(Math.round(99.3));//四舍五入
        System.out.println(Math.max(12, 23));//取较大的值
        System.out.println(Math.min(12, 23));//取较小的值
        System.out.println(min(15, 23));//静态导入，import用static修饰

    }
    //如果跟Math中方法重复了，那么会优先走本类中的方法（就近原则）
    public static int random(){
        return 100;

    }
}

Random类

public class RandomMethod {
    public static void main(String[] args) {
        System.out.println("随机数："+Math.random());
        
        //学习Random类
        //利用带参构造器创建对象
        Random r = new Random(System.currentTimeMillis());
        int i = r.nextInt();
        System.out.println(i);

        //利用空参构造器创建对象
        Random r2 = new Random();
        System.out.println(r2.nextInt(10));在 0（包括）和指定值（不包括）之间均匀分布的 int 值。

        System.out.println( (r2.nextDouble()));在 0.0 和 1.0 之间均匀分布的 double 值。


    }
}

String

public class Method {
    public static void main(String[] args) {
        String str = "abd";
        String str2 = "";
        System.out.println(str);
        String s = new String();
        String s1 = new String("abc");
        String s2 = new String(new char[]{'a','1','c'});
        String s4 = "abc";
        System.out.println("字符串的长度"+s4.length());
        String s5 = new String();
        System.out.println("字符串是否为空："+s5.isEmpty());
        System.out.println("获取字符串下标对应的字符："+s4.charAt(1));

        //equals
        String s6 = "abc";
        String s7 = "abc";
        System.out.println(s6.equals(s7));//true

        //compareTo
        String s8 = new String("abc");
        String s9 = new String("abcd456");
        System.out.println(s8.compareTo(s9));//-1

        //substring:字符串截取
        String s10 = new String("abcd456");
        s10.substring(1);
        System.out.println(s10.substring(3, 5));//不包括索引为5的这个字符
        
        //字符串拼接
        System.out.println(s10.concat("890"));

        //字符串中的字符的替换：
        String s11 = "abcd";
        System.out.println(s11.replace('a', 'u'));

        //spilt:按照指定的字符串进行分裂为数组的形式
        String s12 = "a-b-c-d-e-f";
        String[] split = s12.split("-");
        System.out.println(Arrays.toString(split));//[a, b, c, d, e, f]

        //转换大小写
        String s13 = "abc";
        System.out.println(s13.toUpperCase());//ABC
        System.out.println(s13.toUpperCase().toLowerCase());//abc

        //去除首尾空格
        String s14 = "     a   b    c    ";
        System.out.println(s14.trim());//a   b    c

        //toString
        String s15 = "abx";
        System.out.println(s15.toString());

        //valueOf：转换为String类型
        String valueOf = String.valueOf(true);
        System.out.println(valueOf);
    }

}

StringBuilder和StringBuffer

与String不同，这两个属于可变字符串

StringBuilder

public class Builder {
    public static void main(String[] args) {
        //创建StringBuilder的对象
        StringBuilder builder = new StringBuilder();//表面上调用StringBuilder的空构造器，实际底层是对value数组进行初始化，长度为16
        StringBuilder builder1 = new StringBuilder(3);//表面上调用StringBuilder的有参构造器，传入一个int类型的数，实际底层就是对value数组进行初始化，长度为你传入的数字
        StringBuilder builder2 = new StringBuilder("abc");
        System.out.println(builder2.append("defghi").append("jklmn").append("opqrst").append("uvwxyz").toString());
//abcdefghijklmnopqrstuvwxyz
    }
}

在这里插入图片描述

可变数组和不可变数组的区别

不可变：在地址不变的情况下，想把“abc”变成“abcdef”是不可能的

可变：在StringBuilder这个对象的地址不变的情况下，想把“abc”变成“abcdef”是可能的，直接追加即可

StringBuilder的常用方法

public class Builder {
    public static void main(String[] args) {
        //创建StringBuilder的对象
       

        //常用方法
        StringBuilder sb = new StringBuilder("abcdefghi");
        //增
        sb.append("这是字母表");
        System.out.println(sb);  //abcdefghi 这是字母表

        //删
        sb.delete(1, 2);//删除位置在[1,2)上的字符，不包括索引2
        System.out.println(sb);//acdefghi这是字母表

        sb.deleteCharAt(0);//删除索引为0位置上的字符
        System.out.println(sb);//cdefghi这是字母表

        //改-->插入
        sb.insert(3, "--");//在下标为3的位置上插入--
        System.out.println(sb);//cde--fghi这是字母表

        //改-->替换
        sb.replace(0, 1, "++");//在下标[0,1)位置上替换字符串
        System.out.println(sb);//++de--fghi这是字母表
        sb.setCharAt(1, '-');//在下标1位置上替换字符
        System.out.println(sb);//+-de--fghi这是字母表

        //查
        for (int i= 0;i<sb.length();i++){
            System.out.print(sb.charAt(i)+"\t");//+	-	d	e	-	-	f	g	h	i	这	是	字	母	表
        }
        System.out.println();

        //截取
        String substring = sb.substring(0, 2);//截取[0,2)返回的是一个新的String，对StringBuilder没有影响
        System.out.println(substring);//+-
    }
}

StringBuffer在常用方法上和StringBuilder没有区别

String，StringBuilder和StringBuffer的区别

String类是不可变类，即一旦一个String对象被创建后，包含在这个对象中的字符序列是不可改变的，直至这个对象销毁。
StringBuffer类则代表一个字符序列可变的字符串，可以通过append、insert、reverse、setChartAt、setLength等方法改变其内容。一旦生成了最终的字符串，调用toString方法将其转变为String
JDK1.5新增了一个StringBuilder类，与StringBuffer相似，构造方法和方法基本相同。不同是StringBuffer是线程安全的，而StringBuilder是线程不安全的，所以性能略高。通常情况下，创建一个内容可变的字符串，应该优先考虑使用StringBuilder
```
         StringBuilder:JDK1.5开始  效率高   线程不安全


         StringBuffer:JDK1.0开始   效率低    线程安全
```

有不懂的地方可以私信~

内容来源于马士兵教育赵珊珊老师的Java笔记。

予生

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
3
评论
Java基础_常用类_18

常用类包装类Interger日期相关类java.util.Datejava.sql.DateSimpleDateFormatCalendar打印出日历LocalDate/LocalTime/LocalDateTimeDateTimeFormatterMathMath常用方法Random类StringStringBuilder和StringBufferStringBuilder可变数组和不可变数组的区别StringBuilder的常用方法StringBuffer在常用方法上和StringBuilder没有区别
复制链接

扫一扫