Day15-常见API

于 2024-04-23 11:07:40 发布
阅读量541 收藏 23
点赞数 21
分类专栏： JavaSE 文章标签： 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52807258/article/details/138116910
版权

Day15 常见API

学习目标

  • 了解数学相关API
  • 了解日期时间API
  • 了解系统类API
  • 掌握数组工具类的使用

1. 包装类

Java提供了两个类型系统：基本类型与引用类型。使用基本类型可以提高代码的执行效率，然而由于基本数据类型不支持方法调用和访问属性，很多情况下我们需要将基本数据类型转换成为基本包装类型。

基本数据类型和其对应的应用数据类型关系如下：

基本类型对应的包装类（位于java.lang包中）
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharacter
booleanBoolean

1.1 装箱和拆箱

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：

  • 装箱：从基本类型转换为对应的包装类对象。

  • 拆箱：从包装类对象转换为对应的基本类型。

    int a = 10;

// 装箱:使用构造方法 或者 valueOf 方法将基本数据类型a包装成为包装类型
Integer i1 = new Integer(a);
Integer i2 = Integer.valueOf(a);

// 拆箱:将包装类型转换成为基本数据类型
int b = i1.intValue();

  • 自动装箱拆箱:由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：

    Integer i = 4; //自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5; //等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。

1.2 基本数据类型转换成为字符串

  1. 使用+将基本数据类型和字符串拼接，例如String x = 1 + "";得到的结果x就是个字符串。
  2. 调用包装类的toString方法，例如Integer a = 1; String b = a.toString();得到的结果是一个字符串。
  3. 调用String类的valueOf方法，例如String x = String.valueOf(1);得到的结果是一个字符串。

1.3 字符串转换成为基本数据类型

基本包装类型里基本上都有parseXXX方法，将字符串转换成为指定的基本数据类型。

byte a = Byte.parseByte("34");
short b = Short.parseShort("45");
int c = Integer.parseInt("123");
long d = Long.parseLong("456");
float e = Float.parseFloat("2.18");
double f = Double.parseDouble("3.14");
boolean g = Boolean.parseBoolean("true");

注意：如果传入的字符串不是一个合法的基本数据类型，会抛出NumberFormatException异常。

2 和数学相关的类

2.1 java.lang.Math

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

  • public static double abs(double a) ：返回 double 值的绝对值。
double d1 = Math.abs(-5); //d1的值为5
double d2 = Math.abs(5); //d2的值为5
  • public static double ceil(double a) ：返回大于等于参数的最小的整数。
double d1 = Math.ceil(3.3); //d1的值为 4.0
double d2 = Math.ceil(-3.3); //d2的值为 -3.0
double d3 = Math.ceil(5.1); //d3的值为 6.0
  • public static double floor(double a) ：返回小于等于参数最大的整数。
double d1 = Math.floor(3.3); //d1的值为3.0
double d2 = Math.floor(-3.3); //d2的值为-4.0
double d3 = Math.floor(5.1); //d3的值为 5.0
  • public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)
long d1 = Math.round(5.5); //d1的值为6.0
long d2 = Math.round(5.4); //d2的值为5.0
  • public static double pow(double a,double b)：返回a的b幂次方法
  • public static double sqrt(double a)：返回a的平方根
  • public static double random()：返回[0,1)的随机值
  • public static final double PI：返回圆周率
  • public static double max(double x, double y)：返回x,y中的最大值
  • public static double min(double x, double y)：返回x,y中的最小值
double result = Math.pow(2,31);
double sqrt = Math.sqrt(256);
double rand = Math.random();
double pi = Math.PI;

2.2 java.math包

（1）BigInteger

不可变的任意精度的整数。

  • BigInteger(String val)
  • BigInteger add(BigInteger val)
  • BigInteger subtract(BigInteger val)
  • BigInteger multiply(BigInteger val)
  • BigInteger divide(BigInteger val)
  • BigInteger remainder(BigInteger val)
  • …
	@Test
	public void test01(){
//		long bigNum = 123456789123456789123456789L;
		
		BigInteger b1 = new BigInteger("123456789123456789123456789");
		BigInteger b2 = new BigInteger("78923456789123456789123456789");
		
//		System.out.println("和：" + (b1+b2));//错误的，无法直接使用+进行求和
		
		System.out.println("和：" + b1.add(b2));
		System.out.println("减：" + b1.subtract(b2));
		System.out.println("乘：" + b1.multiply(b2));
		System.out.println("除：" + b2.divide(b1));
		System.out.println("余：" + b2.remainder(b1));
	}
