Java基础复习-常用类

Java基础复习-常用类

本文仅对学习过程中所缺java知识点的查缺补漏复习

String

代表字符串。Java程序中的所有字符串字面值（如"abc"）都作为此类的实例实现。

• String是一个final类，代表不可变的字符序列；
• 字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改；
• String对象的字符内容是存储在一个字符数组value[]中的。
• 字符串常量存储在字符串常量池，目的是共享；
• 字符串非常量对象存储在堆中；

例子1

/**
 * @Author: fxx
 * @Date: 2020/12/22 21:18
 */
public class StringTest {

    /**
     * String字符串，使用一对""引起来表示
     * 1.String声明为final，不可被继承
     * 2.String实现了Serializable接口：表示字符串是支持序列化的
     *          实现了Comparable接口：表示String可以比较大小
     * 3.String内部定义了final char[] value用于存储字符串数据
     * 4.String：代表不可变的字符序列
     *      体现：1.当对字符串重复赋值时，需要重新指定内存区域赋值，不能修改原来的地址处的值。
     *            2.当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能修改原来地址处的值。
     *            3.当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能修改原来地址处的值。
     *
     * 5.通过字面量方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中.
     * 6.字符串常量池中是不会存储相同内容的字符串的。
     */
    @Test
    public void test01(){
        //通过字面量定义方式：此时s1和s2的数据abc声明在方法区中的字符串常量池中
        String s1 = "abc";  //字面量的定义方式
        String s2 = "abc";
        s2 = "hello";
        System.out.println(s1 == s2);
        System.out.println(s1);
        System.out.println(s2);
        System.out.println("------------------------");
        //通过new+构造器方式：此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。
        String s3 = new String("hello");
        String s4 = new String("hello");
        System.out.println(s3 == s4);
    }
}

例子2

String s1 = "hello";
String s2 = "world";
String s3 = "hello" + "world";
String s4 = s1 + "world";
String s5 = "hello" + s2;
String s6 = s1 + s2;
String s7 = (s1 + s2).intern();
final String s8 = "world";		//s8用final修饰，是个常量
String s9 = "hello" + s8;
System.out.println(s3 == s4);	//false
System.out.println(s3 == s5);	//false
System.out.println(s4 == s5);	//false
System.out.println(s3 == s6);	//false
System.out.println(s4 == s6);	//false
System.out.println(s3 == s7);	//true
System.out.println(s3 == s9);	//true

这是上面2个例子的演示图

结论

• 常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量；
• 只要其中一个是变量，结果就在堆中；
• 如果拼接的结果调用intern()方法，返回值就在常量池中。

常用方法

