一 常用类之String类
1 String类概述
1.1 String类简介
String类代表字符串类,java程序中所有的字符串文字都作为该类的实例,字符串不变,他们的值在创建之后不可被更改。
特点:
- 类被final修饰,表明不可被继承。
- 类实现了Serializable接口,表明该类可以序列化。
- 类实现了Comparable接口,表明该类可以比较大小。
- 类内部定义了final char[] value,用于存储字符串数据。
1.2 创建字符串对象的方式
1)字面量的方式
String string=“abc”; //生成的对象在方法区的常量池中
2)调用构造器的方式来创建String对象
String string=new String(“abc”); //创建了两个对象
初始化新创建的String
对象,使其表示与参数相同的字符序列; 换句话说,新创建的字符串是参数字符串的副本。
1.3 内存分析
1)创建的对象的个数
String s1=“123”;
s1=s1+“45”;
对于这两行代码来说,创建了3个字符串对象,即值为“123”,“45”,“122345”。
2)创建的对象的个数
String string=new String(“abc”);
创建了两个对象,一个对象为“abc”存在于常量池中,另一个为String对象,存在于堆中。
3)jvm内存解析
在jvm的规范中,方法区(又称永久区)逻辑上属于堆的一部分,但是实际落地的时候,方法区和堆是分开的。
常量池的位置也随着JDK版本的迭代发生着变化。
JDK1.6及以前:常量池分配在永久代,在方法区中。
JDK1.7:依旧存在,但是已经逐步去永久代的路上,1.7在堆中(heap space)。
JDK1.8及以后:字符串常量池依旧在方法区,此时不叫永久代,叫metadata,元数据。
1.4 String类常见的构造器的使用
-
String()
初始化新创建的String
对象,使其表示空字符序列。String(byte[] bytes)
通过使用平台的默认字符集解码指定的字节数组来构造新的String
。String(byte[] bytes, int offset, int length)
通过使用平台的默认字符集解码指定的字节子阵列来构造新的String
。String(byte[] bytes, String charsetName)
构造一个新的String
由指定用指定的字节的数组解码[charset]。String(char[] value, int offset, int count)
分配一个新的String
,其中包含字符数组参数的子阵列中的字符。String(String original)
初始化新创建的String
对象,使其表示与参数相同的字符序列; 换句话说,新创建的字符串是参数字符串的副本。String(StringBuffer buffer)
分配一个新的字符串,其中包含当前包含在字符串缓冲区参数中的字符序列。String(StringBuilder builder)
分配一个新的字符串,其中包含当前包含在字符串构建器参数中的字符序列。常见的编码集:UTF-8,GBK,GB2312,ISO-8859-1,ascII
1.5 StringAPI
1.5.1 常见API
- int length():返回字符串的长度。
- char charAt(Int index):返回指定索引处的字符。
- boolean isEmpty():判断数组是否是空的。
- String toLowerCase():全部字符转换为小写的。
- String toUpperCase():全部的字符转换为大写。
- String trim():忽略前后空白,字符串中间的空白不会发生变化。
- boolean equals(String str):比较两个字符串的内容是否相同。
- boolean equalsIgnoreCase(String str):忽略大小写的对比。
- String concat(String str):字符串的连接。
- int compareTo(string str):比较两个字符串的大小,涉及到字符串的排序,关注的是内容。
- String substring(int beginIndex):返回索引以后的字符串。
- String substring(int beginIndex,int endIndex):返会索引区间内的字符串.[begin,end)
1.5.2 查找相关的API
- boolean endsWith(String suffix):测试此字符串是不是以指定的字符串结束的。
- boolean startsWith(String prefix):测试字符串是不是以指定字符串结尾的。
- boolean startsWith(String prefix,int offset):此字符串从指定的索引处的子字符串是不是以指定字符串开头的。
1.5.3 判断是否包含某字符串
-
boolean contains(CharSequence s):判断当前字符串是否包含指定的字符串
-
int indexOf(String str):判断指定字符是否存在,存在的话返回第一次出现的索引位置,未找到返回-1.
-
int indexOf(String str,int fromIndex):从指定索引处,查找是否存在指定的字符串,存在返回指定索引,不存在就返回-1.
-
int lastIndexOf(String str):返回最后一次出现该字符串的索引位置。
-
int lastIndexOf(String str,int fromIndex):从指定的索引位置开始反向搜索,从右往左,返回最后一次出现该字符串的索引位置。
注意:什么情况下,indexOf和lastIndexOf返回值相同?==>存在唯一的指定字符串,或者不存在该字符串。
1.5.4 替换
- String replace(char oldChar,char new Char):返回一个新的字符串,将原有字符串中某个字符进行替换。
- String replace(charSequence target,charSequence replacement):返回一个新的字符串,将原有字符串中某个字符串使用新的字符串进行替换。
- String replaceAll(String regex,String replacement):使用给定的字符串替换符合正则表达式的部分。
- String replaceFirst(String regex,String replacement):使用给定的字符串替换第一次符合正则表达式的部分。
1.5.5 匹配
- boolean matches(String regex)::告知该字符串是否匹配正则表达式。
1.5.6 切分
- String[] split(String regex):根据给定的正则表达式的匹配拆分此字符串。
- String[] split(String regex,int limit):根据匹配给定的正则表达式拆分此字符串,最多不超过指定个数。
1.6字符串和其他类型转换问题
1)String和基本数据类型,包装类之间的转换
String==>基本数据类型,包装类:调用包装类的静态方法:parseXxx();
基本数据类型,包装类==>String :调用String重载的valueOf()方法.
2)String和char[]之间的转换
String==>char[] :string里面的方法toCharArray()。
char==>String:String的构造器。
面试题:字符串的反转,变成char数组,然后进行反转
4)String和byte[]之间的转换
String==>byte[]:String方法里面的getBytes()==>编码
byte[]>String:String的构造器>解码
2 字符串缓冲区
2.1 StringBuffer,StringBuilder和String三者的异同
String:JDK1.0,不可变字符序列,底层使用char[]来进行存储。
StringBuffer:JDK1.0,可变字符序列,线程安全的(效率低),底层使用char[]来进行存储。
StringBuilder:JDK1.5新增,可变字符序列,线程不安全的(效率高),底层使用char[]来进行存储。
2.2 简单分析:
1)String
String str=new String(); //char[] value=new char[0];
String str1=new String(“abc”); //char[] value=new char[]{‘a’,‘b’,‘c’};
2)StringBuffer和StringBuilder
StringBuffer sb1=new StringBuffer();//new char[16]相当于创建了一个char类型数组长度为16。
sb1.append(‘a’); value[0]=‘a’;
sb1.append(‘b’); value[1]=‘a’;
StringBuffer sb1=new StringBuffer(“abc”);//new char[16+abc.length]相当于创建了一个数组长度为16+abc.length。sb.length=3
sb1.append(‘a’); value[abc.length]=‘a’;
sb1.append(‘b’); value[abca.length]=‘a’;
注意:输出数组的长度为实际字符串的长度。
2.3 扩容机制
因为StringBuilder底层使用char[ ] value来进行存储数据,当我们进行追加的时候需要对数组的长度进行判断。接下来对源码进行分析。
//追加字符串的方法,调用父类的方法
@Override
public StringBuilder append(String str) {
//调用父类中的append();
super.append(str);
return this;
}
//父类中的append方法如下
public AbstractStringBuilder append(String str) {
//判断添加的字符串是否为空
if (str == null)
return appendNull();
int len = str.length();
//确定容量足够(已经使用的字符长度和新添加的字符串的长度)
ensureCapacityInternal(count + len);
str.getChars(0, len, value, count);
//修改字符数
count += len;
return this;
}
//确定容量的方法(参数为已经使用的字符长度和新添加的字符串的长度)
private void ensureCapacityInternal(int minimumCapacity) {
// overflow-conscious code
//如果长度不够,进行扩容操作
if (minimumCapacity - value.length > 0) {
value = Arrays.copyOf(value,
newCapacity(minimumCapacity));
}
}
//扩容
private int newCapacity(int minCapacity) {
// overflow-conscious code
//容量增大一倍且+2
int newCapacity = (value.length << 1) + 2;
if (newCapacity - minCapacity < 0) {
newCapacity = minCapacity;
}
return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
? hugeCapacity(minCapacity)
: newCapacity;
}
private int hugeCapacity(int minCapacity) {
if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
throw new OutOfMemoryError();
}
//Integer.MAX_VALUE - 8==0x7fffffff-8
return (minCapacity > MAX_ARRAY_SIZE)
? minCapacity : MAX_ARRAY_SIZE;
}
总结:如果要添加的数据底层数组盛不下,那就需要扩容底层数组,默认情况下扩容为原来容量的的2倍加2。如果还不够用,则新的长度为添加的字符串的长度与原字符串的长度和。然后将这个将数组中的数据复制到新的数组中去。
2.4 常用方法
-
StringBuffer append(XXX) :追加指定的字符串到末尾。
-
StringBuffer delete(int start,int end) :删除指定位置的内容。[begin,end)
-
StringBuffer replace(int start,int end,String str) :替换指定位置的内容。
-
StringBuffer insert(int offset,xxx) :指定位置插入数据。
-
StringBuffer reverse() :把当前字符序列反转
-
public int indexOf(String str):返回指定字符串第一次出现的索引位置
-
public String substring(int start,int end):返回[start,end)的子字符串。
-
public int length():返回字符串的长度。
-
public char charAt(int n):返回指定位置的字符串
-
public void setCharAt(int n,char ch):修改指定位置的字符
2.5 简单使用
@Test
public void test02(){
StringBuffer sb1=new StringBuffer("abcd123");
sb1.append("abc");
//abcd123abc
System.out.println(sb1);
//[start,end)
sb1.delete(3,7);
//abcabc:
System.out.println(sb1);
sb1.replace(0,3,"hello");
//helloabc
System.out.println(sb1);
sb1.insert(5,",");
//hello,abc
System.out.println(sb1);
sb1.reverse();
//cba,olleh
System.out.println(sb1);
String substring = sb1.substring(0, 3);
//cba
System.out.println(substring);
sb1.setCharAt(7,'o');
sb1.setCharAt(8,'。');
System.out.println(sb1);
}
2.6 练习
1.字符串大写转化为小写,小写转化为大写,删除其中的数字
public static void main(String[] args) {
System.out.println(changestr1("asDSSasd qhw 12131 awdq"));
System.out.println(changestr2("asDSSasd qhw 12131 awdq"));
}
public static String changestr1(String str) {
StringBuilder builder=new StringBuilder(str);
for (int i = 0; i < builder.length(); i++) {
if (builder.charAt(i)>='0'&&builder.charAt(i)<='9') {
builder.deleteCharAt(i);
i--;
}else if (builder.charAt(i)>='a'&&builder.charAt(i)<='z') {
builder.setCharAt(i, (char)(builder.charAt(i)-('a'-'A')));
}else if (builder.charAt(i)>='A'&&builder.charAt(i)<='Z') {
builder.setCharAt(i, (char)(builder.charAt(i)+('a'-'A')));
}
}
return builder.toString();
}
public static String changestr2(String str) {
StringBuilder builder=new StringBuilder(str);
for (int i = 0; i < builder.length(); i++) {
if (Character.isDigit(builder.charAt(i))) {
builder.deleteCharAt(i);
i--;
}else if (Character.isLowerCase(builder.charAt(i))) {
builder.setCharAt(i, (char)(builder.charAt(i)-('a'-'A')));
}else if (Character.isUpperCase(builder.charAt(i))) {
builder.setCharAt(i, (char)(builder.charAt(i)+('a'-'A')));
}
}
return builder.toString();
}
拓展:String类常见的练习题
1.模拟一个trim方法,去除字符串两端的空格。
1.1 trim源码
public String trim() {
int len = value.length;
int st = 0;
char[] val = value; /* avoid getfield opcode */
while ((st < len) && (val[st] <= ' ')) {
st++;
}
while ((st < len) && (val[len - 1] <= ' ')) {
len--;
}
return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
}
1.2自定义trim( )
public static String getTrim(String oldString){
char[] chars=oldString.toCharArray();
int beginIndex=0;
int lastIndex=0;
for (int i = 0; i < oldString.length(); i++) {
if(chars[i]!=' '){
beginIndex=i;
break;
}
}
for (int i = oldString.length()-1; i>=beginIndex; i--) {
if(chars[i]!=' '){
lastIndex=i;
break;
}
}
return lastIndex>beginIndex?oldString.substring(beginIndex,lastIndex+1):"";
}
public static String myTrim2(String oldString) {
char[] chars = oldString.toCharArray();
int beginIndex = -1;
int lastIndex = -1;
// 获取第一个非空字符的下标
for (int i = 0; i < oldString.length(); i++) {
if (chars[i] != ' ' && beginIndex == -1) {
beginIndex = i;
}
if (chars[oldString.length() - 1 - i] != ' ' && lastIndex == -1) {
lastIndex = oldString.length() - 1 - i;
}
}
if (beginIndex == -1) {
return "";
}
return oldString.substring(beginIndex, lastIndex + 1);
}
2.将字符串指定索引内的数据进行反转
public static void main(String[] args) {
try {
//此处要求[beginIndex,endIndex)
System.out.println(StringReverse.getReverse("abcdefg",4,6)); //abcdfeg
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
/**
* @param oldString :待查找的字符串
* @param beginIndex :起始下标
* @param endIndex :结束下标
* @return :反转之后的字符串
* @throws Exception :抛出异常
*/
public static String getReverse(String oldString,int beginIndex,int endIndex) throws Exception {
if(endIndex<0||beginIndex<0||beginIndex>=oldString.length()-1||endIndex>=oldString.length()){
throw new Exception("输入的下标越界!!");
}
if (beginIndex>endIndex){
throw new Exception("输入的下标不合理!!");
}
if (beginIndex==endIndex||beginIndex==endIndex+1){
return oldString;
}
char[] chars = oldString.toCharArray();
char temp=' ';
for (int i = beginIndex,j=endIndex-1; i < j ; i++,j--) {
temp=chars[i];
chars[i]=chars[j];
chars[j]=temp;
}
return new String(chars);
}
//方式2
public static String reverse(String str) {
String ss = "";
for (int i = 0; i < str.length(); i++) {
ss = str.charAt(i) + ss;
}
return ss;
}
3.获取字符串在另一个字符串中出现的次数
public static void main(String[] args) {
int count = NumOfString.getNumOfString("abcabcabc", "ca");
if (count == -1 || count == 0) {
System.out.println("该字符串不存在");
} else {
System.out.println(count);
}
}
/**
* @param str1 :字符串
* @param str2 :待查找的字符串
* @return :出现的次数
*/
public static int getNumOfString(String str1, String str2) {
int num = 0;
int i1 = 0;
for (int i = 0; i < str1.length(); i = (i1 + str2.length())) {
i1 = str1.indexOf(str2, i);
if (i1 == -1) {
break;
}
num++;
}
return num;
}
4.获取两个字符串中最大的相同字串。比如:str1=“wefweufihellonqdcbhf”;str2=“qwdchello”;
4.1实现方式1
public static void main(String[] args) {
String[] maxString = MaxStringSize.getMaxString("hellohello11", "hello123");
System.out.println(Arrays.toString(maxString));
}
public static String[] getMaxString(String str1, String str2) {
String[] maxString = new String[10];
int count = 0;
String minString = "";
//始终要求str1为两个字符串中比较长的串。
if ((str1.length() < str2.length())) {
minString = str2;
str2 = str1;
str1 = minString;
}
boolean flag = false;
//控制拆分的字符串的长度,长度依次递减
for (int i = str2.length(); i > 0; i--) {
//对字符串进行遍历
for (int j = 0; j < str2.length() - i; j++) {
//判断长的字符串中是否含有中是否拆分的字符串
String max = str2.substring(j, j + i + 1);
boolean contains = str1.contains(max);
if (contains) {
flag = true;
maxString[count++] = max;
}
}
if (flag) {
break;
}
}
return maxString;
}
4.2实现方式2
/**
* 获取str1和str2中最大长度的字符串。
* 前提,只有一个最大相同字串。
* 解决方式,使用StringBuffer将其进行追加,以,分隔,然后切分为String类型数组。
* @param str1 :字符串1
* @param str2 :字符串2
* @return :最大相同字串
*/
public String getMaxSameString(String str1,String str2){
if (str1!=null&&str2!=null){
String maxStr=(str1.length()>=str2.length())?str1:str2;
String minStr=(str1.length()<str2.length())?str1:str2;
int length=minStr.length();
//公共存在几大轮
for (int i = 0; i < length; i++) {
for (int x = 0,y=length-i; y <=length; x++,y++) {
//注意此处时前开后闭
String subStr=minStr.substring(x,y);
if (maxStr.contains(subStr)){
return subStr;
}
}
}
}
return null;
}
@Test
public void testGetMaxSameString(){
String str1="abcwerthello1yuiodefabcdef";
String str2="cvhello1bnm";
String maxSameString = getMaxSameString(str1, str2);
System.out.println(maxSameString);
}
5.查找字符串作用指定字符的数量
/**
* @Description:1.获取字符串s中出现字符c次数num
* @author 龍 date 2020年6月18日下午2:18:03
* @param s
* @param c
* @return :字符串中出现的指定字符的次数
*/
public static int getNumFromString(String s, char c) {
int index = -1;
int num = 0;
int no = 0;
for (int i = 0; i < s.length(); i++) {
//进行查找指定的字符
index = s.indexOf(c, no);
//如果字符不存在,则跳出循环
if (index == -1) {
break;
}
//找到了指定的字符,字符数量以及寻找的下标++。
num++;
no = index + 1;
}
//返回查找到的数目
return num;
}
6.字符转换:对指定的字符串进行转换 大写转换为小写 小写转换为大写并 删除其中数字
public static String changeStr(String s) {
char[] chars = s.toCharArray();
for (int i = 0; i < chars.length; i++) {
if (chars[i] >= 'A' && chars[i] <= 'Z') {
chars[i] = (char) (chars[i] + 32);
} else if (chars[i] >= 'a' && chars[i] <= 'z') {
chars[i] = (char) (chars[i] - 32);
}
}
// 利用正则表达式去除数字
return new String(chars).replaceAll("\\d+", "");
}
public static String changeStr02(String s) {
char[] chars = s.toCharArray();
String ss = "";
for (int i = 0; i < chars.length; i++) {
if (chars[i] >= 'A' && chars[i] <= 'Z') {
//如果是大写字母,则转化为小写字母
ss += (char) (chars[i] + 32);
} else if (chars[i] >= 'a' && chars[i] <= 'z') {
ss += (char) (chars[i] - 32);
} else if (chars[i] > '9' || chars[i] < '0') {
ss += chars[i];
}
}
return ss;
}
7.实现compareTo方法
public static int myCompara02(String str1, String str2) {
char[] charArray1 = str1.toCharArray();
char[] charArray2 = str2.toCharArray();
int len = Math.min(charArray1.length, charArray2.length);
int last = 0;
for (int i = 0; i < len; i++) {
last = charArray1[i] - charArray2[i];
if (last != 0) {
return last;
}
}
return charArray1.length - charArray2.length;
}
8.传入的字符串格式为xxxx-xx-xx。将日期s对应的日期加10天后的日期。
public static String getDays02(String str) {
int firstIndex = str.indexOf('-');
String year = str.substring(0, firstIndex);
int secondIndex = str.indexOf('-', firstIndex + 1);
String month = str.substring(firstIndex + 1, secondIndex);
String date = str.substring(secondIndex + 1);
int intDate = parstInt(date);
int intMonth = parstInt(month);
int intYear = parstInt(year);
System.out.println(intYear + "==" + intMonth + "==" + intDate);
int days = getDayFromMonth(intYear, intMonth);
intDate += 10;
if (days < intDate) {
intDate -= days;
intMonth++;
}
if (intMonth == 13) {
intYear++;
intMonth = 1;
}
String newDate = "" + intYear + "-" + intMonth + "-" + intDate;
return newDate;
}
public static int parstInt(String time) {
int n = 0;
for (int i = time.length() - 1, k = 1; i >= 0; i--, k *= 10) {
// 获取当前位置的字符
char c = time.charAt(i);
// 获取当前位置的数
int cInt = c - '0';
n += k * cInt;
}
return n;
}
public static int getDayFromMonth(int year, int month) {
switch (month) {
case 4:
case 6:
case 9:
case 11:
return 30;
case 2:
return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0) ? 29 : 28;
default:
return 31;
}
}
9.获取参数字符串s中所有数字字符组成的最大整数
public static int getInt(String s) {
String ss = "";
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) >= '0' && s.charAt(i) <= '9') {
ss += s.charAt(i);
}
}
char[] chars = ss.toCharArray();
// 注意循环前缀。
for (int i = 0; i < chars.length - 1; i++) {
for (int j = i + 1; j < chars.length; j++) {
// 保证是从小到大的顺序,进行排序。
if (chars[j] > chars[i]) {
char tmp = chars[i];
chars[i] = chars[j];
chars[j] = tmp;
}
}
}
String newStr = new String(chars);
return parstInt(newStr);
}
10.写一个方法 合并参数字符串中的所有叠词。如:“1111abcaabbbcccddd”—>“1abcabcd”
public static String changeStr04(String s) {
/**
* 定义一个变量ss来保存不同的字符 如果是第一个字符,则直接添加到ss中 如果不是第一个字符串,和前一个字符进行比较
*/
String ss = "";
for (int i = 0; i < s.length(); i++) {
if (i == 0) {
ss += s.charAt(i);
} else {
if (s.charAt(i) != s.charAt(i - 1)) {
ss += s.charAt(i);
}
}
}
return ss;
}
11.打印参数字符串中数字字符,字母字符和其他字符出现的次数
public static void showAscll(String str) {
int numCount = 0;
int enCount = 0;
int otherCount = 0;
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
if (c >= '0' && c <= '9') {
numCount++;
} else if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
enCount++;
} else {
otherCount++;
}
}
System.out.println("数字的个数为:" + numCount + ",字母的个数为:" + enCount + ",其他字符的个数为:" + otherCount);
}
12.提取数字中的数字到数组中去
public static void showArryFromStr(String str) {
String[] nums = new String[10];
String ss = "";
int index = 0;
for (int i = 0; i < str.length(); i++) {
// 如果是数字则进行保存
if (str.charAt(i) >= '0' && str.charAt(i) <= '9') {
ss += str.charAt(i);
} else {
if (!"".equals(ss)) {
nums[index] = ss;
index++;
ss = "";
}
}
}
if (!"".equals(ss)) {
nums[index] = ss;
index++;
ss = "";
}
System.out.println(Arrays.toString(nums));
}
public static void getArr(String str) {
//遍历字符串把其中所有非数组字符替换为-
for (int i = 0; i < str.length(); i++) {
char c=str.charAt(i);
if (c>'9'||c<'0') {
str=str.replace(c, '-');
}
}
String[] arrs=str.split("-"); //[123, , , 123, , , , 98, , , , , , 876]
System.out.println(Arrays.toString(arrs));
int len=0;
for (int i = 0; i < arrs.length; i++) {
len+=arrs[i].isEmpty()?0:1;
}
String[] strArr=new String[len];
int index=0;
for (int i = 0; i < arrs.length; i++) {
if (!arrs[i].isEmpty()) {
strArr[index]=arrs[i];
index++;
}
}
System.out.println(Arrays.toString(strArr));
}
public static void getArr02(String str) {
//遍历字符串把其中所有非数组字符替换为,
String ss="";
for (int i = 0; i < str.length(); i++) {
char c=str.charAt(i);
if (c<'9'&&c>'0') {
ss+=c;
}else {
if (ss!=""&&!ss.endsWith(",")) {
ss+=',';
}
}
}
String[] strArr=ss.split(",");
System.out.println(Arrays.toString(strArr));
}
13.一个任意的四位正整数。将数字重新组合成一个最大的数和最小的数相减,重复这个过程,最多七步,必得6174。即:7641-1467=6174。将永远出不来。 求证:所有四位数数字(全相同的除外),均能得到6174。输出掉进黑洞的步数。
public static void darkPool() {
for (int i = 1000; i < 10000; i++) {
boolean flag = false;
int temp = i;
for (int j = 0; j < 7; j++) {
temp = getMax(temp) - getMin(temp);
if (temp == 6174) {
System.out.println(i+"调入黑洞,运行了"+(j+1)+"次。");
flag = true;
break;
}
}
if (!flag) {
System.out.println(i+"未掉入黑洞");
}
}
}
public static int getMax(int k) {
int[] nums = getArray(k);
// 注意循环前缀。
for (int i = 0; i < nums.length - 1; i++) {
for (int j = i + 1; j < nums.length; j++) {
// 保证是从小到大的顺序,进行排序。
if (nums[j] > nums[i]) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
}
}
int max = nums[0] * 1000 + nums[1] * 100 + nums[2] * 10 + nums[3];
return max;
}
public static int getMin(int k) {
int[] nums = getArray(k);
// 注意循环前缀。
for (int i = 0; i < nums.length - 1; i++) {
for (int j = i + 1; j < nums.length; j++) {
// 保证是从小到大的顺序,进行排序。
if (nums[j] > nums[i]) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
}
}
int min = nums[3] * 1000 + nums[2] * 100 + nums[1] * 10 + nums[0];
return min;
}
public static int[] getArray(int i) {
int num1 = i % 10;
int num2 = i / 10 % 10;
int num3 = i / 100 % 10;
int num4 = i / 1000;
int[] nums = new int[] { num1, num2, num3, num4 };
return nums;
}
二 常用类之时间相关类
1.日期类:java.util.Date
1.1Date概述
很多方法都过时了,推荐使用日历类Calendar来进行代替。
1.2 简单使用
public static void main(String[] args) {
//1.1.空参构造器:默认获取当前时间
Date date=new Date();
System.out.println(date); //Thu Jun 18 17:19:44 CST 2020
//1.2.根据传入毫秒值,创建date
Date date1=new Date(0l);
System.out.println(date1); //Thu Jan 01 08:00:00 CST 1970
//2.1将时间的年设置为指定年
date1.setYear(date.getYear()-1);
System.out.println(date1); //Tue Jan 01 08:00:00 CST 2019
//2.2毫秒值和date之间的转换
System.out.println(date.getTime()); //1592473246614
date.setTime(0);
System.out.println(date); //Thu Jan 01 08:00:00 CST 1970
//2.3获取当前系统对应的字符串形式
String localeString = date.toLocaleString();
System.out.println(localeString); //1970-1-1 8:00:00
System.out.println(dateToStr(new Date())); //2020年6月18日 星期四 17时5分37秒
}
/**
* @Description :将时间转化为指定格式的字符串
* @author 龍
* date 2020年6月18日下午5:39:36
* @param date
* @return
*/
public static String dateToStr(Date date) {
int year = date.getYear();
int month =date.getMonth();
int day=date.getDate();
int week=date.getDay();
int hour=date.getHours();
int minute=date.getMinutes();
int second=date.getSeconds();
String weeks="一二三四五六日";
return (1900+year)+"年"+(month+1)+"月"+day+"日"
+" 星期"+weeks.charAt(week-1)+"\t"+hour+"时"+month+"分"+second+"秒";
}
2 SimpleDateFormat
2.1 出现背景
Data类的API不易于国际化,该类是为了对日期Date类进行格式化和解析,位于java.text.SimpleDateFormat。
年 | 月 | 日 | 星期 | 时 | 分 | 秒 |
---|---|---|---|---|---|---|
y | M | d | E | H | m | s |
2.2 简单使用
@Test
public void TestSimpleDateFormat() throws ParseException {
//1.实例化SimpleDateFormat类对象
SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
//2.格式化:日期-->字符串
//2.1创建Date对象
Date date = new Date();
System.out.println(date);
//2.2对date进行格式化
String format = simpleDateFormat.format(date);
System.out.println(format);
//3.解析-->通常我们不喜欢使用默认的格式进行解析,所以需要使用带参数SimpleDateFormat对象。
SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd");
String string="2019-08-09";
//3.1将需要解析的字符串传入parse方法的参数中去
//注意:解析的时候字符串格式要符合SimpleDateFormat的解析格式,否则会报异常
//java.text.ParseException: Unparseable date: "2019-08-09"
Date parse = simpleDateFormat1.parse(string);
System.out.println(parse);
System.out.println(simpleDateFormat1.parse(format));
System.out.println(simpleDateFormat1.format(date));
}
2.3 常见场景
/**
* 练习一:字符串“2020-8-9”转换为java.sql.Data
*/
@Test
public void test01() throws ParseException {
String string="2020-8-9";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date parse = simpleDateFormat.parse(string);
//数据库中date设置需要使用毫秒值来进行赋值
java.sql.Date date=new java.sql.Date(parse.getTime());
//2020-08-09
System.out.println(date);
//class java.sql.Date
System.out.println(date.getClass());
}
/**
* "三天打鱼,两天晒网" 1990-1-1开始 xxxx-xx-xx 打渔?or晒网?
* 总天数计算,
*/
public static void main(String[] args) {
try {
new SimpleDateFormatTest().test02();
} catch (ParseException e) {
System.out.println(e.getMessage());
}
}
//@Test
public void test02() throws ParseException {
String startDate="1990-1-1";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date parse = simpleDateFormat.parse(startDate);
long start=parse.getTime();
Scanner scanner = new Scanner(System.in);
while(true){
System.out.println("请输入日期(xxxx-MM-dd):");
String next = scanner.next();
Date parse1 = simpleDateFormat.parse(next);
long end=parse1.getTime();
switch ((int)(((end-start)/1000/60/60/24)%5)){
case 0:
case 1:
case 2:
System.out.println("打渔!!!");
break;
default:
System.out.println("晒网");
break;
}
}
}
3 日历类:Calendar
3.1 简介
所述Calendar类是一个抽象类,可以为在某一特定时刻和一组之间的转换的方法[calendar fields]如YEAR , MONTH ,DAY_OF_MONTH ,HOUR 等等,以及用于操纵该日历字段,如获取的日期下个星期。 时间上的瞬间可以用毫秒值表示,该值是从1970年1月1日00:00 00:00.000 GMT(Gregorian)的Epoch的偏移量
3.2 对象的创建
- 创建其子类(GregorianCalendar)对象。
- 调用其静态方法getInstance():实际返回的依旧是其子类对象
3.3 常用方法
- **get(int field):**填入Calendar中的静态属性。可以获取一些常用的属性
- **set(int field,int value):**修改当前Calendar对象的值。
- **add():**增加指定值到当前属性。
- **getTime():**日历类–>Date
- **setTime(Date date):**Date–>日期类
3.4 简单使用
@Test
public void testCalendar(){
//4.1实例化
//方式一:创建其子类(GregorianCalendar)对象。
//方式二:调用其静态方法getInstance()
Calendar instance = Calendar.getInstance();
//class java.util.GregorianCalendar。
System.out.println(instance.getClass());
//4.1方法的测试
//get(int field):获取指定的参数值
int i = instance.get(Calendar.DAY_OF_MONTH);
System.out.println(i);
//set(int field,value):设置参数为指定的值
instance.set(Calendar.DAY_OF_MONTH,22);
int i1 = instance.get(Calendar.DAY_OF_MONTH);
System.out.println(i1);
//add(int field,amount):
instance.add(Calendar.DAY_OF_MONTH,3);
int i2 = instance.get(Calendar.DAY_OF_MONTH);
System.out.println(i2);
//getTime():日历类-->Date
Date time = instance.getTime();
//Wed Mar 25 11:45:00 CST 2020
System.out.println(time);
//setTime(Date date):Date-->日期类
Date date = new Date();
instance.setTime(date);
int i3 = instance.get(Calendar.DAY_OF_MONTH);
System.out.println(i3);
Date date1 = new Date(2020, 10, 1); //设置的时候是从1900年开始算起的
//Mon Nov 01 00:00:00 CST 3920
System.out.println(date1);
//void setTimeInMillis(long millis) :设置日历对象为参数毫秒值对应的时间
//void getTimeInMillis():获取日历对象对应的毫秒值
}
/**
public static void calendarTest1() {
Calendar calendar=Calendar.getInstance();
calendar.set(Calendar.YEAR, 2010);
calendar.set(Calendar.MONTH, 0);
calendar.set(Calendar.DAY_OF_MONTH, 1);
Calendar now=Calendar.getInstance();
Long time=now.getTimeInMillis()-calendar.getTimeInMillis();
int date=(int)(time/1000/3600/24);
System.out.println(date);
switch (date%5) {
case 0:
case 1:
case 2:
System.out.println("打渔日!");
break;
default:
System.out.println("晒网日");
break;
}
}
4 日期时间:LocalDateTime
4.1 出现的背景
-
可变性:像日期和时间这样的类应该是不可变的。
-
偏移性:Date中的年份是从1900年开始的,月份是从0开始的。
Date date1 = new Date(2020, 10, 1);
System.out.println(date1); //Mon Nov 01 00:00:00 CST 3920
-
格式化:格式化只对Date有用,Calendar则不行。
-
也不是线程安全的,也不能处理闰秒等。
4.2 改进
java8吸收了joda-Time的精华,新的java.time中包括所有关于本地日期(LocalDate),本地时间(LocalTime),本地日期时间(LocalDateTime),时区(ZonedDateTime)和持续时间(Duration)的类。Date类新增了toInstant( )用于将Date转换成新的表示形式。这些新增的本地化时间日期API大大的简化了日期时间和本地化的管理。
4.3 包结构
- java.time-包含值对象的基础包。
- java.time.chrono-提供对不同的日历系统的访问
- java.time.format-格式化和解析时间和日期
- java.time.temporal-包括底层框架和扩展性
- java.time.zone-包括时区支持的类。
4.4 简单使用
@Test
public void testTime(){
//now():静态方法,获取当前的日期,时间,日期+时间。
LocalDate now = LocalDate.now();
LocalTime now1 = LocalTime.now();
LocalDateTime now2 = LocalDateTime.now();
//2020-03-15
System.out.println(now);
//12:54:58.043
System.out.println(now1);
//2020-03-15T12:54:58.043
System.out.println(now2);
//of():设置指定的年月日时分秒,
LocalDateTime of = LocalDateTime.of(2020, 10, 1, 8, 10, 4);
//2020-10-01T08:10:04(无偏移量)
System.out.println(of);
//getXxx():获取指定的属性
//15
System.out.println(now2.getDayOfMonth());
//SUNDAY
System.out.println(now2.getDayOfWeek());
//MARCH
System.out.println(now2.getMonth());
//75
System.out.println(now2.getDayOfYear());
//withXxx():设置相关的属性。体现了不可变性,返回值是修改之后的对象,本来的对象不会发生改变。比起Calendar更加的靠谱。
LocalDateTime localDateTime = now2.withDayOfMonth(21);
//2020-03-21T13:08:09.420
System.out.println(localDateTime);
//2020-03-15T13:08:09.420
System.out.println(now2);
//plusXxx():给指定属性增加。仍然是不可变性,本身对象属性不发生变化
LocalDateTime localDateTime1 = localDateTime.plusMonths(3);
//2020-03-21T13:08:09.420
System.out.println(localDateTime);
//2020-06-21T13:08:09.420
System.out.println(localDateTime1);
//minusXxx():给指定属性减少
LocalDateTime localDateTime2 = localDateTime.minusDays(1);
//2020-03-21T13:12:33.693
System.out.println(localDateTime);
//2020-03-20T13:12:33.693
System.out.println(localDateTime2);
}
4.5 练习
@Test
public void test04(){
//当前时间
LocalDate today = LocalDate.now();
System.out.println("Current Date="+today);
//根据输入的参数获取日期
LocalDate firstDay_2014 = LocalDate.of(2014, Month.JANUARY, 1);
System.out.println("Specific Date="+firstDay_2014);
//Try creating date by providing invalid inputs
//LocalDate feb29_2014 = LocalDate.of(2014, Month.FEBRUARY, 29);
//Exception in thread "main" java.time.DateTimeException:
//Invalid date 'February 29' as '2014' is not a leap year
//获取韩国当前的日期
LocalDate todayKolkata = LocalDate.now(ZoneId.of("Asia/Kolkata"));
System.out.println("Current Date in IST="+todayKolkata);
//java.time.zone.ZoneRulesException: Unknown time-zone ID: IST
//LocalDate todayIST = LocalDate.now(ZoneId.of("IST"));
//获取从基数01/01/1970开始偏移365天的日期
LocalDate dateFromBase = LocalDate.ofEpochDay(365);
System.out.println("365th day from base date= "+dateFromBase);
//获取2014年第100天后的日期
LocalDate hundredDay2014 = LocalDate.ofYearDay(2014, 100);
System.out.println("100th day of 2014="+hundredDay2014);
}
拓展:
1 瞬时
1.1 瞬时简介
instant:时间线上的一个瞬时点,可能被用来记录应用程序中的事件时间戳。对于人来说年月日时分秒,对于机器来说时间线中一个点就是一个很大的数,有利于计算的处理。UNIX中这个数从1970年开始(utc),以秒为单位,在java中以毫秒为单位。java.time包是基于纳秒计算的,所以instant可以精确到纳秒。
常见的 时间标准:
- UTC:世界标准时间
- GMT:格林尼治时间==>英国
- CST:北京时间。UTC+8
1.2 瞬时简单使用
@Test
public void testInstant(){
//1.实例化
Instant now = Instant.now();
//2020-03-15T05:33:31.729Z;;返回的是UTC的时间,如果是我们的时间就需要+8个小时
System.out.println(now);
//atOffset(ZoneOffset.ofHours(8)):根据时区添加偏移量
OffsetDateTime offsetDateTime = now.atOffset(ZoneOffset.ofHours(8));
//2020-03-15T13:37:00.750+08:00
System.out.println(offsetDateTime);
//toEpochMilli():获取1970年1月1日到现在的毫秒数。
long l = now.toEpochMilli();
System.out.println(l);
//ofEpochMilli(l):根据指定的毫秒数获取指定对象。
Instant instant = Instant.ofEpochMilli(l);
//2020-03-15T05:40:53.664Z
System.out.println(instant);
}
2 DateTimeFormatter
2.1 简介
对时间进行本土化设置
2.2 简单使用
@Test
public void testDateTimeFormat(){
//方式一:预定义的标准格式。
// 如:ISO_LOCAL_DATE_TIME
DateTimeFormatter isoLocalDateTime = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
//格式化:
LocalDateTime localDateTime = LocalDateTime.now();
String format = isoLocalDateTime.format(localDateTime);
//2020-03-15T14:50:06.953
System.out.println(format);
//解析:
TemporalAccessor parse = isoLocalDateTime.parse(format);
//{},ISO resolved to 2020-03-15T14:53:14.206
System.out.println(parse);
//方式二:本地化相关的操作:
//ofLocalizedDateTime()
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
//格式化:
//风格:FormatStyle.SHORT,FormatStyle.LONG,FormatStyle.MEDIUM(适用于LocalDateTime)
String format1 = dateTimeFormatter.format(localDateTime);
//20-3-15 下午3:03
System.out.println(format1);
DateTimeFormatter dateTimeFormatter2 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
String format2 = dateTimeFormatter2.format(localDateTime);
//2020年3月15日 下午03时03分01秒
System.out.println(format2);
DateTimeFormatter dateTimeFormatter3 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM);
String format3 = dateTimeFormatter3.format(localDateTime);
//2020-3-15 15:03:01
System.out.println(format3);
//风格:FormatStyle.FULL(适用于LocalDate以上三种风格也适用于LocalDate)
LocalDate localDate = LocalDate.now();
DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);
String format4 = dateTimeFormatter1.format(localDate);
//2020年3月15日 星期日
System.out.println(format4);
//方式三:自定义格式:ofPattern("yyyy-MM-dd hh:mm:ss E")
DateTimeFormatter dateTimeFormatter4 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss E");
String format5 = dateTimeFormatter4.format(localDateTime);
//2020-03-15 03:17:25 星期日
System.out.println(format5);
//解析
TemporalAccessor parse1 = dateTimeFormatter4.parse(format5);
//{SecondOfMinute=15, HourOfAmPm=3, NanoOfSecond=0, MicroOfSecond=0, MinuteOfHour=21, MilliOfSecond=0},ISO resolved to 2020-03-15
System.out.println(parse1);
}
三 常用类之比较器
1 出现的背景
在java中涉及到数组对象的排序问题
说明:java中的对象,正常情况下,只能进行比较:==或者!=,不能使用>或者<,但是在实际的开发场景中,我们需要对多个对象进行排序,言外之意,就需要比较对象的大小,如何实现?
2 实现对象排序的方式
- 自然排序:java.lang.Comparable
- 定制排序:java.util.Comparator
3 使用
3.1 Comparable:自然排序
String,包装类等实现了Comparable接口,重写compareTo()方法,给出了比较两个对象的大小。
重写compareTo(obj)的规则:
-
如果当前对象this大于形参对象obj,则返回正整数。
-
如果当前对象this小于形参对象obj,则返回负整数。
-
如果当前对象this等于形参对现象obj,则返回0。
说明:对于自定义类进行排序,自定义类需要实现Comparable接口,若不实现Comparable接口,会报异常:java.lang.ClassCastException: com.atguigu.comparejava.Goods cannot be cast to java.lang.Comparable
自定义类代码compareTo方法实现
class Goods implements Comparable {
private String name;
private double price;
public Goods() {
}
public Goods(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
/**
* 指明该类比较大小的方式:先按照价格从低到高,然后按照产品名称从低到高。
*
* @param o:待比较的对象
* @return :结果。正数说明this大,负数说明obj大,o则相等
*/
@Override
public int compareTo(Object o) {
if (o instanceof Goods) {
Goods goods = (Goods) o;
if (this.price > goods.price) {
return 1;
} else if (this.price < goods.price) {
return -1;
} else {
//return 0;
return this.name.compareTo(goods.name);
}
}
throw new RuntimeException("你输入的商品类型不对!");
}
@Override
public String toString() {
return "Goods{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
}
@Test
public void testCompareGoods() {
Goods[] goods = new Goods[4];
goods[0] = new Goods("lenovo", 34);
goods[1] = new Goods("xiaomi", 50);
goods[2] = new Goods("dell", 50);
goods[3] = new Goods("huawei", 50);
Arrays.sort(goods);
System.out.println(Arrays.toString(goods));
}
3.2 Comparator接口的使用:定制排序
1)排序:当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码,或者实现了java.lang.Comparable接口的排序规则不适合当前的操作,那么可以考虑使用Comparator的对象来排序。
2)实现compare(Object o1,Object o2)方法,比较o1,o2的大小:如果返回值是正数则o1>o2;负数则o1<o2;0则相等。
简单使用
@Test
public void testCompareGoods02() {
Goods[] goods = new Goods[5];
goods[0] = new Goods("lenovo", 34);
goods[1] = new Goods("xiaomi", 50);
goods[2] = new Goods("dell", 50);
goods[3] = new Goods("huawei", 50);
goods[3] = new Goods("huawei", 70);
//产品名称从低到高,价格从高到低
Arrays.sort(goods, new Comparator() {
@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());
}
}
return 0;
}
});
System.out.println(Arrays.toString(goods));
}
四 常用类之其他类
1 System类
1.1System类的概述
System类代表系统,是系统级的属性和控制方法都放置到该类的内部,位于java.lang包。
特点:
- 该类的构造器是private的,所以无法创建该类的对象,也无法实例化该类。
- 其内部的成员变量和成员方法都是static的,所以也很方便的进行调用。
1.2成员变量及方法
1.2.1 成员变量
- in:标准输入流(键盘输入)
- out:标准输出流(显示器)
- err:标准错误输出流(显示器)
1.2.2 成员方法
- **native long currentTimeMills():**返回当前的计算机时间,返回值是于GMT1970年1月1日0时0分0秒所差毫秒数。
- **void exit(int status)😗*作用是退出程序,status为0表示正常退出,非零代表异常退出,可以在图形化界面中实现程序的退出。
- **void gc()😗*请求系统进行垃圾回收,至于是否立即执行,取决于系统中垃圾回收算法的实现以及系统执行时的情况。
- **String getProperty(String key)😗*获取系统中属性名为key的属性的对应的值。
常见如下:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Odh6wlCw-1593748287805)(E:\note\p15194420545@163.com\85fc1a6a8e524d29ab3bbb8a1c5c734c\clipboard.png)]
1.2.3 简单使用
@Test
public void testSystem(){
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);
}
2 Math类的使用
2.1 Math的特点
位于java.lang包,提供了一系列静态方法用于科学计算,其方法的参数和返回值类型一般为double型。
2.2常见的方法
- abs :绝对值
- acos,asin,atan,cos,sin,tan:三角函数
- qrt:平方根
- pow(double a,doble b) :a的b次幂
- log:自然对数
- exp :e为底指数
- max(double a,double b):求最大值
- min(double a,double b):求最小值
- random():返回0.0到1.0的随机数[0,1);求[a,b)=>random()*(b-a)+a
- long round(double a): double型数据a转换为long 型(四舍五入)
- toDegrees(double angrad):弧度—> 角度
- toRadians(double angdeg):角度—>弧度
3 BigInteger和BigDecimal的使用
3.1 BigInteger类
3.1.1 出现的背景
Integer类作为int的包装类,能存储的最大整型值为2^31 -1,Long类也是有限的,最大为2^63 -1。如果要表示再大的整数,不管是基本数据类型还是他们的包装类都无能为力,更不用说进行运算了。因此BigInteger应运而生。
3.1.2BigInteger的特点
java.math包的BigInteger可以表示不可变的任意长度的整数。BigInteger提供所有Java的基本整数操作符的对应物,并提供 java.lang.Math的所有相关方法。另外,BigInteger还提供以下运算:模算术、GCD计算、质数测试、素数生成,位操作以及一些其他操作。
3.1.3 构造器
- **BigInteger(String val):**根据字符串构建BigInteger对象。
3.1.4 常见方法
- **public BigInteger abs():**返回此BigInteger的绝对值的BigInteger。
- **BigInteger add(BigInteger val):**返回其值为(this + val)的 BigInteger
- **BigInteger subtract(BigInteger val):**返回其值为(this - val) 的BigInteger
- **BigInteger multiply(BigInteger val):**返回其值为(this/val)的BigInteger
- **BigInteger divide(BigInteger val):**返回其值为(this / val)的BigInteger。整数相除只保留整数部分。
- **BigInteger remainder(BigInteger val):**返回其值为 (this % val)的BigInteger。
- **BigInteger[] divideAndRemainder(BigInteger val):**返回包含(this / val)后跟(this % val)的两个BigInteger的数组。
- **BigInteger pow(int exponent):**返回其值为(this exponent )的BigInteger。
3.2 BigDecimal类
3.2.1 出现背景
一般的Float类和Double类可以用来做科学计算或工程计算,但在商业计算中到要求数字精度比较高,故用到java.math.BigDecimal类 。
3.2.2 特点
BigDecimal类支持不可变的、任意精度的有符号十进制定点数。
3.2.3 构造器
- public BigDecimal(double val)
- public BigDecimal(String val)
3.2.4 常见方法
- **public BigDecimal add(BigDecimal augend):**加法
- **public BigDecimal subtract(BigDecimal subtrahend):**减法
- **public BigDecimal multiply(BigDecimal multiplicand):**乘法
- **public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode):**除法
3.2.5 简单测试
@Test
public void testBigInteger() {
BigInteger bi = new BigInteger("1243324112312312312312312312312312312312312312");
BigDecimal bd = new BigDecimal("12435.351");
BigDecimal bd2 = new BigDecimal("11");
System.out.println(bi);
// System.out.println(bd.divide(bd2));
//必须指定精度,此时四舍五入,否则会报错,例如上一个,此输出为:1130.486
System.out.println(bd.divide(bd2, BigDecimal.ROUND_HALF_UP));
//自定义精度:1130.486454545454545
System.out.println(bd.divide(bd2, 15, BigDecimal.ROUND_HALF_UP));
}
4 包装类
4.1 包装类简述
包装类(封装类):针对八种基本数据类型定义相应的引用数据类型–包装类(封装类)
基本数据类型 | 包装类 |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
boolean | Boolean |
char | Character |
float | Float |
double | Double |
4.2 基本数据类型,包装类,String三者之间的相互转换
-
基本数据类型–>包装类:调用包装类的构造器
-
包装类–>基本数据类型:调用包装类中xxxValue()。
-
基本数据类型,包装类–>String类型:①使用拼接符号②String.valueOf()
-
String类型–>基本数据类型,包装类:包装类.parseXxx();
4.3 自动装箱与自动拆箱
自动装箱:不需要使用构造器进行封装。
int num=10;
Integer in1=num;
自动拆箱:自动转化为int类型
Integer in2=new Integer(10);
int num2=in2;
注:如果Boolean输入不是一个标准的“true”,则都认为是false。如果数字类型字符串的转换为包装类的时候,有可能报成NumberFormatException。
4.4 简单使用
@Test
public void test01() {
//基本数据类型-->包装类,调用包装类的构造器
int num=1;
Integer n=new Integer(num);
//包装类-->基本数据类型:调用包装类中xxxValue()。
int num2=new Integer(2).intValue();
num2+=1;
System.out.println(num2);
int num3=Integer.parseInt("20");
System.out.println(num3);
Boolean boolean1=new Boolean("True12");
System.out.println(boolean1);
}
4.5 面试题
1.自动装箱面试1
public void wrapperTest(){
Integer a = new Integer(3);
Integer b=3;
int c=3;
Integer d=new Integer(3);
//false:不同的对象引用
System.out.println(a==b);
//true:a进行自动拆箱
System.out.println(a==c);
//true:b进行自动拆箱
System.out.println(b==c);
//false:不同的对象引用
System.out.println(a==d);
Integer f1=100,f2=100,f3=200,f4=200;
//true:没有超出缓存范围,使用了同一个引用
System.out.println(f1==f2);
//false:超出了内部缓存的范围,使用了不同的引用
System.out.println(f3==f4);
}
解析:首先需要注意的是 f1、f2、f3、f4 四个变量都是 Integer 对象引用,所以下面的==运算比较的不是值而是引用。装箱的本质是什么呢?当我们给一个 Integer 对象赋一个 int 值的时候,会调用 Integer 类的静态方法 valueOf,如果看看 valueOf 的源代码就知道发生了什么。
```java
//源码
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
/**
* Cache to support the object identity semantics of autoboxing for values between
* -128 and 127 (inclusive) as required by JLS.
*
* The cache is initialized on first usage. The size of the cache
* may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
* During VM initialization, java.lang.Integer.IntegerCache.high property
* may be set and saved in the private system properties in the
* sun.misc.VM class.
*/
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
private IntegerCache() {}
}
```java
简单的说,如果整型字面量的值在-128 到 127 之间,那么不会 new 新的 Integer 对象,而是直接引用同一个对象
semantics of autoboxing for values between
* -128 and 127 (inclusive) as required by JLS.
*
* The cache is initialized on first usage. The size of the cache
* may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
* During VM initialization, java.lang.Integer.IntegerCache.high property
* may be set and saved in the private system properties in the
* sun.misc.VM class.
*/
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
private IntegerCache() {}
}
简单的说,如果整型字面量的值在-128 到 127 之间,那么不会 new 新的 Integer 对象,而是直接引用常量池
中的 Integer 对象,所以上面的面试题中 f1 == f2 的结果是 true,而 f3==f4 的结果是 false。