（2）RoundingMode枚举类

CEILING ：向正无限大方向舍入的舍入模式。

DOWN ：向零方向舍入的舍入模式。

FLOOR：向负无限大方向舍入的舍入模式。

HALF_DOWN ：向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向下舍入。

HALF_EVEN：向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。

HALF_UP：向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向上舍入。

UNNECESSARY：用于断言请求的操作具有精确结果的舍入模式，因此不需要舍入。
UP：远离零方向舍入的舍入模式。

（3）BigDecimal

不可变的、任意精度的有符号十进制数。

  • BigDecimal(String val)
  • BigDecimal add(BigDecimal val)
  • BigDecimal subtract(BigDecimal val)
  • BigDecimal multiply(BigDecimal val)
  • BigDecimal divide(BigDecimal val)
  • BigDecimal divide(BigDecimal divisor, int roundingMode)
  • BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode)
  • BigDecimal remainder(BigDecimal val)
  • …
	@Test
	public void test02(){
		/*double big = 12.123456789123456789123456789;
		System.out.println("big = " + big);*/
		
		BigDecimal b1 = new BigDecimal("123.45678912345678912345678912345678");
		BigDecimal b2 = new BigDecimal("7.8923456789123456789123456789998898888");
		
//		System.out.println("和：" + (b1+b2));//错误的，无法直接使用+进行求和
		
		System.out.println("和：" + b1.add(b2));
		System.out.println("减：" + b1.subtract(b2));
		System.out.println("乘：" + b1.multiply(b2));
		System.out.println("除：" + b1.divide(b2,20,RoundingMode.UP));//divide(BigDecimal divisor, int scale, int roundingMode)
		System.out.println("除：" + b1.divide(b2,20,RoundingMode.DOWN));//divide(BigDecimal divisor, int scale, int roundingMode)
		System.out.println("余：" + b1.remainder(b2));
	}

2.3 java.util.Random

用于产生随机数

  • boolean nextBoolean():返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 boolean 值。

  • void nextBytes(byte[] bytes):生成随机字节并将其置于用户提供的 byte 数组中。

  • double nextDouble():返回下一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 double 值。

  • float nextFloat():返回下一个伪随机数，它是取自此随机数生成器序列的、在 0.0 和 1.0 之间均匀分布的 float 值。

  • double nextGaussian():返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（“正态”）分布的 double 值，其平均值是 0.0，标准差是 1.0。

  • int nextInt():返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。

  • int nextInt(int n):返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。

  • long nextLong():返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long 值。

	@Test
	public void test03(){
		Random r = new Random();
		System.out.println("随机整数：" + r.nextInt());
        System.out.println("[0,100)范围的随机整数：" + r.nextInt(100));
		System.out.println("随机小数：" + r.nextDouble());
		System.out.println("随机布尔值：" + r.nextBoolean());
	}

3 日期时间API

3.1 第一代日期时间

1、java.util.Date

new Date()：当前系统时间

long getTime()：返回该日期时间对象距离1970-1-1 0.0.0 0毫秒之间的毫秒值

new Date(long 毫秒)：把该毫秒值换算成日期时间对象

	@Test
	public void test5(){
		long time = Long.MAX_VALUE;
		Date d = new Date(time);
		System.out.println(d);
	}
	
	@Test
	public void test4(){
		long time = 1559807047979L;
		Date d = new Date(time);
		System.out.println(d);
	}
	@Test
	public void test3(){
		Date d = new Date();
		long time = d.getTime();
		System.out.println(time);//1559807047979
	}
	
	@Test
	public void test2(){
		long time = System.currentTimeMillis();
		System.out.println(time);//1559806982971
		//当前系统时间距离1970-1-1 0:0:0 0毫秒的时间差，毫秒为单位
	}
	
	@Test
	public void test1(){
		Date d = new Date();
		System.out.println(d);
	}
2、java.text.SimpleDateFormat

SimpleDateFormat用于日期时间的格式化。

  • public final String format(Date date)将一个 Date 格式化为日期/时间字符串。
  • public Date parse(String source)throws ParseException从给定字符串的开始解析文本，以生成一个日期。