• int length()：返回字符串长度
• char charAt(int index)：返回索引处字符
• boolean isEmpty()：判断是否为空字符串，即str.length == 0`
• String toLowerCase()：全部字母转小写
• String toUpperCase()：全部字母转大写
• String trim()：返回字符串的副本，去掉最前和最后的空白
• boolean equals(Object obj)：比较字符串内容是否相同
• boolean equalsIgnoreCase(String anotherString)：同上（忽略大小写）
• String concat(String str)：连接字符串
• int compareTo(String anotherString)：比较两个字符串大小
• String substring(int beginIndex)：返回一个从beginIndex开始截取的字符串
• String substring(int beginIndex, int endIndex)：返回一个从beginIndex到endIndex的字符串（左闭右开）
• boolean endsWith(String suffix)：测试此字符串是否以指定的后缀字符串结束
• boolean startsWith(String prefix)：测试此字符串是否以指定的前缀字符串开始
• boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始
• boolean contains(CharSequence s)：当且仅当此字符串包含指定的char值序列时，返回true
• int indexOf(String str)：返回指定字符串在此字符串中第一次出现处的索引
• int indexOf(String str, int fromIndex)：返回指定字符串在此字符串中第一次出现处的索引，从指定索引开始
• int lastIndexOf(String str)：返回指定字符串在此字符串中最右边出现处的索引
• int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
  • 注意：indexOf和lastIndexOf方法如果未找到都是返回**-1**。
• String replace(char oldChar, char newChar)：返回一个新的字符串，是通过用newChar替换字符串中出现的所有oldChar得到的
• String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串中所有匹配字面值目标序列的子字符串
• String replaceAll(String regex, String replacement)：使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串
• String replaceFirst(String regex, String replacement)：使用给定的replacement替换此字符串匹配给定的正则表达式的第一个子字符串
• boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式
• String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串
• String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中

String与字节数组转换

• 字节数组----->字符串
  • String(byte[])：通过使用平台的默认字符集解码指定的byte数组，构造一个新String
  • String(byte[], int offset, int length)：用指定的字节数组的一部分，即从数组起始位置offset开始取length个字节构造一个字符串对象
• 字符串----->字节数组
  • public byte[] getBytes()：使用平台的默认字符集将此String编码为byte序列，并将结果存储到一个新的byte数组中
  • public byte[] getBytes(String charsetName)：使用指定的字符集将此String编码到byte序列，并将结果存储到新的byte数组

编码与解码

/**
 * 编码与解码
 * @Author: fxx
 * @Date: 2020/12/23 15:49
 */
public class BytesTest {

    @Test
    public void test01() throws UnsupportedEncodingException {
        String str1 = "abc123中国";
        byte[] bytes = str1.getBytes(); //使用默认字符集进行编码
        System.out.println(Arrays.toString(bytes));

        byte[] gbks = str1.getBytes("gbk"); //使用gbk字符集进行编码
        System.out.println(Arrays.toString(gbks));

        System.out.println("*********************");

        String str2 = new String(bytes);    //用默认字符集解默认字符集编码的字节数组
        System.out.println(str2);

        String str3 = new String(gbks);//用默认字符集解gbk字符集编码的字节数组
        System.out.println(str3);
    }
}

结果

StringBuffer和StringBuilder

StringBuffer常用方法

• StringBuffer append(xxx)：进行字符串拼接
• StringBuffer delete(int start, int end)：删除指定位置内容
• StringBuffer replace(int start, int end, String str)：把[start, end)位置替换为str
• StringBuffer insert(int offset, xxx)：在指定位置插入xxx
• StringBuffer reverse()：逆转当前字符序列
• public int indexOf(String str)
• public String substring(int start, int end)
• public int length()
• public char charAt(int n)
• public void setCharAt(int n, char ch)

StringBuffer底层原理

/**
 * @Author: fxx
 * @Date: 2020/12/23 16:38
 */
public class StringBTest {

    /**
     * String、StringBuffer、StringBuilder三者异同？
     * 源码分析：
     * 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数组
     * sb1.append('a');     //value[0] = 'a';
     * sb1.append('b');    //value[1] = 'b';
     *
     * StringBuffer sb2 = new StringBuffer("abc");  //char[] value = new char["abc".length() + 16 ];每次都会多出16个字符长度
     * System.out.println(sb2.length());    //3
     * 如果添加的字符串长度超过了16，那么就要扩容
     * 扩容问题：如果要添加的数据底层数组装不下了，那就需要扩容底层的数组。
     *              默认情况下，扩容为原来容量的2倍 + 2，同时将原有数组中的元素复制到新的数组中。
     *    指导意义：开发中建议大家使用：StringBuffer(int capacity) 或 StringBuilder(int capacity)，指定容量，避免进行扩容操作，影响效率
     */
    @Test
    public void test01(){

    }
}

时间日期API

Date

• System类提供了public static long currentTimeMillis()用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差，称为时间戳（此API适合计算时间差）

java.util.Date类
*      java.sql.Date类---上面Date类的子类
*
* 1.两个构造器的使用
*      (1) Date()：创建一个对应当前时间的Date对象
*      (2) Date(long time)：创建一个指定毫秒数的Data对象
* 2.两个方法的使用
*      (1) toString()：显示当前的年、月、日、时、分、秒
*      (2) getTime()：获取当前Date对象对应的毫秒数：时间戳
*
* 3.如何转换java.sql.Date和java.util.Date
*  (1) 面向对象方式：java.util.Date date = new java.sql.Date();   多态
*                      java.sql.Date date1 = (java.sql.Date)date;
*
*  (2) java.util.Date d = new java.util.Date();
*      java.sql.Date date = new java.sql.Date(d.getTime());    //用时间戳转换

例子

/**
 * 时间日期测试
 * @Author: fxx
 * @Date: 2020/12/23 17:11
 */
public class DateTimeTest {

    /**
     * java.util.Date类
     *      java.sql.Date类
     *
     * 1.两个构造器的使用
     *      (1).Date()：创建一个对应当前时间的Date对象
     *      (2)Date(long time)：创建一个指定毫秒数的Data对象
     * 2.两个方法的使用
     *      (1).toString()：显示当前的年、月、日、时、分、秒
     *      (2).getTime()：获取当前Date对象对应的毫秒数：时间戳
     *
     * 3.如何转换java.sql.Date和java.util.Date
     *  (1).面向对象方式：java.util.Date date = new java.sql.Date();   多态
     *                      java.sql.Date date1 = (java.sql.Date)date;
     *
     *  (2).java.util.Date d = new java.util.Date();
     *      java.sql.Date date = new java.sql.Date(d.getTime());    //用时间戳转换
     */

    @Test
    public void test2(){
        //构造器一：创建一个对应当前时间的Date对象
        Date date = new Date();
        //打印出当前时间
        System.out.println(date.toString());    //Wed Dec 23 17:19:37 CST 2020
        //返回时间戳
        System.out.println(date.getTime());     //1608715177471

        //构造器二：创建一个指定毫秒数的Data对象
        Date date1 = new Date(1608715177471L);
        System.out.println(date1);
    }

    @Test
    public void test1(){
        //时间戳
        long time = System.currentTimeMillis();
        System.out.println(time);
    }
}

SimpleDateFormat

• Date类的API不易于国际化，大部分被废弃了，java.text.SimpleDateFormat类是一个不与语言环境有关的方式来格式化和解析日期的具体类；
• 它允许进行格式化：日期—>文本、解析：文本—>日期
• 格式化：
  • SimpleDateFormat()：默认的模式和语言环境创建对象
  • public SimpleDateFormat(String pattern)：该构造方法可以用参数pattern指定的格式创建一个对象，该对象调用：
    • public String format(Date date)：方法格式化时间对象date
• 解析：
  • public Date parse(String source)：从给定字符串的开始解析文本，以生成一个日期

例子

@Test
public void test3() throws ParseException {
    //使用默认构造器：格式化出来的是默认的日期格式
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
    //格式化：日期---->字符串
    Date date = new Date();
    System.out.println(date);
    String format = simpleDateFormat.format(date);
    System.out.println(format);
    //解析：字符串--->日期
    String str = "20-12-23 下午8:32";
    Date parse = simpleDateFormat.parse(str);
    System.out.println(parse);
    //---------------------------下面是开发中常用方式-----------------------------
    //自定义日期格式
    SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
    String format1 = simpleDateFormat1.format(date);
    System.out.println(format1);
    //自定义的解析
    Date parse1 = simpleDateFormat1.parse(format1);
    System.out.println(parse1);
}

Calendar

java.util.Calendar（日历）类

• Calendar是一个抽象基类，主要用于完成日期字段之间相互操作的功能；
• 获取Calendar实例的方法
  • 使用Calendar.getInstance()方法
  • 调用它的子类GregorianCalendar的构造器
• 一个Calendar的实例是系统时间的抽象表示，通过get(int field)方法来取得想要的时间信息。比如YEAR、MONTH、DAY_OF_WEEK、HOUR_OF_DAY、MINUTE、SECOND
  • public void set(int field, int value)
  • public void add(int field, int amount)
  • public final Date getTime()
  • public final void setTime(Date date)
• 注意：
  • 获取月份时：一月是0，二月是1，以此类推，12月是11
  • 获取星期时：周日是1，周二是2，以此类推，周六是7

例子

  /**
  * Calendar日历类（抽象类）使用
  */
@Test
public void test4(){
/*
      1.实例化：
      方式一：Calendar.getInstance();
      方式二：创建其子类GregorianCalendar的对象
*/
    Calendar calendar = Calendar.getInstance();
    //        System.out.println(calendar);   //可以查看是哪个类创建了calendar
    //2.常用方法：

    //get：获得属性值
    int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);
    System.out.println(dayOfMonth); //当前是一个月的第几天
    System.out.println(calendar.get(Calendar.YEAR));    //现在年份

    //set：属性值，即修改当前calendar对象的属性值
    calendar.set(Calendar.YEAR, 3000);
    System.out.println(calendar.get(Calendar.YEAR));

    //add：属性值+多少或者-多少
    calendar.add(Calendar.YEAR, 3);
    System.out.println(calendar.get(Calendar.YEAR));
    calendar.add(Calendar.YEAR, -13);
    System.out.println(calendar.get(Calendar.YEAR));

    //getTime：日历类--->Date
    Date date = calendar.getTime();
    System.out.println(date);

    //setTime：Date--->日历类
    Date date1 = new Date();
    calendar.setTime(date1);
    System.out.println(calendar.get(Calendar.YEAR));
}

下面都是JDK1.8之后才有的（包括JDK1.8）

Time：推荐

LocalDateTime系列

LocalDate、LocalTime、LocalDateTime是不可变的对象，分别表示ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的的本地日期或时间，并不包含当前的时间信息，也不包含与时区相关的信息。

• LocalDate代表IOS格式（yyyy-MM-dd）的日期，可以存储生日、纪念日等日期
• LocalTime：表示一个时间，而不是日期
• LocalDateTime：用来表示日期和时间的，最常用的类之一
• IOS-8601日历系统是国际标准化组织制定的现代公民的日期和时间的表示法，也就是公历

例子

@Test
public void test(){
    //now：获取当前的日期和时间
    LocalDate localDate = LocalDate.now();
    LocalTime localTime = LocalTime.now();
    LocalDateTime localDateTime = LocalDateTime.now();
    System.out.println(localDate);  //2020-12-23
    System.out.println(localTime);  //22:04:46.586
    System.out.println(localDateTime);  //2020-12-23T22:04:46.586

    //of：设置指定的年月日时分秒，没有偏移量
    LocalDateTime localDateTime1 = LocalDateTime.of(2020, 12, 31, 23, 59, 59);
    System.out.println(localDateTime1);

    //getxxx：获得时间日期相关值
    System.out.println(localDateTime.getDayOfMonth());
    System.out.println(localDateTime.getDayOfWeek());
    System.out.println(localDateTime.getMonth());

    //withxxx()：设置属性---不会改变原对象值
    LocalDateTime localDateTime2 = localDateTime.withDayOfYear(22);
    System.out.println(localDateTime);
    System.out.println(localDateTime2);

    //plus：加
    LocalDateTime localDateTime3 = localDateTime.plusYears(3);
    System.out.println(localDateTime);
    System.out.println(localDateTime3);
}

Instant

/**
* Instant的使用
*/
@Test
public void test2(){
    //now()：获取本初子午线对应的标准时间
    Instant instant = Instant.now();
    System.out.println(instant);    //2020-12-23T15:09:53.228Z

    //添加时间偏移量：东八区，+8个小时
    OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
    System.out.println(offsetDateTime); //2020-12-23T23:09:53.228+08:00

    //获取自1970年1月1日0时0分0秒（UTC)开始的毫秒数
    long milli = instant.toEpochMilli();
    System.out.println(milli);  //1608736193228

    //通过给定的毫秒数，获取Instant实例
    Instant instant1 = Instant.ofEpochMilli(1608736193228L);
    System.out.println(instant1);
}

DateTimeFormatter

类似于SimpleDateFormat，都是用于时间日期格式化。

该类提供了三种格式化方式：

• 预定义的标准方式：ISO_LOCAL_DATE_TIME等
• 本地化相关的格式。如：ofLocalizedDateTime(FormatStyle.LONG)等
• 自定义的格式，如：ofPattern("yyyy-MM-dd hh:mm:ss E")

方法	描述
ofPattern(String pattern)	静态方法，返回一个指定字符串格式的DateTimeFormatter
format(TemporalAccessor t)	格式化一个日期、时间，返回字符串
parse(CharSequence text)	将指定格式的字符序列解析为一个日期、时间

例子

@Test
public void test3(){
    //方式一：预定义
    DateTimeFormatter isoLocalDateTime = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
    //格式化：日期--->字符串
    LocalDateTime localDateTime = LocalDateTime.now();
    String format = isoLocalDateTime.format(localDateTime);
    System.out.println(localDateTime);
    System.out.println(format);
    //解析：字符串--->日期
    TemporalAccessor parse = isoLocalDateTime.parse("2020-12-23T23:36:28.582");
    System.out.println(parse);

    //方式二：本地化相关格式：多种格式可选
    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
    //格式化
    String format1 = dateTimeFormatter.format(localDateTime);
    System.out.println(format1);

    //方式三：自定义格式
    DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
    String format2 = dateTimeFormatter1.format(localDateTime);
    System.out.println(format2);
    //解析
    TemporalAccessor parse1 = dateTimeFormatter1.parse(format2);
    System.out.println(parse1);

}

Java比较器

Comparable

实现Java对象的比较，可以实现Comparable接口，重写compareTo()方法，没有实现比较器的对象是无法比较和调用内置排序方法的

例子

/**
 * 说明：Java中的对象，正常情况下，只能进行比较：== 或 != 。不能使用 > 或 < 的
 *          但是开发过程中需要对多个对象进行排序，就需要比较对象的大小。就需要
 *          使用下面两个接口中的任意一个：Comparable（自然排序） 或 Comparator
 *      1.像String、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小方式
 *      2.像String、包装类重写compareTo()方法以后，进行了从小到大的排列
 *      3.重写compareTo(obj)的规则：
 *          如果当前对象this大于形参obj，那么返回正整数；
 *          如果当前对象this小于形参obj，那么返回负整数；
 *          如果当前对象this等于形参obj，那么返回0；
 *      4.对于自定义类，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo(obj)方法
 *          在compareTo(obj)方法中指明如何排序
 * @Author: fxx
 * @Date: 2020/12/23 23:54
 */
public class CompareTest {

    @Test
    public void test1(){
        Good[] goods = new Good[4];
        goods[0] = new Good("华为平板", 3000);
        goods[1] = new Good("小米平板", 2000);
        goods[2] = new Good("联想笔记本", 3500);
        goods[3] = new Good("戴尔笔记本", 1500);
        Arrays.sort(goods);
        System.out.println(Arrays.toString(goods));
    }
}

/**    
 * 商品类
 * @Author: fxx                                                                 
 * @Date: 2020/12/24 12:45                                                      
 */                                                                             
public class Good implements Comparable{                                        
    private String name;                                                        
    private double price;                                                       
                                                                                
    public String getName() {                                                   
        return name;                                                            
    }                                                                           
                                                                                
    public void setName(String name) {                                          
        this.name = name;                                                       
    }                                                                           
                                                                                
    public double getPrice() {                                                  
        return price;                                                           
    }                                                                           
                                                                                
    public void setPrice(double price) {                                        
        this.price = price;                                                     
    }                                                                           
                                                                                
    public Good(String name, double price) {                                    
        this.name = name;                                                       
        this.price = price;                                                     
    }                                                                           
                                                                                
    @Override                                                                   
    public String toString() {                                                  
        return "Good{" +                                                        
                "name='" + name + '\'' +                                        
                ", price=" + price +                                            
                '}';                                                            
    }                                                                           
                                                                                
    //按照什么规则进行排序，这里假设按照价格从低到高                                                   
    @Override                                                                   
    public int compareTo(Object o) {                                            
        if(o instanceof Good){                                                  
            Good good = (Good)o;                                                
            if(this.price > good.price)                                         
                return 1;                                                       
            else if (this.price < good.price)                                   
                return -1;                                                      
            return 0;                                                           
        }                                                                       
        throw new RuntimeException("比较的数据类型不一致");                               
    }                                                                           
}                                                                               
                                                                                

Comparator

在调用排序方法的时候临时创建出来用于比较的一个类

@Test
public void test2(){
    Good[] goods = new Good[5];
    goods[0] = new Good("huaweicomputer", 3000);
    goods[1] = new Good("lenovocomputer", 3500);
    goods[2] = new Good("micomputer", 2000);
    goods[3] = new Good("dellcomputer", 1500);
    goods[4] = new Good("nicomputer", 1500);
    Arrays.sort(goods, new Comparator() {
        //指明商品比较大小的方式：按照产品名称从低到高排序，再按照价格从高到低排序
        @Override
        public int compare(Object o1, Object o2) {
            if(o1 instanceof Good && o2 instanceof Good){
                Good good1 = (Good) o1;
                Good good2 = (Good) o2;
                if(good1.getName().equals(good2.getName())){
                    if(good1.getPrice() > good2.getPrice())
                        return 1;
                    else if(good1.getPrice() < good2.getPrice())
                        return -1;
                    return 0;
                }else{
                    return good1.getName().compareTo(good2.getName());
                }
            }
            throw new RuntimeException("比较的数据类型不一致");
        }
    });
    System.out.println(Arrays.toString(goods));
}

System类

• 该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。但其内部成员变量和方法都是static的；

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

• 成员方法：

  • native long currentTimeMillis()：返回当前计算机时间与格林威治时间1970年1月1日0时0分0秒所差的毫秒数；

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

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

  • String getProperty(String key)：该方法的作用是获得系统中属性名为key的属性对应的值。常见属性如下：

  • 属性名	属性说明
    java.version	java运行时环境版本
    java.home	java安装目录
    os.name	操作系统名称
    os.version	操作系统版本
    user.name	用户的账户名
    user.home	用户的主目录
    user.dir	用户当前的工作目录

例子

@Test
public void test(){
    System.out.println(System.getProperty("java.version"));
    System.out.println(System.getProperty("java.home"));
    System.out.println(System.getProperty("os.name"));
    System.out.println(System.getProperty("os.version"));
    System.out.println(System.getProperty("user.name"));
    System.out.println(System.getProperty("user.home"));
    System.out.println(System.getProperty("user.dir"));
}

Math类

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

• abs：绝对值
• acos、asin、atan、cos、sin、tan：三角函数
• sqrt：平方根
• pow(double a, double 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)：角度—>弧度

BigInteger和BigDecimal

BigInteger

• Integer类作为int的包装类，能存储的最大整型值为2^(31)-1，Long类也是有限的，最大为2^(63)-1。如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。
• java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger提供所有Java的基本整数操作符的对应物，并提供java.lang.Math的所有相关方法。另外，BigInteger还提供以下运算：模算术、GCD计算、质数测试、素数生成、位操作以及一些其他操作。
• 构造器：
  • BigInteger(String val): 根据字符串构建BigInteger对象

BigDecimal

• 一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，可以用到BigDecimal；
• BigDecimal类支持不可变的、任意精度的有符号十进制符号数

例子

@Test
public void test1(){
    BigInteger bigInteger = new BigInteger("1231131145487945544644654646587");
    BigDecimal bigDecimal = new BigDecimal("12435.351");
    BigDecimal bigDecimal1 = new BigDecimal("11");
    System.out.println(bigInteger);
    //divide是除运算，如果结果是除不尽的，需要指定小数点后留多少位，不然会报错
    System.out.println(bigDecimal.divide(bigDecimal1, BigDecimal.ROUND_HALF_UP));
    //小数点后保留25位
    System.out.println(bigDecimal.divide(bigDecimal1, 25, BigDecimal.ROUND_HALF_UP));
}

面试题

1

String的实例化方式：

1. 通过字面量定义的方式；
2. 通过new+构造器的方式。

2

String s = new String("abc");方式创建对象，在内存中创建了几个对象？

2个：一个是堆空间中new出来的结构，另一个是char[]对应的常量池中的数据：“abc”。

3

String、StringBuffer、StringBuilder三者的异同？

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

4

Comparable和Comparator的区别？

• Comparable是用于实现的接口，实现之后重写compareTo()方法后，可以实现对象的比较，一直可用；
• Comparator是在排序时临时new出来用的，以后要排序还是需要重新new出来，临时用；
• 但两者都能实现排序时属性比较功能。