Java部分集合以及部分常用类-CSDN博客

本文链接：https://blog.csdn.net/Lalune_YM/article/details/125516304

学习内容：

集合
1.1 Collection接口
1.2 List接口
1.3 Set接口
1.4 Map接口
常用类
2.1 Object
2.2 String
2.3 StringBuilder和StringBuffer
2.4 System
2.5 Date

学习笔记：

1.集合

在这里插入图片描述
在程序中可以通过数组来保存多个对象，但在某些情况下开发人员无法预先确定需要保存对象的个数，此时数组将不再适用，因为数组的长度不可变。为了在程序中可以保存这些数目不确定的对象，JDK中提供了一系列特殊的类，这些类可以存储任意类型的对象，并且长度可变，在Java中这些类被统称为集合。
集合类都位于java.util包中，在使用时一定要记得导包，否则会出现异常。

集合与数组的区别：

	长度	内容	数据类型
数组	长度固定	储存的同一类型的元素	数组可以储存基本数据类型，也可以储存引用数据类型
集合	长度可变	可以储存不同类型的元素	只能存储引用类型

1.1Collection接口

概述：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是List和Set。其中，List的特点是元素有序、元素可重复。Set的特点是元素无序，而且不可重复。List接口的主要实现类有ArrayList和LinkedList，Set接口的主要实现类有HashSet和TreeSet。
添加功能：
- add( )添加一个元素
- addAll( )将集合的全部元素添加到原集合元素后返回true
删除功能：
- clear( )移除所有元素
- remove( )移除一个元素
- removeAll（）移除一个集合的元素，只要有一个被移除就返回true，改变原集合，删除原集合中和c中相同的元素
判断功能：
- contain( )判断集合中是否包含指定的元素。
- containsAll( )判断原集合中是否包含指定集合的所有元素，有则true，
- isEmpty( )判断集合是否为空
获取功能：
- iterator( )迭代器，集合的专用方式，实现遍历的功能
- size( )元素的个数
- retainAll( )取两个集合的交集
- toArray( ) 把集合转成数组，可以实现集合的遍历

1.2List接口

概述：有序的 collection（也称为序列/线性表）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。与 set 不同，列表通常允许重复的元素。
List接口是Collection接口的一个子接口，List集合的特性是：有序，可重复，元素有索引，List接口有三个实现类：
- ArrayList：底层数据结构是数组，查询快，增删慢，非线程安全，效率高，数据增长为原来的50%
- Vector：底层数据结构是数组，查询快，增删慢，线程安全，效率低，数据增长为原来的一倍
- LinkedList：底层数据结构是链表，查询慢，增删快，非线程安全，效率高

Vector

底层数据结构是数组，查询快，增删慢，线程安全，效率低。
Vector类特有功能
- public void addElement(E obj)：添加元素
- public E elementAt(int index)：根据索引获取元素
- public Enumeration elements()：获取所有的元素

ArrayList

底层数据结构是数组，查询快，增删慢，线程不安全，效率高。

LinkedList

与ArrayList基于数组结构不同的是，LinkedList是基于链表的结构，因此具有链表特有的功能

方法声明	功能描述
addFirst()	在集合的第0个位置添加元素
addLast()	在集合的最后位置添加元素
getFirst()	获取集合的第0个元素
getLast()	获取集合的最后一个元素
removeFirst()	删除集合的第0个元素
removeLast()	删除集合的最后一个元素

1.3Set接口

概述：一个不包含重复元素的 collection，无序。
哈希表确定元素是否相同

判断的是两个元素的哈希值是否相同。
如果相同，再判断两个对象的内容是否相同。
判断哈希值相同，其实判断的是对象的HashCode方法。判断内容相同，用的是equals方法。

HashSet

不保证 set 的迭代顺序，特别是它不保证该顺序恒久不变。
HashSet如何保证元素唯一性
底层数据结构是哈希表(元素是链表的数组)
哈希表依赖于哈希值存储
添加功能底层依赖两个方法：int hashCode()、boolean equals(Object obj)
因为HashSet是Set类的子类，而Set类是Collection的子类，即hashCode的基本方法继承了Collection方法，
集合使用格式：