1572599023197

	@Test
	public void test10() throws ParseException{
		String str = "2019年06月06日 16时03分14秒 545毫秒  星期四 +0800";
		SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 SSS毫秒  E Z");
		Date d = sf.parse(str);
		System.out.println(d);
	}
	
	@Test
	public void test9(){
		Date d = new Date();

		SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 SSS毫秒  E Z");
		//把Date日期转成字符串，按照指定的格式转
		String str = sf.format(d);
		System.out.println(str);
	}

3.2 第二代日期时间（JDK1.1）

1、java.util.TimeZone

通常，使用 getDefault 获取 TimeZone，getDefault 基于程序运行所在的时区创建 TimeZone。

也可以用 getTimeZone 及时区 ID 获取 TimeZone 。例如美国太平洋时区的时区 ID 是 “America/Los_Angeles”。

package com.atguigu.datetime.two;

import org.junit.Test;

import java.util.TimeZone;

public class TestTimeZone {
    @Test
    public void test1(){
        TimeZone t = TimeZone.getDefault();
        System.out.println(t);
    }

    @Test
    public void test2(){
        TimeZone t = TimeZone.getTimeZone("UTC");
        System.out.println(t);
    }

    @Test
    public void test3(){
        TimeZone t = TimeZone.getTimeZone("America/Los_Angeles");
        System.out.println(t);
    }

    @Test
    public void test4(){
        String[] all = TimeZone.getAvailableIDs();
        for (int i = 0; i < all.length; i++) {
            System.out.println(all[i]);
        }
    }
}

常见时区ID：

Asia/Shanghai
UTC
America/New_York
America/Los_Angeles
2、java.util.Locale

Locale 对象表示了特定的地理、政治和文化地区。需要 Locale 来执行其任务的操作称为语言环境敏感的 操作，它使用 Locale 为用户量身定制信息。

语言参数是一个有效的 ISO 语言代码。这些代码是由 ISO-639 定义的小写两字母代码。

国家/地区参数是一个有效的 ISO 国家/地区代码。这些代码是由 ISO-3166 定义的大写两字母代码。

Locale 类提供了一些方便的常量，可用这些常量为常用的语言环境创建 Locale 对象。

import org.junit.Test;

import java.util.Locale;

public class TestLocale {
    @Test
    public void test01(){
        Locale[] all = Locale.getAvailableLocales();
        for (int i = 0; i < all.length; i++) {
            System.out.println(all[i]);
        }
    }
    
    @Test
    public void test02(){
        Locale china = Locale.CHINA;
        System.out.println("china = " + china);
    }
}
3、java.util.Calendar

Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，格里高利历）的偏移量。与其他语言环境敏感类一样，Calendar 提供了一个类方法 getInstance，以获得此类型的一个通用的对象。

image-20220123184906903

修改和获取 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段对应的时间值。

void add(int field,int amount)
int get(int field)
void set(int field, int value)

示例代码：

package com.atguigu.datetime.two;

import org.junit.Test;

import java.util.Calendar;
import java.util.TimeZone;

public class TestCalendar {
    @Test
    public void test1(){
        Calendar c = Calendar.getInstance();
        System.out.println(c);

        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        int day = c.get(Calendar.DATE);
        int hour = c.get(Calendar.HOUR_OF_DAY);
        int minute = c.get(Calendar.MINUTE);
        int second = c.get(Calendar.SECOND);

        System.out.println(year + "-" + month + "-" + day + " " + hour + ":" + minute + ":" + second);
    }

    @Test
    public void test2(){
        TimeZone t = TimeZone.getTimeZone("America/Los_Angeles");
        
        Calendar c = Calendar.getInstance(t);
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        int day = c.get(Calendar.DATE);
        int hour = c.get(Calendar.HOUR_OF_DAY);
        int minute = c.get(Calendar.MINUTE);
        int second = c.get(Calendar.SECOND);

        System.out.println(year + "-" + month + "-" + day + " " + hour + ":" + minute + ":" + second);
    }
}

3.3 第三代日期时间（JDK1.8）

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

  • 可变性：象日期和时间这样的类对象应该是不可变的。Calendar类中可以使用三种方法更改日历字段：set()、add() 和 roll()。
  • 偏移性：Date中的年份是从1900开始的，而月份都是从0开始的。
  • 格式化：格式化只对Date有用，Calendar则不行。
  • 此外，它们也不是线程安全的，不能处理闰秒等。

