Java 核心类API(下)

简介: Java 核心类API

Java 核心类API(上):https://developer.aliyun.com/article/1491131


9.5 系统相关类


9.5.1 java.lang.System类


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

  • static long currentTimeMillis() :返回当前系统时间距离1970-1-1 0:0:0的毫秒值
  • static void exit(int status) :退出当前系统
  • static void gc() :运行垃圾回收器。
  • static String getProperty(String key):获取某个系统属性

public class Test{
    public static void main(String[] args){
      long time = System.currentTimeMillis();
      System.out.println("现在的系统时间距离1970年1月1日凌晨:" + time + "毫秒");
      
      System.exit(0);
      System.out.println("over");//不会执行
    }
}


9.5.2 java.lang.Runtime类


每个 Java 应用程序都有一个 Runtime 类实例,使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时。 应用程序不能创建自己的 Runtime 类实例。

public static Runtime getRuntime(): 返回与当前 Java 应用程序相关的运行时对象。

public long totalMemory():返回 Java 虚拟机中的内存总量。此方法返回的值可能随时间的推移而变化,这取决于主机环境。

public long freeMemory():回 Java 虚拟机中的空闲内存量。调用 gc 方法可能导致 freeMemory 返回值的增加。

public long maxMemory(): 返回 Java 虚拟机试图使用的最大内存量。

Process exec(String command):在单独的进程中执行指定的字符串命令。


9.6 数组工具类


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

  • static int binarySearch(int[] a, int key) :要求数组有序,在数组中查找key是否存在,如果存在返回第一次找到的下标,不存在返回负数
  • static int[] copyOf(int[] original, int newLength) :根据original原数组复制一个长度为newLength的新数组,并返回新数组
  • static int[] copyOfRange(int[] original, int from, int to) :复制original原数组的[from,to)构成新数组,并返回新数组
  • static boolean equals(int[] a, int[] a2) :比较两个数组的长度、元素是否完全相同
  • static void fill(int[] a, int val) :用val填充整个a数组
  • static void fill(int[] a, int fromIndex, int toIndex, int val):将a数组[fromIndex,toIndex)部分填充为val
  • static void sort(int[] a) :将a数组按照从小到大进行排序
  • static void sort(int[] a, int fromIndex, int toIndex) :将a数组的[fromIndex, toIndex)部分按照升序排列
  • static String toString(int[] a) :把a数组的元素,拼接为一个字符串,形式为:[元素1,元素2,元素3。。。]

示例代码:

import java.util.Arrays;
import java.util.Random;
public class Test{
    public static void main(String[] args){
      int[] arr = new int[5];
        // 打印数组,输出地址值
      System.out.println(arr); // [I@2ac1fdc4
      // 数组内容转为字符串
      System.out.println("arr数组初始状态:"+ Arrays.toString(arr));
      
      Arrays.fill(arr, 3);
      System.out.println("arr数组现在状态:"+ Arrays.toString(arr));
      
      Random rand = new Random();
      for (int i = 0; i < arr.length; i++) {
      arr[i] = rand.nextInt(100);//赋值为100以内的随机整数
    }
      System.out.println("arr数组现在状态:"+ Arrays.toString(arr));
      
      int[] arr2 = Arrays.copyOf(arr, 10);
      System.out.println("新数组:" + Arrays.toString(arr2));
      
      System.out.println("两个数组的比较结果:" + Arrays.equals(arr, arr2));
      
      Arrays.sort(arr);
      System.out.println("arr数组现在状态:"+ Arrays.toString(arr));
    }
}


9.7 包装类


9.7.1 包装类


Java提供了两大类数据类型,基本类型与引用类型,使用基本类型在于效率,但是缺少像引用数据类型一样的丰富API,那么Java提供了针对基本数据类型的保证类,以提供更加便捷的操作功能,包装类就是把基本数据类型包装成对应的引用数据类型。

序号 基本数据类型 包装类(java.lang包)
1 byte Byte
2 short Short
3 int Integer
4 long Long
5 float Float
6 double Double
7 char Character
8 boolean Boolean
9 void Void


9.7.2 装箱与拆箱


装箱:把基本数据类型转为包装类对象。

转为包装类的对象,是为了使用专门为对象设计的API和特性

拆箱:把包装类对象拆为基本数据类型。

转为基本数据类型,一般是因为需要运算,Java中的大多数运算符是为基本数据类型设计的。比较、算术等

基本数值---->包装对象

Integer i1 = new Integer(4);//使用构造函数函数
Integer i2 = Integer.valueOf(4);//使用包装类中的valueOf方法

包装对象---->基本数值

Integer i1 = new Integer(4);
int num1 = i1.intValue();

