【Java SE】8. Java常用类

最新推荐文章于 2023-02-21 15:06:47 发布
最新推荐文章于 2023-02-21 15:06:47 发布
阅读量155 收藏 1
点赞数
分类专栏： JavaSE 文章标签： java常用类
原文链接：https://blog.csdn.net/Qmilumilu/article/details/119518425
版权

8. Java常用类

8.1 字符串相关的类

  1. String的特性：

    1. Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现

    2. 是一个final类，代表不可变的字符序列，不可被继承

    3. String实现了java.io.Serializable接口，表示字符串可以序列化

    4. String实现了Comparable<String>接口，表示字符串可以比较大小

    5. String内部定义了final byte[] value;用与存储字符串数据

      public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence,
               Constable, ConstantDesc {
    @Stable
    private final byte[] value;
}

    6. String代表一个不可变的字符序列，简称：不可变性：只要需要修改，就一定会重新造

      1. 当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中（字符串常量池中是不会存储相同内容的字符串的）

        首先判断常量池里是否有"abc"或"hello"，如果没有创建一个常量；如果有直接指向

        在这里插入图片描述

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

        String s2 = "abc";

String s3 = s2 + "def";
System.out.println(s3);//abcdef
System.out.println(s2);//abc——s2不会改变

      3. 当调用String的replace( )方法修改字符串的指定字符时，也需要重新指定内存区域赋值

        String s5 = s2.replace('a','m');
System.out.println(s2);//abc——s2不会改变
System.out.println(s5);//mbc

  2. String的赋值方式：

    1. 字面量赋值：

      String str = "abc";

    2. String对象的创建：String的构造器

      String() 
//初始化一个新创建的 String 对象，使其表示一个空字符序列。
    
String(char[] value)
//分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
    
String(char[] value, int offset, int count) 
//分配一个新的 String，它包含取自字符数组参数一个子数组的字符。 
    
String(String original) 
//初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。 
String(StringBuffer buffer) 
//分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。

    3. 两种方式的区别：

      在这里插入图片描述

      //通过字面量定义的方式:
//此时s1和s2的数据abc声明在方法区中的字符串常量池中
String s1 = "abc";
String s2 = "abc";

//通过new构造器的方式:
//此时s3和s4保存的地址值，是数据在堆空间中开辟的空间地址
String s3 = new String("abc");
String s4 = new String("abc");

System.out.println(s1 == s2);
System.out.println(s3 == s4);

      在这里插入图片描述

    4. 面试题一：

      Perdon p1 = new Person("Tom",12);
Perdon p2 = new Person("Tom",12);

System.out.println(p1.name == p2.name);//true

p1.name = "Jack";
System.out.println(p2.name);//Tom

      在这里插入图片描述

    5. 面试题二：

      String s = new String("abc");//在内存中创建了几个数组？
//两个，一个是对空间中new的结构，另一个是char[]对应的常量池中的数据"abc"

  3. String的拼接操作：

    1. 在这里插入图片描述

    2. 结论：

      1. 常量与常量（字面量赋值或final修饰）的拼接结果在常量池。 且常量池中不会存在相同内容的常量
      2. 只要其中有一个是变量， 结果就在堆中
      3. 如果拼接的结果调用intern()方法， 返回值就在常量池中

  4. String的常用方法：

    1. int length()返回字符串的长度

      String s1 = "helloworld";
System.out.println(s1.length());//10

    2. char charAt(int index)返回某索引处的字符

      System.out.println(s1.charAt(2));//l

    3. boolean isEmpty()判断是否是空字符串

      System.out.println(s1.isEmpty());//false

    4. String toLowerCase() String toUpperCase()将 String 中的所有字符转换为大、小写

      String s2 = s1.toLowerCase();
String s5 = s1.toUpperCase(Locale.ROOT);
System.out.println(s2);//helloworld
System.out.println(s1);//helloworld

    5. String trim()返回字符串的副本， 忽略前导空白和尾部空白

      String s3 = "  hello world  ";
String s4 = s3.trim();
System.out.println(s4);//hello world

    6. boolean equals(Object obj)比较字符串的内容是否相同

      System.out.println(s1.equals(s4));//false

    7. boolean equalsIgnoreCase(String anotherString)与equals方法类似， 忽略大小写

      System.out.println(s1.equalsIgnoreCase(s5));//t

    8. String concat(String str)将指定字符串连接到此字符串的结尾。 等价于用“+”

      String s6 = s3.concat("def");
