StringBuilder
一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。
StringBuilder
一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。
该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。
如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。
在 StringBuilder 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。
每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符添加或插入到字符串生成器中。
append 方法始终将这些字符添加到生成器的末端；而 insert 方法则在指定的点添加字符。
构造方法
StringBuilder() 构造一个没有字符的字符串构建器，初始容量为16个字符。
StringBuilder(String str) 构造一个初始化为指定字符串内容的字符串构建器。
代码演示
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/19 15:36
*/
public class StringBuilderDemo01 {
public static void main(String[] args) {
/**
* public StringBuilder(): 创建StringBuilder对象
* public StringBuilder(String str):将String封装成StringBuilder对象
*/
StringBuilder sb = new StringBuilder();
System.out.println("sb:"+sb);//输出的是值，说明重写了toString方法
StringBuilder abc = new StringBuilder("abc");
System.out.println("abc:"+abc);
}
}常见方法（添加，反转）
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/19 15:39
*/
public class StringBuilderDemo02 {
public static void main(String[] args) {
/**
* public StringBuilder append(Object obj): 将数据追加到序列中(StringBuilder)
*/
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(10.24);
stringBuilder.append("张三");
stringBuilder.append(20).append("HelloWorld").append(true).append(3.14);//链式编程，返回的是一个对象后面可紧跟着该对象中的方法直接使用
System.out.println("stringBuilder:"+stringBuilder);
}
}
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/19 15:45
*/
public class StringBuilderDemo03 {
public static void main(String[] args) {
/**
* public StringBuilder reverse(): 将该此字符序列中的内容进行反转，并返回其本身对象
*/
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(20).append("helloWorld").append("10.24").append("Abc");
stringBuilder.reverse();
System.out.println(stringBuilder);
}
}StringBuilder与String相互转换
StringBuilder转换为String
public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String
String转换为StringBuilder
public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/19 15:51
*/
public class StringBuilderDemo {
public static void main(String[] args) {
//public String toString(): 将该此字符序列中的内容,转换成String
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(20).append("acb").append(true).append(10.24);
String string = stringBuilder.toString();//将stringBuilder转换成string
System.out.println(string);
StringBuffer stringBuffer = new StringBuffer();
}
}StringBuilder案例（一）
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/19 15:55
*/
public class StringBuilderTest01 {
public static void main(String[] args) {
/**
* 使用StringBuilder按照指定的格式进行拼接
* 前提：使用方法完成
* 将数组中的内容按照指定的格式进行拼接
*/
int [] arr = {10,13,56,34,76,45};
String s = arrayToString01(arr);
System.out.println(s);
System.out.println("############");
String s1 = arrayToString02(arr);
System.out.println(s1);
}
/**
* 拼接数组
* @param arr
* @return
*/
public static String arrayToString02(int[] arr){
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int i = 0; i < arr.length; i++) {
if (arr[i] == arr.length-1){
sb.append(arr[i]);
}else {
sb.append(arr[i]).append(",");
}
}
sb.append("]");
return sb.toString();
}
/**
* 拼接数组
* @param arr
* @return
*/
public static String arrayToString01(int[] arr){
String str = "[";
for (int i = 0; i < arr.length; i++) {
if (arr[i]==arr.length-1){
str += arr[i];
}else {
str += arr[i] + ",";
}
}
str += "]";
return str;
}
}StringBuilder案例（二）
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/19 16:27
*/
public class StringBuilderTest02 {
public static void main(String[] args) {
/**
* 定义方法，实现判断一个字符串是否是对称的
* "abc" --> "cba" 不是对称的
* "aba" --> "aba" 对称的
*/
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String str = scanner.nextLine();
boolean flag = isFlag(str);
System.out.println(flag);
boolean same = isSame(str);
System.out.println(same);
}
public static boolean isFlag(String str){
//创建StringBuilder对象，将str转换成StringBuilder对象
//反转
//比较两个字符串的内容是否一样，使用equals方法
/* StringBuilder stringBuilder = new StringBuilder(str);
stringBuilder.reverse();
String newString = stringBuilder.toString();
boolean flag = str.equals(newString);
return flag;*/
//简化一下
return str.equals(new StringBuilder(str).reverse().toString());
}
public static boolean isSame(String str){
StringBuilder stringBuilder = new StringBuilder(str);
stringBuilder.reverse();
String string = stringBuilder.toString();
boolean flag = str.equals(string);
return flag;
}
}Math类
常用方法
方法名 说明
Math.PI 常量，圆周率
public static double abs(double num) 取绝对值
public static double ceil(double num) 向上取整
public static double floor(double num) 向下取整
public static long round(double num) 四舍五入
public static int max(int a, int b) 求最大值
public static int min(int a, int b) 求最小值
public static double pow(double a, double b) 求a的b次幂
public static double random() 随机数，随机的范围[0,1)
代码演示
package math;
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/19 17:17
*/
public class MathDemo01 {
public static void main(String[] args) {
/**
* public static double abs(double num): 取绝对值
* public static double ceil(double num): 向上取整 6.5 2
* public static double floor(double num):向下取整
* public static long round(double num): 四舍五入 4.35
* public static int max(int a, int b) : 求最大值
* public static int min(int a, int b) : 求最小值
* public static double pow(double a, double b):求a的b次幂
* public static double random() : 随机的范围[0,1)
*/
System.out.println(Math.abs(-10));
System.out.println(Math.abs(3.14));
System.out.println(Math.ceil(3.14));
System.out.println(Math.floor(3.14));
System.out.println(Math.round(3.14));
System.out.println(Math.max(-2,-3));
System.out.println(Math.min(-2,-3));
System.out.println(Math.pow(2,3));
System.out.println(Math.random()*100+1);
/**
* 随机1~100之内随机数
* 范围是0-1 但是不包含1
* math.random();
* 0-100: 不包含100
* math.random()*100
* 使用ceil向上取整，如果使用floor手动+1操作
* 生成的数据是一个浮点类型的数据，所以要强转为int
* math.ceil(math.random() * 100);
*/
}
}Arrays类
常用方法
public static String toString(int[] a)
public static void sort(char[] a)
public static void sort(int[] a)代码演示
package arrays;
import java.util.Arrays;
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/19 16:57
*/
public class ArraysDemo01 {
public static void main(String[] args) {
/**
* public static String toString(int[] a)
* public static void sort(char[] a)
* public static void sort(int[] a)
*/
int [] arr = {1,3,2,5,7,4};
System.out.println("元数组中的内容:"+ Arrays.toString(arr));
Arrays.sort(arr);
System.out.println("排序后的内容:"+Arrays.toString(arr));
System.out.println("#################");
String string = Arrays.toString(arr);
System.out.println(string);
//对于字符数组，内容的排序是无序的
//按照自然顺序进行排序，abcdefg....
char[] chars = {'a','c','e','b','d'};
System.out.println("原数组的元素："+Arrays.toString(chars));
Arrays.sort(chars);
System.out.println("排序后的数组："+Arrays.toString(chars));
}
}Arrays案例
package arrays;
import java.util.Arrays;
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/19 17:13
*/
public class ArrayTest01 {
public static void main(String[] args) {
/**
* Arrays练习：字符串倒序排列
* 请使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印。
*/
String str = "dsadsaghdagfjkasfjaghf";
char[] chars = str.toCharArray();
Arrays.sort(chars);
for (int i = chars.length - 1; i >= 0; i--) {
System.out.print(chars[i]+",");
}
}
}System类
常用方法
方法 说明
public static long currentTimeMillis() 返回以毫秒为单位的当前时间。
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 将数组中指定的数据拷贝到另一个数组中。
public static void exit(int status) l 用来结束正在运行的Java程序。参数传入一个数字即可。通常传入0记为正常状态，其他为异常状态
代码演示
currentTimeMillis()方法
package System;
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/19 16:46
*/
public class SystemDemo01 {
public static void main(String[] args) {
//static long currentTimeMillis()
/**
* 获取当前系统的时间
* 毫秒值的计算：
* 从1970 年 1 月 1 日 0时0分0秒到现在的时间之间的毫秒差值
*在java中时间的单位是以毫秒为单位不是秒
*/
System.out.println(System.currentTimeMillis());
//计算性能
long start = System.currentTimeMillis();
for (int i = 0; i < 1000000; i++) {
System.out.println("hello world");
}
long end = System.currentTimeMillis();
System.out.println("总耗时："+(end-start));
}
}arraycopy()方法
package System;
import java.util.Arrays;
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/19 16:52
*/
public class SystemDemo02 {
public static void main(String[] args) {
/**
* static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
* Object src: 复制的源数组
* int srcPos: 从源数组中第几个位置开始复制
* Object dest: 将源数组中的内容要复制到目标的那一个数组中
* int destPos: 目标数组开始存储元素的位置
* int length: 要从源数组中复制多少个元素
*/
int [] arr1 = {19,34,42,52};
int [] arr2 = new int[4];
System.arraycopy(arr1,0,arr2,0,4);
System.out.println(Arrays.toString(arr2));
}
}
exit()方法
package System;
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/19 16:55
*/
public class SystemDemo03 {
public static void main(String[] args) {
//static void exit(int status) : 终止jvm执行
for (int i = 0; i < 10; i++) {
if (i == 5){
System.exit(0);
}
System.out.println(i);
}
}
}包装类
基本类型 对应的包装类（位于java.lang包中）
byte Byte
short Short
int ==Integer==
long Long
float Float
double Double
char ==Character==
boolean Boolean
装箱与拆箱
什么是装箱：从基本类型转换为对应的包装类对象。
什么是拆箱：从包装类对象转换为对应的基本类型。
Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。 /**
* @Describe
* @Author Double LiFly
* @date 2021/4/19 17:25
*/
public class IntegerDemo02 {
public static void main(String[] args) {
/**
* 包装类的手动装箱与拆箱
* 装箱： 将基本数据手动转换为对应的包装类
* 拆箱: 将包装类手动转换为对应的基本数据类型
*/
Integer integer = Integer.valueOf(100);
Integer integer1 = Integer.valueOf("200");
System.out.println(integer);
System.out.println(integer1);
//将integer1和integer2转换为int类型
int i = integer.intValue();
int i1 = integer1.intValue();
System.out.println(i);
System.out.println(i1);
}
}
package integer;
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/19 17:28
*/
public class IntegerDemo03 {
public static void main(String[] args) {
/**
* 包装类的自动装箱与拆箱
* 装箱： 将基本数据自动转换为对应的包装类
* 拆箱: 将包装类自动转换为对应的基本数据类型
*
* 基本类型和引用数据类型，它们不是同一个数据类型
* 他们之间是不可能进行赋值使用的,但是包装类会自动完成它们之间不同类型的转换
*/
//自动装箱
Integer integer = 10;
//自动拆箱
int num = integer;
Integer i = 20;
/**
* 自动装箱为Integer类型的20
* 自动拆箱为int类型的 i i+20
*/
int num1 = i+20;
}
}String转换成对应的基本数据类型
将字符串的数组转换成int类型
public class Demo18WrapperParse {
public static void main(String[] args) {
int num = Integer.parseInt("100");
}
}除了Integer类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：
方法 说明
public static byte parseByte(String s) 将字符串参数转换为对应的byte基本类型。
public static short parseShort(String s) 将字符串参数转换为对应的short基本类型。
public static int parseInt(String s) 将字符串参数转换为对应的int基本类型。
public static long parseLong(String s) 将字符串参数转换为对应的long基本类型。
public static float parseFloat(String s) 将字符串参数转换为对应的float基本类型。
public static double parseDouble(String s) 将字符串参数转换为对应的double基本类型。
public static boolean parseBoolean(String s) 将字符串参数转换为对应的boolean基本类型。
BigInteger类
构造方法
方法 说明
public BigInteger(String val) 将字符串的数组封装成BigInteger对象
常用方法
方法 说明
public BigInteger add(BigInteger val) 两个BigInteger进行相加，并返回BigInteger
public BigInteger subtract(BigInteger val) 两个BigInteger进行相减，并返回BigInteger
public BigInteger multiply(BigInteger val) 两个BigInteger进行相乘，并返回BigInteger
public BigInteger divide(BigInteger val) 两个BigInteger进行相除，并返回BigInteger
代码演示
package bigInteger;
import java.math.BigInteger;
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/19 18:33
*/
public class BigIntegerDemo01 {
public static void main(String[] args) {
/**
* public bigInteger add(bigInteger val):两个BigInteger进行相加，并返回BigInteger
* public bigInteger subtract(bigInteger val):两个BigInteger进行相减，并返回BigInteger
* public bigInteger multiply(bigInteger val):两个BigInteger进行相乘，并返回BigInteger
* public bigInteger divide(bigInteger val):两个BigInteger进行相除，并返回BigInteger
*/
//四则运算
BigInteger bigInteger1 = new BigInteger("100");
BigInteger bigInteger2 = new BigInteger("200");
//public bigInteger add(bigInteger val):两个BigInteger进行相加，并返回BigInteger
BigInteger add = bigInteger1.add(bigInteger2);
System.out.println(add);
//public bigInteger subtract(bigInteger val):两个BigInteger进行相减，并返回BigInteger
BigInteger subtract = bigInteger1.subtract(bigInteger2);
System.out.println(subtract);
//public bigInteger multiply(bigInteger val):两个BigInteger进行相乘，并返回BigInteger
BigInteger multiply = bigInteger1.multiply(bigInteger2);
System.out.println(multiply);
//public bigInteger divide(bigInteger val):两个BigInteger进行相除，并返回BigInteger
BigInteger divide = bigInteger1.divide(bigInteger2);
System.out.println(divide);
}
}BigDecimal类
构造方法
方法名 说明
public BigDecimal(String val) 将String类型的数组封装为BigDecimal对象
常用方法
方法名 说明
public BigDecimal add(BigDecimal augend) 浮点类型数据相加操作
public BigDecimal subtract(BigDecimal subtrahend) 浮点类型数据相减操作
public BigDecimal multiply(BigDecimal multiplicand) 浮点类型数据相乘操作
public BigDecimal divide(BigDecimal divisor) 浮点类型数据相除操作
public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode) 浮点类型数据相除操作，按照指定的模式，保留几位小数
代码演示
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/19 18:41
*/
public class BigDecimalDemo02 {
public static void main(String[] args) {
/**
* 使用BigDecimal完成四则运算，目前来演示 + - *
* public BigDecimal add(BigDecimal augend):浮点类型数据相加操作
* public BigDecimal subtract(BigDecimal subtrahend):浮点类型数据相减操作
* public BigDecimal multiply(BigDecimal multiplicand):浮点类型数据相乘操作
*/
BigDecimal bigDecimal1 = new BigDecimal("0.9");
BigDecimal bigDecimal2 = new BigDecimal("0.1");
//public BigDecimal add(BigDecimal augend):浮点类型数据相加操作
BigDecimal add = bigDecimal1.add(bigDecimal2);
System.out.println(add);
//public BigDecimal subtract(BigDecimal subtrahend):浮点类型数据相减操作
BigDecimal subtract = bigDecimal1.subtract(bigDecimal2);
System.out.println(subtract);
//public BigDecimal multiply(BigDecimal multiplicand):浮点类型数据相乘操作
BigDecimal multiply = bigDecimal1.multiply(bigDecimal2);
System.out.println(multiply);
}
}BigDecimal除法
package bigDecimal;
import java.math.BigDecimal;
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/19 18:46
*/
public class BigDecimalDemo03 {
public static void main(String[] args) {
/**
* 使用BigDecimal完成 除法操作
* public BigDecimal divide(BigDecimal divisor):浮点类型数据相除操作
* public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode):浮点类型数据相除操作，按照指定的模式，保留几位小数
*/
BigDecimal bigDecimal1 = new BigDecimal("10.0");
BigDecimal bigDecimal2 = new BigDecimal("3.0");
// BigDecimal divide = bigDecimal1.divide(bigDecimal2);
//System.out.println(divide);//java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
/**
* public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode):浮点类型数据相除操作，按照指定的模式，保留几位小数
* BigDecimal divisor: 需要参与运算的数据
* int scale: 要精确的位数，小数点后要保留多少位
* int roundingMode: 舍入的模式
* BigDecimal.ROUND_UP： 进一法
* BigDecimal.ROUND_FLOOR：去尾法
*/
BigDecimal divide1 = bigDecimal1.divide(bigDecimal2, 3, BigDecimal.ROUND_FLOOR);
System.out.println(divide1);
BigDecimal divide = bigDecimal1.divide(bigDecimal2, 3, BigDecimal.ROUND_HALF_UP);
System.out.println(divide);
BigDecimal divide2 = bigDecimal1.divide(bigDecimal2, 3, BigDecimal.ROUND_UP);
System.out.println(divide2);
}
}
ROUND_HALF_UP 与 ROUND_FLOOR 区别
package bigDecimal;
import java.math.BigDecimal;
/**
* @Describe
* @Author Double LiFly
* @date 2021/4/19 18:55
*/
public class BigDecimalDemo04 {
public static void main(String[] args) {
/**
* ROUND_HALF_UP 与 ROUND_FLOOR 区别?
* ROUND_FLOOR: 保留的小数位的最接近的那一位不管是否是>=5都要舍弃年掉
* ROUND_HALF_UP: 保留的小数位的最接近的那一位是否是>=5,如果是向前进一，反之不进一
*/
BigDecimal bigDecimal1 = new BigDecimal("0.3");
BigDecimal bigDecimal2 = new BigDecimal("4.0");
BigDecimal divide = bigDecimal1.divide(bigDecimal2);
System.out.println(divide);
BigDecimal divide1 = bigDecimal1.divide(bigDecimal2, 2, BigDecimal.ROUND_FLOOR);
System.out.println(divide1);
BigDecimal divide2 = bigDecimal1.divide(bigDecimal2, 2, BigDecimal.ROUND_HALF_UP);
System.out.println(divide2);
BigDecimal divide3 = bigDecimal1.divide(bigDecimal2, 2, BigDecimal.ROUND_UP);
System.out.println(divide3);
}
}
扫一扫
503
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