可以说，对日期和时间的操作一直是Java程序员最痛苦的地方之一。第三次引入的API是成功的，并且java 8中引入的java.time API 已经纠正了过去的缺陷，将来很长一段时间内它都会为我们服务。

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

  • java.time – 包含值对象的基础包
  • java.time.chrono – 提供对不同的日历系统的访问。
  • java.time.format – 格式化和解析时间和日期
  • java.time.temporal – 包括底层框架和扩展特性
  • java.time.zone – 包含时区支持的类

Java 8 吸收了 Joda-Time 的精华，以一个新的开始为 Java 创建优秀的 API。新的 java.time 中包含了所有关于时钟（Clock），本地日期（LocalDate）、本地时间（LocalTime）、本地日期时间（LocalDateTime）、时区（ZonedDateTime）和持续时间（Duration）的类。

1、本地日期时间：LocalDate、LocalTime、LocalDateTime
序号方法描述
1now() / now(ZoneId zone)静态方法，根据当前时间创建对象/指定时区的对象
2of()静态方法，根据指定日期/时间创建对象
3getDayOfMonth()/getDayOfYear()获得月份天数(1-31) /获得年份天数(1-366)
4getDayOfWeek()获得星期几(返回一个 DayOfWeek 枚举值)
5getMonth()获得月份, 返回一个 Month 枚举值
6getMonthValue() / getYear()获得月份(1-12) /获得年份
7getHours()/getMinute()/getSecond()获得当前对象对应的小时、分钟、秒
8withDayOfMonth()/withDayOfYear()/withMonth()/withYear()将月份天数、年份天数、月份、年份修改为指定的值并返回新的对象
9with(TemporalAdjuster t)将当前日期时间设置为校对器指定的日期时间
10plusDays(), plusWeeks(), plusMonths(), plusYears(),plusHours()向当前对象添加几天、几周、几个月、几年、几小时
11minusMonths() / minusWeeks()/minusDays()/minusYears()/minusHours()从当前对象减去几月、几周、几天、几年、几小时
12plus(TemporalAmount t)/minus(TemporalAmount t)添加或减少一个 Duration 或 Period
13isBefore()/isAfter()比较两个 LocalDate
14isLeapYear()判断是否是闰年（在LocalDate类中声明）
15format(DateTimeFormatter t)格式化本地日期、时间，返回一个字符串
16parse(Charsequence text)将指定格式的字符串解析为日期、时间
import org.junit.Test;

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

public class TestLocalDateTime {
    @Test
    public void test7(){
        LocalDate now = LocalDate.now();
        LocalDate before = now.minusDays(100);
        System.out.println(before);//2019-02-26
    }

    @Test
    public void test06(){
        LocalDate lai = LocalDate.of(2019, 5, 13);
        LocalDate go = lai.plusDays(160);
        System.out.println(go);//2019-10-20
    }

    @Test
    public void test05(){
        LocalDate lai = LocalDate.of(2019, 5, 13);
        System.out.println(lai.getDayOfYear());
    }


    @Test
    public void test04(){
        LocalDate lai = LocalDate.of(2019, 5, 13);
        System.out.println(lai);
    }

    @Test
    public void test03(){
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);
    }

    @Test
    public void test02(){
        LocalTime now = LocalTime.now();
        System.out.println(now);
    }

    @Test
    public void test01(){
        LocalDate now = LocalDate.now();
        System.out.println(now);
    }
}
2、指定时区日期时间：ZondId和ZonedDateTime

常见时区ID：

Asia/Shanghai
UTC
America/New_York
America/Los_Angeles

可以通过ZondId获取所有可用的时区ID：

import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.Set;

public class TestZone {
    @Test
    public void test01() {
        //需要知道一些时区的id
        //Set<String>是一个集合，容器
        Set<String> availableZoneIds = ZoneId.getAvailableZoneIds();
        //快捷模板iter
        for (String availableZoneId : availableZoneIds) {
            System.out.println(availableZoneId);
        }
    }

    @Test
    public void test02(){
        ZonedDateTime t1 = ZonedDateTime.now();
        System.out.println(t1);

        ZonedDateTime t2 = ZonedDateTime.now(ZoneId.of("America/New_York"));
        System.out.println(t2);
    }
}
3、持续日期/时间：Period和Duration