System.out.println(s6);//  hello world  def

    9. int compareTo(String anotherString)比较两个字符串的大小

      String s7 = "abc";
String s8 = "abd";
System.out.println(s7.compareTo(s8));//-1

    10. String substring(int beginIndex)返回一个新的字符串， 它是此字符串的从beginIndex开始截取到最后的一个子字符串

      String s9 = s2.substring(2);
System.out.println(s9);//lloworld

    11. String substring(int beginIndex, int endIndex)返回一个新字符串， 它是此字符串从beginIndex开始截取到endIndex（不包含)的一个子字符串）

      String s10 = s2.substring(2,4);
System.out.println(s10);//ll

    12. boolean endsWith(String suffix测试此字符串是否以指定的后缀结束

      System.out.println(s1.endsWith("ld"));//true

    13. boolean startsWith(String prefix)测试此字符串是否以指定的前缀开始

      System.out.println(s1.startsWith("he"));//true
System.out.println(s1.startsWith("HE"));//false

    14. boolean startsWith(String prefix, int toffset)测试此字符串从指定索引开始的子字符串是否以指定前缀开始

      System.out.println(s1.startsWith("he",0));//true

    15. boolean contains(CharSequence s)当且仅当此字符串包含指定的 char 值序列时，返回 true

    16. int indexOf(String str)返回指定子字符串在此字符串中第一次出现处的索引

    17. int indexOf(String str, int fromIndex)返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始

    18. int lastIndexOf(String str)返回指定子字符串在此字符串中最后一次出现处的索引

    19. int lastIndexOf(String str, int fromIndex) 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
      注： indexOf和lastIndexOf方法如果未找到都是返回-1

    20. String replace(char oldChar, char newChar)返回一个新的字符串， 它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的

    21. String replace(CharSequence target, CharSequence replacement)测使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串

    22. String replaceAll(String regex, String replacement)使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串

      String str = "12hello34world5java7891mysql456";
//把字符串中的数字（d）替换成",""，如果结果中开头和结尾有","的话去掉
String string = str.replaceAll("\\d+", ",").replaceAll("^,|,$", "");
System.out.println(string);

    23. String replaceFirst(String regex, String replacement)使用给定的replacement替换此字符串匹配给定的正则表达式的第一个子字符串

    24. boolean matches(String regex)告知此字符串是否匹配给定的正则表达式

      String str = "12345";
//判断str字符串中是否全部有数字组成，即有1-n个数字组成
boolean matches = str.matches("\\d+");
System.out.println(matches);

String tel = "0571-4534289";
//判断这是否是一个杭州的固定电话
boolean result = tel.matches("0571-\\d{7,8}");
System.out.println(result);

    25. String[] split(String regex)根据给定正则表达式的匹配拆分此字符串

      String str = "hello|world|java";
String[] strs = str.split("\\|");   //以"|"切分
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
System.out.println();

    26. String[] split(String regex, int limit)根据匹配给定的正则表达式来拆分此字符串， 最多不超过limit个， 如果超过了， 剩下的全部都放到最后一个元素中

  5. String与其他结构之间的转换：

    1. 字符串 → \to →基本数据类型、包装类：调用包装类的静态方法：parseXxx( )
    2. 基本数据类型、包装类 → \to →字符串：调用String重载的valueOf( )
    3. 字符数组 → \to →字符串：调用String的构造器new String(arr)
    4. 字符串 → \to →字符数组：调用String的toCharArray( )
    5. **字节（二进制）数组 → \to →字符串：**调用String的构造器new String(bytes)
    6. 字符串 → \to →字节数组：调用String的getBytes( )

  6. 关于StringBuffer和StringBuilder的使用

    1. 三者区别：

      1. String：不可变的字符序列；底层使用char[ ]存储
      2. StringBuffer：可变字符序列；线程安全的，效率偏低；底层使用char[ ]存储
      3. StringBuilder：可变字符序列；jdk5.0新增，线程不安全的，效率高；底层使用char[ ]存储

    2. 源码分析：

      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[]
System.out.println(sb1.length());

sb1.append('a');//value[0] = 'a';
sb1.append('b');//value[1] = 'b';

StringBuffer sb2 = new StringBuffer("abc");
//char[] value = new char["abc".length() +16];

    3. 扩容问题：

      如果要添加的数据底层数组放不下了，那就需要扩容底层数组，默认情况下，扩容为原来的2倍+2，同时将原有数组中的元素复制到新的数组中

    4. 指导意义：

      开发中使用StringBuffer(int capacity)或StringBuilder(int capacity)

    5. 使用：（StringBuffer和StringBuilder基本相同）

      1. 构造器

        1. StringBuffer()：初始容量为16的字符串缓冲区

        2. StringBuffer(int size)：构造指定容量的字符串缓冲区

        3. StringBuffer(String str)：将内容初始化为指定字符串内容

          //不可变
String s = new String("我喜欢学习");
//可变
StringBuffer buffer = new StringBuffer("我喜欢学习");
buffer.append("数学");

      2. 常用方法

        1. append(xxx)：提供了很多的append()方法， 用于进行字符串拼接
        2. delete(int start,int end)：删除指定位置的内容
        3. replace(int start, int end, String str)：把[start,end)位置替换为str
        4. insert(int offset, xxx)：在指定位置插入xxx
        5. reverse() ：把当前字符序列逆转
        6. int indexOf(String str)：返回第一个出现的位置
        7. String substring(int start,int end)：返回指定范围的子串
        8. int length()：返回长度
        9. char charAt(int n )：返回指定字符的位置
        10. void setCharAt(int n ,char ch)：将指定位置的字符改为新的

    6. 效率对比：StringBuilder > StringBuffer > String

8.2 JDK 8之前的日期时间API

  1. java.lang.System类

    1. System类提供的public static long currentTimeMillis( )用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差

    2. long time = System.currentTimeMillis();
System.out.println(time);//1622513200505(时间戳)

  2. java.util.Date类

    1. 表示特定的瞬间，精确到毫秒

    2. 构造器：

      1. Date()： 使用无参构造器创建的对象可以获取本地当前时间

      2. Date(long date)

        Date date = new Date(1622513500124L);

    3. 常用方法：

      1. getTime():返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象
        表示的毫秒数

        Date date = new Date();
System.out.println(date.getTime());//1622513500124

      2. toString():把此 Date 对象转换为以下形式的 String： dow mon ddhh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue,Wed, Thu, Fri, Sat)， zzz是时间标准

        Date date = new Date();