Set<T>  对象名=new  HashSet<T>();  //T是数据类型
HashSet   对象名=new   HashSet<T>();

LinkedHashSet

元素有序唯一，哈希表和链表实现Set接口，具有可预测的迭代次序，由链表保证元素有序，由哈希表保证元素唯一。
集合创建对象格式：

Set<T>  集合名=new LinkHashSet<T>();  //T是数据类型

LinkHashSet <T>   集合名=new  LinkHashSet<T>()；

集合的基本用法与Hashset用法基本一致

TreeSet

使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。
不能用普通的for循环遍历，可以用加强for或迭代器iterator，因为没有索引的方法。
创建对象格式：

Set<T>  集合名=new  TreeSet<T>();  //  T表示数据类型

TreeSet<T>  集合名=new TreeSet<T>();

1.4Map接口

概述：双列集合类的根接口，用于存储具有键(Key)、值(Value)映射关系的元素，每个元素都包含一对键值，在使用Map集合时可以通过指定的Key找到对应的Value，例如根据一个学生的学号就可以找到对应的学生。Map接口的主要实现类有HashMap和TreeMap。
将键映射到值的对象，一个映射不能包含重复的键，每个键最多只能映射到一个值。其实Map集合中存储的就是键值对。map集合中必须保证键的唯一性。
Map接口和Collection接口的不同：
- Map是双列的,Collection是单列的
- Map的键唯一,Collection的子体系Set是唯一的
- Map集合的数据结构值针对键有效，跟值无关
- Collection集合的数据结构是针对元素有效
Map常用的子类：
- Hashtable：内部结构是哈希表，是同步的。不允许null作为键，null作为值。
- Properties：用来存储键值对型的配置文件的信息，可以和IO技术相结合。
- HashMap：内部结构式哈希表，不是同步的。允许null作为键，null作为值。
- TreeMap：内部结构式二叉树，不是同步的。可以对Map结合中的键进行排序。
- HashSet实现Set接口，由哈希表（实际上是一个HashMap实例）支持。
接口常用方法：

方法声明	功能描述
put(K key, V value)	有添加和替换功能
putAll(Map m)	添加一个Map的元素
clear()	清空集合
remove(Object key)	根据键删除一个元素
containsKey()	判断集合是否包含指定的键
containsValue()	判断集合是否包含指定的值
isEmpty()	判断集合是否为空
get(Object key)	根据键获取值
keySet()	获取所有的键
values()	获取所有的值
entrySet()	获取所有的Entry
size()	获取集合元素的个数

哈希值

哈希值：是JDK根据u第项的地址或者数字运算出来的int类的数值；
Object类中有一个方式可以获取哈希值：
public int hashCode();返回哈希值。
对象哈希值的特点：

同一个对象多次调用和hashCode()方法返回的哈希值是相同的。
默认情况下，不同对象的哈希值是不同，但可以通过重写hashCode方法使得哈希值相同。
有的不一样的字符串的哈希值可能是一样，因为String 重写了hashCode方法，比如“重地“和”通话“，哈希值都是1179395

2.常用类

2.1 Object

Object 是 Java 类库中的一个特殊类，也是所有类的父类。也就是说，Java 允许把任何类型的对象赋给 Object 类型的变量
除了Object类，所有的类都存在继承关系
Object 类位于 java.lang 包中，编译时会自动导入，当一个类被定义后，如果没有指定继承的父类，那么默认父类就是 Object 类。

2.1.1equals

在Java中为了比较两者的对象是否相同，提供了一个方法叫做equals。
语法结构为： System.out.println(person.equals(person1));

equals只能用来判断引用类型

 public static void main(String[] args) {
        String str1=new String("hello");
        String str2=new String("hello");
        System.out.println(str1==str2);//false
        System.out.println(str1.equals(str2));//true
    }

2.1.2hashCode()

Java中的 hashCode() 方法返回的数据类型是 int 类型
有关 String 对象 Hash 算法计算方式是：

s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]

两个引用，如果指向的是同一个对象，则哈希值是一样的，如果指向的是不同对象，则哈希值不一样

