今天就分享一下一些常用类.
String
String不可变长的字符序列"abc" 在java程序中所有的字符串常量值(如"abc"),都作为此类的实例实现.其内部是由字符串组表示的.public static final char value [] .
String str=“abc”;==============//这代表有1个对象,字符串常量池中 “abc”
String str2=new String(“cde”); //代表有2个对象 new ->String,堆中一个 字符串常量池中有一个"cde".
它一共可分为三种情况:
String:不可变长字符串
StringBuilder:可变长字符串,但线程是不安全的.
StringBuffer:可变长字符串,线程不安全的.
String() 初始化一个新创建的 String 对象，使其表示一个空字符序列
String str=new String();
String(char[] value) 分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。
String s2=new String(new char[]{‘s’,‘h’,‘s’,‘x’,‘t’})
String(char[] value, int offset, int count) 分配一个新的 String，它包含取自字符数组参数一个子数组的字符
String s3=new String(new char[]{‘s’,‘h’,‘s’,‘x’,‘t’},2,3);
//String(byte[] bytes) 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
String string=“李四”;
byte [] arr=string.getBytes();
System.out.println(Arrays.toString(arr));
String s4=new String(new byte[]{-26, -99, -114, -27, -101, -101});
System.out.println(s4);
//String(byte[] bytes, Charset charset) 在GBK的模式下打印
String s5=new String(new byte[]{-26, -99, -114, -27, -101, -101},“GBK”);
//String(byte[] bytes, int offset, int length)
String s6=new String(new byte[]{-26, -99, -114, -27, -101, -101},0,1);
现在在来讲一下String 一些常用方法.
String str=“shsxtgood”;
String str2=“Shsxtgood”;
char charAt(int index) 返回指定索引处的 char 值。 ***
System.out.println(“charAt():”+str.charAt(2));
//int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引 ***
System.out.println(“indexOf():”+str.indexOf(“s”));
/*
* String substring(int beginIndex) *****
返回一个新的字符串，它是此字符串的一个子字符串。
String substring(int beginIndex, int endIndex) endIndex不包含
返回一个新字符串，它是此字符串的一个子字符串。
*/
System.out.println(“substring()”+str.substring(3));
System.out.println(“substring()”+str.substring(2,5));
// char[] toCharArray() 将此字符串转换为一个新的字符数组。 ***
char[] ch=str.toCharArray();
System.out.println(Arrays.toString(ch));
//String toLowerCase() 转小写
//String toUpperCase() 转大写
System.out.println(“toLowerCase()”+str1.toLowerCase());
System.out.println(“toUpperCase()”+str1.toUpperCase());
//String trim()返回字符串的副本，忽略前导空白和尾部空白。
System.out.println(" yinwei ".trim());
//valueOf() 参数转为字符串
double d=123.123;
System.out.println(String.valueOf(d).length());
// tring[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。 ****
String str3 = “name=zhangsan”;
String[] s = str3.split("=");
System.out.println(Arrays.toString(s));
//length() *****
System.out.println(str.length());
// String replace(char oldChar, char newChar) 新串替换老串 ***
System.out.println(“replace()”+str.replace(“s”,“S”));
以上的方法还有很多就不一一的举例了
下面我们在来讲一下
StringBuilder:
StringBuffer
//StringBuilder() 构造一个其中不带字符的字符串生成器，初始容量为 16 个字符。
StringBuilder sb=new StringBuilder();
System.out.println(sb);
System.out.println(sb.capacity()); //16
System.out.println(sb.length());
//StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。
StringBuilder sb1=new StringBuilder("abc");
System.out.println(sb1);
System.out.println(sb1.capacity());
System.out.println(sb1.length());
//StringBuilder(int capacity) 构造一个其中不带字符的字符串生成器，初始容量由 capacity 参数指定。
StringBuilder sb2=new StringBuilder(15);
System.out.println(sb2);
System.out.println(sb2.capacity());
System.out.println(sb2.length());
* append扩容: 如果原容量放不下进行扩容, 原容量size-->size*2+2,如果扩容后的大小还是放不下,直接以内容的长度进行扩容
*/
StringBuilder s=sb.append("12345678901234567");
sb.append(123.123);
System.out.println(sb);
System.out.println(s==sb);
System.out.println(sb.capacity()); //16
System.out.println(sb.length()); //4
//StringBuilder delete(int start, int end) 不包含end
sb.delete(2, 4);
System.out.println(sb);
Math类.
// static double floor(double a) 向下取整
System.out.println(Math.floor(1.98));
// static double ceil(double a) 向上取整
System.out.println(Math.ceil(1.18));
// static double max(double a, double b) 返回两个 double 值中较大的一个。
System.out.println(Math.max(1.1, 1));
// static int min(int a, int b) 返回两个 int 值中较小的一个。
System.out.println(Math.min(1.1, 2.2));// 1.1
// static long round(double a) 返回最接近参数的 long。
System.out.println(Math.round(1.49)); // 1
包装类
基本数据类型的包装类型
byte ----- Byte
short ----- Short
int ----- Integer
long ----- Long
float ----- Float
double ----- Double
char ----- Character
boolean ----- Boolean
自动装箱: 从基本数据类型->包装类型
自动拆箱: 从包装类型->基本数据类型
Integer 类在对象中包装了一个基本类型 int 的值
int i=101; =======int类型
Integer i2 =======自动装箱 Integer.valueof(i2)
int i3=i2; ========自动拆箱 i2.intValue()
//缓冲区对象的表示范围: [-128,127] ==>valueOf()
Integer int3=127;
Integer int4=127;
System.out.println(int3==int4); //true
Integer int5=new Integer(127);
Integer int6=new Integer(127);
System.out.println(int5==int6); //false
Integer int7=128;
Integer int8=128;
System.out.println(int7==int8); //false
1.int 和 Integer(无论是否new)比较:发生自动拆箱,如果值相同就相同
2.如果两个Integer比较,如果有new,就不相同
3.如果都没有new,要看是否再缓冲区对象的范围之内,在相同,不在不相同 [-128,127]
日期类
构造器
Date() 根据当前时间创建日期对象(本地)
Date(long time) 根据long类型的毫秒数构建指定时间的日期对象
boolean after(Date when)
测试此日期是否在指定日期之后。
boolean before(Date when)
测试此日期是否在指定日期之前。
Object clone()
返回此对象的副本。
int compareTo(Date anotherDate)
比较两个日期的顺序。
boolean equals(Object obj)
比较两个日期的相等性。
void setTime(long time)
设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。
date.setTime(1560151689048L);
date.setTime(0);
System.out.println(date); //Thu Jan 01 08:00:00 CST 1970
SimpleDateFormat 日期格式类
以指定格式把字符串与日期对象之间进行转换
y : 年
M : 月
d: 日期
H : 24小时
h : 12小时
m : 分
s : 秒
S : 毫秒
设置转换器格式:SimpleDateFormat对象
SimpleDateFormat() 默认的转换格式
用默认的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。 SimpleDateFormat(String pattern) 指定转换格式
format(Date) 日期对象准为字符串
parse(String) 字符串准为日期对象
public static void main(String[] args) throws ParseException {
//默认转换器
SimpleDateFormat simple=new SimpleDateFormat();
System.out.println(simple.format(new Date())); //19-6-10 下午3:40
//指定格式转换器
SimpleDateFormat simple2=new SimpleDateFormat("yyyy/MM/dd E hh:mm:ss SSS");
System.out.println(simple2.format(new Date()));
String str="2018年3月12日";
SimpleDateFormat simple3=new SimpleDateFormat("yyyy年MM月dd日");
System.out.println(simple3.parse(str));
今天就先分享这么多吧.