System.out.println(date.toString());//Tue Jun 01 10:10:46 CST 2021

      3. 其它很多方法都过时了

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

      1. 如何实例化：

        java.sql.Date date = new java.sql.Date(1622513500124L);
System.out.println(date);//2021-06-01

      2. java.util.Date对象如何转化为java.sql.Date对象

        Date date1 = new Date();
java.sql.Date date2 = new java.sql.Date(date1.getTime());
System.out.println(date2);//2021-06-01

  3. java.text.SimpleDateFormat类

    1. 一个不与语言环境有关的方式来格式化和解析日期的具体类，允许进行

      1. 格式化：日期 → \to →指定字符串
      2. 解析：字符串 → \to →日期

    2. 格式化：sdf.format(date)

      //1.使用默认构造器SimpleDateFormat sdf = new SimpleDateFormat();Date date = new Date();System.out.println(date);//Tue Jun 01 10:49:27 CST 2021String format = sdf.format(date);System.out.println(format);//2021/6/1 上午11:13//2.使用带参数的构造器SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); //指定格式Date date1 = new Date();String format1 = sdf1.format(date1);System.out.println(format1);//2021-06-01 12:01:11

    3. 解析：sdf.parse( )

      //String str = "2019-08-09";
//识别不了会报异常:ParseException

String str = "2021/6/1 上午11:57";  //要符合格式
Date parse = sdf.parse(str);
System.out.println(parse);

  4. java.util.Calendar(日历)类

    1. 抽象基类，用于完成日期字段之间相互操作的功能

    2. 实例化：

      1. 方式一：创建其子类（GregorianCalendar）的对象

      2. 方式二：调用其静态方法：getInstance()

        Calendar calendar = Calendar.getInstance();

    3. 常用方法：

      1. get()

        Calendar calendar = Calendar.getInstance();
int i = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(i);//1
int i1 = calendar.get(Calendar.DAY_OF_YEAR);
System.out.println(i1);//152

      2. set()

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

      3. add()

        calendar.add(Calendar.DAY_OF_MONTH,3);
