个人中心
文章发布
退出
作者热门文章
- ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机
- Ubuntu 通过无线网络安装Ubuntu Server启动系统后连接无线网络的方法
- 在Ubuntu上搭建网桥的方法
- ubuntu 虚拟机上网方式及相关配置详解
26
4
CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.
这篇CFSDN的博客文章Java常用工具类汇总(附示例代码)由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.
|
1
2
3
4
5
6
7
|
public
final
class
string
implements
java.io.serializable,comparable<string>,charsequence{
/** the value is used for character storage*/
private
final
char
value[];
//string 的底层就是放在char型数组当中（字符构成的串） //final：value是引用类型 其指向的地址不可以被修改
/*cache the hash code for the string*/
private
int
hash;
//default to 0
}
|
|
1
2
3
4
5
6
7
8
9
10
11
|
/*
string:字符串：使用一对“”引起来表示
1. string声明为final的，不可被继承
2. string
实现了serializable接口：表示字符串是可序列化的
（对象默认不可以通过网络传输，但是如果是可序列化的，那么就可以通过网络传输给对方 io流部分知识）
实现了comparable接口，表示string是可以比较大小的
3. string在内部定义了final的char型数组:final char value[] value用与存储字符串数据
4. 通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中
5. 字符串常量池中是不会存储相同内容的字符串的
*/
|
|
1
2
3
4
5
|
/*4. final：数组引用变量不能在指向别的数组，且数组对象内的元素也不能改变
即const int* const p; p是常量指针，且不能通过p对所指向的变量进行修改
体现
1）当对字符串重新赋值是，需要重写指定内存区域赋值，不能使用原有的value进行赋值
2) 当对现有的字符串进行连接操作时，也需要重新制定内存区域赋值，不能使用原有的字符串*/
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
@test
public
void
test(){
string s1 =
"abc"
;
//字面量的定义方式
string s2 =
"abc"
;
system.out.println(s1==s2);
//true
// s1="hello";
string s3 =
"abc"
;
s3+=
"def"
;
//并没有改变“abc” 而是新造了一个
system.out.println(s3);
//abcdef 并没有改变“abc” 而是新造了一个
system.out.println(s2);
//abc
system.out.println(
"******************"
);
string s4 =
"abc"
;
string s5 = s4.replace(
'a'
,
'z'
);
system.out.println(s5);
system.out.println(s4);
system.out.println(s2);
}
|
|
1
2
3
|
//string 实例化的方式
// 方式一：通过字面量定义的方式
// 方式二：通过new+构造器的方式
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
@test
public
void
test2(){
//通过字面量的方式 这个abc声明在方法区的字符串常量池种
string s1 =
"abc"
;
string s2 =
"abc"
;
//通过new+构造器的方式：此时的s3,s4保存的地址值，是数据在堆空间中开辟空间以后堆空间中地址值
string s3 =
new
string(
"abc"
);
string s4 =
new
string(
"abc"
);
system.out.println(s1==s2);
//true
system.out.println(s1==s3);
//false
system.out.println(s3==s2);
//false
system.out.println(
"********************"
);
person p1 =
new
person(
"shc"
);
person p2 =
new
person(
"shc"
);
system.out.println(p1.name.equals(p2.name));
//true
system.out.println(p1.name==p2.name);
//true 因为在person的对象中，生成string字符串的方式也是通过字面量 this.name="shc"
//如果在peron的构造器中用this.name=new string("shc"); 的方式，那么就是false
}
|
面试题:
面试题：!!!常考 string s = new string("abc"); 方式创建对象，在内存中创建了几个对象 两个：一个是堆空间中new结构，另一个是char[]对应的常量池中的数据："abc",
|
1
2
3
4
5
|
/*
1. 常量与与常量的拼接结果在常量池中，且常量池中不会存在相同内容的常量
2. 只要其中有一个是变量，结果就在堆中
3. 如果拼接的结果调用intern()方法，返回值就在常量池中
*/
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
@test
public
void
test3(){
string s1 =
"abc"
;
string s2 =
"hhh"
;
string s3 =
"abchhh"
;
//字面量
string s4 =
"abc"
+
"hhh"
;
//两个字面量的连接 还是字面量 在常量池中
string s5 = s1+
"hhh"
;
string s6 =
"abc"
+ s2;
string s7 = s1+s2;
system.out.println(s3==s4);
//true
system.out.println(s3==s5);
//false
system.out.println(s3==s6);
//false
system.out.println(s3==s7);
//false
system.out.println(s5==s6);
//false
system.out.println(s5==s7);
//false
system.out.println(s6==s7);
//false
string s = s5.intern();
system.out.println(s==s3);
//true
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
/**
* int length()：返回字符串的长度： return value.length
* char charat(int index)： 返回某索引处的字符return value[index]
* boolean isempty()：判断是否是空字符串：return value.length == 0
* string tolowercase()：使用默认语言环境，将 string 中的所有字符转换为小写
* string touppercase()：使用默认语言环境，将 string 中的所有字符转换为大写
* string trim()：返回字符串的副本，忽略前导空白和尾部空白
* boolean equals(object obj)：比较字符串的内容是否相同
* boolean equalsignorecase(string anotherstring)：与equals方法类似，忽略大小写
* string concat(string str)：将指定字符串连接到此字符串的结尾。 等价于用“+”
* int compareto(string anotherstring)：比较两个字符串的大小
* string substring(int beginindex)：返回一个新的字符串，它是此字符串的从
* beginindex开始截取到最后的一个子字符串。
* string substring(int beginindex, int endindex) ：返回一个新字符串，它是此字
* 符串从beginindex开始截取到endindex(不包含)的一个子字符串。
*
* boolean endswith(string suffix)：测试此字符串是否以指定的后缀结束
* boolean startswith(string prefix)：测试此字符串是否以指定的前缀开始
* boolean startswith(string prefix, int toffset)：测试此字符串从指定索引开始的
* 子字符串是否以指定前缀开始
*
* boolean contains(charsequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true
* int indexof(string str)：返回指定子字符串在此字符串中第一次出现处的索引
* int indexof(string str, int fromindex)：返回指定子字符串在此字符串中第一次出
* 现处的索引，从指定的索引开始
* int lastindexof(string str)：返回指定子字符串在此字符串中最右边出现处的索引
* int lastindexof(string str, int fromindex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
* 注：indexof和lastindexof方法如果未找到都是返回-1
*
* string replace(char oldchar, char newchar)：返回一个新的字符串，它是
* 通过用 newchar 替换此字符串中出现的所有 oldchar 得到的。
* string replace(charsequence target, charsequence replacement)：使
* 用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
* string replaceall(string regex, string replacement) ： 使 用 给 定 的
* replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
* string replacefirst(string regex, string replacement) ： 使 用 给 定 的
* replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
*
* boolean matches(string regex)：告知此字符串是否匹配给定的正则表达式
*
* string[] split(string regex)：根据给定正则表达式的匹配拆分此字符串。
* string[] split(string regex, int limit)：根据匹配给定的正则表达式来拆分此
* 字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。
* @author shc
* @create 2021-05-20 15:06
*/
|
|
1
2
3
4
5
|
/*
string与基本数据类型，包装类之间的转换
string --> 基本数据类型，包装类 :调用基本数据类型的 parsexxx（str）;
基本数据类型，包装类 ---> string :调用string类重载的valueof（xxx）; 或者直接+""
*/
|
|
1
2
3
4
5
6
7
8
9
10
|
@test
public
void
test(){
string str =
"123"
;
// int num = (int) str; //必须是子父类的关系才可以强转
int
num = integer.parseint(str);
//注意str中不能有数字 否则numberformatexception
system.out.println(num);
string str1 = string.valueof(num);
string str2 = num+
""
;
system.out.println(str1+
" "
+str2);
}
|
string与字符数组之间的转换 。
|
1
2
3
4
5
|
/*
string与char[]之间的转换
string -->char[] 调用string的tochararray()
char[] -->string 调用string的构造器
*/
|
|
1
2
3
4
5
6
7
8
9
10
11
|
@test
public
void
test2(){
string str1 =
"abc123"
;
char
[] chararray = str1.tochararray();
for
(
int
i=
0
;i<chararray.length;i++){
system.out.print(chararray[i]+
" "
);
}
char
[] arr =
new
char
[]{
'h'
,
'e'
,
'l'
,
'l'
,
'o'
};
string str =
new
string(arr);
system.out.println(str);
}
|
string与字节数组之间的转换 。
|
1
2
3
4
5
6
7
8
|
/*
string与byte[]之间的转换
编码：string --> byte[]:调用string的getbytes()
解码：byte[] --> string
编码：字符串 --> 字节 （看得懂 --> 看不懂）
解码：编码的逆过程 字节 --> 字符串 （看不懂的二进制 --> 看得懂）
说明：要求编码时使用的字符集和解码时使用的字符集必须一致
*/
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
@test
public
void
test3()
throws
unsupportedencodingexception {
string str1 =
"abc123中国"
;
byte
[] bytes = str1.getbytes();
//使用默认的字符集。进行转换
system.out.println(arrays.tostring(bytes));
byte
[] gbks = str1.getbytes(
"gbk"
);
//使用gbk字符集进行编码
system.out.println(str1);
system.out.println(arrays.tostring(gbks));
system.out.println(
"****************"
);
string str2 =
new
string(bytes);
//使用默认字符集进行解码
system.out.println(str2);
string gbks1 =
new
string(gbks);
system.out.println(gbks1);
//乱码
}
|
与stringbuilder,stringbuffer之间的转换 。
|
1
2
3
4
|
string --> stringbuffer、stringbuilder:调用stringbuffer、stringbuilder构造器
stringbuffer、stringbuilder --> string:
①调用string构造器
②stringbuffer、stringbuilder的tostring()
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
/*
string、stringbuilder、stringbuffer三者异同？
string：不可变的字符序列 ,char型数组存储
stringbuffer：可变的字符序列：线程安全，效率偏低，char型数组存储
stringbuilder：可变的字符序列：jdk5.0新增 线程不安全，效率高，char型数组存储
三者效率：stringbuilder > stringbuffer > string
源码分析：
string str = new string(); //char[] value = new char[0];
string str1 = new string("abc);//char[] value = new char[]={'a','b','c'};
stringbuffer sb1 = new stringbuffer();//char[] value = new char[16];//底层创建了一个长度为16的字符串数组
sb1.append('a');//value[0]='a';
sb1.append('b');//value[1]='b';
stringbuffer sb2 = new string("abc"); //char[] value = new char["abc".length()+16];
question 1：sout(sb2.length()); //"abc".length;
2：扩容问题：如果要添加的数据底层数组撑不下了，就要扩容底层的数组
默认情况下，扩容为原来容量的2倍+2，同时将原有数组中的元素复制到新的数组中。
指导意义：开发中建议大家使用：stringbuffer（int capacity)或者(stringbuilder(int capacity) 尽量避免扩容，影响效率
*/
@test
public
void
test(){
stringbuffer str1 =
new
stringbuffer(
"abc"
);
str1.setcharat(
0
,
'n'
);
system.out.println(str1);
}
|
jvm中字符常量池存放位置说明:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
public
class
stringbuilderbuffertest {
/*
string、stringbuilder、stringbuffer三者异同？
string：不可变的字符序列 ,char型数组存储
stringbuffer：可变的字符序列：线程安全，效率偏低，char型数组存储
stringbuilder：可变的字符序列：jdk5.0新增 线程不安全，效率高，char型数组存储
三者效率：stringbuilder > stringbuffer > string
源码分析：
string str = new string(); //char[] value = new char[0];
string str1 = new string("abc);//char[] value = new char[]={'a','b','c'};
stringbuffer sb1 = new stringbuffer();//char[] value = new char[16];//底层创建了一个长度为16的字符串数组
sb1.append('a');//value[0]='a';
sb1.append('b');//value[1]='b';
stringbuffer sb2 = new string("abc"); //char[] value = new char["abc".length()+16];
question 1：sout(sb2.length()); //"abc".length;
2：扩容问题：如果要添加的数据底层数组撑不下了，就要扩容底层的数组
默认情况下，扩容为原来容量的2倍+2，同时将原有数组中的元素复制到新的数组中。
指导意义：开发中建议大家使用：stringbuffer（int capacity)或者(stringbuilder(int capacity) 尽量避免扩容，影响效率
*/
@test
public
void
test(){
stringbuffer str1 =
new
stringbuffer(
"abc"
);
str1.setcharat(
0
,
'n'
);
system.out.println(str1);
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
/*
* stringbuffer类不同于string，其对象必须使用构造器生成。有三个构造器：
stringbuffer()：初始容量为16的字符串缓冲区
stringbuffer(int size)：构造指定容量的字符串缓冲区
stringbuffer(string str)：将内容初始化为指定字符串内容
常用方法
stringbuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接
stringbuffer delete(int start,int end)：删除指定位置的内容
stringbuffer replace(int start, int end, string str)：把[start,end)位置替换为str
stringbuffer insert(int offset, xxx)：在指定位置插入xxx
stringbuffer reverse() ：把当前字符序列逆转
* public int indexof(string str)
public string substring(int start,int end)
public int length()
public char charat(int n )
public void setcharat(int n ,char ch)
*
* 总结
* 增 append(x)
* 删 delete(int start,int end)
* 改 setcharat(int n,char ch) / repalce(int start,int end,string str)
* 查 charat(int n)
* 插 insert(int offset,xxx)
* 长度 length()
* 遍历 for()+charat() / tostring()
*
*/
|
面试题 。
获取当前系统时间java.lang.system类中的currenttimemillis() 。
|
1
2
3
4
|
long
time = system.currenttimemillis();
//返回时间为当前时间与1970年1月1日00:00之间以ms为单位的时间差，称为时间戳
system.out.println(time);
//1621602510493
|
java.util.date与java.sql.date 。
java.sql.date extends java.util.date 。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
/*
2. java.util.date类
① 两个构造器的使用
>构造器一：date（）创建一个对应当前时间的date对象
>构造器二：创建指定毫秒数(指定时间戳)的date对象
② 两个方法的使用
>tostring():显示当前的年、月、日、时、分、秒
>gettime();获取当前date对象的时间戳
③ java.sql.date类 extends java.util.date
>如何实例化
>如何将java.util.date对象转化为java.sql.date对象
*/
@test
public
void
test2(){
//构造器一：date（）创建一个对应当前时间的date对象
date date1 =
new
date();
system.out.println(date1.tostring());
//fri may 21 21:07:33 cst 2021
system.out.println(date1.gettime());
//1621602495849
//构造器二：创建指定毫秒数的date对象
date date2 =
new
date(1621602495849l);
system.out.println(date2.tostring());
//frimay 21 21:08:15 cst 2021
//或者直接date2也一样，因为sout就是会调用tostring啊。
//这可不是把date类对象转化成string类对象了！！！！！！！
system.out.println(
"*****************"
);
//创建java.sql.date对象
java.sql.date date3 =
new
java.sql.date(323156136l);
system.out.println(date3);
//1970-01-05
//如何将java.util.date对象转化为java.sql.date对象
//情况1：(java多态）
date date4 =
new
java.sql.date(1235346456l);
java.sql.date date5 = (java.sql.date)date4;
//情况2：
date date6 =
new
date();
java.sql.date date7 =
new
java.sql.date(date6.gettime());
//而不能是java.sql.date date7 = (java.sql.date)date6;
}
|
java.text.simpledateformat类 。
用处：simpledateformat对日期date类的 格式化和 解析（date里还有很多方法被@deprecated了）（jdk8建议用calendar） 。
|
1
2
3
4
5
6
7
8
9
10
11
|
//1. 实例化simpledateformat
simpledateformat sdf =
new
simpledateformat();
//2. 格式化：日期 (date)--> 字符串(string)
date date =
new
date();
//date（）创建一个对应当前时间的date对象
system.out.println(date);
// sat may 22 19:50:32 cst 2021
string format = sdf.format(date);
// simpledateformat对date进行解析，获得字符串：21-5-22 下午7:50
system.out.println(format);
// 输出解析后得到的字符串 21-5-22 下午7:50
//解析：格式化的逆过程。字符串(string) ---> 日期(date)
string str =
"21-5-22 下午7:49"
;
date date1 = sdf.parse(str);
//可能导致编译异常原因：字符串格式不对
system.out.println(date1);
//sat may 22 19:49:00 cst 2021
|
（3）以下为开发中主要方式 --> 按照指定方式格式化和解析 ：调用带参构造器 。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
//开发中通常不用默认构造器，而是用指定的构造器来确定格式化方式
//simpledateformat sdf2 = new simpledateformat("yyyyy.mmmmm.dd ggg hh:mm aaa");
//年 yyyy -- 月 mm (大写是为了和分钟mm区分开) -- 天 dd -- 时 hh -- 分钟 mm -- 秒 ss
//1. 实例化
simpledateformat sdf2 =
new
simpledateformat(
"yyyy-mm-dd ---- hh:mm:ss"
);
//2. 格式化
string format2 = sdf2.format(date);
//以我们制定的yyyy-mm-dd ---- hh:mm:ss格式来进行转化
system.out.println(format2);
//2021-05-23 ---- 01:22:21
//3. 解析:
//要求字符串必须是符合simpledateformat识别的格式（通过构造器参数体现），否则就会抛出异常
date date2 = sdf2.parse(
"2021-05-23 ---- 01:22:21"
);
system.out.println(date2);
//sun may 23 01:22:21 cst 2021
|
calendar类：日历类，抽象类 。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
/*
calendar日历类（抽象类）的使用
*/
@test
public
void
testcalendar(){
//1.实例化
//方式一：创建其子类(gregoriancalendar)的对象
//方式二：调用其静态方法getinstance();
calendar calendar = calendar.getinstance();
system.out.println(calendar.getclass());
//class java.util.gregoriancalendar
//2.常用方法
//get()
system.out.println(calendar.get(calendar.day_of_month));
//23
system.out.println(calendar.get(calendar.day_of_year));
//143
//set()
//calendar劣势：可变性
calendar.set(calendar.day_of_month,
7
);
//void set() 把calendar本身给改了
system.out.println(calendar.get(calendar.day_of_month));
//7
//add()
calendar.add(calendar.day_of_month,-
3
);
//4
system.out.println(calendar.get(calendar.day_of_month));
//gettime():日历类 ---> date
date date = calendar.gettime();
system.out.println(date);
//tue may 04 13:45:07 cst 2021
system.out.println(
"****************"
);
//settime():date --> 日历类
date date1 =
new
date();
calendar.settime(date1);
system.out.println(calendar.get(calendar.day_of_month));
//23
|
本地日期、本地时间、本地日期时间的使用：localdate、localtime、localdatetime 。
时间点：instant 。
说明 。
常用方法 。
特别的，自定义格式，如:如：ofpattern(“yyyy-mm-dd hh:mm:ss”)* 。
|
1
2
3
4
5
6
7
8
9
10
|
//方式三：自定义的格式。如：ofpattern(“yyyy-mm-dd hh:mm:ss”)
datetimeformatter formatter3 = datetimeformatter.ofpattern(
"yyyy-mm-dd hh:mm:ss"
);
//格式化
string str4 = formatter3.format(localdatetime.now());
system.out.println(str4);
//2021-05-22 11:07:16
//解析：
temporalaccessor accessor = formatter3.parse(
"2021-05-22 03:06:09"
);
system.out.println(accessor);
//{nanoofsecond=0, milliofsecond=0, minuteofhour=6, secondofminute=9, microofsecond=0, hourofampm=3},iso resolved to 2021-05-22
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
package
com.shc.java1;
import
org.junit.test;
import
java.math.bigdecimal;
import
java.math.biginteger;
/**
* 1. system
* 2. math
* 3. biginteger bigdecimal
* @author shc
* @create 2021-05-23 12:29
*/
public
class
othertest {
@test
public
void
test1(){
string javaversion = system.getproperty(
"java.version"
);
system.out.println(
"java的version:"
+ javaversion);
string javahome = system.getproperty(
"java.home"
);
system.out.println(
"java的home:"
+ javahome);
string osname = system.getproperty(
"os.name"
);
system.out.println(
"os的name:"
+ osname);
string osversion = system.getproperty(
"os.version"
);
system.out.println(
"os的version:"
+ osversion);
string username = system.getproperty(
"user.name"
);
system.out.println(
"user的name:"
+ username);
string userhome = system.getproperty(
"user.home"
);
system.out.println(
"user的home:"
+ userhome);
string userdir = system.getproperty(
"user.dir"
);
system.out.println(
"user的dir:"
+ userdir);
}
@test
public
void
test2(){
biginteger bi =
new
biginteger(
"12433241123"
);
bigdecimal bd =
new
bigdecimal(
"12435.351"
);
bigdecimal bd2 =
new
bigdecimal(
"10"
);
system.out.println(bi);
// system.out.println(bd.divide(bd2)); 魏没有指明精度 如果除不尽的话会异常
system.out.println(bd.divide(bd2, bigdecimal.round_half_up));
//四舍五入
system.out.println(bd.divide(bd2,
20
, bigdecimal.round_half_up));
//scale：小数位位数 支持任意精度的小数位
}
}
|
引入 。
|
1
2
3
|
* 说明：java中的对象中，正常情况下，只能进行比较：== 或者 != 不能使用>或者<的
* 但是在开发场景中，我们需要对多个对象进行排序，言外之意，就是要比较对象的大小
* 如何实现? 使用两个接口中的任何一个：comparable 或 compare任意一个
|
自然排序comparable 。
说明 。
|
1
2
3
4
5
6
7
8
9
10
11
|
/*
comparable接口使用举例：自然排序
1. 像string、包装类等实现了comparable接口，重写compareto()方法，给出比较两个对象大小的方式
2. 像string、包装类重写了compareto方法以后，进行了从小到大的排列
3. 重写compareto()的规则
如果当前对象this大于形参对象obj，则返回正整数，
如果当前对象this小于形参对象obj，则返回负整数，
如果当前对象this等于形参对象obj，则返回零。
4. 对于自定义类来说，如果需要排序，我们可以自定义类实现comparable接口，重写compareto方法，
在compareto(obj)指明如何排序。
*/
|
代码举例 。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
/**
* 商品类
* @author shc
* @create 2021-05-23 10:57
*/
public
class
goods
implements
comparable{
private
string name;
private
double
price;
//指明商品比较方式，先按照价格递增，再按照名字递增
@override
public
int
compareto(object o){
system.out.println(
"=================="
);
if
(o
instanceof
goods){
goods good = (goods) o;
if
(good.price<
this
.price){
return
1
;
}
else
if
(good.price>
this
.price){
return
-
1
;
}
else
{
return
this
.name.compareto(good.name);
//再按照名字排序
// return 0;
}
//方式二
// return double.compare(this.price,((goods)o).price);
}
throw
new
runtimeexception(
"传入数据类型不一致错误"
);
}
}
@test
public
void
test2(){
goods[] goods =
new
goods[
5
];
int
x = goods.length;
system.out.println(goods.length);
//5 是数组本身的长度
goods[
0
] =
new
goods(
"shubiao"
,
12
);
goods[
1
] =
new
goods(
"diannao"
,
78
);
goods[
2
] =
new
goods(
"erji"
,
10
);
goods[
3
] =
new
goods(
"xianshiqi"
,
1
);
goods[
4
] =
new
goods(
"xian"
,
1
);
arrays.sort(goods,
0
,goods.length);
for
(
int
i=
0
;i<goods.length;i++){
system.out.println(goods[i]);
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
/*sort方法时回调用compareto*/
==================
==================
==================
==================
==================
==================
==================
==================
==================
goods{name=
'xian'
, price=
1.0
}
goods{name=
'xianshiqi'
, price=
1.0
}
goods{name=
'erji'
, price=
10.0
}
goods{name=
'shubiao'
, price=
12.0
}
goods{name=
'diannao'
, price=
78.0
}
|
定制排序 comparator 。
引入 。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
arrays.sort(goods,
new
comparator(){
//接口可以new吗？
@override
public
int
compare(object o1,object o2){
if
(o1
instanceof
goods && o2
instanceof
goods){
goods g1 = (goods) o1;
goods g2 = (goods) o2;
if
(g1.getname().equals(g2.getname())){
//名字相同时 按照价格递减
return
-
double
.compare(g1.getprice(),g2.getprice());
}
else
{
return
g1.getname().compareto(g2.getname());
}
}
throw
new
runtimeexception(o1+
"输入数据类型错误"
);
//如果有一个数组元素为空的话也会走到这里 因为null instanceof goods 为false 不会进入if
//如果用的是o1.tostring()的话则会是nullpointerexception 因为在throwruntimeexception的时候会走到tostring()这一步 而null调用tostring()则是空指针异常
}
});
|
两种排序方式对比 。
|
1
2
3
4
|
/* 2、comparable接口与comparator的使用的对比
* comparable接口的方式一旦设定，保证了comparable接口实现类的对象在任意位置都可以比较大小
* comparator接口属于临时性的比较
*/
|
画出如下几行代码的内容结构 。
|
1
2
3
4
|
string s1 =
"hello"
;
string s2 =
"hello"
;
string s3 =
new
string(
"hello"
);
s1+=
"world"
; <---> s1 = s1+
"hello"
; 右则有变量s1参与，所以拼接结果在堆中
|
length()/charat()/equals()/compareto()... 。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
simpledateformat
simpledateformat sdf =
new
simpledateformat(
"yyyy--mm--dd"
);
// 解析（字符串string-->日期date）：
java.util.date utildate = sdf.parse(
"2021-02-23"
);
// 再用date来gettime（）（返回的是longms），再放入构造器中
java.sql.date sqldate =
new
java.sql.date(utildate.gettime());
datetimeformatter
datetimeformatterdtf = datetimeformatter.ofpattern(
"yyyy-mm-dd"
);
..............
实例化方式：
new
+构造器
单例模式（
private
构造器）
calendar.getinstance()
//calendar是一个抽象类，获取的是他的子类（private构造器）
|
解释何为编码？解码？何为日期时间的格式化，解析?
编码：字符串 -> 字节 。
解码：字节 -> 字符串 。
格式化（format）：日期 ->字符串 。
解析（parse）：字符串 -> 日期 。
自定义person类如下，如何实现自然排序？（按照名字从小到大） 。
|
1
2
3
4
5
6
7
8
9
10
11
|
class
person
implements
comparable{
private
string name;
@override
public
int
compareto(object o){
if
(o
instanceof
person){
person p = (person) o;
return
this
.name.compareto(p.name);
}
throw
new
exception(
""
);
}
}
|
提供定制排序涉及到的接口的实现类对象，并按person类的年龄从大到小排序 。
|
1
2
3
4
5
6
|
comparator cp =
new
comparator(){
@override
public
int
compare(object obj1,object obj2){
if
(..)
}
}
|
jdk8 之前和 jdk8 中与日期、时间相关的类分别有哪些?
|
1
2
3
4
|
jdk8之前 jdk8
java.util.date 和 java.sql.date ---> instant (本初子午线的时间)
simpledateformat --->datetimeformatter
calendar --->localdate,localtime,localdatetime
|
这篇文章就到这里了，希望能给大家带来帮助，更多也可参考:Java常用工具类汇总 附示例代码 也希望您能多多关注我的更多内容！ 。
原文链接：https://www.cnblogs.com/4-Prestar/p/14824254.html 。
最后此篇关于Java常用工具类汇总(附示例代码)的文章就讲到这里了,如果你想了解更多关于Java常用工具类汇总(附示例代码)的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。
26
4
0
这个问题在这里已经有了答案: Android ADT version required 20.0.0 and above (10 个答案) 关闭 9 年前。 我刚刚安装了 Eclipse Juno
按照 This page from codeplex 上的指南进行操作后，我无法在我的工具/选项窗口中看到 Python 选项。我认为我与指南的唯一偏差是: 发行版:没有安装 activestate
我有一个非常大的 .sql 脚本。我将此脚本添加到 Visual Studio 2013 下的 SQL Server 项目中。当我尝试构建它时，我收到此错误消息 This T-SQL script e
当我在SpringBoot项目中想加个依赖，但是不确定现有依赖的依赖的依赖.....有没有添加过这个依赖，怎么办呢？如果添加过了但是不知道我需要的这个依赖属于哪个依赖的下面，怎么查呢？ IDEA中提供
我正在做一个项目来减少 PDF 的大小，压缩它们。我想知道市场上是否有任何非常好的工具/库(.NET)。 我确实尝试了一些像 Onstream Compression 这样的工具，但结果并不令人满意。
我想从我的源代码编译一个安卓内核。 但我想使用工具或类似的东西。 所以我只需单击一个按钮并获得一个可闪存的 zip 文件... 有工具吗？ 我可以用脚本来做吗？ 谢谢! 最佳答案 这取决于您从哪里获得
我们生成 pdf 文件，其中包含有关数万名客户每月财务余额的数据。在高峰期(年底有 100.000 个文件)，使用在 5 台服务器之间分配负载，该过程可能需要长达 5 天的时间才能完成。工作负载的分配
模块：xmllib xmllib 是一个非验证的低级语法分析器。应用程序员使用的 xmllib 可以覆盖 XMLParser 类，并提供处理文档元素（如特定或类属标记，或字符实体）的方法。从 Py
关闭。这个问题不符合Stack Overflow guidelines .它目前不接受答案。 我们不允许提问寻求书籍、工具、软件库等的推荐。您可以编辑问题，以便用事实和引用来回答。 关闭 3 年前。
我在一家医疗保健公司工作，拥有有关患者位置(地址、城市、州、 zip )的信息。我试图确定有多少百分比的患者住在离 5 个特定位置最近的地方。我正在寻找的答案是“25% 的患者住在离#1 地点最近的地
关闭。这个问题不符合Stack Overflow guidelines .它目前不接受答案。 4年前关闭。 我们不允许在 Stack Overflow 上提出有关通用计算硬件和软件的问题。您可以编辑问
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be
请问我在哪里可以得到 SvcTraceViewer 工具？ 我尝试下载并安装许多 SDK。 我查看了程序文件的垃圾箱。 我需要它来跟踪我的 WCF 调用出了什么问题。 最佳答案 您可以通过下载 Win
我正在尝试在我最喜欢的编辑器中设置适当的代码完成功能，我们将其称为AnEditor，以避免互联网上充斥着特定于程序的答案。 (您知道语言是ALanguage。)编辑器具有两个我喜欢的功能:它既可以在控
就目前而言，这个问题不适合我们的问答形式。我们希望答案得到事实、引用或专业知识的支持，但这个问题可能会引起辩论、争论、投票或扩展讨论。如果您觉得这个问题可以改进并可能重新打开，visit the he
当 merge 的两个分支对同一文件有更改时，Mercurial 是否总是使用外部 merge 工具？ 或者它是否首先查看它是否可以 merge 文件本身，如果不能，则仅转向外部工具？ 我问的原因是我
我正在为我使用的编辑器编写 Scala 插件，该插件将突出显示所有未使用的代码路径(可能未使用 defs 、 vals 、 classes 和 implicits )，并为用户提供一个选项以将它们从.
我有 jquery 工具滚动器...我喜欢它只为 swipeLeft swipeRight 实现触摸选项。 当我使用 touch: true 时，它也会在向上/向下滑动时旋转.. 我按照此处的说明
我已经尝试了一些用于构建 UML(对象/依赖图)的 Eclipse 工具，但我真正需要的是一个工具来生成这样的代码外 UML。 (反之亦然) 我更喜欢一个简单的 UML 工具，它易于安装并且没有任何依
已关闭。此问题不符合Stack Overflow guidelines 。目前不接受答案。 要求我们推荐或查找工具、库或最喜欢的场外资源的问题对于 Stack Overflow 来说是偏离主题的，因为
我是一名优秀的程序员,十分优秀！