JDK1.5之后,可以自动装箱与拆箱。

注意:只能与自己对应的类型之间才能实现自动装箱与拆箱。

Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边:将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后,再次装箱,把基本数值转成对象。
Integer i = 1;
Double d = 1;//错误的,1是int类型

总结:对象(引用数据类型)能用的运算符有哪些?

(1)instanceof

(2)=:赋值运算符

(3)==和!=:用于比较地址,但是要求左右两边对象的类型一致或者是有父子类继承关系。

(4)对于字符串这一种特殊的对象,支持“+”,表示拼接。


9.7.3 包装类的常用API


  1. 基本数据类型和字符串之间的转换(1)把基本数据类型转为字符串
int a = 10;
//String str = a;//错误的
//方式一:
String str = a + "";
//方式二:
String str = String.valueOf(a);
//方式三:
Integer i=10;
String str=i.toString();

(2)把字符串转为基本数据类型String转换成对应的基本类型 ,除了Character类之外,其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型,例如:

  • public static int parseInt(String s):将字符串参数转换为对应的int基本类型。
  • public static long parseLong(String s):将字符串参数转换为对应的long基本类型。
  • public static double parseDouble(String s):将字符串参数转换为对应的double基本类型。

或把字符串转为包装类,然后可以自动拆箱为基本数据类型

  • public static Integer valueOf(String s):将字符串参数转换为对应的Integer包装类,然后可以自动拆箱为int基本类型
  • public static Long valueOf(String s):将字符串参数转换为对应的Long包装类,然后可以自动拆箱为long基本类型
  • public static Double valueOf(String s):将字符串参数转换为对应的Double包装类,然后可以自动拆箱为double基本类型

注意:如果字符串参数的内容无法正确转换为对应的基本类型,则会抛出java.lang.NumberFormatException异常。

int a = Integer.parseInt("整数的字符串");
double d = Double.parseDouble("小数的字符串");
boolean b = Boolean.parseBoolean("true或false");
int a = Integer.valueOf("整数的字符串");
double d = Double.valueOf("小数的字符串");
boolean b = Boolean.valueOf("true或false");
  1. 数据类型的最大最小值
Integer.MAX_VALUE和Integer.MIN_VALUE
Long.MAX_VALUE和Long.MIN_VALUE
Double.MAX_VALUE和Double.MIN_VALUE
  1. 字符转大小写
Character.toUpperCase('x');
Character.toLowerCase('X');
  1. 整数转进制
Integer.toBinaryString(int i) 
Integer.toHexString(int i)
Integer.toOctalString(int i)


9.7.4 包装类对象的缓存问题


包装类的数据在缓存数值范围内时,直接从内存中取出对象,超过范围会创建新的对象

包装类 缓存对象
Byte -128~127
Short -128~127
Integer -128~127
Long -128~127
Float 没有
Double 没有
Character 0~127
Boolean true和false

示例代码:

Integer i = 1;
Integer j = 1;
System.out.println(i == j);//true
Integer i = 128;
Integer j = 128;
System.out.println(i == j);//false
Integer i = new Integer(1);//新new的在堆中
Integer j = 1;//这个用的是缓冲的常量对象,在方法区
System.out.println(i == j);//false
Integer i = new Integer(1);//新new的在堆中
Integer j = new Integer(1);//另一个新new的在堆中
System.out.println(i == j);//false
@Test
  public void test3(){
    Double d1 = 1.0;
    Double d2 = 1.0;
    System.out.println(d1==d2);//false 比较地址,没有缓存对象,每一个都是新new的
  }

以上示例代码证明缓存的存在,源码中也有体现,


9.7.5 面试题


  1. 类型转换问题
@Test
  public void test4(){
    Double d1 = 1.0;
    double d2 = 1.0;
    System.out.println(d1==d2);//true 和基本数据类型比较会自动拆箱,比较数据值
  }
  
  @Test
  public void test2(){
    Integer i = 1000;
    double j = 1000;
    System.out.println(i==j);//true  会先将i自动拆箱为int,然后根据基本数据类型“自动类型转换”规则,转为double比较
  }
  
  @Test
  public void test(){
    Integer i = 1000;
    int j = 1000;
    System.out.println(i==j);//true 会自动拆箱,按照基本数据类型进行比较
  }
  1. 不可变对象
public class TestExam {
  public static void main(String[] args) {
    int i = 1;
    Integer j = new Integer(2);
    Circle c = new Circle();
    change(i,j,c);
    System.out.println("i = " + i);//1
    System.out.println("j = " + j);//2
    System.out.println("c.radius = " + c.radius);//10.0
  }
  
