⭐Java——常用类
一、包装类 Wrapper
针对八种基本数据类型 相应的引用类型——包装类
有了类的特点，就可以调用类中的方法
| 基本数据类型 | 包装类 |
|---|---|
| boolean | Boolean |
| char | Character |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
红色的包装类的父类都是 Number
包装类和基本数据的转换
装箱：基本类型 -> 包装类型
拆箱：包装类型 -> 基本类型
在jdk5以后含自动装箱和拆箱方式
自动装箱底层调用的是valueOf方法，比如Integer.valueOf( )
转换的代码演示
package com.ylxstudy.wrapper_;
/**
* @author 杨乐昕
* @version 1.0
*
* 演示 Integer 的 装箱和拆箱
*/
public class Integer01 {
public static void main(String[] args) {
//手动装箱
int n1 = 100;
Integer integer = new Integer(n1);//第一种方式
Integer integer1 = Integer.valueOf(n1);
//手动拆箱
int i = integer.intValue();
System.out.println(i);
System.out.println("===我是分割线===");
//自动装箱
int n2 = 200 ;
Integer integer2 = n2;//底层使用的是 Integer.valueOf()
//自动拆箱
int n3 = integer2;//底层使用的是 integer2.intValue()
}
}
其他包装类的转换一样
包装类 相互转换 String
package com.ylxstudy.wrapper_;
/**
* @author 杨乐昕
* @version 1.0
*/
public class WrapperVSString {
public static void main(String[] args) {
//包装类（Integer）-》String
Integer i = 100 ;
// 方式一
String str = i+ "";
//以Integer 类型的 i作为原始的数据，加上双引号后，变成字符串，对原先的i
//的类型没有改变
// 方式二
String str2 = i.toString();
// 方式三
String str3 = String.valueOf(i);
// String -> 包装类
String str4 = "12345";
Integer i2 = Integer.parseInt(str4);//使用到自动装箱
Integer i3 = new Integer(str4);//构造器
System.out.println("ok" );
}
}
关于包装类的面试题
面试题一
package com.ylxstudy.wrapper_;
/**
* @author 杨乐昕
* @version 1.0
*/
public class WrapperExercise02 {
public static void main(String[] args) {
WrapperExercise02 wrapperExercise02 = new WrapperExercise02();
wrapperExercise02.method1();
}
public void method1(){
Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j);//false
//new对象，对于对象的 == 符号判断，判断的是地址
Integer m = 1;//底层是Integer.valueOf(1)
Integer n = 1;//底层是Integer.valueOf(1)
System.out.println(m == n);//true
//Integer.valueOf()的源码是
/*
*public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
*
* IntegerCache.cache[i + (-IntegerCache.low)]是一个数组，在类加载的
* 时候就加载好了
*
* i >= IntegerCache.low && i <= IntegerCache.high
* 这是一个范围IntegerCache.low = -128 ， IntegerCache.high = 127
* 当在这个范围的时候，就直接返回，否则就new Integer(xx)
* */
Integer x = 128;
Integer y = 128;
System.out.println(x == y);//false
//超出范围，所以是new 对象，判断的是对象的地址，结果输出false
}
}
面试题二
package com.ylxstudy.wrapper_;
/**
* @author 杨乐昕
* @version 1.0
*/
public class WrapperExercise03 {
public static void main(String[] args) {
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2);//false,只要是new就是不同对象
Integer i3 = new Integer(128);
Integer i4 = new Integer(128);
System.out.println(i3 == i4);//false
Integer i5 =127;
Integer i6 = 127;
System.out.println(i5 == i6);//true
Integer i7 = 128;
Integer i8 = 128;
System.out.println(i7 == i8);//false
Integer i9 = 127 ;//从IntegerCache数组中取出来的
Integer i10 = new Integer(127);
System.out.println(i9 == i10);//false
//==========================================================================
Integer i11 = 127 ;
int i12 = 127;
//只要有基本数据类型，== 判断就是值，不是地址
System.out.println(i11 == i12);//true
Integer i13 = 128;
int i14 = 128;
//只要有基本数据类型，== 判断就是值，不是地址
System.out.println(i13 == i14);//true
}
}
二、⭐String 类
- String 对象用于保存字符串，也就是一组字符序列
- “jack”字符串常量，双引号括起来的字符序列
- 字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节
- String 类有很多的构造器，构造器的重载
常用的构造器的有：
String s1 = new String ();
String s2 = new String (String original);
String s3 = new String (char[] a);
String s4 = new String (char[] a,int startIndex,int count);
String s5 = new String (byte[] b);- Serializable:String 实现了Serializable接口，说明String 可以串行化
Comparable:String 实现了Comparable接口，说明String对象可以比较- String 是final类，不能被其他的类继承
- String 有属性 private final char value[]; 用于存放字符串内容
- 一定要注意：value是一个final类型，不可以修改：即指的是value不能指向新的地址，但是单个字符内容可以修改可以变化
package com.ylxstudy.string_;
/**
* @author 杨乐昕
* @version 1.0
*/
public class String01 {
public static void main(String[] args) {
/*
* 1.String 对象用于保存字符串，也就是一组字符序列
* 2.“jack”字符串常量，双引号括起来的字符序列
* 3.字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节
* 4.String 类有很多的构造器，构造器的重载
* 常用的构造器的有：
* String s1 = new String ();
* String s2 = new String (String original);
* String s3 = new String (char[] a);
* String s4 = new String (char[] a,int startIndex,int count);
* String s5 = new String (byte[] b);
* 5.Serializable:String 实现了Serializable接口，说明String 可以串行化
Comparable:String 实现了Comparable接口，说明String对象可以比较
* 6.String 是final类，不能被其他的类继承
* 7.String 有属性 private final char value[]; 用于存放字符串内容
* 8.一定要注意：value是一个final类型，不可以修改，：即指的是value不能指向新的地址
* 但是单个字符内容可以修改可以变化
*
* */
String name = "jack";
final char[] value = {'a','b','c'};
char[] v2 = {'t','o','m'};
value[0] = 'h';
//value = v2 ;是错误的，不可以修改value地址
}
}
String对象有两种创建方式
方式一：String s = “ylx”;
方式一先从常量池查看是否有"ylx"数据空间，如果有，直接指向；如果没有，则重新创建，然后再指向，s最终指向的是常量池的空间地址
方式二：String s1 = new String(“ylx”);// 调用构造器
方式二先再堆中创建空间，里面维护了value属性，指向常量池的ylx空间。
如果常量池没有ylx，重新创建，如果有，直接通过value指向。最终指向的是
堆中的空间地址
package com.ylxstudy.string_;
/**
* @author 杨乐昕
* @version 1.0
*/
public class StringExercise01 {
public static void main(String[] args) {
//两种创建String对象的区别
String s = "ylx";//直接赋值
String s1 = new String("ylx");//调用构造器
/*
* 1.方式一先从常量池查看是否有"ylx"数据空间，如果有，直接指向；如果没有，
* 则重新创建，然后再指向，s最终指向的是常量池的空间地址
* 2.方式二先再堆中创建空间，里面维护了value属性，指向常量池的ylx空间。
* 如果常量池没有ylx，重新创建，如果有，直接通过value指向。最终指向的是
* 堆中的空间地址
* */
String a = "abc";
String b = "abc";
System.out.println(a.equals(b));//根据源码，判断的是a和b之间的内容相等返回true
//String重写了Object的equals方法
/*
* public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
* */
System.out.println(a == b);//true
//a在常量池中查看有没有"abc"，没有之后创建，a指向该"abc"的地址
//b在常量池中查看有没有"abc",发现有之后，b直接指向“abc”的地址
//所以两个判断的是地址是否相同，结果是相同的
}
}
intern()方法 : 如果常量池中包含一个等于此String对象的字符串，用equals(Object)方法确定，有则返回池中的字符串地址,否则将String 对象添加到池中，并返回此String对象的引用
package com.ylxstudy.string_;
/**
* @author 杨乐昕
* @version 1.0
*/
public class StringExercise03 {
public static void main(String[] args) {
String a = "ylx";
String b = new String("ylx");
//intern()方法，如果常量池中包含一个等于此String对象的字符串，
// 用equals(Object)方法确定，则返回池中的字符串
//否则将String 对象添加到池中，并返回此String对象的引用
//!!!b.intern()方法最终返回的是常量池的地址（对象）
System.out.println(a == b.intern());//地址相同true
System.out.println(b == b.intern());
//b是指向堆中的地址，和常量池的地址不一样，返回false
}
}
字符串特性
一、
package com.ylxstudy.string_;
/**
* @author 杨乐昕
* @version 1.0
*/
public class StringExercise08 {
public static void main(String[] args) {
String a = "hello";
String b = "abc";
String c = a + b;
//先创建一个StringBuilder sb = new StringBuilder();
//先执行sb.append("hello")
//再执行sb.append("abc")
//String c = sb.toString()
//最后其实是c指向堆中的对象(String)value[]->"helloabc"
}
}
这里创建了三个对象
底层StringBuilder sb = new StringBuilder();
sb.append(a) 和 sb.append(b)
sb是在堆中，并且append是在原来的字符串的基础上追加的
❗❗重要规则：
String c1 = “ab” + “cd”; 常量相加，看的是常量池
String c2 = a + b; 变量相加，看的是堆中
二、
package com.ylxstudy.string_;
/**
* @author 杨乐昕
* @version 1.0
*/
public class StringExercise09 {
public static void main(String[] args) {
String s1 = "ylxstudy";//指向池中的ylxstudy
String s2 = "java" ;//指向池中java
String s5 = "ylxstudyjava";//指向池中的ylxstudyjava"
String s6 = (s1 + s2).intern();
//s6接收到的是s1 + s2常量池的内容ylxstudyjava返回的地址
System.out.println(s5 == s6);//所以这里地址相同，true
System.out.println(s5.equals(s6));//地址相同，内容也相同，true
}
}
三、
String 类的属性是final类型的，当发生改变时，指向也会发生改变
每次调用一次方法就创建一个新的对应方法的栈空间
package com.ylxstudy.string_;
/**
* @author 杨乐昕
* @version 1.0
*/
public class StringExercise10 {
public static void main(String[] args) {
Test1 ex = new Test1();
ex.change(ex.str,ex.ch);
System.out.print(ex.str + " and ");//javaand
System.out.println(ex.ch);//hava
}
}
class Test1 {
String str = new String("ylx");
final char[] ch = {'j', 'a', 'v', 'a'};
public void change (String str,char ch[]){
str = "java";
ch[0] = 'h';
}
}
String常用方法
String类是保存字符串常量的
每次更新都需要重新开辟空间，效率较低。
因此Java设计者提供了StringBuilder和StringBuffer
来增强String的功能并提高效率
怎么用就可以了
equals是区分大小写的；equalsIgnoreCase是忽略大小写的
“ylx”.length返回字符串的长度
indexOf: 从左向右索引
String s1 = “sjineu@jj”
int index = s1.indexOf(‘@’);
LastIndexOf: 从左向右索引
String s1 = “sjineu@jj@”
int index = s1.LastIndexOf(‘@’);
返回的是最后一个@ 的索引，前面出现@不取，只取最后一个
int index1 = s1.LastIndexOf(“sj”);
返回的是第一次出现该字符串的第一个字符的索引。0
substring
String name = “hello,张三”;
//下面的name.substring(6),从索引6开始截取后面的所有内容
sout(name.substirng(6));
//name.substirng(2,5)从索引第二个开始截取，截取到索引的5-1=4的位置(左闭右开)
sout(name.substring(2,5));
toUpperCase:将字符串全部转化为大写
toLowerCase:将字符串全部转化为小写
package com.ylxstudy.string_;
/**
* @author 杨乐昕
* @version 1.0
*/
public class StringMethod02 {
public static void main(String[] args) {
//3.concat字符串并接
String s1 = "贾宝玉 ";
s1 = s1.concat(" 林黛玉 ").concat(" 薛宝钗 ").concat("together");
System.out.println(s1);
//4.replace替换字符串中的字符
s1 = "杨乐昕 and 云来喜";
//s1.replace() 方法执行之后，返回的结果才是替换过的，
//注意对s1是没有任何影响的
s1 = s1.replace("杨乐昕","ylx");
System.out.println(s1);
//5.split 分割字符串
String[] split;
String poem = "E:\\AAA\\BBB&&nn";
//如果分割有特殊字符，需要假如特殊字符
split = poem.split("\\\\");//????
for (int i= 0;i < split.length;i++){
System.out.println(split[i]);
}
//6.toCharAarray 转化成字符数组
String s = "happy";
char[] chs = s.toCharArray();
for (int i = 0;i<chs.length;i++){
System.out.println(chs[i]);
}
//7.compareTo 比较两个字符串的大小，如果前者大，则返回正数
//后者大则返回负数；如果相等，返回0
//细节：
//如果长度相同，并且每个字符也相同，就返回0
//如果长度相同或者不相同，但是在进行比较时，可以区分大小就返回
//（某个字符的ASCII码减去另外一个的码）
//如果前面的部分都相同，就返回，str1.len - str2.len
String a = "jak";
String b = "jack";
System.out.println(a.compareTo(b));//a.len - b.len = -1
//8.format 格式字符串
String name = "yanglx";
int age = 21 ;
double score = 90 / 3;
char gender = '男';
String formatStr = "我的名字是%s 年龄是%d 成绩是%.2f 性别是%c ";
String info = String.format(formatStr,name,age,score,gender);
System.out.println("info=" + info);
}
}
三、⭐StringBuffer类
java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删，很多方法和String 相同，但StringBuffer是可变长度的。（用在多线程）
StringBuffer是一个容器
- StringBuffer的直接父类是AbstractStringBuilder
- StringBuffer 实现了 Serializable 即StringBuffer的对象可以串行化
- 在父类中 AbstractStringBuilder 有属性 char[] value,是存放StringBuffer对象字符串内容的
不是final,该value数组存放字符串内容，存放在堆中，而不是常量池 - StringBuffer是一个final类，不能被继承
- 因为StringBuffer 的字符内容是存放在char[] value，所有在变化（增加/删除）
不用每次都更换地址(即不是每次创建新对象)，所以效率较高
String 和 StringBuffer 的比较区别
- string保存的是字符串常量，里面的值不能更改，每次String类的更新实际
上是更改地址，效率较低
String -> private final char value[]- StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer
的更新实际上是更新内容，不用每次更新地址，效率较高；当value数组的空间
不够的时候，StringBuffer有自己的一套扩容机制，value扩容之后，会返回一个
全新的地址给value
StringBuffer -> char[] value
StringBuffer的构造器
- StringBuffer()
构造一个其中不带字符的字符串缓冲区，其初始值容量为16个字符
- StringBuffer(int capcity)
通过构造器指定char[]大小
- StringBuffer(String str)
构造一个字符串缓冲区，并将内容初始化为指定的字符串内容
StringBuffer hello = new StringBuffer(“hello”);
把当前传进去的字符串 的长度 加上 16，创建一个长度为“字符串长度+16”的char类型的数组
String 和 StringBuffer 的相互转换
package com.ylxstudy.stringbuffer_;
/**
* @author 杨乐昕
* @version 1.0
* String 和 StringBuffer的相互转换
*/
public class StringBuffer02 {
public static void main(String[] args) {
// String -> StringBuffer
String str = "hello tom";
//方式一使用构造器
StringBuffer stringBuffer = new StringBuffer(str);
//方式二使用append方法
StringBuffer stringBuffer1 = new StringBuffer();
stringBuffer1 = stringBuffer1.append(str);
//============================================================
// StringBuffer -> String
StringBuffer ylx = new StringBuffer("ylx");
//方式一使用提供的toString方法
String s = ylx.toString();
//方式二使用构造器
String s1 = new String(ylx);
}
}
StringBuffer类的常用方法
增——append 追加
删——delete(start,end) 左闭右开
改——replace(start,end,string)
查——indexOf(string) 查找字符串的第一个字符的索引返回，没有返回-1
插——insert(位置,字符串) 找到索引为9的字符位置插入要插入的字符串，原来位置的字符串后移
获取长度——length 返回字符串的长度
四、⭐StringBuilder类
基本介绍
- 一个可变的字符序列。此类提供一个与StringBuffer兼容的API，但不保证同步。（不是线程安全的）
该类被设计用作StringBuffer的简易替换，用在字符串缓冲区被单个线程使用的时候。
如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer要快 - 在StringBuilder上的主要操作是append和insert方法，它可以重载这些方法，以接受任意类型的数据
StringBuilder常用方法
StringBuilder和StringBuffer的方法是一样的，常用方法参考StringBuffer的常用方法
StringBuilder结构剖析
- StringBuilder的直接父类是AbstractStringBuilder
- StringBuilder 实现了 Serializable 即StringBuilder的对象可以串行化(对象可以在网络传输，可以保存文件)
- StringBuilder是final类，不能被继承
- StirngBuilder对象序列仍然是存放在父类 AbstractStringBuilder 的 char[] value
- StringBuilder的方法，没有做互斥的处理，即没有synchronized 关键字，因此在单线程的情况下使用StringBuilder
String StringBuffer StringBuilder之间的比较
- StringBuffer 和 StringBuilde非常类似，均可待变可变的字符序列，而且方法也一样
- String: 不可变字符序列，效率低，但是复用率搞高
- StringBuffer: 可变字符序列，效率较高（增删），线程安全
- StringBuilder: 可变字符序列，效率最高，线程不安全
- String使用注意说明
string s = “a”;//创建一个字符
s += “b”;//
实际上原来的“a”字符串对象已经丢弃了，现在又产生了一个字符串s+“b”,也就是“ab”，如果多次执行串内容的操作，会导致大量的副本字符串对象存留在内存中，降低效率，如果这样的操作放在循环中，会极大的影响程序的性能
结论：如果使用String做大量的修改，不要使用String
String StringBuffer StringBuilder 的选择
- 如果字符串存在大量的修改操作，一般使用StringBuffer或者StringBuilder
- 如果字符串存在大量的修改操作，并在单线程的情况，使用StringBuilder.
- 如果字符串存在大量的修改操作，并在多线程的情况下，使用StringBuffer
- 如果我们的字符串很少修改，被多个对象引用，使用String,比如配置信息
五、Math类
用于执行基本数学运算，都是静态方法，直接引用
常用数学静态方法
abs 绝对值
pow 求幂
ceil 向上取整
floor 向下取整
round 四舍五入
sqrt 求开方
random 求随机数 int num = (int)(Math.random()*(b-a+1)+a)
min( , ) 最小值
max( , ) 最大值
六、Arrays类
方法一：toString()
package com.ylxstudy.arrays_;
import java.util.Arrays;
/**
* @author 杨乐昕
* @version 1.0
* 使用Array类自带的遍历方法 Arrays.toString方法 显示数组
*/
public class ArraysMethod01 {
public static void main(String[] args) {
Integer[] integers = {1,20,98};
//使用Array类自带的遍历方法 Arrays.toString方法 显示数组
System.out.println(Arrays.toString(integers));
}
}
方法二：sort排序（自然排序和定制排序）
自然排序
是从小到大
package com.ylxstudy.arrays_;
import java.util.Arrays;
import java.util.Comparator;
/**
* @author 杨乐昕
* @version 1.0
*/
public class ArraysMethod02 {
public static void main(String[] args) {
Integer[] arr = {1,-1,7,0,89};
// //传统排序：冒泡排序 (从小到大)
// int temp = 0;//初始化一个变量 用于交换变量
// for (int i = 0;i < arr.length-1 ; i++){
// for (int j = 0 ; j < arr.length-1-i ; j++){
// if(arr[j] > arr[j+1]){
// temp = arr[j];
// arr[j] = arr[j+1];
// arr[j+1] = temp;
// }
// }
// }
// for (int i = 0;i< arr.length ;i++){
// System.out.print(arr[i] + " ");
// }
//默认排序
Arrays.sort(arr);
System.out.println("=====排序之后的====");
System.out.println(Arrays.toString(arr));
}
}
⭐定制排序
结合了 接口编程 多态的动态绑定 匿名内部类 内容
package com.ylxstudy.arrays_;
import java.util.Arrays;
import java.util.Comparator;
/**
* @author 杨乐昕
* @version 1.0
*/
public class ArraysMethod02 {
public static void main(String[] args) {
Integer[] arr = {1,-1,7,0,89};
//定制排序
/*
* 1.数组是引用类型，所以通过sort排序后，会直接影响到 实参 arr
* 2、sort是重载的，也可以通过传入一个接口 Comparator 实现定制排序
* 3.调用定制排序时，传入两个参数
* （1）要排序的数组 arr
* （2）实现了Comparator接口的匿名内部类，要求实现 compare方法
*
* 源码分析
* 1.Arrays.sort(arr,new Comparator(){...};)
* 2.最终到TimSort类的private static void binarySort(T[] a, int lo, int hi, int start,
Comparator c)
*3.执行到binarySort方法的代码，会根据动态绑定机制，c.compare()执行我们传入的匿名内部类的compare()
* binarySort()方法的一段关键代码
* while (left < right) {
int mid = (left + right) >>> 1;
if (c.compare(pivot, a[mid]) < 0)
right = mid;
else
left = mid + 1;
}
* 4.
* ...new Comparator() {
@Override
public int compare(Object o1, Object o2) {
Integer i1 = (Integer)o1;
Integer i2 = (Integer)o2;
return i2 -i1;//大于0还是小于0决定排序的顺序
}
* 5.public int compare(Object o1,Object o2) 返回的值 > 0 ，还是<0
* 会影响整个排序结果，还充分表现了 接口编程+动态绑定+匿名内部类 的综合使用
* 将来的底层框架和源码的使用方式，会非常常见
* */
Arrays.sort(arr, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
Integer i1 = (Integer)o1;
Integer i2 = (Integer)o2;
return i2 -i1;//大于0还是小于0决定排序的顺序
}
});
System.out.println("====定制排序=====");
System.out.println(Arrays.toString(arr));
}
}
方法三：binarySearch()方法
通过二分搜索法进行查找，要求必须排好序
package com.ylxstudy.arrays_;
import java.util.Arrays;
/**
* @author 杨乐昕
* @version 1.0
*/
public class ArraysMethod03 {
public static void main(String[] args) {
Integer[] integers = {1,34,55,123,445};
//使用Arrays类的binarySearch方法进行查找
//当查找的数字不在数组里面时，会通过要查找数字的大小在数字的其他元素中
//应该存放的位置，返回存放位置的索引
//int index = Arrays.binarySearch(integers,45);
//通过系统的比较，应该是在34 和 55 之间，根据索引，返回的是 ”2“+1 = 3
int index = Arrays.binarySearch(integers,34);
System.out.println("index = " + (index+1));
}
}
方法四：copyOf()方法
复制数组
package com.ylxstudy.arrays_;
import java.util.Arrays;
/**
* @author 杨乐昕
* @version 1.0
*/
public class ArraysMethod04 {
public static void main(String[] args) {
Integer[] arr4 = {12,23,44,45,23};
//从arr4数组中复制arr4.length个元素给 arrCopy
//如果要拷贝的长度大于被拷贝的数组的长度 就在多出来的元素位置添加一个null
//如果拷贝的长度<0 就会抛出异常
Integer[] arrCopy = Arrays.copyOf(arr4,5);
System.out.println(Arrays.toString(arrCopy));
}
}
方法五：fill() 填充
替换数组里面的元素
package com.ylxstudy.arrays_;
import java.util.Arrays;
/**
* @author 杨乐昕
* @version 1.0
*/
public class ArraysMethod05 {
public static void main(String[] args) {
//数组的填充fill
Integer[] arr5 = {12,23,33};
Arrays.fill(arr5,66);
System.out.println(Arrays.toString(arr5));
}
}
方法六：equals()
比较两个数组的元素是否一样
package com.ylxstudy.arrays_;
import java.util.Arrays;
/**
* @author 杨乐昕
* @version 1.0
*/
public class ArraysMethod06 {
public static void main(String[] args) {
Integer[] arr6 = {11,22,33};
Integer[] arr61 = {11,22,33};
//比较两个数组的元素是否一样
boolean equals = Arrays.equals(arr6,arr61);
System.out.println(equals);
}
}
方法七：aslist()
将一个数组的值，转为集合list
package com.ylxstudy.arrays_;
import java.util.Arrays;
import java.util.List;
/**
* @author 杨乐昕
* @version 1.0
*/
public class ArraysMethod07 {
public static void main(String[] args) {
List<Integer> asList = Arrays.asList(2,3,4,5,6,1);
System.out.println("asList= " + asList);
}
}
七、System类
方法一：exit退出当前的程序
exit(0) 参数0表示以正常状态退出
public class System_ {
public static void main(String[] args) {
System.out.println("ok1" );
exit(0);
System.out.println("ok2");
}
}
方法二：arraycopy( )
int[] src = {1,2,3};
int[] dest= new int[3];
System.arraycopy(src,0,dest,0,3);
System.out.println(Arrays.toString(dest));
arraycopy(x,x,x,x)
第一个参数表示要复制的原数组
第二个参数表示从原数组的第几个位置开始复制
第三个参数表示复制到哪个数组去
第四个参数表示从哪个位置开始粘贴
第五个参数表示复制原数组的多少个元素，以数组的长度决定
方法三：currentTimeMillens()
返回当前时间距离1970-1-1 的毫秒数
方法四：gc()垃圾回收机制
八、BigInteger类
当我们编程的中，需要处理很大的整数时，long不够用，可以使用BigInteger的类来搞定
package com.ylxstudy.biginteger_;
import java.math.BigInteger;
/**
* @author 杨乐昕
* @version 1.0
*/
public class BigInteger_ {
public static void main(String[] args) {
//long 不够存储这么大的数字，使用，BigInteger类来存储
// long num = 127777172774727277777l;
//传进去的值 要用双引号给括起来，源码是String类型的
//把数据当成字符串处理完之后，在转为BigInteger
BigInteger bigInteger = new BigInteger("127777172774727277777");
BigInteger bigInteger1 = new BigInteger("100");
//通过使用BigInteger类的方法来实现 加减乘除
//加
BigInteger add = bigInteger.add(bigInteger1);
System.out.println(add);
//减
BigInteger subtract = bigInteger.subtract(bigInteger1);
System.out.println(subtract);
//乘
BigInteger multiply = bigInteger.multiply(bigInteger1);
System.out.println(multiply);
//除
BigInteger divide = bigInteger.divide(bigInteger1);
System.out.println(divide);
}
}
九、BigDecimal类
当我们要保存一个精度很高的数字时，double不够用
加法 减法 乘法 和BigInteger类的用法是一样的
package com.ylxstudy.bigdecimal_;
import java.math.BigDecimal;
import java.math.BigInteger;
/**
* @author 杨乐昕
* @version 1.0
*/
public class BigDecimal_ {
public static void main(String[] args) {
// double D = 1223.44444334343433434434343434343434343434d;
BigDecimal bigDecimal = new BigDecimal("123.444455556666677");
BigDecimal bigDecimal1 = new BigDecimal("1.2");
//除法
// BigDecimal divide = bigDecimal.divide(bigDecimal1);
// System.out.println(divide);//会抛出异常，原因是，除不尽
//我们要在bigDecimal1 后面加上 BigDecimal.ROUND_CEILING
//如果有无限循环的小数，就会保留 和分子 一致的精度
BigDecimal divide = bigDecimal.divide(bigDecimal1,BigDecimal.ROUND_CEILING);
System.out.println(divide);
}
}
十、Date类
SimpleDateFormat 的日期格式
package com.ylxstudy.date_;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* @author 杨乐昕
* @version 1.0
*/
public class Date01 {
public static void main(String[] args) throws ParseException {
//获取当前的系统时间
//这里的Date是java.util包下的
//默认的输出日期格式是国外的格式
Date date = new Date();
System.out.println(date);
//可以通过指定的毫秒数得到时间
Date date1 = new Date(878724);
System.out.println(date1);
//创建SimpleDateFormat对象，可以指定相应的格式，要按照API文档要求的写
//这里的格式要规定好
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss E");
//SimpleDateFormat类下的 format() 方法是将日期转换成指定格式的字符串
String format = sdf.format(date);
System.out.println(format);
//可以把一个格式化的String 转成 对应的 Date
//得到的date仍然在输出时，还是以国外的形式输出，希望以规定的格式输出，需要转换
//把String -> Date,使用的sdf格式需要和你给的String 的格式一样，否则就会抛出异常
String s = "1996年01月01日 10:20:30 星期一";
Date parse = sdf.parse(s);
System.out.println("parse = " + sdf.format(parse));
}
}
十一、Calendar类
package com.ylxstudy.date_;
import java.util.Calendar;
/**
* @author 杨乐昕
* @version 1.0
*/
public class Calendar_ {
public static void main(String[] args) {
//Calendar 的构造器是受保护的，不能直接创建实例，要通过get方法获取
//抽象类，构造器是受保护的，通过，getInstance()来获取实例
//提供大量的方法和字段提供
//1.获取一个日历对象
Calendar c = Calendar.getInstance();
//2.获取日历对象的某个日历字段
System.out.println("年，" + c.get(Calendar.YEAR));
//3.获取月时 要 加一 ，因为Calendar返回月的时候，是按照从0 开始编号的
System.out.println("月，" + (c.get(Calendar.MONTH) + 1));
//4.日
System.out.println("日，" + c.get(Calendar.DAY_OF_MONTH));
//没有提供对应格式化的类，需要自己组合
System.out.println(c.get(Calendar.YEAR) + "年"
+ (c.get(Calendar.MONTH) + 1) + "月"
+ c.get(Calendar.DAY_OF_MONTH) + "日");
//按照24小时制
System.out.println(c.get(Calendar.YEAR) + "年"
+ (c.get(Calendar.MONTH) + 1) + "月"
+ c.get(Calendar.DAY_OF_MONTH) + "日"
+ c.get(Calendar.HOUR_OF_DAY) + ":"
+ c.get(Calendar.MINUTE) + ":"
+ c.get(Calendar.SECOND));
//不是线程安全的，
}
以上内容皆是本人通过韩顺平老师视频Java零基础学习的笔记，如果有侵权，请联系我删除❗❗❗