public class Test01 {

	public static void main(String[] args) {
        A a = new A();
        A a1 = new A();
        System.out.println("a.hashCode="+a.hashCode()); 
        System.out.println("a1.hashCode="+a1.hashCode());
    }
}

输出结果为：

a.hashCode=515132998
a1.hashCode=474675244

哈希值主要是根据地址来号来的！不能完全将哈希值等价于地址

2.1.3 toString

默认返回：全类名（包名、类名）+@+哈希值的十六进制，子类往往重写toString方法，用于返回对象的属性信息
（1）getClass().getName() 类的全类名（包名+类名）
（2）Integer.toHexString(hashCode() 将对象的hashCode值转成16进制字符串

2.1.4 finalize

当对象被回收，系统自动调用该对象的finalize方法，子类可以重写该方法，做一些释放资源的操作

2.2String

String表示字符串类型，属于引用数据类型，不属于基本数据类型。
在java中随便使用双引号括起来的都是String对象。
双引号括起来的字符串，是不可变的
在JDK当中双引号括起来的字符串，都是直接存储在“方法区”的“字符串常量池”当中的。

public class Test01 {
	    public static void main(String[] args) {
	        String s1 = "hi";
	        // "hi"是存储在方法区的字符串常量池当中
	        // 因为这个“hi”已经存在了所以他并不会再次新建
	        String s2 = "hi";
	        System.out.println(s1 == s2); // true
 			// == 双等号比较的是变量中保存的内存地址
	        String x = new String("xy");
	        String y = new String("xy");
	        System.out.println(x == y); //false
	    }
	}

注意：字符串对象之间的比较不能使用“ = = ”,"= ="不保险。应该调用String类的equals方法。

public class Test01 {
	    public static void main(String[] args) {
	    	String w = new String("aString");
	    	//String w = null;
	    	// 因为"aString"是一个String字符串对象，只要是对象都能调用方法。所以可以加“.”
	    	System.out.println("aString".equals(w)); 
	    	// 使用这种方式可以避免空指针异常。
	    	System.out.println(w.equals("aString")); 
	    	// 这样写存在空指针异常的风险。
	    }
	}

构造方法名：

String s = “xxx”
String(String original)
String(char数组)
String(char数组,起始下标,长度)
String(byte数组)
String(byte数组,起始下标,长度)
String(StringBuffer buffer)
String(StringBuilder builder)
例子：

	    public static void main(String[] args) {
	    	
	        String eg1 = "wym";
	        System.out.println(eg1);//wym

	        String eg2 = new String("wym");
	        System.out.println(eg2);//wym

	        char[] c = {'w' , 'y', 'm'};
	        String eg3 = new String(c);
	        System.out.println(eg3);//wym

	        String eg4 = new String(c, 1, 2);
	        System.out.println(eg4);//ym

	        byte[] b = {70, 71 ,72, 73};
	        String eg5 = new String(b);
	        System.out.println(eg5);//FGHI

	        String eg6 = new String(b, 1, 2);
	        System.out.println(eg6);//GH

	        StringBuffer name1 = new StringBuffer("wym");
	        String eg7 = new String(name1);
	        System.out.println(eg7);//wym

	        StringBuilder name2 = new StringBuilder("wym");
	        String eg8 = new String(name2);
	        System.out.println(eg8);//wym
	    }

方法：

方法名	作用
char charAt(int index)	返回指定位置的字符
int compareTo(String anotherString)	比较两个字符串。相等返回0；前大后小返回1；前小后大返回-1
boolean contains(CharSequence s)	判断字符串是否包含s
boolean endsWith(String suffix)	判断字符串是否以suffix结尾
boolean equals(Object anObject)	判断两个串是否相等
boolean equalsIgnoreCase(String anotherString)	忽略大小写判断两个串是否相等
byte[] getBytes()	将字符串串变成字节数组返回
int indexOf(String str)	返回str在字符串第一次出现的位置
boolean isEmpty()	字符串是否为空
int length()	字符串长度
int lastIndexOf(String str)	返回str最后一次出现的位置
String replace(CharSequence target, CharSequence replacement)	用replacement替换字符串target的字符
String[] split(String regex)	将字符串以regex分割
boolean startsWith(String prefix)	判断字符串是否以prefix开始
String substring(int beginIndex)	从beginIndex开始截取字串
String substring(int beginIndex, int endIndex)	截取beginIndex到endIndex - 1的字符串
char[] toCharArray()	将字符串转换乘char数组
String toLowerCase()	字符串转小写
String toUpperCase()	字符串转大写
String trim()	去除字符串两边空格
静态方法
static String valueOf(int i)	将 i 转换成字符串

import java.util.Arrays;

public class Test01 {
	    public static void main(String[] args) {
	        String s1 = "abcdefg";

	        System.out.println(s1.charAt(6));//g

	        String s2 = "y";
	        String s3 = "z";
	        String s4 = "z";
	        System.out.println(s2.compareTo(s3));//-1
	        System.out.println(s3.compareTo(s4));//0
	        System.out.println(s4.compareTo(s1));//25

	        System.out.println(s2.equals(s3));//false

	        System.out.println(s1.endsWith("efg"));//true
	        System.out.println(s1.endsWith("t"));//false

	        String s5 = "ABCDEFG";
	        System.out.println(s1.equalsIgnoreCase(s5));//true

	        byte[] b = s1.getBytes();
	        System.out.println(Arrays.toString(b));//[97,98,99,100,101,102,103]

	        System.out.println(s1.indexOf("a"));//0
	        System.out.println(s1.indexOf("g"));//6

	        System.out.println(s1.isEmpty());//false

	        System.out.println(s1.length());//7

	        String s6 = "asdfghjklkjhgfdsa";
	        System.out.println(s6.lastIndexOf("s"));//15
	        System.out.println(s6.lastIndexOf("h"));//11

	        String s7 = "name=wym&age=18&sex=男";
	        String newS7 = s7.replace("&", ";");
	        System.out.println(newS7);//name=wym;age=18;sex=男

	        String[] splitS7 = s7.split("&");
	        System.out.println(Arrays.toString(splitS7));//[name=wym, age=18, sex=男]

	        System.out.println(s6.startsWith("asd"));//true
	        System.out.println(s6.startsWith("dsa"));//false

	        System.out.println(s6.substring(10));//jhgfdsa
	        System.out.println(s6.substring(10, 13));//jhg

	        char[] charS6 = s6.toCharArray();
	        System.out.println(Arrays.toString(charS6));//[a,s,d,f,g,h,j,k,l,k,j,h,g,f,d,s,a]

	        System.out.println(s6.toUpperCase());//ASDFGHJKLKJHGFDSA

	        System.out.println(s5.toLowerCase());//abcdefg

	        String s8 = "           你 好 世 界                   ";
	        System.out.println(s8.trim());//你 好 世 界

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

	        System.out.println(String.valueOf(123));//123
	        System.out.println(String.valueOf(3.14));//3.14
	        System.out.println(String.valueOf(true));//true
	        System.out.println(String.valueOf(new Object()));//java.lang.Object@4554617c
	        //valueOf会自动调用toString()方法

	    }
	}

2.3StringBuffer和StringBuilder

概述：在实际的开发过程中，如果需要进行字符串的拼接，会出现以下问题：Java中的字符串不可改变，每一次拼接都导致会产生新的字符串，而这样额话会导致占用大量的方法区内存造成内存空间的浪费。
StringBuffer和StringBuilder性能的优化重点：创建的时候就给一个尽可能大的初始化容量，减少底层数组的扩容次数，以此提高程序效率。
StringBuffer和StringBuilder的区别：
- StringBuilder: 可变的字符序列，线程不安全的，效率高，底层是 char[]数组存储，方法中都没有synchronized 关键字修饰
- StringBuffer : 可变的字符序列，线程安全的，效率低，底层是 char[]数组存储，方法中都有synchronized 关键字修饰
源代码内，StringBuffer和StringBuilder内部实际上是一个 byte[ ]数组，这个byte[]数组没有被final修饰，而String类内部实际上也是一个byte[ ]数组，但是这个byte[ ]数组被final修饰，一旦被final修饰的引用指向某对象之后，不可再指向其他对象，所以String是不变的。
注意：StringBuffer和StringBuilder默认初始化容量为16个byte[] 数组
构造方法名:

StringBuilder()
StringBuilder(int capacity)
StringBuilder(String str)

public class Test01 {
	    public static void main(String[] args) {
	        StringBuffer s1 = new StringBuffer();//创建一个容量为16的StringBuffer对象

	        StringBuffer s2 = new StringBuffer("I'm ironman");
	        System.out.println(s2);

	        StringBuffer s3 = new StringBuffer(100);//创建一个容量为100的StringBuffer对象
	    }
	}

Column 1	Column 2
StringBuilder append(char c)	在字符串尾巴追加字符
int capacity()	当前StringBuffer/StringBuilder的容量
char charAt(int index)	返回指定位置的字符
StringBuilder delete(int start, int end)	删除[start, end)范围的字符
StringBuilder deleteCharAt(int index)	删除指定位置的字符
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)	将字符串转换成char复制到dst数组中
int indexOf(String str)	返回str第一次出现的位置
int lastIndexOf(String str)	返回str最后一次出现的位置
StringBuilder insert(int offset, char c)	在offset位置插入字符
int length()	返回字符串长度
StringBuilder replace(int start, int end, String str)	将[start, end)的内容替换成str
StringBuilder reverse()	字符串翻转
void setCharAt(int index, char ch)	将index位置的字符设置为ch
String substring(int start)	从start开始截取字串
String substring(int start, int end)	截取start到end - 1的字符串
void setLength(int newLength)	设置StringBuffer/StringBuilder的长度，默认补空格，并自动扩充容量
CharSequence subSequence(int start, int end)	和substring一样，只不过返回CharSequence

