文章目录
API
API(Application Programming Interface)应用程序编程接口是对java预先定义的类或接口功能和函数功能的说明文档,目的是提供给开发人员进行使用帮助说明
基本数据类型包装类
Java语言是一个面向对象的语言,但是Java中的基本数据类型却是不面向对象的,这在实际使用时存在很多的不便,为了解决这个不足,在设计类时为每个基本数据类型设计了一个对应的类进行代表,这样八个和基本数据类型对应的类统称为包装类
- 八种基本数据类型的包装类
byte ——Byte
short ——Short
int ——Integer
long-----Long
float-----Float
double----Double
char----Character
boolean—Boolean - 1字节(byte、boolean)、 2字节(short、char)、4字节(int、float)、8字节(long、double)
类型转换
基本数据类型---->字符串
- 基本数据类型对象包装类中的方法 toString(基本类型);
- String类中的方法: valueOf(基本类型)
- 基本类型数据 +“ ”;
Integer.toString(10); //将整数转为 String
Integer.valueOf(10);
String s =10+"11";
字符串---->基本数据类型
基本类型包装类 . parseInt(“字符串”)
int i = Integer.parseInt("4564987"); //将String类型转为int
System.out.println(Integer.parseInt("23") + 1);
基本类型的对象---->基本数据类型数值
integer对象中的 intValue()方法
Integer w =new Integer(15);
int ww = w.intValue(); //取出对象中包含的int值
基本类型---->引用类型
自动装箱:valueOf ()
自动拆箱:intValue ()
int x = 10;
/*
基本类型转引用类型
Integer n = new Integer(x);
Integer n1 = Integer.valueOf(x);
*/
Integer n = x; //自动装箱 默认调用valueOf()方法 创建一个Integer对象
//n.intValue()
int y = n;//自动拆箱 将引用类型转为基本类型 默认调用intValue()方法 取出包含的int值
进制转换
使用Integer类的静态方法
//将十进制转换成
Integer.toBinaryString(16); //二进制
Integer.toOctalString(16); //八进制
Integer.toHexString(16); //十六进制
Integer.toString(15,3);//将15转换成3进制
常用方法
1、包含了int类型的信息:@Native public static final int 修饰的常量
System.out.println(Integer.MAX_VALUE);//最大的int型数:2的31次方-1 2147483647
System.out.println(Integer.MIN_VALUE);//最小的int型数:2的31次方
System.out.println(Integer.SIZE);//32 位数
System.out.println(Integer.BYTES);//4 字节数
2、静态方法
int max = Integer.max(10, 5);
//选出两个中大的
System.out.println(max);//10
3、成员方法
- compateTo()
- equals()
Integer n = new Integer("10");
Integer m = new Integer("12");
System.out.println(m+10);
System.out.println(m.compareTo(n));//比较大小 返回-1/0/1
System.out.println(n.equals(m));//比较是否相等
== & equals
==比较基本类型的时候比较的是他们的值,比较引用的时候表的是他们在内存中的地址
基本数据类型与基本数据类型封装类使用==比较:会将基本数据类型封装类自动拆箱成基本数据类型后比较
int i=0;
Integer j = new Integer(0);
System.out.println(i==j);//true
equals()比较的是对象的值
-
基本类型自动装箱( valueOf() )时,如果数值在-128到127之间,会从缓存中取出一个对象返回,如果多个值相同返回的是同一个对象,不在这个范围之间会创建新的对象返回
Long n = -128L; Long m = -128L; System.out.println(n==m);//nm都用同一对象,地址相同,返回true Integer a = 128; Integer b = 128; System.out.println(a==b);//创建新的对象,地址不同,返回false
-
如果比较new出的对象,无论数值,地址都不相同
Integer m = new Integer(127); Integer n = new Integer(127); System.out.println(m==n);//false System.out.println(m.equals(n));//true System.out.println(128==128);//true
Object类
java.lang包下的核心类,是所有类的父类,何一个类时候如果没有明确的继承一个父类的话,那么它就是Object的子类;所有对象(包括数组)都实现这个类的方法。
hasCode()
本地方法,返回的对象地址值
String等封装类中对此方法进行了重写。方法调用得到一个计算公式得到的 int值
equals()
对象内容比较
- 因为此时直接调用equals()方法默认进行比较的是两个对象的地址
- 在源码中,传递来的Object对象和当前对象比较地址值,返回布尔值
public class Person extends Object{
private String name;
private int age;
Person(String name,int age){
this.name = name;
this.age = age;
}
/*
Object类中equals
public boolean equals(Object obj) {
return (this == obj);
}
*/
public static void main(String[] args) {
Person p1 = new Person("张三",18);
Person p2 = new Person("张三",18);
System.out.println(p1.equals(p2)); //false 比较地址
String s = new String("abc");
String s1 = new String("abc");
System.out.println(s==s1);//false
System.out.println(s.equals(s1));//true String类重写了equals() 比较的是对象中包含的内容是否相等
Integer x = 128; //new Integer(128);
Integer y = 128; //new Integer(128);
System.out.println(x==y);//false
System.out.println(x.equals(y));//true
//几乎API中所有类都重写Object类中equals(),比较的是对象中包含的内容是否相等
}
}
重写比较规则equals(),判断对象的值是否相等
@Override
public boolean equals(Object obj) {
if (obj instanceof Person) {
Person person = (Person) obj;
return this.age == person.age && this.name == person.name;
} else {
System.out.println("类型错误");
return false;
}
}
System.out.println(p1.equals(p2)); //false 比较值
为什么重写equals方法必须重写hashcode方法
判断先比较hashcode()再比较equals(),要是只重写equals()就可能导致equals()比较为True但hashcode()值不同
toString()
取得对象信息,返回该对象的字符串表示
- 使用System.out.println§;输出对象,此时会默认调用对象中的toString()
当类中没有toString()时,默认调用父类toString() - Object类中toString()输出的是对象地址
- 一般情况下可以重写Object类中toString()
//没有重写toString()
Person p = new Person("张三",18);
System.out.println(p);
-----------------------------------------------
com.ffyc.javaapi.day2.objectdemo.Person@1b6d3586
//在Person类中重写toSting()
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
----------------------------------------
Person{name='张三', age=18}
getClass()
获取一个对象其类的Class类
Object.class:静态方法,获取Object类的Class类
finalize()
对象回收的时候默认调用的方法。见 JVM
@Override
protected void finalize() throws Throwable {
System.out.println("对象已被回收");
}
public static void main(String[] args){
new Person("张三",18);
System.gc();
}
wait() & notify()
wait();wait(long);wait(long,int);notify();notifyAll()
这几个函数体现的是Java的多线程机制
- 在使用的时候要求在synchronize语句中使用
- wait()用于让当前线程失去操作权限,当前线程进入等待序列
- notify()用于随机通知一个持有对象的锁的线程获取操作权限
- notifyAll()用于通知所有持有对象的锁的线程获取操作权限
- wait(long) 和wait(long,int)用于设定下一次获取锁的距离当前释放锁的时间间隔
Arrays类
位于java.util包内,用于操作数组工具类,里面定义了常见操作数组的静态方法
toString()
重写又重载了Object类中的toString方法
public class ArrayToString {
public static void main(String[] args) {
int [] a = {1,2,3,4,5};
System.out.println(a);
System.out.println(Arrays.toString(a));
}
}
-------------------------------------------------
[I@1b6d3586
[1, 2, 3, 4, 5]
equals()
比较两个非同一数组是否相等,而数组本身的equals判断另一个数组是否它本身
int []a = {1,2,3,4};
int []b = {1,2,3,4};
System.out.println(a==b); //false
System.out.println(a.equals(b));//Object中未重写的equals() false
System.out.println(Arrays.equals(a,b));// Arrays类重写重载过后的equals() true
/* 重写后的equals源码
public static boolean equals(int[] a, int[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
return false;
int length = a.length;
if (a2.length != length)
return false;
for (int i=0; i<length; i++)
if (a[i] != a2[i])
return false;
return true;
}
*/
sort()
对数组排序,可以指定区间:Arrays.sort(array, start, end)
对对象数组排序:指定排序规则:Arrays.sort(T[] array, comparator<? super T> c)
基本类型排序
int[]a = {3,7,6,9,4,1,6,9,41};
//Arrays.sort(a);
Arrays.sort(a,0,5); //指定区间排序
System.out.println(Arrays.toString(a));
//输出[3, 4, 6, 7, 9, 1, 6, 9, 41]
-------------------------------------------------
//按大小写字母顺序排序,不区分大小写
String[] strArray = new String[] { “z”, “a”, “C” };
Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
//输出: [a, C, z]
---------------------------------------------------------
//逆向排序
Arrays.sort(strArray, Collections.reverseOrder());
//输出:[z, a, C]
字符串排序
按照字典中顺序排列
String[]a = {"a","3","樊","景"};
Arrays.sort(a);
System.out.println(Arrays.toString(a));
--------------------------------------------------
[3, a, 景, 樊]
Object类排序
先继承compare接口并定义泛型(要排序的类),在重写compare()---->(定义排序规则)
compareTo()方法会在sort()的底层中调用
public class Student implements Comparable<Student> {
private int num;
private String name;
public Student(int num, String name) {
this.num = num;
this.name = name;
}
//用来做比较, 提供的一个自定义排序规则的方法
//compareTo()方法会在sort()的底层中调用
@Override
public int compareTo(Student o) {
return this.num - o.num; //按num
//return this.name.compareTo(o.name); //按name
}
@Override
public String toString() {
return "Student{" +
"num=" + num +
", name='" + name + '\'' +
'}';
}
}
public class ArraySortObject {
public static void main(String[] args) {
Student[] students = new Student[5]; //创建Student[]存放Student类
Student student1 = new Student(101, "张三1");
Student student2 = new Student(102, "张三2");
Student student3 = new Student(103, "张三3");
Student student4 = new Student(104, "张三4");
Student student5 = new Student(105, "张三5");
students[0] = student3;
students[1] = student1;
students[2] = student4;
students[3] = student2;
students[4] = student5;
System.out.println(Arrays.toString(students));
Arrays.sort(students);
System.out.println(Arrays.toString(students));
}
}
-------------------------------------------------------
[Student{num=103, name='张三3'}, Student{num=101, name='张三1'}, Student{num=104, name='张三4'}, Student{num=102, name='张三2'}, Student{num=105, name='张三5'}]
[Student{num=101, name='张三1'}, Student{num=102, name='张三2'}, Student{num=103, name='张三3'}, Student{num=104, name='张三4'}, Student{num=105, name='张三5'}]
或者使用Lambda表达式
Arrays.sort(students,((o1, o2) -> {
return o1.getNum() - o2.getNum();
}));
binarySearch()
二分查找法找指定元素的索引
数组一定是排好序的,否则会出错。找到元素,只会返回最后一个位置
//底层排序源码
private static int binarySearch0(int[] a, int fromIndex, int toIndex, int key) {
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
int midVal = a[mid];
if (midVal < key)
low = mid + 1;
else if (midVal > key)
high = mid - 1;
else
return mid; // key found
}
return -(low + 1); // key not found.
}
找不到就返回这个数理应出现在整个数组的位置加上负号
int[] arr = {10,20,30,40,50};
System.out.println(Arrays.binarySearch(arr, 30));
//输出:2 (下标索引值从0开始)
System.out.println(Arrays.binarySearch(arr, 36));
//输出:-4 (找不到元素,返回如果存在应该所在的位置取负,从-1开始数,如题,返回-4)
System.out.println(Arrays.binarySearch(arr, 0,3,30));
//输出:2 (从0到3位(不包括)找30,找到了,在第2位,返回2)
System.out.println(Arrays.binarySearch(arr, 0,3,40));
//输出:-4 (从0到3位(不包括)找40,找不到,从-1开始数,返回-4)
copyOf()
截取/扩容
底层调用System.arraycopy 本地方法
int[] arr = {10,20,30,40,50};
int[] arr1 = Arrays.copyOf(arr, 3);
System.out.print(Arrays.toString(arr1));
//输出:[10, 20, 30] (截取arr数组的3个元素赋值给新数组arr1)
//复制数组以扩容
int[] a = {1,2,3,4,5};
//返回一个指定长度的新数组,并将原数组中的内容复制到新数组中
int [] b = Arrays.copyOf(a, 10);
System.out.println(Arrays.toString(b));
//输出:[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
//copyOfRange()
int[] a = {1,2,3,4,5};
//截取指定位置元素 //第一位从0开始,截取到第三位,不包括第三位
int [] b = Arrays.copyOfRange(a,0,2);
System.out.println(Arrays.toString(b));
//输出:[1, 2]
String类
位于java.lang包下
所有字符串都是String类的实例(对象)字符串值不能改变(一旦给定字符串的值,值就不能改变) 因为底层用到一个final修饰的char 数组
private final char value[]; 底层是单个字符存储 char a=97 b=98 c=99
两种创建形式
- String s = " ":首先会在字符串常量池中查找,如果没有,就在常量池中创建;如果常量池已经存在,就不需要创建,直接返回地址即可
- String s = new String(" "):都会在堆中创建一个对象
String s1 = "abc";//首先会在字符串常量池中查找,如果没有,就在常量池中创建
String s2 = "abc";//如果常量池已经存在,就不需要创建,直接返回地址即可
System.out.println(s1==s2);//true
System.out.println(s1.equals(s2));//true
String s3 = new String("abc");
String s4 = new String("abc"); //都会在堆中创建一个对象
System.out.println(s3==s4);//false
System.out.println(s3.equals(s4));//true
为什么设计成不可变的
- 实现字符串常量池:字符串常量池要求存入的数据不可改变
- 多线程安全:防止多线程并发修改
- 安全:网络、数据库连接都是字符串作为参数,如果可以改变容易被攻击
- 加快字符串处理速度:由于String是不可变的,保证了hashcode的唯一性,于是在创建对象时其hashcode就可以放心的缓存了,不需要重新计算。这也就是Map喜欢将String作为Key的原因,处理速度要快过其它的键对象。所以HashMap中的键往往都使用String。
"+"连接符
底层会创建一个StringBuilder,使用append()操作实现的,然后用toString方法把对象转成字符串
int i = 10;
String s = "abc";
System.out.println(s + i);
/*
byte byte0 = 10;
String s = "abc";
System.out.println((new StringBuilder()).append(s).append(byte0).toString());
每次连接一个字符串都会new一个StringBuilder,所以当进行大量字符串连接时,自己先new一个
StringBuilder sb = new StringBuilder("abc");
sb.append("");
*/
- 直接相加:“樊”+“景”+“泽"会在编译期间转成"樊景泽”
- 使用引用间接相加:s1+s2+s3 编译期间无法确定值,降低效率
字符串常量池
String s = " " 创建方式会先从字符串常量池中找,如果没有再创建并放入字符串常量池
因为字符串对象频繁创建和回收,提升性能+减少开销
JDK6:永久代(方法区),存储的是对象
JDK7:堆,存储的是引用
JDK8:方法区被元空间取代
存在于堆区,底层是StringTable,StringTable继承自HashTable,长度为1009
intern()
直接使用双引号声明出来的String对象会直接存储在字符串常量池中,如果不是用双引号声明的String对象,可以使用String提供的intern方法。intern 方法是一个native方法,intern方法会从字符串常量池中查询当前字符串是否存在,如果存在,就直接返回当前字符串;如果不存在就会将当前字符串放入常量池中,之后再返回
创建了几个对象?
string s = “aaa”
:先在常量池找,没有就将’‘aaa’'放入常量池中,然后将地址赋给s。
string s = new String(“aaa”)
:在堆内存出开辟一块空间,然后在看常量池中有无
常用方法
判断
- equals(Object obj):判断两个字符串的内容是否相等
- equalsIgnoreCase(String str):判断内容忽略大小写
- contains(String str):是否包含指定字符串
- isEmpty() boolean:是否为空
- startsWith(String prefix):是否以指定字符串开头
- endsWith(String suffix):结尾
获取
- int length():返回字符串长度
- char charAt(int index):返回指定索引的字符
- int indexOf(String str):获取指定字符串首次出现的位置 从头开始向后找
- int indexOf(String str,int fromIndex):获取指定字符串首次出现的位置,从指定索引开始
- int lastIndexOf(String str):最后一次出现的位置
- String substring(int start):从指定位置截取到结束
- String substring(int start,int end):指定区间,不包括结束的
转换
- String toLowerCase():转小写
- String toUpperCase():转大写
- String concat(String str):两个字符串拼接 并返回新的字符串对象
- Stirng[] split " ," ):用指定符号 来分割字符串为数组
替换 replace()
- String replace(char/String old,char new):替换所有的该字符串为什么等同于replaceAll()
- replaceAll(String regex, String replacement):替换所有的
- replaceFirst(String regex, String replacement):只替换第一个
- 去除字符串两端空格 String trim()
String str = " abCd ECdfg ";
String str1 = str.replace("Cd","ccc"); //替换所有
System.out.println(str1);
System.out.println(str.replaceFirst("Cd","ccc")); //只替换第一个
String str2 = str.trim(); //去除两端空格
System.out.println(str2);
--------------------------------------------------
abccc Ecccfg
abccc ECdfg
abCd ECdfg
分割 split()
String str = " a3b:c66de";
String[] s1 = str.split(":"); //按:拆分成一个String[]
System.out.println(Arrays.toString(s1));
String[] s2 = str.split("\\d"); //按数字拆分
System.out.println(Arrays.toString(s2));
---------------------------------------------------
[ a3b, c66de]
[ a, b:c, , de]
编码解码 getBytes()
System.out.println('樊'+0);
String s = "樊景泽";
byte[] b = s.getBytes(); //编码 把字符串转化为编码数组 utf-8
System.out.println(Arrays.toString(b));
String s1 = new String(b);
System.out.println(s1); //解码
byte[] b1 =s.getBytes("GBK"); //选择GBK编码,抛UnsupportedEncodingException异常
System.out.println(Arrays.toString(b1));
String s2 = new String(b1,0,3,"GBK"); //区域解码,从0到3,不包含3
System.out.println(s2);
------------------------------------------------
27146
[-26, -88, -118, -26, -103, -81, -26, -77, -67]
樊景泽
[-73, -82, -66, -80, -44, -13]
樊�
转数组toCharArray()
把字符串分割成字符,转换成char数组,可以进行数组操作
- 字符串—>数组:toCahrArray()
- 数组—>字符串:1、String的构造方法;2、String的valueOf()
String s = "bdac";
char[] chars = s.toCharArray(); //把字符串分割,转换成一个char[]
Arrays.sort(chars); //排序char[]
System.out.println(Arrays.toString(chars));
//把char[]转换成字符串
String s1 = new String(chars); //String的构造方法
System.out.println(s1);
String s2 = String.valueOf(chars); //String的valueOf()
System.out.println(chars);
char[] c = {'a','b','c'};
System.out.println(Arrays.toString(c));
System.out.println(c); //输出char[]会自动转化成字符串的形式
int[] a={1,2,3};
System.out.println(a); //int[]则为地址
----------------------------------------------------------------
[a, b, c, d]
abcd
abcd
[a, b, c]
abc
[I@5caf905d
正则表达式
正则表达式是由一些具有特殊含义的字符组成的字符串,多用于查找、替换符合规则的字符串。在表单验证、Url映射等处都会经常用到
Scanner scanner = new Scanner(System.in);
String mail = scanner.next();
boolean res = mail.matches("\\w{6,10}@\\w{2,5}\\.(com|com\\.cn)");
System.out.println(res);
元字符
代码 | 说明 |
---|---|
. | 除换行符以外的任意字符 |
\w | 字母或数字或下划线或汉字 |
\s | 任意的空白符 |
\d | 数字 |
\b | 单词的开始或结束 |
^ | 字符串的开始(在集合字符里[^a]表示非(不匹配)的意思 |
$ | 字符串的结束 |
反义字符
代码/语法 | 说明 |
---|---|
\W | 任意不是字母,数字,下划线,汉字的字符 |
\S | 任意不是空白符的字符 |
\D | 任意非数字的字符 |
\B | 不是单词开头或结束的位置 |
[^x] | 除了x以外的任意字符 |
[^aeiou] | 除了aeiou这几个字母以外的任意字符 |
限定字符
代码/语法 | 说明 |
---|---|
* | 重复零次或更多次 |
+ | 重复一次或更多次 |
? | 重复零次或一次 |
{n} | 重复n次 |
{n,} | 重复n次或更多次 |
{n,m} | 重复n到m次 |
懒惰限定符
代码/语法 | 说明 |
---|---|
*? | 重复任意次,但尽可能少重复 |
+? | 重复1次或更多次,但尽可能少重复 |
?? | 重复0次或1次,但尽可能少重复 |
{n,m}? | 重复n到m次,但尽可能少重复 |
{n,}? | 重复n次以上,但尽可能少重复 |
转义字符
/*
$ ---> \$
( ---> \(
) ---> \)
* ---> \*
+ ---> \+
. ---> \.
[ ---> \[
] ---> \]
? ---> \?
\ ---> \\
/ ---> \/
^ ---> \^
{ ---> \{
} ---> \}
*/
StringBuilder&StringBuffer
String | StringBuffer | StringBuilder |
---|---|---|
值是不可变的,这就导致每次对String的操作都会生成新的String对象,不仅效率低下,而且浪费大量优先的内存空间 | 值可变,线程安全,不会产生新对象。每个StringBuffer对象都有一定的缓冲区容量,可自动扩容 | 值可变,线程不安全,速度更快 |
对String操作时内存变化:
初始String值为“hello”,然后在后面加上“world”,就需要重新开辟空间存word,然后再开辟空间存hello world,在让引用指向hello world,消耗大。使用StringBuilder&StringBuffer
继承关系
常用方法
/*
StringBuffer线程安全的,值可变的字符串(指的是底层char[]的值在变)
public StringBuffer() {
super(16);
}
AbstractStringBuilder(int capacity) {
value = new char[capacity];
}
StringBuilder线程不安全的,值可变的字符串
*/
StringBuffer stringBuffer = new StringBuffer("abc");//创建了一个字符串对象,底层是一个默认长度为3+16的数组
System.out.println(stringBuffer.capacity());//返回底层char[]的长度
stringBuffer.append("111111");
stringBuffer.append("222222");
stringBuffer.append("3333de"); //底层数组扩容int newCapacity = (value.length << 1) + 2;
System.out.println(stringBuffer);//输出字符串
System.out.println(stringBuffer.indexOf("1",6));//获取指定字符串的索引(第一次出现),从第几个开始
System.out.println(stringBuffer.charAt(20));//获取指定索引的字符
System.out.println(stringBuffer.insert(2,"F"));//在指定索引位置添加字符串
System.out.println(stringBuffer.deleteCharAt(2));//删除指定索引位置的字符
System.out.println(stringBuffer.delete(3,9));//删除索引区间的字符,从3到9不含9
System.out.println(stringBuffer.reverse());//字符串取反
System.out.println(stringBuffer.replace(0,14,"qwer"));//替换
System.out.println(stringBuffer.substring(1,3));//字符串截取:直接返回String类型
-----------------------------------------------
19
abc1111112222223333de
6
e
abFc1111112222223333de
abc1111112222223333de
abc2222223333de
ed3333222222cba
qwera
we
Math类
java.lang.Math提供了一系列静态方法用于科学计算;其方法的参数和,返回值类型一般为double型
System.out.println(Math.abs(-2.0)); //绝对值 2.0
System.out.println(Math.sqrt(64.0)); //立方根 8.0
System.out.println(Math.max(56,78)); //两者之间较大的 78
System.out.println(Math.min(56,78)); //两者之间较小的 56
System.out.println(Math.random()); //随机,数大于等于 0.0 ,小于 1.0
System.out.println(Math.pow(2,10)); //幂 1024.0
System.out.println(Math.ceil(18.36)); //向上取整 19.0
System.out.println(Math.floor(18.66)); //向下取整 18.0
System.out.println(Math.round(11.5)); //四舍五入 -->long 12
System.out.println(Math.round(-11.5)); //四舍五入 -11
Random类
此类用于产生随机数
- Random random = new Random(long send):send为随机数种子,如果send相同,随机数也相同,无参就按照当前时间
- public int nextInt(int bound) :bound为随机数范围,从0开始
Random random = new Random();
int a = random.nextInt(100)+1; //范围在1~100之间
byte[] bytes = new byte[5];
random.nextBytes(bytes); //直接对byte[]进行操作,随机赋值,只有byte[]
System.out.println(Arrays.toString(bytes));
-----------------------------------------------
[-69, 4, -9, -105, -94]
System类
位于java.lang包,代表系统,系统级的很多属性和控制方法都放置在该类的内部
构造方法是私有的,所以无法创建该类的对象,也就是无法实例化该类。
其内部的成员方法和成员变量都是静态的,直接使用类
成员变量
in、out、err
out是PrintStream的final static来修饰变量,由此可见,out是可以调用printStream中的方法的。例如,system.out.println中的println就是printStream中的一种输出方法
public final static InputStream in; //标准输入流
public final static PrintStream out; //标准输出流
public final static PrintStream err; //标准错误流
成员方法
- currentTimeMillis():获取时间
- arraycopy():复制数组
- exit():停机
- gc():垃圾回收
System.out.println(System.currentTimeMillis()); //获取操作系统的时间-毫秒 自1970-1-1 0:0:0
System.out.println(System.getProperty("os.version"));//操作系统版本
System.out.println(System.getenv());//获取环境变量
System.out.println(System.getenv("Path")); //接收指定环境变量
//返回一个指定长度的新数组,把原数组的值填充进去
int[] a = {1, 2, 3, 4, 5};
int[] ints = Arrays.copyOf(a, 10);
System.out.println(Arrays.toString(ints));
/*
src 原数组
srcpos 原数组的起点
dest 目标数组
destpos 目标数组起点
length 要复制的数量
*/
int[] c = new int[10];
System.arraycopy(a, 0, c, 4, a.length);
System.out.println(Arrays.toString(c));
}
System.exit(0); //退出,停止虚拟机
System.gc();//手动垃圾回收
-------------------------------------------------------
1643547929217
10.0
{USERDOMAIN_ROAMINGPROFILE=DEEVAN...
D:\Program Files\VMware\VMware workstation\bin\...
[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 2, 3, 4, 5, 0]
Date类
Date类是经常会使用到的一个用来处理日期、时间的一个类
Date date = new Date(); // 创建一个日期对象,里面包含程序运行时那一刻的时间
System.out.println(date);//格式输出时间
System.out.println(date.getTime());//获取long类型的时间
System.out.println(date.toLocaleString()); 根据本地区习惯输出一个字符串格式的时间
Date date1 = new Date(1627062196656L);
System.out.println(date1);
System.out.println(date.after(date1)); //true
System.out.println(date.before(date1)); //false
System.out.println(date.compareTo(date1)); //1 返回-1/0/1
/*
System.out.println(date.getYear()+1900);//获得年 过期方法 可以使用 只是官方不推荐
System.out.println(date.getMonth()+1); // 0开始
System.out.println(date.getDate()); //月中的第几天
System.out.println(date.getDay()); //周中的第0天 从0开始 0-星期天
System.out.println(date.getHours());
System.out.println(date.getMinutes());
System.out.println(date.getSeconds());
*/
-----------------------------------------------------------
Sat Jul 24 01:47:35 GMT+08:00 2021
1627062455800
2021-7-24 1:47:35
Sat Jul 24 01:43:16 GMT+08:00 2021
Calendar类
Calendar是java util包下的一个工具类,提供了很方便的不同日期格式的处理
//Calendar是抽象类 不能创建对象 ,两种方法创建
Calendar calendar =Calendar.getInstance(); //获取子类对象
Calendar calendar1 = new GregorianCalendar(); //直接new子类对象
//calender.set(year, month, date, hourOfDay, minute, second)
calendar.set(2021,7,24);
calendar.add(Calendar.SECOND,1);//时间加1秒
System.out.println(calendar.getTime()); //Tue Aug 24 02:18:57 GMT+08:00 2021
System.out.println(calendar.getTimeInMillis()); //1629742737877
System.out.println(calendar.get(Calendar.MONTH)+1);//获取月数+1 8
System.out.println(calendar.get(Calendar.DAY_OF_YEAR));//一年中的第几天 236
SimpleDateFormat类
根据给定的日期格式字符串
通过SimpleDateFormat在String和Date之间相互转换
Date date = new Date();
System.out.println(date); //默认格式 Sat Jul 24 02:39:19 GMT+08:00 2021
System.out.println(date.toLocaleString());//当地默认格式 2021-7-24 2:39:19
//日期转字符串
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日\thh:mm:ss SSS E");//日期格式化
String str = simpleDateFormat.format(date); //把java中的对象型(new Date() Calendar ) 转为指定格式的字符
System.out.println(str); //2021年07月24日 02:39:19 627 星期六
//字符串转日期
String birthday ="2001-11-15";
SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd");
try {
Date date1 =simpleDateFormat1.parse(birthday);//字符串日期格式与 指定格式必须一致
System.out.println(date1); //Thu Nov 15 00:00:00 GMT+08:00 2001
} catch (ParseException e) { //表示解析时意外出现错误异常
e.printStackTrace();
}
BigInteger类
大整数 可以表示任意的整数
add(),subtract(),multiply(),divide() 加减乘除
BigInteger a = new BigInteger("1111111111111111111111111111111111111111111111111");
BigInteger c = a.add(b);//加
BigDecimal类
- 在计算机中不论是float 还是double都是浮点数,而计算机是二进制的,浮点数会失去 一定的精确度。
- 根本原因是:十进制值通常没有完全相同的二进制表示形式;十进制数的二进制表示形式可能不精确。只能无限接近于那个值
System.out.println((10.5-10.4)==0.1); //false
金融项目,因为涉及金额的计算都必须十分精确
add(),subtract(),multiply(),divide() 加减乘除
BigDecimal a = new BigDecimal("10.5");
BigDecimal b = new BigDecimal("10.4");
System.out.println(a.subtract(b)); //0.1