Period:用于计算两个“日期”间隔

Duration:用于计算两个“时间”间隔

import org.junit.Test;

import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.Period;

public class TestPeriodDuration {
    @Test
    public void test01(){
        LocalDate t1 = LocalDate.now();
        LocalDate t2 = LocalDate.of(2018, 12, 31);
        Period between = Period.between(t1, t2);
        System.out.println(between);

        System.out.println("相差的年数："+between.getYears());
        System.out.println("相差的月数："+between.getMonths());
        System.out.println("相差的天数："+between.getDays());
        System.out.println("相差的总数："+between.toTotalMonths());
    }

    @Test
    public void test02(){
        LocalDateTime t1 = LocalDateTime.now();
        LocalDateTime t2 = LocalDateTime.of(2017, 8, 29, 0, 0, 0, 0);
        Duration between = Duration.between(t1, t2);
        System.out.println(between);

        System.out.println("相差的总天数："+between.toDays());
        System.out.println("相差的总小时数："+between.toHours());
        System.out.println("相差的总分钟数："+between.toMinutes());
        System.out.println("相差的总秒数："+between.getSeconds());
        System.out.println("相差的总毫秒数："+between.toMillis());
        System.out.println("相差的总纳秒数："+between.toNanos());
        System.out.println("不够一秒的纳秒数："+between.getNano());
    }
}
4、DateTimeFormatter：日期时间格式化

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

预定义的标准格式。如：ISO_DATE_TIME;ISO_DATE

本地化相关的格式。如：ofLocalizedDate(FormatStyle.MEDIUM)

自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)

import org.junit.Test;

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;

public class TestDatetimeFormatter {
    @Test
    public void test1(){
        LocalDateTime now = LocalDateTime.now();
        DateTimeFormatter df = DateTimeFormatter.ISO_DATE_TIME;//2019-06-06T16:38:23.756
        String str = df.format(now);
        System.out.println(str);
    }
    
    @Test
    public void test2(){
        LocalDateTime now = LocalDateTime.now();
//		DateTimeFormatter df = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);//2019年6月6日 下午04时40分03秒
//        DateTimeFormatter df = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM);//2019-6-6 16:40:37
//        DateTimeFormatter df = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);//19-6-6 下午4:40
        DateTimeFormatter df = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL).withZone(ZoneId.systemDefault());
        String str = df.format(now);
        System.out.println(str);
    }
    


    @Test
    public void test3(){
        LocalDateTime now = LocalDateTime.now();
        DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH时mm分ss秒  SSS毫秒  E 是这一年的D天");
        String str = df.format(now);
        System.out.println(str);
    }
}

4 System类

系统类中很多好用的方法，其中几个如下：

  • static long currentTimeMillis() ：返回当前系统时间距离1970-1-1 0:0:0的毫秒值
  • static void exit(int status) ：退出当前系统
  • static void gc() ：运行垃圾回收器。
  • static String getProperty(String key)：获取某个系统属性，例如：java.version、user.language、user.country、file.encoding、user.name、os.version、os.name等等
import org.junit.Test;

public class TestSystem {
    @Test
    public void test01(){
        long time = System.currentTimeMillis();
        System.out.println("现在的系统时间距离1970年1月1日凌晨：" + time + "毫秒");

        System.exit(0);

        System.out.println("over");//不会执行
    }

    @Test
    public void test02(){
        System.out.println(System.getProperty("java.version"));
        System.out.println(System.getProperty("user.language"));
        System.out.println(System.getProperty("user.country"));
        System.out.println(System.getProperty("file.encoding"));
        System.out.println(System.getProperty("user.name"));
        System.out.println(System.getProperty("os.version"));
        System.out.println(System.getProperty("os.name"));
    }

    @Test
    public void test03() throws InterruptedException {
        for (int i=1; i <=10; i++){
            MyDemo my = new MyDemo(i);
            //每一次循环my就会指向新的对象，那么上次的对象就没有变量引用它了，就成垃圾对象
        }

        //为了看到垃圾回收器工作，我要加下面的代码，让main方法不那么快结束，因为main结束就会导致JVM退出，GC也会跟着结束。
        System.gc();//如果不调用这句代码，GC可能不工作，因为当前内存很充足，GC就觉得不着急回收垃圾对象。
        //调用这句代码，会让GC尽快来工作。
        Thread.sleep(5000);
    }
}