class Test01{
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();

        s1.append("a");
        s1.append("b").append('c').append('d').append('e').append('f').append('g').append("g");
        System.out.println(s1);//abcdefgg

        System.out.println(s1.capacity());//16

        System.out.println(s1.charAt(2));//c

        System.out.println(s1.delete(1, 3));//adefgg

        System.out.println(s1.deleteCharAt(2));//adfgg

        System.out.println(s1.indexOf("c"));//-1

        System.out.println(s1.lastIndexOf("f"));//6

        System.out.println(s1.insert(1, 123));//a123dfgg

        char[] c = new char[20];
        s1.getChars(0, s1.length(), c, 0);
        System.out.println(Arrays.toString(c));//[a, 1, 2, 3, d, f, g,  g,  ,  ,  ,  ,  ,  ,  ,  ]

        System.out.println(s1.length());//8

        System.out.println(s1.replace(1, 4, "A"));//aAdfgg

        System.out.println(s1.reverse());//ggfdAa

        s1.setCharAt(1, 'a');
        System.out.println(s1);//gafdAa

        System.out.println(s1.substring(2));//fdAa
        System.out.println(s1.substring(2,5));//fdA
        System.out.println(s1.subSequence(1, 3));//af

        s1.setLength(100);
        System.out.println(s1.length());//100 直接在后面追加空格
        System.out.println(s1.capacity());//100
    }
}