  /*
   * 方法的参数传递机制:
   * (1)基本数据类型:形参的修改完全不影响实参
   * (2)引用数据类型:通过形参修改对象的属性值,会影响实参的属性值
   * 这类Integer等包装类对象是“不可变”对象,即一旦修改,就是新对象,和实参就无关了
   */
  public static void change(int a ,Integer b,Circle c ){
    a += 10;
//    b += 10;//等价于  b = new Integer(b+10);
    c.radius += 10;
    /*c = new Circle();
    c.radius+=10;*/
  }
}
class Circle{
  double radius;
}


9.8 枚举Enum


9.8.1 概述


1、枚举的理解

某些类型的对象应该或者需要是有限的几个,这样的例子举不胜举:

  • 星期:Monday(星期一)…Sunday(星期天)
  • 性别:Man(男)、Woman(女)
  • 月份:January(1月)…December(12月)
  • 季节:Spring(春节)…Winter(冬天)
  • 支付方式:Cash(现金)、WeChatPay(微信)、Alipay(支付宝)、BankCard(银行卡)、CreditCard(信用卡)
  • 员工工作状态:Busy(忙)、Free(闲)、Vocation(休假)
  • 订单状态:Nonpayment(未付款)、Paid(已付款)、Fulfilled(已配货)、Delivered(已发货)、Checked(已确认收货)、Return(退货)、Exchange(换货)、Cancel(取消)

如何实现一个类只有固定的几个对象,而且不能随意创建对象?


2、早期实现方式

在JDK1.5之前,需要程序员自己通过特殊的方式来定义枚举类型。

  • 构造器加private私有化
  • 本类内部创建一组常量对象,并添加public static修饰符,对外暴露这些常量对象
//只有固定4个对象的季节类
public class Season{
    private String seasonName;
    public static final Season SPRING=new Season("春");
    public static final Season SUMMER=new Season("夏");
    public static final Season AUTUMN=new Season("秋");
    public static final Season WINTER=new Season("冬");
    private Season(String name){
        this.seasonName = name;
    }
    @Override
    public String toString() {
        return seasonName;
    }
}
//测试类
public class TestEnum {
  public static void main(String[] args) {
    Season spring = Season.SPRING;
    System.out.println(spring);
  }
}


9.8.2 枚举类型


在JDK1.5之后,Java支持enum关键字来快速的定义枚举类型。

枚举类型本质上也是一种类,只不过是这个类的对象是固定的几个,而不能随意让用户创建。

1、枚举类型的定义

语法格式:

【修饰符】 enum 枚举类名{
    常量对象列表
}
【修饰符】 enum 枚举类名{
    常量对象列表;
    
    其他成员列表;
}

示例代码 1:

//定义枚举类型Season
public enum Season{
  SPRING, SUMMER, AUTUMN, WINTER
}
//测试
public class TestEnum {
  public static void main(String[] args) {
    Season spring = Season.SPRING;
    System.out.println(spring);
  }
}
2、 枚举类的要求和特点
  • 枚举类的常量对象列表必须在枚举类的首行,因为是常量,所以建议大写。
  • 如果常量对象列表后面没有其他代码,那么“;”可以省略,否则不可以省略“;”。
  • 编译器给枚举类默认提供private的无参构造
  • 如果需要也可以定义有参构造,默认也是private修饰,常量对象名后面加(实参列表)调用有参构造器。
  • 枚举类默认继承自java.lang.Enum类,不能再继承其他的类型;枚举类默认是final修饰的也不能被继承。
  • JDK1.5之后switch,提供支持枚举类型,case后面可以写枚举常量名。
  • 枚举类型如有其它属性,建议这些属性也声明为final的,因为常量对象在逻辑意义上应该不可变。
public enum Week {
    MONDAY("星期一"),
    TUESDAY("星期二"),
    WEDNESDAY("星期三"),
    THURSDAY("星期四"),
    FRIDAY("星期五"),
    SATURDAY("星期六"),
    SUNDAY("星期日");
    private final String description;
    Week(String description){
        this.description = description;
    }
    @Override
    public String toString() {
        return super.toString() +":"+ description;
    }
}
public class TestWeek {
    public static void main(String[] args) {
        Week week = Week.MONDAY;
        System.out.println(week);
        switch (week){//switch语句支持枚举类型
            case MONDAY:
                System.out.println("怀念周末,困意很浓");
                break;
            case TUESDAY:
                System.out.println("进入学习状态");
                break;
            case WEDNESDAY:
                System.out.println("死撑");
                break;
            case THURSDAY:
                System.out.println("小放松");
                break;
            case FRIDAY:
                System.out.println("又信心满满");
                break;
            case SATURDAY:
                System.out.println("开始盼周末,无心学习");
                break;
            case SUNDAY:
                System.out.println("一觉到下午");
                break;
        }
    }
}
3、 枚举类型常用方法
  • String toString(): 默认返回的是常量名(对象名),可以继续手动重写该方法!
  • String name():返回的是常量名(对象名)
  • int ordinal():返回常量的次序号,默认从0开始
  • 枚举类型[] values():返回该枚举类的所有的常量对象,返回类型是当前枚举的数组类型,是一个静态方法
  • 枚举类型 valueOf(String name):静态方法,根据枚举常量对象名称获取枚举对象