class MyDemo{
    private int value;

    public MyDemo(int value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyDemo{" + "value=" + value + '}';
    }

    //重写finalize方法，让大家看一下它的调用效果
    @Override
    protected void finalize() throws Throwable {
//        正常重写，这里是编写清理系统内存的代码
//        这里写输出语句是为了看到finalize()方法被调用的效果
        System.out.println(this+ "轻轻的走了，不带走一段代码....");
    }
}

5 Arrays数组工具类

java.util.Arrays数组工具类，提供了很多静态方法来对数组进行操作，而且如下每一个方法都有各种重载形式，以下只列出int[]和Object[]类型的，其他类型的数组依次类推：

  • 数组元素拼接
    • static String toString(int[] a) ：字符串表示形式由数组的元素列表组成，括在方括号（“[]”）中。相邻元素用字符 “, “（逗号加空格）分隔。形式为：[元素1，元素2，元素3。。。]
      static String toString(Object[] a) ：字符串表示形式由数组的元素列表组成，括在方括号（”[]”）中。相邻元素用字符 ", "（逗号加空格）分隔。元素将自动调用自己从Object继承的toString方法将对象转为字符串进行拼接，如果没有重写，则返回类型@hash值，如果重写则按重写返回的字符串进行拼接。
  • 数组排序
    • static void sort(int[] a) ：将a数组按照从小到大进行排序
    • static void sort(int[] a, int fromIndex, int toIndex) ：将a数组的[fromIndex, toIndex)部分按照升序排列
  • 数组元素的二分查找
    • static int binarySearch(int[] a, int key)
  • 数组的复制
    • static int[] copyOf(int[] original, int newLength) ：根据original原数组复制一个长度为newLength的新数组，并返回新数组
    • static T[] copyOf(T[] original,int newLength)：根据original原数组复制一个长度为newLength的新数组，并返回新数组
    • static int[] copyOfRange(int[] original, int from, int to) ：复制original原数组的[from,to)构成新数组，并返回新数组
    • static T[] copyOfRange(T[] original,int from,int to)：复制original原数组的[from,to)构成新数组，并返回新数组
  • 比较两个数组是否相等
    • static boolean equals(int[] a, int[] a2) ：比较两个数组的长度、元素是否完全相同
    • static boolean equals(Object[] a,Object[] a2)：比较两个数组的长度、元素是否完全相同
  • 填充数组
    • static void fill(int[] a, int val) ：用val值填充整个a数组
    • static void fill(Object[] a,Object val)：用val对象填充整个a数组
    • static void fill(int[] a, int fromIndex, int toIndex, int val)：将a数组[fromIndex,toIndex)部分填充为val值
    • static void fill(Object[] a, int fromIndex, int toIndex, Object val) ：将a数组[fromIndex,toIndex)部分填充为val对象
  • 排序和查找
    • static void sort(Object[] a) ：根据元素的自然顺序对指定对象数组按升序进行排序。
    • static void sort(T[] a, Comparator<? super T> c) ：根据指定比较器产生的顺序对指定对象数组进行排序。
    • static int binarySearch(Object[] a, Object key) ：要求数组有序，在数组中查找key是否存在，如果存在返回第一次找到的下标，不存在返回负数
import org.junit.Test;

import java.text.Collator;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Locale;

public class TestArrays {
    @Test
    public void test01() {
        int[] arr = {1, 2, 3, 4, 5};
        System.out.println(Arrays.toString(arr));

        Student[] students = new Student[3];
        students[0] = new Student("张三", 96);
        students[1] = new Student("李四", 85);
        students[2] = new Student("王五", 98);
        System.out.println(Arrays.toString(students));
    }

    @Test
    public void test02() {
        int[] arr = {3, 2, 5, 1, 6};
        System.out.println("排序前" + Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println("排序后" + Arrays.toString(arr));

        Student[] students = new Student[3];
        students[0] = new Student("张三", 96);
        students[1] = new Student("李四", 85);
        students[2] = new Student("王五", 98);

        System.out.println(Arrays.toString(students));
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
        Arrays.sort(students, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return Collator.getInstance(Locale.CHINA).compare(((Student) o1).getName(), ((Student) o2).getName());
            }
        });
        System.out.println(Arrays.toString(students));
    }