2.4 System

概述：System类代表当前Java程序的运行平台，位于java.lang包下，该类被private修饰，所以不能创建System类的对象，System类提供了一些类变量和方法，允许直接通过System类来调用这些类变量和方法。

Column 1	Column 2
public static void exit(int status)	系统退出，如果status为0就表示退出。
public static void gc()	运行垃圾收集机制，调用的是Runtime类中的gc方法。
public static long currentTimeMillis()	返回以毫秒为单位的当前时间。
public static void arraycopy(Object src,int srcPos, Object dest,int desPos,int length)	数组拷贝操作
public static Properties getProperties()	取得当前系统的全部属性。
public static String getProperty(String key)	根据键值取得属性的具体内容。

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Map;
import java.util.Properties;

class Test01{
    public static void main(String[] args) throws FileNotFoundException,IOException {
        //获取系统所有的环境变量
    	Map<String,String> envMap = System.getenv();
    	for(String name : envMap.keySet()) {
    		System.out.println(name+"--->"+envMap.get(name));
    	}
    	//获取指定的环境变量
    	System.out.println(envMap.get("JAVA_HOME"));
    	//获取所有的系统属性
    	Properties props = System.getProperties();
    	//将所有的系统属性保存在props.txt文档中
    	props.store(new FileOutputStream("prop.txt"),"System properties");
    	//输出特定的系统属性
    	System.out.println(System.getProperty("os.name"));
    }
}