示例代码:

public class TestEnumMethod {
    public static void main(String[] args) {
        Week[] values = Week.values();
        for (int i = 0; i < values.length; i++) {
            System.out.println((values[i].ordinal()+1) + "->" + values[i].name());
        }
        System.out.println("------------------------");
        Scanner input = new Scanner(System.in);
        System.out.print("请输入星期值:");
        int weekValue = input.nextInt();
        Week week = values[weekValue-1];
        System.out.println(week);
        System.out.print("请输入星期名:");
        String weekName = input.next();
        week = Week.valueOf(weekName);
        System.out.println(week);
        input.close();
    }
}
相关文章
|
19小时前
|
Java
Java Object 类
5月更文挑战第16天
|
1天前
|
分布式计算 Java 程序员
Java 8新特性之Lambda表达式与Stream API
【5月更文挑战第21天】本文主要介绍了Java 8中的两个重要新特性:Lambda表达式和Stream API。Lambda表达式是Java 8引入的一种新的编程方式,它允许我们将函数作为参数传递给其他方法。而Stream API则是一种新的数据处理方式,它允许我们以声明式的方式处理数据,使得代码更加简洁易读。
|
1天前
|
存储 Java 程序员
【Java】第二讲:字符串相关类
返回长度。这里的length同时包含间隔符号、开始符号、结束符号在内。
9 1
|
2天前
|
Java 程序员 API
Java 8 Lambda 表达式和Stream API:概念、优势和实战应用
【5月更文挑战第20天】在Java 8中,Lambda 表达式和Stream API是两个非常强大的特性,它们显著改变了Java程序员处理数据和编写代码的方式。本篇技术文章将深入探讨这些特性的概念、优点,并提供实战示例,帮助理解如何有效地利用这些工具来编写更简洁、更高效的代码。
20 6
|
3天前
|
安全 Java 容器
Java一分钟之-并发编程:线程安全的集合类
【5月更文挑战第19天】Java提供线程安全集合类以解决并发环境中的数据一致性问题。例如,Vector是线程安全但效率低;可以使用Collections.synchronizedXxx将ArrayList或HashMap同步;ConcurrentHashMap是高效线程安全的映射;CopyOnWriteArrayList和CopyOnWriteArraySet适合读多写少场景;LinkedBlockingQueue是生产者-消费者模型中的线程安全队列。注意,过度同步可能影响性能,应尽量减少共享状态并利用并发工具类。
17 2
|
4天前
|
安全 Java API
Java进阶-Java Stream API详解与使用
效、更易于维护的代码,同时享受到函数式编程带来的好处。
14 2
|
5天前
|
Java 大数据 API
利用Java Stream API实现高效数据处理
在大数据和云计算时代,数据处理效率成为了软件开发者必须面对的重要挑战。Java 8及以后版本引入的Stream API为开发者提供了一种声明式、函数式的数据处理方式,极大提升了数据处理的效率和可读性。本文将详细介绍Java Stream API的基本概念、使用方法和性能优势,并通过实际案例展示如何在实际项目中应用Stream API实现高效数据处理。
|
5天前
|
自然语言处理 Java API
Java 8的Stream API和Optional类:概念与实战应用
【5月更文挑战第17天】Java 8引入了许多重要的新特性,其中Stream API和Optional类是最引人注目的两个。这些特性不仅简化了集合操作,还提供了更好的方式来处理可能为空的情况,从而提高了代码的健壮性和可读性。
27 7
|
Java API
Java 8 Stream API详解
版权声明:本文为博主chszs的原创文章,未经博主允许不得转载。 https://blog.csdn.net/chszs/article/details/47038607 Java ...
982 0
|
5天前
|
监控 安全 数据挖掘
Email 接口API有哪些?具体分析一下阿里云和AOK的优点
本文介绍了常见的Email接口API,如阿里云邮件推送、AOKSend、SendGrid、Mailgun和Amazon SES。阿里云API以其高稳定性和数据分析功能脱颖而出,支持批量发送和多语言;而AOKSend API以易于集成、高安全性和优秀客户支持为亮点。企业在选择时应考虑自身需求和预算,以优化邮件营销效果。