JAVA基础-高级编程-常用类
JAVA常用类
字符串String
String类：代表字符串，是一个final类，不可变字符序列，值是一个常量不可改变，存储在一个char[]数组中。
public class StringTest {
/**
* String:字符串，使用一对“”引起来表示
* String声明为final ，不可被继承
* String实现了Serializable接口：表示字符串支持序列化的
* 实现了Comparable接口：表示String可以比较大小
* String内部定义了final char value[]用于存储字符串数据
* String：代表不可变的字符序列，不可变性
* 体现：当对字符串重新赋值时，需要重新指定内存区域，不能使用原有的value赋值
* 对现有的字符串进行连接操作时，也需要重新指定内存区域，不能使用原有的value赋值
* 当调用String的replace方法时也必须重新指定区域 并重新赋值
* 通过字面量(区别于new方式)给一个字符串赋值，此时的字符串值声明在字符串常量池中。
*字符串常量池中不会存储相同的内容字符串，相同内容为一个字符串。
*/
@Test
public void test1(){
String s1="abc";//字面量赋值
String s2="abc";
System.out.println(s1==s2);//true
s1="hello";
System.out.println(s1);//输出hello
System.out.println(s2);//输出abc
String s3="abc";
s3+="def";
System.out.println(s2);
String s4="abc";
String s5=s4.replace('a','m');
System.out.println(s4);//并不会改变s4，因为string时不可变的，所以返回一个新的string
}
/**
* String实例化方式
* 方式一：通过字面量赋值
* 方式二:通过new构造器方式
*
*
*/
@Test
public void test2(){
String s1="javaee";//此时的s1和s2的数据javaee声明在方法去中的字符串常量池中
String s2="javaee";
//通过new构造器方式，此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后的地址值。
String s3=new String("javaee");
String s4=new String("javaee");
System.out.println(s1 == s2);//true
System.out.println(s1 == s3);//false
System.out.println(s1 == s4);//false
System.out.println(s3 == s4);//false
}
@Test
public void test3(){
/**
* 字符串拼接时
* 结论：常量与常量的拼接结果在常量池，且常量池不会存储相同的内容
* 只要有一个拼接是变量，则结果存储在堆空间中，相当于new
* 如果使用intern()方法，返回值就在常量池中
*/
String s1="abc";
String s2="def";
String s3=s1+"def";
String s4="abc"+"def";
String s5="abcdef";
System.out.println(s3 == s4);//false
System.out.println(s4 == s5);//true
String s8=s3.intern();
System.out.println(s5 == s8);//true 返回值得到的s8使用的常量池中已经存在的”abcdef“
}
}
字符串常用方法
/**
* @author from z
* @create 2021-02-03 17:22
*
*
*
*
* 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)：比较字符串内容，忽略大小写
* String concat(String str):将指定字符串连接到此字符串结尾 等价于+
* int compareTo(String s):比较字符串大小，正数当前对象大，负数当前对象小，0代表相等
* String substring(int beginIndex):返回一个新的字符串，从索引处开始截取
* String substring(int beginIndex,int endIndex):返回一个新字符串，截取索引开始和结束,不包含结束索引
*/
public class StringMethodTest {
@Test
public void test(){
String s1="helloworld";
System.out.println(s1.length());
System.out.println(s1.charAt(0));
System.out.println(s1.isEmpty());
System.out.println(s1.toLowerCase());
System.out.println(s1.toUpperCase());
System.out.println(s1.trim());
System.out.println(s1.equals("sss"));
System.out.println(s1.equalsIgnoreCase("ss"));
System.out.println(s1.concat("abc"));
System.out.println(s1.compareTo("aaaa"));
System.out.println(s1.substring(2));
System.out.println(s1.substring(2,3));
}
}
/**
* boolean endsWith(String suffix):测试此字符串是否已指定的后缀结束
* boolean startWith(String prefix):测试此字符串是否以指定的前缀开始
* boolean startWith(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个如果超过了剩下的全部都放到最后一个元素中
*/
String与其他数据结构转换
/**
* 涉及到String类与其他结构之间的转换
* @author from z
* @create 2021-02-03 20:15
*/
public class StringTest2 {
/*
复习：
String与基本数据类型、包装类之间的转换
String--> 基本数据类型、包装类 ：调用包装类的静态方法：parseXxx(str)
基本数据类型、包装类--> String :调用String重载的valueOf()方法
*/
@Test
public void test(){
String s1="123";
//int i=(int)s1;错误
int i=Integer.parseInt(s1);
String s2=String.valueOf(i);//"123"
String s3=i+"123";//与变量+存放在堆中
}
}
/**
* String与char[]之间的转换
* char[] -->String:调用string 的构造器
*/
@Test
public void test2(){
String s1="abc123";
char[] charArray=s1.toCharArray();
for (int i = 0; i < charArray.length; i++) {
System.out.println(charArray[i]);
}
String s2=new String(charArray);
}
/**
* String 与 byte[]之间的转换
* String --> byte[] getBytes()
* byte[] -->String
*
* 编码：字符串-->字节
* 解码：字节-->字符
*/
@Test
public void test3(){
String s1="123";
byte b[]=s1.getBytes();//使用默认的字符集进行转换
System.out.println(Arrays.toString(b));
try {
s1.getBytes("gbk");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
new String(b);
}
StringBuffer和StringBuilder
/**
* 关于StringBuffer和StringBuilder的使用
* @author from z
* @create 2021-02-03 20:52
*/
public class StringBufferAndStringBuilderTest {
/**
* String和StringBuffer和StringBuilder的异同
* String：不可变的字符序列 底层 final char[]
* StringBuffer：可变的字符序列 效率低：线程安全的; 底层char[]
* StringBuilder：可变的字符序列 效率高：线程不安全的 jdk5.0; 底层char[]
*
*源码分析：
* StringBuffer stringBuffer=new StringBuffer();底层创建了一个长度是16的char[] :char[] value=new char[16] --jdk8.0之前
* stringBuffer.append("a");//value[0]='a';
* StringBuffer stringBuffer=new StringBuffer("abc");底层实现：char value[]=new char["abc".length()+16];
* stringBuffer.length();//返回存储字符数量长度，并不是底层char[]长度
*
* 扩容问题：如果要添加的数据底层数组放不下，需要扩容底层的数组
* 默认情况下扩容为原来容量的二倍，同时将原有数组元素复制到新的数组中
*
* 建议使用StringBuffer(int capacity);指定数组长度
*/
/**
* 常用方法
* StringBuffer append(Xxx);提供了很多append方法，用于字符串拼接
* StringBuffer delete(int start,int end)：删除指定位置的内容
* StringBuffer replace(int start,int end,String str)：把[start,end)位置替换为str
* StringBuffer reverse()把当前字符序列逆转
* StringBuffer insert(int offset,xxx)在指定位置插入xxx
*
* int indexOf(String str)
* String substring(int start,int end)
* int length()
* char charAt(int n)
* void setCharAt(int n,char ch)
*/
@Test
public void test(){
StringBuffer stringBuffer=new StringBuffer("abc");
stringBuffer.setCharAt(0,'m');//此方法没有返回值，因为可变，直接改变的StringBuffer
System.out.println(stringBuffer);//“mbc”
StringBuffer stringBuffer1=new StringBuffer();
System.out.println(stringBuffer1.length());//0
}
}
jdk8之前日期时间api
Date
public class DateTimeTest {
/**
* java.util.Date类
* /--java.sql.Date类，util的子类
*
* 1.两个构造器的使用
* 2.两个方法的使用
* >toString():显示当前年月日时分秒
* >getTime():获取当前Date对象对应的毫秒数
* 3.sql.Date类
* util.Date怎么转换为sql.Date
*/
@Test
public void test2(){
//构造器一：创建当前对应时间的date对象
Date date = new Date();
System.out.println(date.toString());
date.getTime();
//构造器二：创建指定毫秒数的对象
Date date1=new Date(11111111L);
//sql.Date实例化
java.sql.Date date2 = new java.sql.Date(15486454648L);
//util.Date转换为sql.Date
new java.sql.Date(date.getTime());
}
//System类中的currentTimeMillis()
@Test
public void test(){
long time=System.currentTimeMillis();//返回1970年以毫秒为单位的时间差
System.out.println(time);
}
}
SimpleDateFormat
/**
* SimpleDateFormat:不与语言环境有关的方式来格式和解析日期的具体类
*
* @author from z
* @create 2021-02-04 14:06
*/
public class SimpleDateFormatTest {
/**
* SimpleDateFormat的使用：SimpleDateFormat对日期Date类的格式化和解析
* 1.格式化 日期---字符串
* 2.解析 字符串--日期
*/
@Test
public void test(){
//SimpleDateFormat的实例化
SimpleDateFormat sdf= new SimpleDateFormat();
Date date = new Date();
//格式化
String format = sdf.format(date);
//解析
String sDate="19-08-09 上午11:43";
try {
Date parse = sdf.parse(format);
System.out.println(parse);
} catch (ParseException e) {
e.printStackTrace();
}
/**
* 指定方式格式化，调用带参数的构造器
*/
//指定格式的SimpleDateFormat构造器
//SimpleDateFormat sdf2=new SimpleDateFormat("yyyyy.MMMMM.dd GGG hh:mm:aa");
SimpleDateFormat sdf2=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
String format1 = sdf2.format(date);
System.out.println(format1);//2021-02-04 02:32:46
try {
System.out.println(sdf2.parse("2021-02-04 02:32:46").toString());//解析
} catch (ParseException e) {
e.printStackTrace();
}
}
}
calendar
public class CalendarTest {
/**
* calendar类 抽象类 其子类是GregorianCalendar
*/
@Test
public void test(){
//实例化
//1创建其子类的对象
// Calendar calendar=new GregorianCalendar();
//方式二：getInstance()方法获取实例类
Calendar calendar=Calendar.getInstance();
//常用方法
//get
calendar.get(Calendar.DAY_OF_MONTH);
//set
calendar.set(Calendar.DAY_OF_MONTH,22);
//add
calendar.add(Calendar.DAY_OF_MONTH,3);
//getTime
Date time = calendar.getTime();
//setTime
calendar.setTime(time);
}
}
jdk8之后的日期类api
LocalTime LocalDate LocalDateTime
public class LocalTest {
/**
* LocalTime LocalDate LocalDateTime
*/
@Test
public void test(){
//实例化 now()
LocalDate local=LocalDate.now();
System.out.println(local);
//of()实例化 主要实例化方式
LocalDateTime localDateTime=LocalDateTime.of(2020,10,6,13,10);
//getXxx
localDateTime.getDayOfMonth();//返回当月第几天
//withXxx设置方法
LocalDateTime localDateTime1 = localDateTime.withDayOfYear(10);
System.out.println(localDateTime1);
System.out.println(localDateTime);//两者不相同，withXxx方法不会改变原来对象会返回新的日期对象，不可变性
//不可变性 加方法 plusXxx
LocalDateTime localDateTime2 = localDateTime.plusDays(10);
//不可变性 减方法 minusXxx
LocalDateTime localDateTime3 = localDateTime.minusDays(10);
}
}
instant
public class InstantTest {
/**
* Instant类
*/
@Test
public void test(){
Instant instant=Instant.now();//返回的是固定时区的时间
System.out.println(instant);
//需要设置偏移
OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
System.out.println(offsetDateTime);//返回的为当前时区时间
//获取对应的毫秒数
long l = instant.toEpochMilli();
Instant instant1 = Instant.ofEpochMilli(l);//通过毫秒数创建instant
}
}
DateTimeFormatter
public class DateTimeFormatTest {
/**
* 格式化解析日期类 datetimeformatter 类似于simpledateformat
*/
@Test
public void test(){
//实例化方式一：预定义标准格式
DateTimeFormatter isoLocalDateTime = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
String format = isoLocalDateTime.format(LocalDate.now());
System.out.println(format);
TemporalAccessor parse = isoLocalDateTime.parse(format);
System.out.println(parse.toString());
//方式二：本地化相关的格式
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
//方式三：自定义的格式
DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
}
}
java比较器
comparable自然排序
goods类implements comparable
public class Goods implements Comparable{
private String name;
private double price;
public Goods(String name, double price) {
this.name = name;
this.price = price;
}
public Goods(){
}
public void setName(String name) {
this.name = name;
}
public void setPrice(double price) {
this.price = price;
}
public String getName() {
return name;
}
public double getPrice() {
return price;
}
@Override
public String toString() {
return "Goods{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
//指明商品比较大小的方式:价格按照从低到高排序
@Override
public int compareTo(Object o) {
if (o instanceof Goods){
Goods goods=(Goods) o;
if (this.price>goods.price){
return 1;
}else if (this.pricetest
public class ComparableTest {
/**
* java中的对象，正常情况下，只能进行比较操作：==或！=不能使用><,可以使用 Comparable或者Comparator进行比较
*
* Comparable接口的使用
*
*
*/
@Test
public void test(){
//comparable使用举例
//像String、包装类等实现了caomparable接口，重写了compareTo()方法，给出了两个对象比较大小的规则
//重写comparaTo()的规则：如果当前对象this大于形参对象obj，则返回正整数，相反则返回负数，相等返回0
String s[]=new String[]{"abc","def","sss","aaa"};
Arrays.sort(s);
System.out.println(Arrays.toString(s));
}
@Test
public void test2(){
//对于自定义来说，如果需要排序，我们可以让自定义类实现comparable接口，重写comparTo方法指明如何排序
Goods goods[]=new Goods[4];
goods[0]=new Goods("hh",100);
goods[1]=new Goods("aa",99);
goods[2]=new Goods("cc",64);
goods[3]=new Goods("dd",21);
goods[4]=new Goods("ss",21);
Arrays.sort(goods);
System.out.println(Arrays.toString(goods));
}
}
comparator
public class ComparatorTest {
/**
* Comparator接口
* 当元素的类型没有实现comparable接口又不方便修改代码
* 或者实现了comparable接口排序规则不适合当前操作
* 那么可以考虑使用comparator的对象来排序
*
* 重写compare(Object o1,Object o2)方法，比较o1和o2的大小：
* 如果方法返回正整数，则表示o1>o2
* 负数表示小于
* 0表示相等
*
*/
@Test
public void test(){
String s[]=new String[]{"abc","def","sss","aaa"};
Arrays.sort(s, new Comparator() {
//按照字符串从大到小排序
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof String && o2 instanceof String){
String s1=(String) o1;
String s2=(String) o2;
return -s1.compareTo(s2);
}
//return 0;
throw new RuntimeException("输入数据类型不一致");
}
});
System.out.println(Arrays.toString(s));
}
}
其他常用类
public class OtherClassTest {
/**
* System、Math、BigInteger、BigDecimal
*/
@Test
public void test(){
System.currentTimeMillis();//获取当前运行的时间
System.exit(0);//0代表正常退出，非零代表异常退出
System.gc();//垃圾回收，请求系统回收垃圾，但是取决于执行情况
System.getProperty("java.version");//通过key获取相应的属性
/**
* Math
* 自行查阅
*/
/**
* BigInteger不可变任意精度整数 \ BigDecimal
*/
}
}