内部クラス
メンバー内部クラス、静的内部クラス、ローカル内部クラス、匿名内部クラス
概念: クラス内で完全なクラスを定義する
特徴：
- コンパイル後、独立したバイトコード ファイルを生成できます。
- 内部クラスは、カプセル化を破ることなく、外部クラスのプライベート メンバーに直接アクセスできます。
- 必要な内部機能コンポーネントを外部クラスに提供します
//身体
public class Body {
private String name;
//头部
class Header{
//也会生成class文件 同时生成构造函数
//可以直接访问外部类私有成员
public void showName(){
System.out.println(name);
}
}
}
メンバーの内部クラス
- クラス内に定義される、インスタンス変数やインスタンスメソッドと同レベルのクラス
- 外部クラスのインスタンス部分。内部クラス オブジェクトを作成するときは、外部クラス オブジェクトに依存する必要があります。
- 外部クラスと内部クラスに同名の属性が存在する場合、内部クラスの属性が先にアクセスされます。
- 静的メンバーはメンバーの内部クラスで定義できず、静的定数 (最終)を含めることができます。
//外部类
public class Outer {
//实例变量
private String name = "张三";
private int age = 20;
//内部类
class Inner{
private String address = "北京";
private String phone = "110";
private String name = "李四";
//方法
public void show(){
//打印外部类属性 此时有重名属性name
System.out.println(Outer.this.name); // 张三
System.out.println(age);
//打印内部类中的属性
System.out.println(name); // 李四
System.out.println(address);
System.out.println(phone);
}
}
}
public class TestOuter {
public static void main(String[] args) {
// 创建外部类对象
Outer outer = new Outer();
// 创建内部类对象
Outer.Inner inner = outer.new Inner();
//一步到位
Outer.Inner inner1 = new Outer().new Inner();
inner1.show();
}
}
静的内部クラス
- 外部クラス オブジェクトに依存せず、直接作成またはクラス名を通じてアクセスでき、静的メンバーを宣言できます。
//外部类
public class Outer {
private String name = "张三";
private int age = 18;
//静态内部类，和外部类相同
static class Inner {
private String address = "上海";
private String phone = "110";
//静态成员
private static int count = 1000;
public void show() {
//调用外部类属性
//1.先创建外部类对象
Outer outer = new Outer();
//2.调用外部类对象的属性
System.out.println(outer.name);
System.out.println(outer.age);
//调用静态内部类属性
System.out.println(address);
System.out.println(phone);
//调用静态内部类的静态属性
System.out.println(Inner.count);
}
}
//测试类
public class TestOuter {
public static void main(String[] args) {
//直接创建静态内部类对象
Outer.Inner inner = new Outer.Inner();
inner.show();
}
}
ローカル内部クラス
- 外部クラスのメソッドで定義され、スコープと作成されたオブジェクトのスコープは現在のメソッドに制限されます。
- ローカル内部クラスが外部クラスの現在のメソッド内のローカル変数にアクセスする場合、変数のライフサイクルがそれ自体と同じであることは保証できないため、変数を Final に変更する必要があります。
- クラスの使用範囲を制限する
//外部类
public class Outer {
private String name = "刘德华";
private int age = 20;
public void show() {
//定义局部变量
final String address = "深圳";
//局部内部类 注意：不可以添加任何访问修饰符
class Inner {
//局部内部类的属性
private String phone = "158";
private String email = "[email protected]";
public void show2() {
//访问外部类的属性
System.out.println(Outer.this.name);
System.out.println(Outer.this.age);
//访问内部类的属性
System.out.println(this.phone);
System.out.println(this.email);
//访问局部变量,jdk1.7要求，变量必须是常量，jdk1.8 自动添加final
System.out.println(address);
}
}
//创建局部内部类对象
Inner inner = new Inner();
inner.show2();
}
}
public class TestOuter {
public static void main(String[] args) {
Outer outer = new Outer();
outer.show();
}
}
匿名内部クラス
- クラス名のないローカル内部クラス (すべての特性はローカル内部クラスと同じです)
- 親クラスを継承するか、インターフェイスを実装する必要があります
- クラスの定義、クラスの実装、オブジェクトの作成の構文が統合され、このクラスのオブジェクトは 1 つだけ作成できます。
- 利点: コードの量を削減します。
- デメリット：可読性が低い
//接口
public interface USB {
//服务
void service();
}
public class Mouse implements USB{
@Override
public void service() {
System.out.println("连接电脑成功，鼠标开始工作");
}
}
public class TestUsb {
public static void main(String[] args) {
//创建一个接口类型的变量
USB usb = new Mouse();
usb.service();
//局部内部类
class Fan implements USB {
@Override
public void service() {
System.out.println("连接电脑成功，风扇开始工作");
}
}
//使用局部内部类创建对象
USB usb = new Fan();
usb.service();
}
匿名内部クラス
public class TestUsb {
//使用匿名内部类(相当于创建了一个局部内部类)
USB usb = new USB() {
@Override
public void service() {
System.out.println("连接电脑成功，风扇开始工作");
}
};
usb.service();
}
オブジェクトクラス
- スーパー クラス、基本クラス、すべてのクラスの直接的または間接的な親クラス。継承ツリーの最上位に位置します。
- 特定のクラスを継承することを示す「extends」を記述していないクラスは、デフォルトで Object クラスから直接継承します。それ以外の場合は、間接的に継承されます。
- Object クラスで定義されるメソッドは、すべてのオブジェクトが持つメソッドです。
- オブジェクト型は任意のオブジェクトを格納できます
- パラメータとして、任意のオブジェクトを受け入れることができます
- 戻り値として任意のオブジェクトを返すことができます
getClassメソッド
public final Class<?> getClass(){}- 参照に格納されている実際のオブジェクト タイプを返します。
- 用途: 通常、2 つの参照に実際に格納されているオブジェクト タイプが一致しているかどうかを判断するために使用されます。
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("aaa", 20);
Student s2 = new Student("bbb", 30);
//判断s1和s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
if (class1 == class2) {
System.out.println("s1和s2属于同一个类型");
} else {
System.out.println("s1和s2不属于同一个类型");
}
}
}
hashCodeメソッド
public int hashCode(){}- このオブジェクトのハッシュ コード値を返します。
- ハッシュ値は、オブジェクトのアドレスまたは文字列または数値に基づいてハッシュアルゴリズムを使用して計算される int 型の値です。
- 一般に、同じオブジェクトは同じハッシュ コードを返します。
//hashCode方法
Student s3=s1;
System.out.println(s1.hashCode());//356573597
System.out.println(s2.hashCode());//1735600054
System.out.println(s3.hashCode());//356573597
toString メソッド
public String toSring(){}- このオブジェクトの文字列表現 (表現) を返します。
- このメソッドは、次のようなプログラム要件に従ってオーバーライドできます。 オブジェクトの各属性値を表示する
//3. toString方法
System.out.println(s1.toString());//Demo07.Student@1540e19d
System.out.println(s2.toString());//Demo07.Student@677327b6
//原码
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
イコールメソッド
public boolean equals(Object obj){}- デフォルトの実装は (this == obj) で、2 つのオブジェクトのアドレスが同じかどうかを比較します。
- 2 つのオブジェクトの内容が同じかどうかを比較するために上書き可能
//4. equals方法 判断两个对象是否相等
System.out.println(s1.equals(s2)); // false
Student s4 = new Student("小明", 17);
Student s5 = new Student("小明", 17);
System.out.println(s4.equals(s5)); // false 堆中地址不同
// 重写 改变其比较内容
/*
步骤 1. 比较两个应用是否指向同一个对象
2. 判断obj是否为null
3. 判断两个引用只想的实际对象类型是否一致
4. 强制类型转换
5. 依次比较各个属性值是否相同
*/
@override
public boolean equals(Object obj){
// 1.
if(this == obj){
return true;
}
// 2.
if(obj == null){
return false;
}
// 3.
// if(this.getClass() == obj.getClass()){
//
// }
// instanceof 判断对象是否是某种类型
if(obj instanceof Student){
// 4.强制类型转换
Student s = (Student)obj;
// 5. 比较属性
if(this.name.equals(s.getName()) && this.age == s.getAge()){
return true;
}
}
return false;
}
ファイナライズメソッド
- オブジェクトがガベージ オブジェクトであると判断されると、JVM によってこのメソッドが自動的に呼び出され、ガベージ オブジェクトにマークが付けられ、リサイクル キューに入れられます。
- ガベージ オブジェクト: このオブジェクトを指す有効な参照がない場合、それはガベージ オブジェクトです。
- ガベージ コレクション: ガベージ オブジェクトは gc によって破棄され、データ ストレージ領域が解放されます。
- 自動リサイクルメカニズム: JVM のメモリが使い果たされ、すべてのガベージオブジェクトが一度にリサイクルされます。
- 手動リサイクル メカニズム: **System.gc();** を使用して、JVM にガベージ コレクションを実行するように通知します。
@Override
protected void finalize() throws Throwable{
sout(this.name + "对象被回收了");
}
//测试类
public class TestStudent2 {
public static void main(String[] args) {
Student s1 = new Student("aaa", 29); // 不是垃圾
Student s2 = new Student("bbb", 29); // 不是垃圾
Student s3 = new Student("ccc", 29); // 不是垃圾
Student s4 = new Student("ddd", 29); // 不是垃圾
Student s5 = new Student("eee", 29); // 不是垃圾
new Student("bbb", 30); // 是垃圾 会被回收
//回收垃圾
System.gc();
System.out.println("回收垃圾");
// 打印出 “回收垃圾
// bbb对象被回收了
}
}
包装
- 基本データ型に対応する参照データ型
- オブジェクトはすべてのデータを統合でき、ラッパー クラスのデフォルト値は null です。
- 基本型とローカル変数はスタック領域に存在し、参照型はヒープ領域を格納します。
| 基本的なデータ型 | 梱包の種類 |
|---|---|
| バイト | バイト |
| 短い | 短い |
| 整数 | 整数 |
| 長さ | 長さ |
| 浮く | 浮く |
| ダブル | ダブル |
| ブール値 | ブール値 |
| 文字 | キャラクター |
型変換、ボックス化、およびボックス化解除
-
8 つのラッパー クラスは、異なる型間の変換メソッドを提供します
-
Number 親クラスで提供される 6 つの一般的なメソッド
-
parseXXX( )静的メソッド -
valueOf( )静的メソッド
-
-
-
注: 型の互換性を確保する必要があります。そうでない場合は、NumberFormatException がスローされます。
psvm(String[] args){
// 装箱， 基本类型 → 引用类型（对象） 栈->堆
// 基本类型
int num1 = 18;
// 使用Integer类创建对象
Integer integer1 = new Integer(num1);
Integer integer2 = Integer.valueOf(num1);
// 拆箱， 引用类型 → 基本类型 堆->栈
Integer integer3 = new Integer(100);
int num2 = integer3.intValue();
// 上述为jdk1.5之前方法，之后提供了自动装箱拆箱
int age = 30;
// 自动装箱
Integer integer4 = age;
// 自动拆箱
int age2 = integer4;
// 基本类型和字符串之间转换
// 1. 基本类型转成字符串
int n1 = 100;
// 1.1 使用+号
String s1 = n1 + "";
// 1.2 使用Integer中的toString()方法
String s2 = Integer.toString(n1);
String s2 = Integer.toString(n1, x); // x为进制要求
String s3 = Integer.toBinaryString(n1);//转换成二进制
// 2. 字符串转成基本类型
String str = "150";
// 使用Integer.parseXXX();
int n2 = Integer.parseInt(str);
// boolean 字符串形式转成基本类型，"true" ---> true 非“true ———> false
String str2 = "true";
boolean b1 = Boolean.parseBoolean(str2);
}
整数バッファ
- Java は、一般的に使用される 256 個の証明書パッケージ タイプ オブジェクトを事前に作成します
- 実際のアプリケーションでは、作成したオブジェクトを再利用する
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;// 自动装箱
// 相当于调用 Integer.valueOf(100);
Integer integer4 = 100;
System.out.println(integer3 == integer4);//true
Integer integer5 = 200;// 自动装箱
Integer integer6 = 200;
System.out.println(integer5==integer6);//false
//valueOf 方法
// 因为缓存区数组 [-128, 127] 在这之内地址一样
// 不在cache数组区间内 则 new Integer(i);
/*
public static Integer valueOf(int i) {
if (i >= Integer.IntegerCache.low && i <= Integer.IntegerCache.high)
return Integer.IntegerCache.cache[i + (-Integer.IntegerCache.low)];
return new Integer(i);
}
*/
}
文字列クラス
- 文字列は定数であり、作成後に変更することはできません。
- 文字列リテラルは文字列プールに保存され、共有できます
String s = "Hello";オブジェクトを生成し、文字列プールに保存します。String s = new String("Hello");ヒープ用とプール用の2 つのオブジェクトを生成します。
public static void main(String[] args) {
//产生一个对象，字符串池中存储
String name = "hello";//"hello" 常量存储在字符串池中
//不可变性
name = "zhansgan"; // "张三"赋值给name,给字符串赋值是没有修改数据
//不是将字符串池中"hello"的值更改，而是重新在字符串池中开辟新的空间
System.out.println(name);
String name2 = "zhangsan";//指向原来字符串池中的"zhansgan"
//字符串字面值存储在字符串池中，可以共享
//演示字符串的另一种创建方式
// 产生两个对象，堆、池各一个
String str1 = new String("java");
String str2 = new String("java");
System.out.println(str1==str2);//false
}
一般的な方法
public class Demo11 {
public static void main(String[] args) {
// 1. length(); 返回字符串长度
// 2. charAt(int index); 返回某个位置的字符
// 3. contains(String str); 判断是否包含某个字符串
String content = "java是最好的语言";
System.out.println(content.length());//10
System.out.println(content.charAt(1));//a
System.out.println(content.contains("java"));//true
// 4. toCharArray(); 返回字符串对应数组
// 5. indexOf(); 返回子字符串首次出现的位置
// 6. lastIndexOf(); 返回字符串最后一次出现的位置
char[] str = content.toCharArray();
System.out.println(str[1]);//a
System.out.println(content.toCharArray());//java是最好的语言
System.out.println(Arrays.toString(content.toCharArray()));//[j, a, v, a, 是, 最, 好, 的, 语, 言]
System.out.println(content.indexOf("ava"));//1
System.out.println(content.indexOf("ava", 4));//从索引4开始找 返回-1
System.out.println(content.lastIndexOf("java"));//0
// 7. trim(); //去掉字符串前后空格
// 8. toUpperCase(); toLowerCase(); 转换大小写
// 9. endWith(str); startWith(str); 判断是否以str 结尾、开头
String ct = " hello world ";
System.out.println(ct.trim());//hello world
System.out.println(ct.toUpperCase());// HELLO WORLD
System.out.println(ct.toLowerCase());// hello world
System.out.println(ct.endsWith("world "));//true
System.out.println(ct.startsWith(" hello"));//true
// 10. replace(char old, char new); 用心的字符或字符串替换旧的字符或字符串
// 11. split(); 对字符串拆分
System.out.println(ct.replace("hello", "fuck"));// fuck world
String say = "java is the best language";
String[] arr = say.split(" ");// "[ ,]+" 表示空格 逗号切分 +号表示切分可以多个 比如多个空格
for (String s : arr) {
System.out.println(s);
}
/* 打印
java
is
the
best
language
*/
// 补充两个equals/compareTo();比较大小
String s1 = "hello";
String s2 = "HELLO";
System.out.println(s1.equals(s2));//false
System.out.println(s1.equalsIgnoreCase(s2));// 忽略大小写比较true
// compareTo(); 两字符不同时比较字符字典序的ascii码
// 字符相同时比较长度 返回差值
String s3 = "abc";//97
String s4 = "xyzaa";//120
System.out.println(s3.compareTo(s4));//-23
String s5 = "abc";//97
String s6 = "abcxyz";//120
System.out.println(s5.compareTo(s6));//-3,比较长度
}
}
事例紹介
必要：
- 既知の文字列 str = “これはテキストです”;
- str 内の単語を個別に取得する
- str 内のテキストを練習に置き換えます
- 前に簡単なテキストを挿入する
- 各単語の最初の文字を大文字にします
public class Demo12 {
public static void main(String[] args) {
//1.将str中的单词单独获取
String str = "this is a text";
String[] arr = str.split(" ");
for (String s : arr) {
System.out.println(s);
}
//2.将str中的text替换成practice
String str2 = str.replace("text", "practice");
System.out.println(str2);//this is a practice
//3.在text前面插入一个easy
String str3 = str.replace("text", "easy text");
System.out.println(str3);//this is a easy text
//4.将每个单词的首字母改为大写
for (int i = 0; i < arr.length; i++) {
char first = arr[i].charAt(0);
char upperFirst = Character.toUpperCase(first);
String news = upperFirst + arr[i].substring(1); //substring 截取，开始脚标
System.out.print(news + " ");//This Is A Text
}
}
}
可変文字列
- StringBuffer: 可変長文字列、動作が遅い、スレッドセーフ
- StringBuilder: 文字列を拡張でき、高速に実行され、スレッドセーフではありません
- 文字列との違い
- 文字列よりも効率的
- 文字列よりもメモリを節約します
public static void main(String[] args) {
// StringBuffer 和 StringBuilder 用法一致
StringBuffer sb = new StringBuffer();
// 1. append(); 追加
sb.append("java");
System.out.println(sb.toString());//java
// 2. insert(); 添加、插入
sb.insert(0, "在第一个位置插入");
System.out.println(sb.toString());//在第一个位置插入java
// 3.replace(); 替换
sb.replace(0, 3, "hello"); // 左闭右开
System.out.println(sb.toString());//hello个位置插入java
// 4. delete(); 删除
sb.delete(0, 5); // 左闭右开
System.out.println(sb.toString());
// 5. 反转
sb.reverse();
System.out.println(sb.toString());
// 6. 清空
sb.delete(0, sb.length());
System.out.println(sb.toString());
}
時間効率の分析
//开始时间
long start = System.currentTimeMillis();
String string = "";
for (int i = 0; i < 9999; i++) {
string += i+" ";
}
System.out.println(string);
long end = System.currentTimeMillis();
System.out.println("用时："+(end-start));//用时：514
long start2 = System.currentTimeMillis();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 9999; i++) {
sb.append(i);
}
System.out.println(sb.toString());
long end2 = System.currentTimeMillis();
System.out.println("用时："+(end2-start2));//用时：2
BigDecimal クラス
java.mathパッケージ内の場所- 浮動小数点数を正確に計算する関数
- 作成方法
BigDecimal bd = new BigDecimal("1.0");
public static void main(String[] args) {
double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1 - d2);//0.09999999999999998
//面试题
double result = (1.4 - 0.5) / 0.9;
System.out.println(result);//0.9999999999999999
//BigDecimal ,大的浮点数精确计算
BigDecimal bd1 = new BigDecimal("1.0");//需要用字符串
BigDecimal bd2 = new BigDecimal("0.9");
// 减法
BigDecimal r1 = bd1.subtract(bd2);
System.out.println(r1);//0.1
//加法
BigDecimal r2 = bd1.add(bd2);
System.out.println(r2);
//乘法
BigDecimal r3 = bd1.multiply(bd2);
System.out.println(r3);
//除法
BigDecimal r4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));
System.out.println(r4);
//除不尽时 x填保留位数 后面为四舍五入之意
BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_EVEN);//3.33
System.out.println(r5);
}
データクラス
- 日付は特定の瞬間をミリ秒単位の精度で表します。Date クラスのメソッドのほとんどは、Calendar クラスのメソッドに置き換えられました。
- 時間単位: 1s = 1,000ms = 1,000,000μs = 1,000,000,000 = ns
public static void main(String[] args) {
// 1 创建Date对象
//今天
Date date1 = new Date();
System.out.println(date1.toString());//Fri Jan 06 21:15:33 CST 2023
System.out.println(date1.toLocaleString());//2023-1-6 21:16:01
//昨天
Date date2 = new Date(date1.getTime()-1000*60*60*24);
System.out.println(date2.toLocaleString());//2023-1-5 21:17:08
// 2 方法after before
boolean b1 = date1.after(date2);
System.out.println(b1);//true
boolean b2 = date1.before(date2);
System.out.println(b2);//false
// 比较compareTo();
int d = date1.compareTo(date2);
System.out.println(d); // 多的为1 少的为 -1
// 比较是否相等 equals()
boolean b3 = date1.equals(date2);
System.out.println(b3); // false
}
カレンダークラス
- カレンダーには、さまざまなカレンダー フィールドを取得または設定するメソッドが用意されています
- コンストラクターは
protected Calendar();保護されているため、直接作成できません。 - その他の方法
| メソッド名 | 説明する |
|---|---|
| 静的カレンダー getInstance() | デフォルトのタイムゾーンと地域を使用してカレンダーを取得する |
| void set(int 年、int 月、int 日付、int 時間、int 分、int 秒) | カレンダーの年、月、日、時、分、秒を設定します |
| int get(intフィールド) | 指定されたカレンダーフィールドの値を返します。年、月、日などのフィールド |
| void setTime(日付日付) | このカレンダー時刻を指定された日付で設定します |
| 日付 getTime() | このカレンダーの時刻を表す日付を返します |
| void add(int フィールド, int 量) | カレンダーのルールに従って、指定されたフィールドに時間を加算または減算します。 |
| 長い getTimeInMiles() | このカレンダーの時間値をミリ秒単位で返します。 |
public static void main(String[] args) {
// 1. 创建 Calendar 对象
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString());//2023-1-6 21:50:13
System.out.println(calendar.getTimeInMillis());//1673013029291
// 2. 获取时间信息
// 获取年
int year = calendar.get(Calendar.YEAR);//2023
// 获取月 从 0 - 11
int month = calendar.get(Calendar.MONTH);//0
// 日
int day = calendar.get(Calendar.DAY_OF_MONTH);//6
//小时
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);
//2023年01月6日 21:55:36
System.out.println(year + "年" + month + 1 + "月" + day + "日 " + hour + ":" + minute + ":" + second);
// 3. 修改时间
Calendar calendar2 = Calendar.getInstance();
calendar2.set(Calendar.DAY_OF_MONTH, 5);
System.out.println(calendar2.getTime().toLocaleString());//2023-1-5 21:57:02
// 4. add修改时间
calendar2.add(Calendar.HOUR, 1); // x为正就加 负就减
System.out.println(calendar2.getTime().toLocaleString());//2023-1-5 22:57:40
// 5. 补充方法
int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);// 月数最大天数 31
int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);//1
}
SimpleDateFormat クラス
- SimpleDateFormat は、ロケールに依存した方法で日付の書式設定と解析を行うための具象クラスです。
- フォーマット（日付→テキスト）、解析（テキスト→日付）
- よく使用される時間パターン文字
| 手紙 | 日付または時刻 | 例 |
|---|---|---|
| y | 年 | 2019年 |
| 08 | 年の真ん中の月 | 08 |
| d | 月の日 | 10 |
| H | 時間 (0 ～ 23) | 22 |
| メートル | 分 | 16 |
| s | 2番 | 59 |
| S | ミリ秒 | 356 |
public static void main(String[] args) {
// 1. 创建对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd");
// 2. 创建Date
Date date = new Date();
// 格式化date（日期→字符串）
String str = sdf.format(date);
System.out.println(str);//2023年01月06日 22:07:41
// 解析（字符串→时间）
Date date2 = null;
try {
date2 = sdf.parse("2001年2月24日 10:24:55");
} catch (ParseException e) {
e.printStackTrace();
}
System.out.println(date2);//Sat Feb 24 10:24:55 CST 2001
}
システムクラス
- 主にシステム属性データの取得やその他の操作に使用され、構築メソッドはプライベートです
| メソッド名 | 説明する |
|---|---|
| 静的無効配列コピー(…) | 配列をコピーする |
| 静的長い currentTimeMillis(); | 現在のシステム時刻を取得し、ミリ秒値を返します。 |
| 静的 void gc(); | jvm がガベージ コレクション期間をすぐに開始してガベージを収集することをお勧めします。 |
| static void exit(int status); | Exit jvm. パラメータが 0 の場合は jvm を正常に終了し、0 以外の場合は異常終了を意味します。 |
public static void main(String[] args) {
//1. arraycopy 数组的复制
//src-原数组 srcPos-从哪个位置开始复制0 dest-目标数组 destPos-目标数组的位置 length-复制的长度
int[] arr = {
20, 18, 15, 8, 35, 26, 45, 90};
int[] dest = new int[8];
//System.arraycopy(src, srcPos, dest, destPos, length);
System.arraycopy(arr, 0, dest, 0, arr.length - 1);
for (int i : dest) {
System.out.print(i + " ");
}
//20 18 15 8 35 26 45 0
// Arrays.copyOf(original, newLength)
System.out.println(System.currentTimeMillis());//1673014964891
//2. currentTimeMillis()
long start = System.currentTimeMillis();
for (int i = 0; i < 999999; i++) {
for (int j = 0; j < 999999; j++) {
int result = i+j;
}
}
long end = System.currentTimeMillis();
System.out.println("用时："+(end-start));//用时：10
//3. gc() 垃圾回收期器回收垃圾
System.gc();
//4. exit() 退出jvm 如果参数是0表示正常退出jvm 非0表示异常退出
System.exit(0);
System.out.println("---程序结束---");
}