props.txt内容：

#System properties
#Wed Jun 29 20:23:23 CST 2022
java.specification.version=17
sun.cpu.isalist=amd64
sun.jnu.encoding=GBK
java.class.path=D\:\\Javaworkspace\\Damon\\bin
java.vm.vendor=Eclipse Adoptium
sun.arch.data.model=64
user.variant=
java.vendor.url=https\://adoptium.net/
user.timezone=Asia/Shanghai
java.vm.specification.version=17
os.name=Windows 10
sun.java.launcher=SUN_STANDARD
user.country=CN
sun.boot.library.path=C\:\\Users\\Lenovo\\.p2\\pool\\plugins\\org.eclipse.justj.openjdk.hotspot.jre.full.win32.x86_64_17.0.3.v20220515-1416\\jre\\bin
sun.java.command=com.damon.Test01
jdk.debug=release
sun.cpu.endian=little
user.home=C\:\\Users\\Lenovo
user.language=zh
java.specification.vendor=Oracle Corporation
java.version.date=2022-04-19
java.home=C\:\\Users\\Lenovo\\.p2\\pool\\plugins\\org.eclipse.justj.openjdk.hotspot.jre.full.win32.x86_64_17.0.3.v20220515-1416\\jre
file.separator=\\
java.vm.compressedOopsMode=Zero based
line.separator=\r\n
java.vm.specification.vendor=Oracle Corporation
java.specification.name=Java Platform API Specification
user.script=
sun.management.compiler=HotSpot 64-Bit Tiered Compilers
java.runtime.version=17.0.3+7
user.name=Lenovo
path.separator=;
os.version=10.0
java.runtime.name=OpenJDK Runtime Environment
file.encoding=UTF-8
java.vm.name=OpenJDK 64-Bit Server VM
java.vendor.version=Temurin-17.0.3+7
java.vendor.url.bug=https\://github.com/adoptium/adoptium-support/issues
java.io.tmpdir=C\:\\Users\\Lenovo\\AppData\\Local\\Temp\\
java.version=17.0.3
user.dir=D\:\\Javaworkspace\\Damon
os.arch=amd64
java.vm.specification.name=Java Virtual Machine Specification
sun.os.patch.level=
native.encoding=GBK
java.library.path=C\:\\Users\\Lenovo\\.p2\\pool\\plugins\\org.eclipse.justj.openjdk.hotspot.jre.full.win32.x86_64_17.0.3.v20220515-1416\\jre\\bin;C\:\\Windows\\Sun\\Java\\bin;C\:\\Windows\\system32;C\:\\Windows;C\:/Users/Lenovo/.p2/pool/plugins/org.eclipse.justj.openjdk.hotspot.jre.full.win32.x86_64_17.0.3.v20220515-1416/jre/bin/server;C\:/Users/Lenovo/.p2/pool/plugins/org.eclipse.justj.openjdk.hotspot.jre.full.win32.x86_64_17.0.3.v20220515-1416/jre/bin;C\:\\Program Files\\Microsoft MPI\\Bin\\;C\:\\Windows\\system32;C\:\\Windows;C\:\\Windows\\System32\\Wbem;C\:\\Windows\\System32\\WindowsPowerShell\\v1.0\\;C\:\\Windows\\System32\\OpenSSH\\;C\:\\Program Files\\Polyspace\\R2020a\\runtime\\win64;C\:\\Program Files\\Polyspace\\R2020a\\bin;C\:\\Program Files\\Polyspace\\R2020a\\polyspace\\bin;C\:\\Program Files\\Microsoft SQL Server\\130\\Tools\\Binn\\;%USERPROFILE%\\AppData\\Local\\Microsoft\\WindowsApps;D\:\\QQGameTempest\\Hall.57734\\;C\:\\Users\\Lenovo\\Desktop;;.
java.vm.info=mixed mode
java.vendor=Eclipse Adoptium
java.vm.version=17.0.3+7
sun.io.unicode.encoding=UnicodeLittle
java.class.version=61.0