//calendar.add(Calendar.DAY_OF_MONTH,-3);
int i3 = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(i3);//25

      4. getTime()日历类 → \to →Date

        Date time = calendar.getTime();
System.out.println(time);//修改后的Fri Jun 25 12:17:19 CST 2021

      5. setTime()Date → \to →日历类

        Date date1 = new Date();
calendar.setTime(date1);
int i4 = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(i4);//1:重新设置回来了

8.3 JDK 8中新的日期时间API

JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用了。而Calendar并不比Date好多少。它们面临的问题是：

  1. 可变性：像日期和时间这样的类应该是不可变的
  2. 偏移性： Date中的年份是从1900开始的，而月份都从0开始
  3. 格式化：格式化只对Date有用， Calendar则不行
  4. 此外，它们也不是线程安全的；不能处理闰秒等

Java 8 吸收了 Joda-Time 的精华，以一个新的开始为 Java 创建优秀的 API

  1. java.time –包含值对象的基础包
  2. java.time.format – 格式化和解析时间和日期

  1. java.time中的类：

    1. LocalDate：代表IOS格式（yyyy-MM-dd）的日期,可以存储 生日、纪念日等日期
    2. LocalTime：表示一个时间，而不是日期
    3. LocalDateTime：用来表示日期和时间

  2. 方法：

    1. now()：静态方法， 根据当前时间创建对象/指定时区的对象

      LocalDate localDate = LocalDate.now();
LocalTime localTime = LocalTime.now();
LocalDateTime localDateTime = LocalDateTime.now();

System.out.println(localDate);//2021-06-01
System.out.println(localTime);//12:57:33.350232500
System.out.println(localDateTime);//2021-06-01T12:57:33.350232500

    2. of()：静态方法， 根据指定日期/时间创建对象（不用再考虑偏移量了）

      LocalDate localDate = LocalDate.of(2021,6,1);
System.out.println(localDate);//2021-06-01

    3. getDayOfMonth() / getDayOfYear() / getDayOfWeek()：当月、年、周的第几天

    4. getMonth()：获得月份, 返回一个 Month 枚举值

    5. getMonthValue() / getYear()：获得月份(1-12) 、获得年份

    6. getHour()/getMinute()/getSecond()：获得当前对象对应的小时、 分钟、 秒

    7. withDayOfMonth() / withDayOfYear() / withMonth()/withYear()：将月份天数、 年份天数、 月份、 年份修改为指定的值并返回新的对象（不需考虑偏移量）

      LocalDateTime localDateTime = LocalDateTime.now();
LocalDateTime localDateTime1 = localDateTime.withDayOfMonth(22);
LocalDateTime localDateTime2 = localDateTime1.withHour(4);

//又不可变性
System.out.println(localDateTime);//2021-06-01T16:04:28.832504400
System.out.println(localDateTime1);//2021-06-22T16:04:28.832504400
System.out.println(localDateTime2);//2021-06-22T04:04:28.832504400

    8. plusDays(), plusWeeks(), plusMonths(), plusYears(),plusHours()：向当前对象添加几天、 几周、 几个月、 几年、 几小时

    9. minusMonths() / minusWeeks()/ minusDays()/minusYears()/minusHours()：从当前对象减去几月、 几周、 几天、 几年、 几小时

  3. instant类

    1. 时间线上的一个瞬时点

    2. 方法：

      1. now()：静态方法， 返回默认UTC格林威治时区的Instant类的对象

      2. ofEpochMilli(long epochMilli)：静态方法 数之后的，Instant 返回在类的对象 1970-01-01 00:00:00基础上加上指定毫秒

      3. atOffset(ZoneOffset offset)：结合即时的偏移来创建一个 OffsetDateTime

      4. toEpochMilli()：返回1970-01-01 00:00:00到当前时间的毫秒数， 即为时间戳

        //实例化
Instant instant = Instant.now();
System.out.println(instant);//格林威治时间

//调整偏移量
OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
System.out.println(offsetDateTime);

//计算instant的时间戳
long l = instant.toEpochMilli();
System.out.println(l);

//用时间戳找instant实例
Instant instant1 = Instant.ofEpochMilli(1622535397734L);
System.out.println(instant1);

  4. java.time.format.DateTimeFormatter类

    1. 该类提供了三种格式化方法

      1. 预定义的标准格式

        DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;

