Java常用API
内部类
内部类：在一个类的内部再定义一个类
特点：
-
编译之后可以生成独立的字节码文件
-
内部类可以直接访问外部类的私有成员，而不破坏封装
-
可以为外部类提供必要的内部功能组件
成员内部类
-
在类的内部定义，与实例变量(属性)、实例方法(方法)同级别的类。
-
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。
-
当外部类与内部类存在重名属性时，会优先访问内部类属性。
-
成员内部类不能定义静态成员，但是可以定义静态常量
package com.api.内部类.成员内部类;
//外部类
public class Demo01 {
//外部实例变量
private String name="张三";
private int age=18;
//内部类
class Inner{
//内部实例变量
private String name="李四"; //内部类属性与外部类属性相同时 调用内部类属性，如果用外部类属性,这样：Demo01.this.
private String city="石家庄";
private String phone="1888888";
//内部方法
public void show(){
System.out.println(Demo01.this.name);
System.out.println(age);
System.out.println(city);
System.out.println(phone);
}
}
}
Test:
package com.api.内部类.成员内部类;
public class Test {
public static void main(String[] args) {
//1. 创建外部类对象
//Demo01 demo01 = new Demo01();
//2. 创建内部类对象
//Demo01.Inner inner = demo01.new Inner();
//1和2写成一个
Demo01.Inner inner = new Demo01().new Inner();
//调用内部类的方法
inner.show();
}
}
静态内部类
-
不依赖外部类对象，可以直接创建或通过类名访问，可以声明静态成员
-
只能直接访问外部类的静态成员(实例成员需实例化外部类对象)
package com.api.内部类.静态内部类;
public class Demo {
private String name="李四";
private int age=3;
static class Inner{
private String phone="123456";
private String city="西安";
private static int id=1; //静态属性
public void show(){
//调用外部类的属性 ：先创建外部类对象
Demo demo = new Demo();
System.out.println(demo.name);
System.out.println(demo.age);
//调用静态内部类的属性 ；直接调用
System.out.println(phone);
System.out.println(city);
//调用静态内部类的静态属性 class.
System.out.println(Inner.id);
}
}
}
Test:
package com.api.内部类.静态内部类;
public class Test {
public static void main(String[] args) {
//创建静态内部类对象
Demo.Inner inner = new Demo.Inner();
//调用其方法
inner.show();
}
}
局部内部类
-
定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。
-
局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的声明周期与自身相同，常量必须修饰为final（JDK1.7之前，final必须写上，JDK1.8后，final可以省略不写，默认已经被修饰为final）。
-
限制类的使用范围。（使用频率低）
package com.api.内部类.局部内部类;
public class Demo {
private String name="王五";
private int age=5;
public void show(){
final String city="衡水"; //默认就是final 可写可不写
//定义局部内部类
class Inner{
private String phone="123789";
public void show02(){
//使用外部类属性：直接调用
System.out.println(name);
System.out.println(age);
//调用局部内部类属性：直接调用
System.out.println(phone);
//调用方法中的局部变量：直接调用
System.out.println(city);
}
}
//调用内部类的方法 先在外部类方法里创建对象
Inner inner = new Inner();
inner.show02();
}
}
Test:
package com.api.内部类.局部内部类;
public class Test {
public static void main(String[] args) {
Demo demo = new Demo();
demo.show();
}
}
匿名内部类
-
没有类名的局部内部类（一切特征都与局部内部类相同）。
-
使用规则：必须继承一个父类或者实现一个接口。
-
定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。
-
优点：减少代码量
-
缺点：可读性较差
接口：
package com.api.内部类.匿名内部类;
public interface Animal {
void eat();
}
接口的实现类：
package com.api.内部类.匿名内部类;
public class Dog implements Animal {
public void eat() {
System.out.println("狗什么都吃！！！");
}
}
Test:
package com.api.内部类.匿名内部类;
public class Test {
public static void main(String[] args) {
//创建接口类型的变量
Animal dog = new Dog();
dog.eat();
//局部内部类
class Cat implements Animal{
public void eat() {
System.out.println("猫吃鱼和老鼠！！！");
}
}
Animal cat=new Cat();
cat.eat();
//匿名内部类：没有名字
Animal rabbit =new Animal(){
public void eat() {
System.out.println("兔子吃草，但不吃窝边草！！！");
}
};
rabbit.eat();
}
}
一步步的简化代码
Object类
概述：
-
超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
-
任何类，如果没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承。
-
Object类中所定义的方法，是所有对象都具备的方法。
-
Object类型可以存储任何对象
-
作为参数：可接收任何对象
-
作为返回值，可返回任何对象
-
getClass()方法
-
public final Class<?> getClass(){}
-
返回引用存储的实际对象类型
-
应用：通常用于判断两个引用中实际存储对象类型是否一致
package com.api.Object类.getClass;
public class People {
private String name;
private String sex;
private int age;
public People() {
}
public People(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
//省略get、set方法
}
Test:
package com.api.Object类.getClass;
public class Test {
public static void main(String[] args) {
People p1 = new People("张三","男",16);
People p2 = new People("胖丫","女",15);
Class p1Class = p1.getClass();
Class p2Class = p2.getClass();
if (p1Class==p2Class){
System.out.println("p1和p2属于同一个类型");
}else {
System.out.println("p1和p2不属于同一个类型");
}
}
}
//输出结果：p1和p2属于同一个类型
hashCode()方法
-
public int hashCode(){}
-
返回该对象的哈希码值
-
哈希码根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值。
-
一般情况下相同对象返回相同的哈希码。
Test:
package com.api.Object类.hashCode;
public class Test {
public static void main(String[] args) {
People p1 = new People("张三","男",16);
People p2 = new People("胖丫","女",15);
System.out.println(p1.hashCode());
System.out.println(p2.hashCode());
People p3=p1;
System.out.println(p3.hashCode());
}
}
/*输出结果：
140435067
1450495309
140435067
*/
toString()方法
-
public String toString(){}
-
返回该对象的字符串表示（表现形式）
-
可以根据程序需求覆盖该方法，如：展示对象的各个属性值。
People:
package com.api.Object类.toString;
public class People {
private String name;
private String sex;
private int age;
public People() {
}
public People(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
public String toString() {
return "People{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
'}';
}
//省略get、set方法
}
Test:
package com.api.Object类.toString;
public class Test {
public static void main(String[] args) {
People p1 = new People("张三","男",16);
System.out.println(p1.toString());
//如果People类里没有覆盖toString()
//默认返回的是getClass().getName() + "@" + Integer.toHexString(hashCode());
//com.api.Object类.toString.People@85ede7b 16进制的哈希码
}
}
/*输出结果：
People{name='张三', sex='男', age=16}
*/
equals()方法
-
public boolean equals(Object obj){}
-
默认实现（this == obj），比较两个对象地址是否相同。
-
可进行覆盖，比较两个对象的内容是否相同。方法覆盖：
-
比较两个引用是否指向同一个对象
-
判断obj是否为null
-
判断两个引用指向的实际对象类型是否一致
-
强制类型转换
-
依次比较各个属性值是否相同
-
Peopel:
package com.api.Object类.equals;
import java.util.Objects;
public class People {
private String name;
private String sex;
private int age;
public People() {
}
public People(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
public boolean equals(Object obj) {
//比较两个引用是否指向同一个对象
if (this == obj) return true;
//判断obj是否为null,判断两个引用指向的实际对象类型是否一致
if (obj == null || getClass() != obj.getClass()) return false;
//强制类型转换
People people = (People) obj;
//比较各个属性值是否相等
return age == people.age &&
Objects.equals(name, people.name) &&
Objects.equals(sex, people.sex);
}
//省略get、set方法
}
Test:
package com.api.Object类.equals;
public class Test {
public static void main(String[] args) {
People p1 = new People("张三","男",16);
People p2 = new People("胖丫","女",15);
System.out.println(p1.equals(p2)); //false
People p3 = new People("胖丫","女",15);
System.out.println(p2.equals(p3)); //未进行覆盖之前false，覆盖之后判断内容是否相同true
}
}
//输出结果：false true
finalize()方法
-
当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。
-
垃圾对象：没有有效引用指向此对象时，为垃圾对象。
-
垃圾回收：由GC销毁垃圾对象，释放数据存储空间
-
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
-
手动回收机制：使用System.gc(); 通知JVM执行垃圾回收。（但是JVM不一定执行，只是相当于给他提个醒）
包装类
概述：
-
基本数据类型所对应的引用数据类型
-
Object可统一所有数据类型，包装类的默认值是null
| 基本数据类型 | 包装类型 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
类型转换：
8种包装类提供不同类型间的转换方式：
-
Number父类中提供的6个共性方法
-
parseXXX()静态方法
-
valueOf()静态方法
装箱、拆箱
装箱：基本类型转换为引用类型
拆箱：引用类型转换为基本类型
Test:
package com.api.包装类.装箱拆箱;
public class Test {
public static void main(String[] args) {
int num01=10;
//类型转换：装箱：基本类型转换为引用类型的过程：两种方法
Integer integer01 = new Integer(num01); //使用Integer类创建对象
Integer integer02 = Integer.valueOf(num01); //使用Integer方法
System.out.println(integer02);
//拆箱：引用类型转换为基本类型的过程
int a=integer02.intValue();
System.out.println(a);
//JDK1.5以后可自动进行装箱拆箱 通过class文件反编译Java可以看出，过程还是上边的，只不过编译器自动调用方法了
int num02=20;
//装箱
Integer integer1=num02;
//拆箱
int b=integer1;
}
}
基本类型和字符串之间转换
Test:
package com.api.包装类.基本类型和字符串转换;
public class Test {
public static void main(String[] args) {
//基本类型转换为字符串类型
int num=100;
//方法一：使用“+”号
String a=num+"";
//方法二：
String b=Integer.toString(num);
//字符串类型转换为基本类型
String str="1000";
//使用parseXXX()方法
int c=Integer.parseInt(str);
//boolean字符串转换为基本类型 true为true 非true都是false
String str2="true";
boolean d=Boolean.parseBoolean(str2);
System.out.println(d); //true
String str3="true0";
boolean e=Boolean.parseBoolean(str3);
System.out.println(e); //false
}
}
整数缓冲区（面试题）
-
Java预先创建了256个常用的整数包装类型对象 -128~~127
-
在实际应用当中，对已创建的对象进行复用
就是堆里有一块缓冲区，存放的是-127~~128的数值，如果在这之间，就直接取，不用创建对象，所以地址是固定的
package com.api.包装类.整数缓存区;
public class Test {
public static void main(String[] args) {
Integer integer1=new Integer(100); //用构造器
Integer integer2=new Integer(100);
System.out.println(integer1==integer2); //false
Integer integer3=100; //通过对class文件进行反编译 可以看出直接转换是用的Integer.valueOf(100)
Integer integer4=Integer.valueOf(100);
System.out.println(integer3==integer4); //true
Integer integer5=200;
Integer integer6=200;
System.out.println(integer5==integer6); //false
}
}
/*
原因：
第一个是因为用的构造器，创建对象，地址不同
第二个是直接转换，调用整数缓冲区中的，100在整数缓冲区范围内，两个100地址相同
第三个，200不在整数缓冲区范围内，地址不同
*/
String类
概述：
-
字符串是常量，创建之后不可改变
-
字符串字面值存储在字符串池中，可以共享
-
String s="Hello"; //产生一个对象，字符串池中存储
-
String s=new String("Hello"); //产生两个对象，堆、池各存储一个
字符串的创建和内存分析
Test:
package com.api.String类.demo01;
public class Test {
public static void main(String[] args) {
String name="Hello";
name="张三";
String name2="张三"; //"张三"赋值给name
//字符串的另一种创建方式：new Sting()
String name3=new String("李四");
String name4=new String("李四");
}
}
内存分析：
字符串方法的使用
-
length(); 返回字符串的长度
-
charAt(int index); 返回某个位置的字符
-
contains(String str); 判断是否包含某个字符串
Test01:
package com.api.String类.字符串方法的使用;
public class Test01 {
public static void main(String[] args) {
String str="世界上最好的编程语言： java";
//length(); 返回字符串的长度
//charAt(int index); 返回某个位置的字符
//contains(String str); 判断是否包含某个字符串
System.out.println(str.length()); //返回字符串的长度 空格也算
System.out.println(str.charAt(str.length()-1)); //输出最后一个字符
System.out.println(str.contains("java")); //输出布尔值
System.out.println(str.contains("python"));
}
}
/*
16
a
true
false
*/
-
public char[] toCharArray(); 将字符串转换成数组
-
public int indexOf(String str); 查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
-
public int lastIndexOf(String str); 查找字符串在当前字符串中最后一次出现的下标索引
Test02:
package com.api.String类.字符串方法的使用;
import java.util.Arrays;
public class Test02 {
public static void main(String[] args) {
//public char[] toCharArray(); 将字符串转换成数组
//public int indexOf(String str); 查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
//public int lastIndexOf(String str); 查找字符串在当前字符串中最后一次出现的下标索引
String str="世界上最好最好最好的编程语言： java";
System.out.println(Arrays.toString(str.toCharArray())); //将字符串转换成数组
System.out.println(str.indexOf("java"));
System.out.println(str.lastIndexOf("最好"));
}
}
/*
[世, 界, 上, 最, 好, 最, 好, 最, 好, 的, 编, 程, 语, 言, ：, , j, a, v, a]
16
7
*/
-
public String trim(); 去掉字符串前后的空格
-
public String toUpperCase(); 将小写转成大写 toLowerCase() 将大写转为小写
-
public boolean endWith(String str); 判断字符串是否以str结尾
Test03:
package com.api.String类.字符串方法的使用;
public class Test03 {
public static void main(String[] args) {
//public String trim(); 去掉字符串前后的空格
//public String toUpperCase(); 将小写转成大写 toLowerCase 大写转为小写
//public boolean endWith(String str); 判断字符串是否以str结尾
String str=" java 是最好的PROGRAMMING LANGUAGE";
System.out.println(str.trim()); //只是前后的空格，不是所有的空格
System.out.println(str.toUpperCase());
System.out.println(str.toLowerCase());
System.out.println(str.endsWith("GE")); //true
}
}
/*
java 是最好的PROGRAMMING LANGUAGE
JAVA 是最好的PROGRAMMING LANGUAGE
java 是最好的programming language
true
*/
-
public String replace(char oldChar,char newChar); 将旧字符串替换成新字符串
-
public String[] split(String str); 根据str做拆分
package com.api.String类.字符串方法的使用;
public class Test04 {
public static void main(String[] args) {
//public String replace(char oldChar,char newChar); 将旧字符串替换成新字符串
//public String[] split(String str); 根据str做拆分
String str="java 是 最好的 编程 语言";
System.out.println(str.replace("java", "python"));
String[] arr = str.split(" ");
System.out.println(arr.length);
for (String s : arr) {
System.out.println(s);
}
}
}
/*
python 是 最好的 编程 语言
5
java
是
最好的
编程
语言
*/
equals()方法：
Test05:
package com.api.String类.字符串方法的使用;
public class Test05 {
public static void main(String[] args) {
String str01="hello";
String str02="HELLO";
System.out.println(str01.equals(str02)); //false
System.out.println(str01.equalsIgnoreCase(str02)); //忽略大小写 true
}
}
案例：
-
已知 String str="this is a test";
-
1 将str中的单词单独获取出来
-
2 将str中的text替换为practice
-
3 在text前面插入一个easy
-
4 将每个单词的首字母改为大写
package com.api.String类.字符串方法的使用;
public class Test {
public static void main(String[] args) {
//已知 String str="this is a test";
//1 将str中的单词单独获取出来
//2 将str中的text替换为practice
//3 在text前面插入一个easy
//4 将每个单词的首字母改为大写
String str="this is a test";
String[] s = str.split(" ");
for (String s1 : s) {
System.out.println(s1);
}
System.out.println("-------------------------------");
String str2 = str.replace("test", "practice");
System.out.println(str2);
System.out.println("-------------------------------");
String str3 = str.replace("test", "easy test");
System.out.println(str3);
System.out.println("-------------------------------");
for (int i = 0; i <s.length; i++) {
char c = s[i].charAt(0);
char C = Character.toUpperCase(c);
String s1 = C + s[i].substring(1); //拼接
System.out.println(s1);
}
}
}
可变字符串：
StringBuffer:可变长字符串，JDK1.0提供，运行效率慢、线程安全。
StringBuider:可变长字符串，JDK5.0提供，运行效率快，线程不安全。
两者用法相同，单线程情况下用StringBuider
package com.api.String类.字符串方法的使用;
public class Test06 {
public static void main(String[] args) {
StringBuilder sb=new StringBuilder();
//1 append() 追加
sb.append("姓名：李四");
System.out.println(sb.toString());
sb.append(",性别：男人");
System.out.println(sb.toString());
//2 insert() 添加
sb.insert(0,"自我介绍：");
System.out.println(sb.toString());
//3 replace() 替换
sb.replace(8, 10, "张三");
System.out.println(sb);
//4 delete() 删除
sb.delete(15,16);
System.out.println(sb);
}
}
BigDecimal
思考：以下程序输出结果是多少？
package com.api.BigDecimal;
public class Test {
public static void main(String[] args) {
double a=1.0;
double b=0.9;
System.out.println(a-b);
float c=1.0f;
float d=0.9f;
System.out.println(c-d);
}
}
输出结果：
0.099999999999999980.100000024
float和double属于近似值存储，如果需要特别精确的运算，比如银行，float和double不符合要求，需要借助：BigDecimal
BigDecimal：
-
位置：java.math包中
-
作用：精确计算浮点数
-
创建方式：BigDecimal bd=new BigDecimal("1.0");
-
方法：
-
BigDecimal add(BigDecimal bd) 加
-
BigDecimal subtract(BigDecimal bd) 减
-
BigDecimal multiply(BigDecimal bd) 乘
-
BigDecimal divide(BigDecimal bd) 除
-
package com.api.BigDecimal;
import java.math.BigDecimal;
public class Test02 {
public static void main(String[] args) {
BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
//减法
BigDecimal subtract = bd1.subtract(bd2);
System.out.println(subtract);
//加法
BigDecimal add = bd1.add(bd2);
System.out.println(add);
//乘法
BigDecimal multiply = bd1.multiply(bd2);
System.out.println(multiply);
//除法
BigDecimal divide = bd1.divide(bd2,2,BigDecimal.ROUND_HALF_DOWN);
System.out.println(divide); //除不尽的话 报错 但是可以选择保留几位小数，4舍5入
}
}
Date
Data表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代。
一下是还没有被取代、没有过时的方法
package com.api.Date;
import java.util.Date;
public class Test {
public static void main(String[] args) {
//创建Date对象
//今天
Date date = new Date();
System.out.println(date.toString());
System.out.println(date.toLocaleString());
//昨天
Date date1 = new Date(date.getTime() - (24 * 60 * 60 * 1000));
System.out.println(date1.toLocaleString());
//方法：after和before
boolean after = date.after(date1);
System.out.println(after); //true 今天比昨天晚
boolean before = date.before(date1);
System.out.println(before); //false
//比较CompareTo() 比较的是：毫秒值 结果就只是-1，0，1
int i = date.compareTo(date1);
System.out.println(i);
//equals 比较是否相等
boolean equals = date.equals(date1);
System.out.println(equals);
}
}
/*
Tue Apr 26 19:15:05 CST 2022
2022年4月26日 下午7:15:05
2022年4月25日 下午7:15:05
true
false
1
false
*/
Calendar类
-
Calendar提供了获取或设置各种日历字段的方法。
-
构造方法：protected Calendar() :由于修饰符是protected（受保护的），所以无法直接创建该对象。
-
其他方法：
方法名 说明 static Calendar getInstance() 使用默认时区和区域获取日历 void set(int year,int month,int date,int hourofday,int minute,int second) 设置日历的年、月、日、时、分、秒 int setTime(Date date) 用给定的Date设置此日历的时间。Date-Calendar Date getTime() 返回一个Date表示此日历的时间。Calendar-Date void add(int field,int amount) 按照日历的规则，给指定字段添加或减少时间量 long getTimelnMillies() 毫秒为单位返回改日历的时间值
package com.api.Calendar类;
import java.util.Calendar;
public class Test {
public static void main(String[] args) {
//1.创建Calendar对象
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString());
System.out.println(calendar.getTimeInMillis()); //毫秒数
//2.获取时间信息
int year = calendar.get(Calendar.YEAR); //获取年
int month = calendar.get(Calendar.MONTH); //获取月 0~11
int date = calendar.get(Calendar.DATE); //获取日
int hour = calendar.get(Calendar.HOUR_OF_DAY); //获取小时 HOUR_OF_DAY:24小时 HOUR：12小时
int minute = calendar.get(Calendar.MINUTE); //获取分钟
int second = calendar.get(Calendar.SECOND); //获取秒
System.out.println(year+"年"+(month+1)+"月"+date+"日"+hour+"时"+minute+"分"+second+"秒");
//3.修改时间
calendar.set(Calendar.DATE,9);
System.out.println(calendar.getTime().toLocaleString());
//4.add()方法修改时间
calendar.add(Calendar.HOUR_OF_DAY,3);
System.out.println(calendar.getTime().toString());
//5.补充方法，获取一个月份的最大天数和最小天数
calendar.set(Calendar.YEAR,2021);
calendar.set(Calendar.MONTH,1);
System.out.println(calendar.getTime().toLocaleString());
int maximum = calendar.getActualMaximum(Calendar.DATE);
int minimum = calendar.getActualMinimum(Calendar.DATE);
System.out.println(maximum);
System.out.println(minimum);
}
}
/*
2022年4月26日 下午7:14:17
1650971657160
2022年4月26日19时14分17秒
2022年4月9日 下午7:14:17
Sat Apr 09 22:14:17 CST 2022
2021年2月9日 下午10:14:17
28
1
*/
SimpleDateFormat类
-
SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
-
进行格式化（日期—>文本） 解析（文本—>日期）
-
常用的时间模式字母
字母 日期或时间 示例 y 年 2022 M 月 04 d 日 26 H 小时 19 m 分钟 13 s 秒 50 S 毫秒 369
package com.api.simpleDateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Tset {
public static void main(String[] args) throws ParseException {
//创建simpleDateFormat 对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
//创建Date
Date date = new Date();
//格式化date（把日期转换为字符串）
String format = sdf.format(date);
System.out.println(format);
//解析（把字符串换成日期）
Date parse = sdf.parse("2100年12月6日 10:08:00");
System.out.println(parse);
}
}
/*
2022年04月26日 19:13:53
Mon Dec 06 10:08:00 CST 2100
*/
System类
System系统类。主要用于获取系统的属性数据和其他操作，构造方法私有的
| 方法名 | 说明 |
|---|---|
| static void arraycopy(...) | 复制数组 |
| static long currentTimeMillis(); | 获取当前系统时间，返回的是毫秒数（一般可以用作计算程序运行用了多长时间） |
| static void gc() | 建议JVM赶快启动垃圾回收器回收垃圾 |
| static void exit(int status) | 退出JVM，如果参数是0表示正常退出jvm，非0表示异常退出jvm |
Test：
package com.api.System;
public class Test {
public static void main(String[] args) {
int[] a={1,2,3,4,5,6,7,8,9};
int[] b=new int[10];
//src:源数组
//srcPos:从那个位置开始复制 （0就是从开头就开始）
//dest:目标数组
//destPos:目标函数的位置
//length:复制原数组的长度
System.arraycopy(a,0,b,1,a.length);
for (int i : b) {
System.out.println(i);
}
System.out.println("---------------------");
long start=System.currentTimeMillis();
for (int i = 0; i <1000000 ; i++) {
i=i+1;
}
long end=System.currentTimeMillis();
System.out.println(end-start);
}
}
内部类
内部类：在一个类的内部再定义一个类
特点：
-
编译之后可以生成独立的字节码文件
-
内部类可以直接访问外部类的私有成员，而不破坏封装
-
可以为外部类提供必要的内部功能组件
成员内部类
-
在类的内部定义，与实例变量(属性)、实例方法(方法)同级别的类。
-
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。
-
当外部类与内部类存在重名属性时，会优先访问内部类属性。
-
成员内部类不能定义静态成员，但是可以定义静态常量
package com.api.内部类.成员内部类;
//外部类
public class Demo01 {
//外部实例变量
private String name="张三";
private int age=18;
//内部类
class Inner{
//内部实例变量
private String name="李四"; //内部类属性与外部类属性相同时 调用内部类属性，如果用外部类属性,这样：Demo01.this.
private String city="石家庄";
private String phone="1888888";
//内部方法
public void show(){
System.out.println(Demo01.this.name);
System.out.println(age);
System.out.println(city);
System.out.println(phone);
}
}
}
Test:
package com.api.内部类.成员内部类;
public class Test {
public static void main(String[] args) {
//1. 创建外部类对象
//Demo01 demo01 = new Demo01();
//2. 创建内部类对象
//Demo01.Inner inner = demo01.new Inner();
//1和2写成一个
Demo01.Inner inner = new Demo01().new Inner();
//调用内部类的方法
inner.show();
}
}
静态内部类
-
不依赖外部类对象，可以直接创建或通过类名访问，可以声明静态成员
-
只能直接访问外部类的静态成员(实例成员需实例化外部类对象)
package com.api.内部类.静态内部类;
public class Demo {
private String name="李四";
private int age=3;
static class Inner{
private String phone="123456";
private String city="西安";
private static int id=1; //静态属性
public void show(){
//调用外部类的属性 ：先创建外部类对象
Demo demo = new Demo();
System.out.println(demo.name);
System.out.println(demo.age);
//调用静态内部类的属性 ；直接调用
System.out.println(phone);
System.out.println(city);
//调用静态内部类的静态属性 class.
System.out.println(Inner.id);
}
}
}
Test:
package com.api.内部类.静态内部类;
public class Test {
public static void main(String[] args) {
//创建静态内部类对象
Demo.Inner inner = new Demo.Inner();
//调用其方法
inner.show();
}
}
局部内部类
-
定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。
-
局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的声明周期与自身相同，常量必须修饰为final（JDK1.7之前，final必须写上，JDK1.8后，final可以省略不写，默认已经被修饰为final）。
-
限制类的使用范围。（使用频率低）
package com.api.内部类.局部内部类;
public class Demo {
private String name="王五";
private int age=5;
public void show(){
final String city="衡水"; //默认就是final 可写可不写
//定义局部内部类
class Inner{
private String phone="123789";
public void show02(){
//使用外部类属性：直接调用
System.out.println(name);
System.out.println(age);
//调用局部内部类属性：直接调用
System.out.println(phone);
//调用方法中的局部变量：直接调用
System.out.println(city);
}
}
//调用内部类的方法 先在外部类方法里创建对象
Inner inner = new Inner();
inner.show02();
}
}
Test:
package com.api.内部类.局部内部类;
public class Test {
public static void main(String[] args) {
Demo demo = new Demo();
demo.show();
}
}
匿名内部类
-
没有类名的局部内部类（一切特征都与局部内部类相同）。
-
使用规则：必须继承一个父类或者实现一个接口。
-
定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。
-
优点：减少代码量
-
缺点：可读性较差
接口：
package com.api.内部类.匿名内部类;
public interface Animal {
void eat();
}
接口的实现类：
package com.api.内部类.匿名内部类;
public class Dog implements Animal {
public void eat() {
System.out.println("狗什么都吃！！！");
}
}
Test:
package com.api.内部类.匿名内部类;
public class Test {
public static void main(String[] args) {
//创建接口类型的变量
Animal dog = new Dog();
dog.eat();
//局部内部类
class Cat implements Animal{
public void eat() {
System.out.println("猫吃鱼和老鼠！！！");
}
}
Animal cat=new Cat();
cat.eat();
//匿名内部类：没有名字
Animal rabbit =new Animal(){
public void eat() {
System.out.println("兔子吃草，但不吃窝边草！！！");
}
};
rabbit.eat();
}
}
一步步的简化代码
Object类
概述：
-
超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
-
任何类，如果没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承。
-
Object类中所定义的方法，是所有对象都具备的方法。
-
Object类型可以存储任何对象
-
作为参数：可接收任何对象
-
作为返回值，可返回任何对象
-
getClass()方法
-
public final Class<?> getClass(){}
-
返回引用存储的实际对象类型
-
应用：通常用于判断两个引用中实际存储对象类型是否一致
package com.api.Object类.getClass;
public class People {
private String name;
private String sex;
private int age;
public People() {
}
public People(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
//省略get、set方法
}
Test:
package com.api.Object类.getClass;
public class Test {
public static void main(String[] args) {
People p1 = new People("张三","男",16);
People p2 = new People("胖丫","女",15);
Class p1Class = p1.getClass();
Class p2Class = p2.getClass();
if (p1Class==p2Class){
System.out.println("p1和p2属于同一个类型");
}else {
System.out.println("p1和p2不属于同一个类型");
}
}
}
//输出结果：p1和p2属于同一个类型
hashCode()方法
-
public int hashCode(){}
-
返回该对象的哈希码值
-
哈希码根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值。
-
一般情况下相同对象返回相同的哈希码。
Test:
package com.api.Object类.hashCode;
public class Test {
public static void main(String[] args) {
People p1 = new People("张三","男",16);
People p2 = new People("胖丫","女",15);
System.out.println(p1.hashCode());
System.out.println(p2.hashCode());
People p3=p1;
System.out.println(p3.hashCode());
}
}
/*输出结果：
140435067
1450495309
140435067
*/
toString()方法
-
public String toString(){}
-
返回该对象的字符串表示（表现形式）
-
可以根据程序需求覆盖该方法，如：展示对象的各个属性值。
People:
package com.api.Object类.toString;
public class People {
private String name;
private String sex;
private int age;
public People() {
}
public People(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
public String toString() {
return "People{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
'}';
}
//省略get、set方法
}
Test:
package com.api.Object类.toString;
public class Test {
public static void main(String[] args) {
People p1 = new People("张三","男",16);
System.out.println(p1.toString());
//如果People类里没有覆盖toString()
//默认返回的是getClass().getName() + "@" + Integer.toHexString(hashCode());
//com.api.Object类.toString.People@85ede7b 16进制的哈希码
}
}
/*输出结果：
People{name='张三', sex='男', age=16}
*/
equals()方法
-
public boolean equals(Object obj){}
-
默认实现（this == obj），比较两个对象地址是否相同。
-
可进行覆盖，比较两个对象的内容是否相同。方法覆盖：
-
比较两个引用是否指向同一个对象
-
判断obj是否为null
-
判断两个引用指向的实际对象类型是否一致
-
强制类型转换
-
依次比较各个属性值是否相同
-
Peopel:
package com.api.Object类.equals;
import java.util.Objects;
public class People {
private String name;
private String sex;
private int age;
public People() {
}
public People(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
public boolean equals(Object obj) {
//比较两个引用是否指向同一个对象
if (this == obj) return true;
//判断obj是否为null,判断两个引用指向的实际对象类型是否一致
if (obj == null || getClass() != obj.getClass()) return false;
//强制类型转换
People people = (People) obj;
//比较各个属性值是否相等
return age == people.age &&
Objects.equals(name, people.name) &&
Objects.equals(sex, people.sex);
}
//省略get、set方法
}
Test:
package com.api.Object类.equals;
public class Test {
public static void main(String[] args) {
People p1 = new People("张三","男",16);
People p2 = new People("胖丫","女",15);
System.out.println(p1.equals(p2)); //false
People p3 = new People("胖丫","女",15);
System.out.println(p2.equals(p3)); //未进行覆盖之前false，覆盖之后判断内容是否相同true
}
}
//输出结果：false true
finalize()方法
-
当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。
-
垃圾对象：没有有效引用指向此对象时，为垃圾对象。
-
垃圾回收：由GC销毁垃圾对象，释放数据存储空间
-
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
-
手动回收机制：使用System.gc(); 通知JVM执行垃圾回收。（但是JVM不一定执行，只是相当于给他提个醒）
包装类
概述：
-
基本数据类型所对应的引用数据类型
-
Object可统一所有数据类型，包装类的默认值是null
| 基本数据类型 | 包装类型 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
类型转换：
8种包装类提供不同类型间的转换方式：
-
Number父类中提供的6个共性方法
-
parseXXX()静态方法
-
valueOf()静态方法
装箱、拆箱
装箱：基本类型转换为引用类型
拆箱：引用类型转换为基本类型
Test:
package com.api.包装类.装箱拆箱;
public class Test {
public static void main(String[] args) {
int num01=10;
//类型转换：装箱：基本类型转换为引用类型的过程：两种方法
Integer integer01 = new Integer(num01); //使用Integer类创建对象
Integer integer02 = Integer.valueOf(num01); //使用Integer方法
System.out.println(integer02);
//拆箱：引用类型转换为基本类型的过程
int a=integer02.intValue();
System.out.println(a);
//JDK1.5以后可自动进行装箱拆箱 通过class文件反编译Java可以看出，过程还是上边的，只不过编译器自动调用方法了
int num02=20;
//装箱
Integer integer1=num02;
//拆箱
int b=integer1;
}
}
基本类型和字符串之间转换
Test:
package com.api.包装类.基本类型和字符串转换;
public class Test {
public static void main(String[] args) {
//基本类型转换为字符串类型
int num=100;
//方法一：使用“+”号
String a=num+"";
//方法二：
String b=Integer.toString(num);
//字符串类型转换为基本类型
String str="1000";
//使用parseXXX()方法
int c=Integer.parseInt(str);
//boolean字符串转换为基本类型 true为true 非true都是false
String str2="true";
boolean d=Boolean.parseBoolean(str2);
System.out.println(d); //true
String str3="true0";
boolean e=Boolean.parseBoolean(str3);
System.out.println(e); //false
}
}
整数缓冲区（面试题）
-
Java预先创建了256个常用的整数包装类型对象 -128~~127
-
在实际应用当中，对已创建的对象进行复用
就是堆里有一块缓冲区，存放的是-127~~128的数值，如果在这之间，就直接取，不用创建对象，所以地址是固定的
package com.api.包装类.整数缓存区;
public class Test {
public static void main(String[] args) {
Integer integer1=new Integer(100); //用构造器
Integer integer2=new Integer(100);
System.out.println(integer1==integer2); //false
Integer integer3=100; //通过对class文件进行反编译 可以看出直接转换是用的Integer.valueOf(100)
Integer integer4=Integer.valueOf(100);
System.out.println(integer3==integer4); //true
Integer integer5=200;
Integer integer6=200;
System.out.println(integer5==integer6); //false
}
}
/*
原因：
第一个是因为用的构造器，创建对象，地址不同
第二个是直接转换，调用整数缓冲区中的，100在整数缓冲区范围内，两个100地址相同
第三个，200不在整数缓冲区范围内，地址不同
*/
String类
概述：
-
字符串是常量，创建之后不可改变
-
字符串字面值存储在字符串池中，可以共享
-
String s="Hello"; //产生一个对象，字符串池中存储
-
String s=new String("Hello"); //产生两个对象，堆、池各存储一个
字符串的创建和内存分析
Test:
package com.api.String类.demo01;
public class Test {
public static void main(String[] args) {
String name="Hello";
name="张三";
String name2="张三"; //"张三"赋值给name
//字符串的另一种创建方式：new Sting()
String name3=new String("李四");
String name4=new String("李四");
}
}
内存分析：
字符串方法的使用
-
length(); 返回字符串的长度
-
charAt(int index); 返回某个位置的字符
-
contains(String str); 判断是否包含某个字符串
Test01:
package com.api.String类.字符串方法的使用;
public class Test01 {
public static void main(String[] args) {
String str="世界上最好的编程语言： java";
//length(); 返回字符串的长度
//charAt(int index); 返回某个位置的字符
//contains(String str); 判断是否包含某个字符串
System.out.println(str.length()); //返回字符串的长度 空格也算
System.out.println(str.charAt(str.length()-1)); //输出最后一个字符
System.out.println(str.contains("java")); //输出布尔值
System.out.println(str.contains("python"));
}
}
/*
16
a
true
false
*/
-
public char[] toCharArray(); 将字符串转换成数组
-
public int indexOf(String str); 查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
-
public int lastIndexOf(String str); 查找字符串在当前字符串中最后一次出现的下标索引
Test02:
package com.api.String类.字符串方法的使用;
import java.util.Arrays;
public class Test02 {
public static void main(String[] args) {
//public char[] toCharArray(); 将字符串转换成数组
//public int indexOf(String str); 查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
//public int lastIndexOf(String str); 查找字符串在当前字符串中最后一次出现的下标索引
String str="世界上最好最好最好的编程语言： java";
System.out.println(Arrays.toString(str.toCharArray())); //将字符串转换成数组
System.out.println(str.indexOf("java"));
System.out.println(str.lastIndexOf("最好"));
}
}
/*
[世, 界, 上, 最, 好, 最, 好, 最, 好, 的, 编, 程, 语, 言, ：, , j, a, v, a]
16
7
*/
-
public String trim(); 去掉字符串前后的空格
-
public String toUpperCase(); 将小写转成大写 toLowerCase() 将大写转为小写
-
public boolean endWith(String str); 判断字符串是否以str结尾
Test03:
package com.api.String类.字符串方法的使用;
public class Test03 {
public static void main(String[] args) {
//public String trim(); 去掉字符串前后的空格
//public String toUpperCase(); 将小写转成大写 toLowerCase 大写转为小写
//public boolean endWith(String str); 判断字符串是否以str结尾
String str=" java 是最好的PROGRAMMING LANGUAGE";
System.out.println(str.trim()); //只是前后的空格，不是所有的空格
System.out.println(str.toUpperCase());
System.out.println(str.toLowerCase());
System.out.println(str.endsWith("GE")); //true
}
}
/*
java 是最好的PROGRAMMING LANGUAGE
JAVA 是最好的PROGRAMMING LANGUAGE
java 是最好的programming language
true
*/
-
public String replace(char oldChar,char newChar); 将旧字符串替换成新字符串
-
public String[] split(String str); 根据str做拆分
package com.api.String类.字符串方法的使用;
public class Test04 {
public static void main(String[] args) {
//public String replace(char oldChar,char newChar); 将旧字符串替换成新字符串
//public String[] split(String str); 根据str做拆分
String str="java 是 最好的 编程 语言";
System.out.println(str.replace("java", "python"));
String[] arr = str.split(" ");
System.out.println(arr.length);
for (String s : arr) {
System.out.println(s);
}
}
}
/*
python 是 最好的 编程 语言
5
java
是
最好的
编程
语言
*/
equals()方法：
Test05:
package com.api.String类.字符串方法的使用;
public class Test05 {
public static void main(String[] args) {
String str01="hello";
String str02="HELLO";
System.out.println(str01.equals(str02)); //false
System.out.println(str01.equalsIgnoreCase(str02)); //忽略大小写 true
}
}
案例：
-
已知 String str="this is a test";
-
1 将str中的单词单独获取出来
-
2 将str中的text替换为practice
-
3 在text前面插入一个easy
-
4 将每个单词的首字母改为大写
package com.api.String类.字符串方法的使用;
public class Test {
public static void main(String[] args) {
//已知 String str="this is a test";
//1 将str中的单词单独获取出来
//2 将str中的text替换为practice
//3 在text前面插入一个easy
//4 将每个单词的首字母改为大写
String str="this is a test";
String[] s = str.split(" ");
for (String s1 : s) {
System.out.println(s1);
}
System.out.println("-------------------------------");
String str2 = str.replace("test", "practice");
System.out.println(str2);
System.out.println("-------------------------------");
String str3 = str.replace("test", "easy test");
System.out.println(str3);
System.out.println("-------------------------------");
for (int i = 0; i <s.length; i++) {
char c = s[i].charAt(0);
char C = Character.toUpperCase(c);
String s1 = C + s[i].substring(1); //拼接
System.out.println(s1);
}
}
}
可变字符串：
StringBuffer:可变长字符串，JDK1.0提供，运行效率慢、线程安全。
StringBuider:可变长字符串，JDK5.0提供，运行效率快，线程不安全。
两者用法相同，单线程情况下用StringBuider
package com.api.String类.字符串方法的使用;
public class Test06 {
public static void main(String[] args) {
StringBuilder sb=new StringBuilder();
//1 append() 追加
sb.append("姓名：李四");
System.out.println(sb.toString());
sb.append(",性别：男人");
System.out.println(sb.toString());
//2 insert() 添加
sb.insert(0,"自我介绍：");
System.out.println(sb.toString());
//3 replace() 替换
sb.replace(8, 10, "张三");
System.out.println(sb);
//4 delete() 删除
sb.delete(15,16);
System.out.println(sb);
}
}
BigDecimal
思考：以下程序输出结果是多少？
package com.api.BigDecimal;
public class Test {
public static void main(String[] args) {
double a=1.0;
double b=0.9;
System.out.println(a-b);
float c=1.0f;
float d=0.9f;
System.out.println(c-d);
}
}
输出结果：
0.099999999999999980.100000024
float和double属于近似值存储，如果需要特别精确的运算，比如银行，float和double不符合要求，需要借助：BigDecimal
BigDecimal：
-
位置：java.math包中
-
作用：精确计算浮点数
-
创建方式：BigDecimal bd=new BigDecimal("1.0");
-
方法：
-
BigDecimal add(BigDecimal bd) 加
-
BigDecimal subtract(BigDecimal bd) 减
-
BigDecimal multiply(BigDecimal bd) 乘
-
BigDecimal divide(BigDecimal bd) 除
-
package com.api.BigDecimal;
import java.math.BigDecimal;
public class Test02 {
public static void main(String[] args) {
BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
//减法
BigDecimal subtract = bd1.subtract(bd2);
System.out.println(subtract);
//加法
BigDecimal add = bd1.add(bd2);
System.out.println(add);
//乘法
BigDecimal multiply = bd1.multiply(bd2);
System.out.println(multiply);
//除法
BigDecimal divide = bd1.divide(bd2,2,BigDecimal.ROUND_HALF_DOWN);
System.out.println(divide); //除不尽的话 报错 但是可以选择保留几位小数，4舍5入
}
}
Date
Data表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代。
一下是还没有被取代、没有过时的方法
package com.api.Date;
import java.util.Date;
public class Test {
public static void main(String[] args) {
//创建Date对象
//今天
Date date = new Date();
System.out.println(date.toString());
System.out.println(date.toLocaleString());
//昨天
Date date1 = new Date(date.getTime() - (24 * 60 * 60 * 1000));
System.out.println(date1.toLocaleString());
//方法：after和before
boolean after = date.after(date1);
System.out.println(after); //true 今天比昨天晚
boolean before = date.before(date1);
System.out.println(before); //false
//比较CompareTo() 比较的是：毫秒值 结果就只是-1，0，1
int i = date.compareTo(date1);
System.out.println(i);
//equals 比较是否相等
boolean equals = date.equals(date1);
System.out.println(equals);
}
}
/*
Tue Apr 26 19:15:05 CST 2022
2022年4月26日 下午7:15:05
2022年4月25日 下午7:15:05
true
false
1
false
*/
Calendar类
-
Calendar提供了获取或设置各种日历字段的方法。
-
构造方法：protected Calendar() :由于修饰符是protected（受保护的），所以无法直接创建该对象。
-
其他方法：
方法名 说明 static Calendar getInstance() 使用默认时区和区域获取日历 void set(int year,int month,int date,int hourofday,int minute,int second) 设置日历的年、月、日、时、分、秒 int setTime(Date date) 用给定的Date设置此日历的时间。Date-Calendar Date getTime() 返回一个Date表示此日历的时间。Calendar-Date void add(int field,int amount) 按照日历的规则，给指定字段添加或减少时间量 long getTimelnMillies() 毫秒为单位返回改日历的时间值
package com.api.Calendar类;
import java.util.Calendar;
public class Test {
public static void main(String[] args) {
//1.创建Calendar对象
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString());
System.out.println(calendar.getTimeInMillis()); //毫秒数
//2.获取时间信息
int year = calendar.get(Calendar.YEAR); //获取年
int month = calendar.get(Calendar.MONTH); //获取月 0~11
int date = calendar.get(Calendar.DATE); //获取日
int hour = calendar.get(Calendar.HOUR_OF_DAY); //获取小时 HOUR_OF_DAY:24小时 HOUR：12小时
int minute = calendar.get(Calendar.MINUTE); //获取分钟
int second = calendar.get(Calendar.SECOND); //获取秒
System.out.println(year+"年"+(month+1)+"月"+date+"日"+hour+"时"+minute+"分"+second+"秒");
//3.修改时间
calendar.set(Calendar.DATE,9);
System.out.println(calendar.getTime().toLocaleString());
//4.add()方法修改时间
calendar.add(Calendar.HOUR_OF_DAY,3);
System.out.println(calendar.getTime().toString());
//5.补充方法，获取一个月份的最大天数和最小天数
calendar.set(Calendar.YEAR,2021);
calendar.set(Calendar.MONTH,1);
System.out.println(calendar.getTime().toLocaleString());
int maximum = calendar.getActualMaximum(Calendar.DATE);
int minimum = calendar.getActualMinimum(Calendar.DATE);
System.out.println(maximum);
System.out.println(minimum);
}
}
/*
2022年4月26日 下午7:14:17
1650971657160
2022年4月26日19时14分17秒
2022年4月9日 下午7:14:17
Sat Apr 09 22:14:17 CST 2022
2021年2月9日 下午10:14:17
28
1
*/
SimpleDateFormat类
-
SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
-
进行格式化（日期—>文本） 解析（文本—>日期）
-
常用的时间模式字母
字母 日期或时间 示例 y 年 2022 M 月 04 d 日 26 H 小时 19 m 分钟 13 s 秒 50 S 毫秒 369
package com.api.simpleDateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Tset {
public static void main(String[] args) throws ParseException {
//创建simpleDateFormat 对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
//创建Date
Date date = new Date();
//格式化date（把日期转换为字符串）
String format = sdf.format(date);
System.out.println(format);
//解析（把字符串换成日期）
Date parse = sdf.parse("2100年12月6日 10:08:00");
System.out.println(parse);
}
}
/*
2022年04月26日 19:13:53
Mon Dec 06 10:08:00 CST 2100
*/
System类
System系统类。主要用于获取系统的属性数据和其他操作，构造方法私有的
| 方法名 | 说明 |
|---|---|
| static void arraycopy(...) | 复制数组 |
| static long currentTimeMillis(); | 获取当前系统时间，返回的是毫秒数（一般可以用作计算程序运行用了多长时间） |
| static void gc() | 建议JVM赶快启动垃圾回收器回收垃圾 |
| static void exit(int status) | 退出JVM，如果参数是0表示正常退出jvm，非0表示异常退出jvm |
Test：
package com.api.System;
public class Test {
public static void main(String[] args) {
int[] a={1,2,3,4,5,6,7,8,9};
int[] b=new int[10];
//src:源数组
//srcPos:从那个位置开始复制 （0就是从开头就开始）
//dest:目标数组
//destPos:目标函数的位置
//length:复制原数组的长度
System.arraycopy(a,0,b,1,a.length);
for (int i : b) {
System.out.println(i);
}
System.out.println("---------------------");
long start=System.currentTimeMillis();
for (int i = 0; i <1000000 ; i++) {
i=i+1;
}
long end=System.currentTimeMillis();
System.out.println(end-start);
}
}