程序运行结果：

USERDOMAIN_ROAMINGPROFILE--->WYM-FOREVER2003
LOCALAPPDATA--->C:\Users\Lenovo\AppData\Local
MSMPI_BIN--->C:\Program Files\Microsoft MPI\Bin\
PROCESSOR_LEVEL--->23
PT5HOME--->E:\packet tracer\Cisco Packet Tracer 6.0
USERDOMAIN--->WYM-FOREVER2003
FPS_BROWSER_APP_PROFILE_STRING--->Internet Explorer
LOGONSERVER--->\\WYM-FOREVER2003
SESSIONNAME--->Console
ALLUSERSPROFILE--->C:\ProgramData
PROCESSOR_ARCHITECTURE--->AMD64
PSModulePath--->C:\Program Files\WindowsPowerShell\Modules;C:\Windows\system32\WindowsPowerShell\v1.0\Modules
SystemDrive--->C:
VS100COMNTOOLS--->E:\高级语言程序设计\Common7\Tools\
OneDrive--->C:\Users\Lenovo\OneDrive
PT8HOME--->E:\packet tracer\Cisco Packet Tracer 8.1.1
APPDATA--->C:\Users\Lenovo\AppData\Roaming
USERNAME--->Lenovo
ProgramFiles(x86)--->C:\Program Files (x86)
CommonProgramFiles--->C:\Program Files\Common Files
Path--->C:/Users/Lenovo/.p2/pool/plugins/org.eclipse.justj.openjdk.hotspot.jre.full.win32.x86_64_17.0.3.v20220515-1416/jre/bin/server;C:/Users/Lenovo/.p2/pool/plugins/org.eclipse.justj.openjdk.hotspot.jre.full.win32.x86_64_17.0.3.v20220515-1416/jre/bin;C:\Program Files\Microsoft MPI\Bin\;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Windows\System32\OpenSSH\;C:\Program Files\Polyspace\R2020a\runtime\win64;C:\Program Files\Polyspace\R2020a\bin;C:\Program Files\Polyspace\R2020a\polyspace\bin;C:\Program Files\Microsoft SQL Server\130\Tools\Binn\;%USERPROFILE%\AppData\Local\Microsoft\WindowsApps;D:\QQGameTempest\Hall.57734\;C:\Users\Lenovo\Desktop;
PT7HOME--->E:\packet tracer\Cisco Packet Tracer 7.0
FPS_BROWSER_USER_PROFILE_STRING--->Default
PATHEXT--->.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC
DriverData--->C:\Windows\System32\Drivers\DriverData
OS--->Windows_NT
COMPUTERNAME--->WYM-FOREVER2003
PROCESSOR_REVISION--->6801
CommonProgramW6432--->C:\Program Files\Common Files
ComSpec--->C:\Windows\system32\cmd.exe
ProgramData--->C:\ProgramData
ProgramW6432--->C:\Program Files
HOMEPATH--->\Users\Lenovo
SystemRoot--->C:\Windows
TEMP--->C:\Users\Lenovo\AppData\Local\Temp
HOMEDRIVE--->C:
PROCESSOR_IDENTIFIER--->AMD64 Family 23 Model 104 Stepping 1, AuthenticAMD
PT6HOME--->E:\packet tracer\Cisco Packet Tracer 6.2sv
USERPROFILE--->C:\Users\Lenovo
TMP--->C:\Users\Lenovo\AppData\Local\Temp
CommonProgramFiles(x86)--->C:\Program Files (x86)\Common Files
ProgramFiles--->C:\Program Files
PUBLIC--->C:\Users\Public
NUMBER_OF_PROCESSORS--->12
windir--->C:\Windows
=::--->::\
null
Windows 10