//格式化：日期-->字符串
LocalDateTime localDateTime = LocalDateTime.now();
String format = formatter.format(localDateTime);
System.out.println(format);//2021-06-01T16:22:10.8436232

//解析：字符串-->日期
TemporalAccessor parse = formatter.parse("2021-06-01T16:22:10.8436232");
System.out.println(parse);//{},ISO resolved to 2021-06-01T16:22:10.843623200

      2. 本地化相关的格式

      3. ⭐自定义的格式

        //格式化：
DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
String format = timeFormatter.format(LocalDateTime.now());
System.out.println(format);//2021-06-01 05:14:54

//解析：
TemporalAccessor parse = timeFormatter.parse("2021-06-01 05:14:54");
System.out.println(parse);
//{NanoOfSecond=0, MicroOfSecond=0, SecondOfMinute=54, HourOfAmPm=5, MinuteOfHour=14, MilliOfSecond=0},ISO resolved to 2021-06-01

8.4 Java比较器

在Java中经常会涉及到对象数组的排序问题，那么就涉及到对象之间的比较问题

  1. Java实现对象排序的方式有两种：

    1. 自然排序：java.lang.Comparable，一旦指定一劳永逸
    2. 定制排序：java.util.Comparator，临时性的给定比较规则

  2. 自然排序：java.lang.Comparable

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

      String[] arr = new String[]{"AA","BB","EE","DD"};
Arrays.sort(arr);//从小到大排的
System.out.println(Arrays.toString(arr));//[AA, BB, DD, EE]

    2. 重写compareTo()方法的规则：

      1. 如果当前对象this大于形参对象obj， 则返回正整数
      2. 如果当前对象this小于形参对象obj， 则返回负整数
      3. 如果当前对象this等于形参对象obj， 则返回零

    3. 对于自定义类，如果需要排序，可以让自定义类实现Comparable接口，重写compareTo()方法

      public class Goods implements Comparable{//⭐实现接口
    private String name;
    private int price;

   	/*get、set、构造器、toString*/

    //⭐指明排序方式
    @Override
    public int compareTo(Object o) {
    if(o instanceof Goods){
        Goods goods = (Goods) o;
        if(this.price > goods.price){
            return 1;
        }else if(this.price < goods.price){
            return -1;
        }else {
            //若价格相同，则比名字，再嵌套一个compareTo()
            //name是String类型的，已经有重写好的了
            //返回-负的实现从高到低
            return -this.name.compareTo(goods.name);
        }
    }
    throw new RuntimeException("传入的数据类型不一致");
}

      public class Test {
    public static void main(String[] args) throws ParseException {
        Goods[] goods = new Goods[4];
        goods[0]=new Goods("lenovo",34);
        goods[1]=new Goods("huawei",22);
        goods[2]=new Goods("xiaomi",3);
        goods[3]=new Goods("dell",56);

        Arrays.sort(goods);
        System.out.println(Arrays.toString(goods));
        //[Goods{name='xiaomi', price=3}, Goods{name='huawei', price=22}, Goods{name='lenovo', price=34}, Goods{name='dell', price=56}]
    }
}

  3. 定制排序：java.util.Comparator

    1. 当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用 Comparator 的对象来排序

    2. 重写compare(Object o1,Object o2)方法的规则：

      1. 如果方法返回正整数，则表示o1大于o2
      2. 如果返回0，表示相等
      3. 返回负整数，表示o1小于o2
    3. public class StringTest {
    public static void main(String[] args) throws ParseException {
        Goods[] goods = new Goods[4];
        goods[0]=new Goods("lenovo",34);
        goods[1]=new Goods("huawei",22);
        goods[2]=new Goods("xiaomi",3);
        goods[3]=new Goods("dell",56);
				
        //⭐要排序时，临时给一个排序方法
        //匿名类实现接口Comparator，重写compare()
        Arrays.sort(goods, new Comparator<Goods>() {
            @Override
            public int compare(Goods o1, Goods o2) {
                if(o1.getPrice() > o2.getPrice()){
                    return 1;
                }if(o1.getPrice() < o2.getPrice()){
                    return -1;
                }else{
                    return o1.getName().compareTo(o2.getName());
                }
            }
        });
        System.out.println(Arrays.toString(goods));
    }
}

8.5 System类

  1. 代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包

  2. 由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的， 所以也可以很方便的进行调用

  3. 成员变量：System类内部包含in、 out和err三个成员变量，分别代表标准输入流(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)

  4. 成员方法：

    1. native long currentTimeMillis()：该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。

    2. void exit(int status)：该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表
      异常退出。 使用该方法可以在图形界面编程中实现程序的退出功能等。

    3. void gc()：该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况

    4. String getProperty(String key)：该方法的作用是获得系统中属性名为key的属性对应的值。系统中常见的属性名以及属性的作用如下表所示：

      String javaVersion = System.getProperty("java.version");
System.out.println("java的version:" + javaVersion);
String javaHome = System.getProperty("java.home");
System.out.println("java的home:" + javaHome);
String osName = System.getProperty("os.name");
System.out.println("os的name:" + osName);
String osVersion = System.getProperty("os.version");
System.out.println("os的version:" + osVersion);
String userName = System.getProperty("user.name");
System.out.println("user的name:" + userName);
String userHome = System.getProperty("user.home");
System.out.println("user的home:" + userHome);
String userDir = System.getProperty("user.dir");
System.out.println("user的dir:" + userDir);

8.6 Math类

  1. java.lang.Math提供了一系列静态方法用于科学计算。其方法的参数和返回值类型一般为double型

  2. abs 绝对值
acos,asin,atan,cos,sin,tan 三角函数
sqrt 平方根
pow(double a,doble b) a的b次幂
log 自然对数
exp e为底指数
max(double a,double b)
min(double a,double b)
random() 返回0.0到1.0的随机数
long round(double a) double型数据a转换为long型（四舍五入）
toDegrees(double angrad) 弧度—>角度
toRadians(double angdeg) 角度—>弧度

8.2 BigInteger和BigDecimal

  1. BigInteger

    1. Integer类作为int的包装类，能存储的最大整型值为 2 31 − 1 2^{31}-1 231−1， Long类也是有限的，最大为 2 63 − 1 2^{63}-1 263−1
    2. BigInteger可以表示不可变的任意精度的整数
    3. 构造器：BigInteger(String val)： 根据字符串构建BigInteger对象

  2. BigDecimal

    1. 商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类
    2. 构造器
      1. public BigDecimal(double val)
      2. public BigDecimal(String val)
    3. 常用方法
      1. public BigDecimal add(BigDecimal augend)
      2. public BigDecimal subtract(BigDecimal subtrahend)
      3. public BigDecimal multiply(BigDecimal multiplicand)
      4. public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)

  3. 示例：

    BigInteger bi = new BigInteger("12433241123");