    @Test
    public void test03() {
        int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = {1, 2, 3, 4, 5};
        System.out.println(Arrays.equals(arr1, arr2));
    }

    @Test
    public void test04() {
        int[] arr1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int[] arr2 = Arrays.copyOf(arr1, 5);
        int[] arr3 = Arrays.copyOfRange(arr1, 3, 8);
        System.out.println(Arrays.toString(arr2));
        System.out.println(Arrays.toString(arr3));

        Arrays.fill(arr1, 5, 9, 3)
        System.out.println(Arrays.toString(arr1));
    }

}
窥一叶而知秋
关注
专栏目录
【Python百日进阶-Web开发-FastAPI】Day811 - FastAPI模额外数据类型
岳涛的博客
09-30 115
下面是一个路径操作的示例，其中的参数使用了上面的一些类型。
【Python百日进阶-Web开发-FastAPI】Day810 - FastAPI模式的额外信息 - 例子
最新发布
岳涛的博客
09-29 58
您可以在JSON模式中定义额外的信息。一个常见的用例是添加一个将在文档中显示的example。有几种方法可以声明额外的 JSON 模式信息。
BigDecimal 舍入模式（Rounding mode）介绍
weixin_33724046的博客
05-06 960
为什么80%的码农都做不了架构师？>>> ...
RoundingMode 参数详解
hantangduhey的博客
10-29 1万+
RoundingMode的几种模式，具体是什么舍入行为呢？看API完全没看懂，还好有人总结过了： https://blog.csdn.net/alanzyy/article/details/8465098 下面是我对这篇文章的图形理解，个人感觉比较好记，具体的示例可以看上边的原文： UP 正数向右边靠，负数向左边靠 DOWN 和up正好相反，正数向左边靠，负数向右边靠 CEI...
Day14-常见API(包装类,Math,BigInteger,RoundingModel,BigDecimal,Random,日期时间API,System类,Arrays数组工具类)
小丁的博客
02-22 825
第三次引入的API是成功的，并且java 8中引入的java.time API 已经纠正了过去的缺陷，将来很长一段时间内它都会为我们服务。Java提供了两个类型系统：基本类型与引用类型。double nextGaussian():返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（“正态”）分布的 double 值，其平均值是 0.0，标准差是 1.0。int nextInt(int n):返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。
BigDecimal用法详解
拂晓的专栏
04-24 2万+
一、BigDecimal介绍       Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数。在实际应用中，需要对更大或者更小的数进行运算和处理。float和double只能用来做科学计算或者是工程计算，在商业计算中若需要精确的计算结果则要用java.math.BigDecimal
Java中BigDecimal类的Rounding Modes(舍入模式)的说明和对比
Panda_陽的博客
08-25 2052
一、RoundingModes说明 1.ROUND_UP——向上取(正数向正无穷方向，负数往负无穷方向，即远离原点方向) 2.ROUND_DOWN——向下取(与ROUND_UP相反) 3.ROUND_CEILING——永远向正无穷方向取 4.ROUND_FLOOR——与ROUND_CEILING相反，永远向负无穷取 - 5.ROUND_HALF_UP——四舍五入 6.ROUND_HALF_DOWN————五舍六入 7.ROUND_HALF_EVEN——银行家舍入，即四舍六入五考虑，五后非零就进一，五后为
day08-常用API1
08-04
两种常见的创建方式是通过构造方法和直接赋值。通过`new String()`创建的字符串每次都会分配新的内存，即使内容相同，地址也不同。而直接用双引号`"abc"`创建的字符串，如果内容相同，Java虚拟机（JVM）会在字符串池...
day03-常用API&异常&Collection;.pdf
08-23
**JAVA常用API与异常处理** 1. **包装类**：Java为了使基本数据类型具有对象的特性，提供了与之对应的包装类。 - **基本类型与包装类**：每个基本类型都有一个对应的包装类，它们分别是Byte、Short、Integer、Long...
day01-地图专题课程-地图基础API与搜索
10-29
国内常见的地图服务供应商包括百度地图、高德地图、腾讯地图和搜狗地图。百度地图和高德地图市场份额较大，提供丰富的SDK功能，如鹰眼轨迹、智能调度、全球服务、室内地图等，而腾讯地图的SDK功能相对基础，搜狗地图...
Java 基础知识 | 02 BigDecimal
分享
05-11 331
BigDecimal 基本使用 使用示例： // 初始化 BigDecimal bd1=new BigDecimal("456"); BigDecimal bd2=new BigDecimal("123"); // 加 BigDecimal add=bd1.add(bd2); // 减 BigDecimal subtract=bd1.subtract(bd2); // 乘 BigDecimal multiply=bd1.multiply(bd2); // 除 BigDecimal divide=bd
Rounding Methods（舍入模式）
Heron——Linux & ARM
01-16 4622
What is "Rounding" ? Rounding means reducing the digits in a number while trying to keep its value similar. The result is less accurate, but easier to use.  Example: 7.3 rounds to 7 B
BigDecimal的四舍五入的RoundingMode 选择
热门推荐
well386的博客
12-30 9万+
转自 http://blog.csdn.net/alanzyy/article/details/8465098 RoundingMode介绍： RoundingMode是一个枚举类，有一下几个常量：UP，DOWN，CEILING，FLOOR，HALF_UP，HALF_DOWN，HALF_EVEN，UNNECESSARY     UP public static
Java大数类的RoundingMode（舍入模式）
bailu666666的博客
04-05 3万+
Java大数类的RoundingMode（舍入模式）        java.math.RoundingMode：这是一种枚举类型，它定义了8种数据的舍入模式。它与java.math.BigDecimal类中定义的8个同名静态常量的作用相同，可用BigDecimal.setScale(int newScale, RoundingMode roundingMode)来设置数据的精度和舍入模式。   ...
Java BigDecimal 的舍入模式（RoundingMode）详解
龙哥盟
08-05 4万+
BigDecimal.divide方法中必须设置roundingMode，不然会报错。 ROUND_UP：向正无穷方向对齐（转换为正无穷方向最接近的所需数值） ROUND_DOWN：向负无穷方向对齐 ROUND_CEILING：向原点的反方向对齐 ROUND_FLOOR：向原点方向对齐 ROUND_HALF_UP：“四舍五入”，如果舍弃部分的最高位大于等于 5，向正无穷方向对齐，否则向负无穷方向对齐 ROUND_HALF_DOWN：“五舍六入”，如果舍弃部分的最高位大于 5，向正无穷方向对齐，否则向负无穷
DecimalFormat对数值格式化的舍入问题——RoundingMode
alanzyy的技术路程
01-04 4万+
背景： 在对数值做一些计算的时候，往往我们需要控制计算结果的精度，所以会使用到DecimalFormat类来将数值格式化成字符串。在最近测试中，突然注意到默认使用DecimalFormat进行格式化时，并非我们一般认识上的四舍五入，而是一种诡异的舍入——(1)5以下舍去(2)5以上舍入(3)若前一位是奇数，5就舍入(4)如前一位是偶数，5就舍去 遇到这样的统计结论，没有理论的支持，我们总是感到
rounding mode
渔道的博客
02-03 1560
文章目录什么是rounding moderounding mode在C99中的定义示例运行结果 什么是rounding mode c语言中rounding mode(rounding direction)的总结(基于C99标准)。所谓rounding mode就是常说的舍入模式，例如，四舍五入、向上取整、向下取整。舍入模式决定了当浮点运算的结果不能在有效值中精确表示时应该如何处理。 rounding mode在C99中的定义 FLT_ROUNDS表示浮点运算的舍入模式。FLT_ROUNDS的值如下图(fro
RoundingMode 几个参数详解
zcw4237256的博客
10-24 2万+
第一版 java.math.RoundingMode 几个参数详解 java.math.RoundingMode里面有几个参数搞得我有点晕，现以个人理解对其一一进行总结： 为了能更好理解，我们可以画一个XY轴 RoundingMode.CEILING：取右边最近的整数 RoundingMode.DOWN：去掉小数部分取整，也就是正数取左边，负数取右边，相当于向原点
Java 30日精进：Day 29 - 反射、Java 8新特性与Stream API详解
在"30天搞定Java–day29(完)"这篇文章中，主要讲解了Java编程语言中的几个核心概念和技术，包括反射、Java 8的新特性、Lambda表达式、函数式接口、方法引用与构造器引用，以及Stream API的使用。 1. **反射的应用：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值