获取当前系统时间：System类里面有两个回去时间的方式，但他们有区别。

class Test01{
    public static void main(String[] args) {
    	long timeMill = System.currentTimeMillis();
    	System.out.println("当前系统毫秒时间：" + timeMill); //当前系统毫秒时间：1656505954837
    	long timeNano = System.nanoTime();
    	System.out.println("当前系统纳秒时间：" + timeNano); //当前系统纳秒时间：1117020308691700
    }
}

注意：

以毫秒的方式返回当前时间。请注意，虽然返回值的时间单位是毫秒，但是这个值的粒度取决于底层操作系统并且可能粒度更大
@return 当前时间和1970年1月1日午夜之间的差值，以毫秒来测量。

区别：

System.nanoTime()的精确度更高一些，如今的硬件设备性能越来越好，如果要更精密计算执行某行代码或者某块代码所消耗的时间，该方法会测量得更精确。
单独获取System.nanoTime()没有什么意义，因为该值是随机的，无法表示当前的时间。如果要记录当前时间点，用System.currentTimeMills()。
System.currentTimeMills()得到的值能够和Date类方便地转换，jdk提供了多个接口来实现；但是System.nanoTime()则不行。
4.System.currentTimeMills()的值是基于系统时间的，可以人为地进行修改；而System.nanoTime()则不能，如果需要根据时间差来过滤某些频繁的操作，用System.nanoTime()会比较合适。

该方法可以用来计算当前日期，当前星期几等，与Date的换算非常方便，JDK提供了相关的接口来换算。
通过该方法获取的值的依据是当前系统的日期和时间，可以在系统设置中进行设置和修改。
垃圾对象的回收：

	class Person{
		   private String name ;
		   private int age ;
		   public Person(String name,int age){
		   	this.name = name ;
		   	this.age = age;
		   }
		   public String toString(){	// 覆写toString()方法
		   	return "姓名：" + this.name + "，年龄：" + this.age ;
		   }
		   public void finalize() throws Throwable{	// 对象释放空间时默认调用此方法
		   	System.out.println("对象被释放 --> " + this) ;
		   }
		};

		public class Test01{
		   public static void main(String args[]){
		   	Person per = new Person("wym",18) ;
		   	per = null ;	// 断开引用
		   	System.gc() ;		// 强制性释放空间
		   }
		};

System.arraycopy（）
- 概述：把一个数组中某一段字节数据放到另一个数组中。至于从第一个数组中取出几个数据，放到第二个数组中的什么位置都是可以通过这个方法的参数控制的。
- 语法结构为：

public static void arraycopy(Object src, int srcPos, Object dest, int ]
destPos, int length)

备注：

src:源数组;
srcPos:源数组要复制的起始位置;
dest:目的数组;
destPos:目的数组放置的起始位置;
length:复制的长度.

要求：

源的起始位置+长度不能超过末尾
目标起始位置+长度不能超过末尾
且所有的参数不能为负数

2.5 Date类

构造方法
Date()	根据当前系统时间创建日期对象
Date(long time):	根据传入的毫秒值时间创建日期对象
SimpleDateFormat(String s)	根据指定模板创建日期格式化对象
成员方法
long getTime()	获取当前日期对象的毫秒值时间
String toLocaleString()	根据本地格式转换日期对象
String format(Date d)	根据指定格式格式化日期对象
Date parse(String s)	根据指定格式解析字符串

import java.text.SimpleDateFormat;
import java.util.Date;

public class Test01 {

	public static void main(String[] args) throws Exception{
		Date d = new Date(3000L);
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
		System.out.println(sdf.format(d) );

		String str = "2088年08月08日 08:08:08";
		Date parse = sdf.parse(str);
		System.out.println(parse);
	}
}

import java.util.Date;

public class Test01 {

	public static void main(String[] args) throws Exception{
		    Date date = new Date();
		    System.out.println(date);//Sat Nov 06 18:31:32 CST 2021
		    System.out.println(date.getTime());//1656509081222
		}
}