BigDecimal bd = new BigDecimal("12435.351");
BigDecimal bd2 = new BigDecimal("11");
//很大的一个数
System.out.println(bi);
//bd除以bd2，默认
System.out.println(bd.divide(bd2, BigDecimal.ROUND_HALF_UP));
//bd除以bd2，保留15位小数
System.out.println(bd.divide(bd2, 15, BigDecimal.ROUND_HALF_UP))
coolcoo1cool
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java的logger_java.util.logging.Logger 使用详解
weixin_42131439的博客
02-15 2111
概述：第1部分创建Logger对象要使用J2SE的日志功能，首先要取得java.util.logging.Logger实例，这可以通过Logger类的两个静态getLogger()方法来取得：staticLogger getLogger(String name)查找或创建一个logger。staticLogger getLogger(String name, String resourceBun...
Java 常用类Date
chen2745213271的博客
05-18 4430
这次介绍Java中常用类中的一种Date，一般常用的Date的包名为util即java.util.Date。还有一种Date类的包名为spl即java.spl.Date，这次不做介绍。 包名为spl的Date类作用于和spl数据库打交道，其内容只包括日期，没有时间，包名为util的Date类作用于平常日期使用其内容包括日期和时间，且大部分的构造器和方法已经过时了，下面介绍的是平时还可以使用的方法和构造器。 1、Date()构造器 定位到现在的时间 ...
Java（八）：Java常用类
weixin_44825185的博客
07-06 104
系列 Java（一）：Java（初级）初识 Java（二）：Java（初级）基础语法 Java（三）：Java（初级）流程控制 Java（四）：Java（初级）方法 Java（五）：Java（初级）数组 Java（六）：Java（初级）面向对象 Java（七）：Java（中级）异常 Java关键字 ...
Java8 LocalDate、LocalTime、LocalDateTime详细使用场景+案例+常用工具类
健身变秃，coding变强
09-09 1443
代码： package com.saint.base.localdate; import java.time.*; import java.time.format.DateTimeFormatter; import java.time.temporal.ChronoUnit; import java.util.Date; /** * @author Saint */ public class CurrentDate { public static void main(String[] arg
Java程序员常用网站（推荐）
FBB360JAVA的博客
02-21 8万+
Java程序员常用网站，下载的软件、IDEA插件推荐
【Java SE 常用类】目录
长生的梦呓
01-05 814
文章目录前言大纲1.java.lang包 前言 这篇文章中会把我写过的常用类链接放在里面。想到更新后我会来更新的 大纲 1.java.lang包 【Java 常用类】（0）java.lang.Object的常用方法 【Java 常用类】（1）java.lang.Number的常用方法（抽象类） 【Java 常用类】（2）java.lang.Byte、Short、Integer、Long 、Fl...
java中(String)类常用方法
buhuisuanfa的博客
07-30 3823
若参数字符串按照该字符串的顺序写下去（如：从"我"开始），返回的是具体的少（多）几个字符。若没有按该字符串的顺序写，则返回的是随机数（大于参数字符串为正数，小于为负数）
深入了解java.util.Date类：历史、功能和使用注意事项
博客
05-06 1445
Java中的类是处理日期和时间的重要类之一。它广泛应用于各种Java应用程序中，包括日期计算、时间戳记录、日历事件等。本文将深入探讨类的历史、功能和使用注意事项，帮助读者更好地理解和使用这个类。
Java 的下载安装教程
热门推荐
暗诺星刻的博客
12-21 24万+
Java 17 的下载安装教程 说明： 本文介绍的是 Windows 下安装 Java 的方法。对于 Linux 下 Java 的安装，可见笔者的另一篇博客： 在 Linux 操作系统中安装 Java：https://blog.csdn.net/wangpaiblog/article/details/120093325 笔者的安装环境： JDK 17 Windows 10 教育版 安装 Java 就是安装 JDK。Java 有三大分支，这里选择的是 Java SE。关于
【Java 常用类】java.util.regex包（1）Pattern、Matcher的常用方法
长生的梦呓
01-24 2197
文章目录前言大纲二、使用1.字段（Pattern类）2.构造器（Pattern类和Matcher类）3.常用方法（Pattern类）3.1 创建正则编译到模式中3.2 创建正则编译到模式中并给定标志3.3 模式的字符串形式3.4 字符串匹配3.5 创建匹配器4.常用方法（Matcher类）4.1 字符串匹配4.2 获取字符串中存在的匹配 前言 我上一篇写了正则表达式的总结，这一篇讲一下Java中...
java运行常用类rt.jar下载
04-10
Java运行时环境（JRE）的核心库之一是`rt.jar`，它包含了Java平台标准版（Java SE）的大部分核心类。这个`rt.jar`文件是Java程序运行的基础，因为它包含了Java开发工具集（JDK）中的核心API，如`java.lang`、`java....
linux-java8.zip
07-30
在IT行业中，Linux操作系统与Java 8的结合是开发者常用的技术栈，特别是在服务器端应用程序的开发和部署上。"linux-java8.zip"这个文件很可能包含了在Linux环境下运行Java 8所需的所有组件，包括JDK（Java ...
Java se 面试题.docx
06-15
单例设计模式是 Java 中最常用的设计模式之一。它的主要思想是：某个类在整个系统中只能有一个实例对象可被获取和使用。 单例设计模式的要点包括： * 某个类只能有一个实例。 * 构造器私有化。 * 它必须自行创建这...
Java SE Development Kit 8u144 Documentation
10-12
2. **Java API文档**：这是Java开发中最常用的部分，它详细列出了Java标准库中的所有类和接口，包括它们的方法、属性、构造函数及其使用说明。例如，`java.util`包中的集合框架、`java.io`包的输入输出操作、`java...
营销策划 -2024非遗大展预热引流策划方案.pptx
最新发布
07-13
营销策划 -2024非遗大展预热引流策划方案.pptx
培训课件 -LEC风险评价法.pptx
07-13
培训课件 -LEC风险评价法.pptx
1.1 计算机网络概述.pptx
07-13
1.1 计算机网络概述.pptx 1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1.1 计算机网络概述.pptx1
项目（使用单位）电源盘柜租用收费明细表.docx
07-13
项目（使用单位）电源盘柜租用收费明细表.docx

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值