学习内容:
- 集合
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
}
}