Object类的使用
包装类概述和使用
时间类的概述和使用
String类的概述和使用
Math类的概述和使用
枚举类的概述
1-1 Object类的使用
概述：
Object类是所有类的超类(根父类)，如果在类的声明中未使用extends关键字指明父类则默认使用java.lang.Object类
常用方法：
System.gc() 垃圾回收(一般不建议自定义使用)
GetClass() 获取类
hashCode() 返回哈希值
toString() 转成指定的字符串类型
equals() 比较两个对象是否相等
1-2 == 和 equals()的区别
1. 可以使用在基本数据类型和引用数据类型中表示两个数是否相等
2. 如果是基本数据类型：比较两个变量保存的数据是否相等(不一定类型要相同)
3. 如果是引用数据类型：比较的是地址值是否相同
equals()：方法
1. 不能使用在基本数据类型中，只适用于引用数据类型
2. 作用和==是相同的，比较两个对象的地址值；
3. 像String，Data，File，包装类都重写了equals方法，重写以后不是比较的地址，而是比较的内容是否相同
区别：
==：即可以比较基本数据类型也可以比较应用数据类型，两边类型要保持一致
equals：只能比较引用数据类型
重写equals方法
public boolean equals(Object obj) { if(this == obj) {//比较当前的地址和参数obj是否相同 return true; } if(obj instanceof Order) {//判断obj是否是Order的对象 Order o = (Order)obj; //比较内容 if(this.name .equals(o.name) && this.id == o.id ) { return true; }else { return false; } } return false; }
2-1 包装类
概述：
基本数据类型转包装类：
int a = 10; Integer b = new Integer(a); System.out.println(b); Integer int1 = new Integer("123");//只能是纯粹的数字 System.out.println(int1); Float f1 = new Float(12.5f); System.out.println(f1); Boolean b1 = new Boolean(false); Boolean b2 = new Boolean("true123"); System.out.println(b2);
包装类转基本数据类型：
包装类转换基本数据类型，调用包装类XXX的xxxValue
Integer a1 = new Integer(111); int a2 = a1.intValue(); System.out.println(a2 + 1);
5.0以后的新特性
int num = 10; Integer num1 = num;//自动装箱操作 int num3 = num1;//自动拆箱 System.out.println(num3);
int num1 = 10;
String s1 = num1 + "";
//valueof
float f1 = 12.5f;
String s2 = String.valueOf(f1);
<!--String 基本数据类型，--包装类 调用ParseXXX();-->
String s4 = "123";
int a = Integer.parseInt(s4);
System.out.println(a + 1);
3-1 时间类
Date：
public static void main(String[] args) {
//创建Date的对象 Date date = new Date(); //计算毫秒差 Date date2 = new Date(System.currentTimeMillis()); System.out.println(date); System.out.println(date2); System.out.println(date.getYear()+1900);//年 System.out.println(date.getMonth()+1);//月 System.out.println(date.getDate());//日 //时区 System.out.println(date.toGMTString()); //我们想要的格式 System.out.println(date.toLocaleString()); Date date1 = new Date(2021, 1, 22, 14, 06); System.out.println(date1); }
SimpleDateFormat:格式化输出日期格式
public static void main(String[] args) { Date date = new Date(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss"); String f1 = sdf.format(date); System.out.println(f1); }
Calendar：
日历类代表的是年月日周星期上午下午。精确到毫秒的时间 * 可以直接调用它的静态方法 * 也可以创建它的子类，GregorianCalendar public static void main(String[] args) { //他是一个抽象类需要子类对象去实现 Calendar cal = Calendar.getInstance(); /*Date date = cal.getTime(); System.out.println(date);*/ //获取年 int year = cal.get(cal.YEAR); System.out.println(year); //获取月 int mon = cal.get(cal.MONTH)+1; System.out.println(mon); //一个月中的第几天(号) int monthDay = cal.get(cal.DAY_OF_MONTH); System.out.println(monthDay); //一年中的第几天 int dayOfYear = cal.get(cal.DAY_OF_YEAR); System.out.println(dayOfYear); //时 int hour = cal.get(cal.HOUR); System.out.println(hour); //分 int minute = cal.get(cal.MINUTE); System.out.println(minute); //秒 int second = cal.get(cal.SECOND); System.out.println(second); //2021年01月20日 17:01:30 String str = year + "年" + mon + "月" + monthDay + "日" + hour+"时" + minute + "分" + second + "秒"; System.out.println(str); System.out.println(cal.getTime()); } }
DateTimeFoamatter： 格式化或解析日期时间，类似于：SimpleDateFormat
public static void main(String[] args) { //按照指定的格式进行日期时间的输出 DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日HH:mm:ss"); String f = dtf.format(LocalDateTime.now()); System.out.println(f); //按照指定的格式进行字符串日期时间的转换--->LocalDateTime LocalDateTime s = LocalDateTime.parse("2021年01月20日19:19:56", dtf); System.out.println(s); }
LocalDateTime：
package Date; import java.time.DayOfWeek; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.LocalTime; /* * 新增的日期时间类 */ public class LocalTest { public static void main(String[] args) { //日期类 LocalDate date = LocalDate.now(); //时间类 LocalTime time = LocalTime.now(); //日期时间类 LocalDateTime datetime = LocalDateTime.now(); System.out.println(date); System.out.println(time); System.out.println(datetime); System.out.println("-----------------"); //另一种比较比较规范严谨的创建方式------推荐用这种 LocalDateTime datetime2 = LocalDateTime.now(); //获取当前日期 LocalDate localDate = datetime2.toLocalDate(); System.out.println(localDate); //获取当前时间 LocalTime localTime = datetime2.toLocalTime(); System.out.println(localTime); System.out.println("---------------------------"); Get(); System.out.println("---------------------------"); SetTime(); System.out.println("---------------------------"); Creat(); } //获取指定的日期时间 public static void Get() { //创建日期时间类 LocalDateTime t1 = LocalDateTime.now(); System.out.println(t1); //获取年 int year = t1.getYear(); System.out.println(year); //获取月 int month = t1.getMonthValue(); System.out.println(month); //获取日 int day = t1.getDayOfMonth();//一个月中的第几天 int day1 = t1.getDayOfYear();//一年中的第几天 DayOfWeek day2 = t1.getDayOfWeek();//一周的第几天 System.out.println(day); System.out.println(day1); System.out.println(day2); //获取时 int hour = t1.getHour(); System.out.println(t1); //获取分 int minute = t1.getMinute(); System.out.println(minute); //获取秒 int second = t1.getSecond(); System.out.println(second); } //按照指定格式设置日期时间格式 public static void SetTime() { LocalDateTime t1 = LocalDateTime.of(2021, 2, 20, 18, 46); System.out.println(t1); } public static void Creat() { LocalDate t1 = LocalDate.parse("2020-01-20"); System.out.println(t1); LocalTime t2 = LocalTime.parse("18:50:15"); System.out.println(t2); LocalDateTime t3 = LocalDateTime.parse("2021-12-19T12:00:59"); System.out.println(t3); } }
DateTimeFormatter： 按照指定的格式进行日期时间的输出
package Date; import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; public class DateTimeFormatTest { public static void main(String[] args) { //按照指定的格式进行日期时间的输出 DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日HH:mm:ss"); String d = "2020-03-06"; String f = dtf.format(LocalDateTime.now()); System.out.println(f); //按照指定的格式进行字符串日期时间的转换--->LocalDateTime LocalDateTime s = LocalDateTime.parse("2021年01月20日19:19:56", dtf); System.out.println(s); } }
4-1 String类
概述：
1.String ：字符串。使用一对" "引起来表示
2.String声明为final的，是不可被继承的(不可变的特性)
3.String实现了Serializable接口：表示字符串是支持序列化的。 实现了Comparable接口：表示可以比较大小。
4.String内部定义了final char[] value用于存储字符串数据
4-2 String不可变性
String s1 = "javaEE"; String s2 = "Hadoop"; String s3 = "javaEEHadoop"; String s4 = "javaEE"+"Hadoop"; String s5 = s1 + "Hadoop"; String s6 = "javaEE" + s2; System.out.println(s3 == s4);//true System.out.println(s6 == s5);//false String s6 = "javaEE" + s2; String s7 = s5.intern();//这个方法强制要求去常量池中声明(返回值是在常量池中) 字面量 + 字面量 = 常量池(不会存在相同内容的常量) 字面量 + new = 堆
4-3 常用方法
String s1 = "HelloWorld";
System.out.println(s1.length());//返回字符串长度
System.out.println(s1.charAt(0));//返回指定索引值
System.out.println(s1.isEmpty());//判断是否为空(判断长度是否为0)
String lower = s1.toLowerCase();//转成小写
System.out.println(lower);
System.out.println(s1.toUpperCase());//转成大写
String s3 = " Hello World ";
String trim = s3.trim();//去除首位空格
System.out.println(s3);
System.out.println(trim);
String s4 = "Hello";
String s5 = "hello";
System.out.println(s4.equals(s5));//比较内容是否相同
System.out.println(s4.equalsIgnoreCase(s5));//忽略大小写
String s6 = "asd";
String s7 = s6.concat(s4);
System.out.println(s7);
String str1 = "abd";
String str2 = "abc";
/**
* 比较两个字符串的大小，整数表示这个数大，反之相反
*/
System.out.println(str1.compareTo(str2));
}
//@Test
public void test2() {
String s1 = "我是程序员";
String sub1 = s1.substring(2);//返回从指定索引以后的
String sub2 = s1.substring(2, 3);//包含开头不包含结尾
System.out.println(sub1);
System.out.println(sub2);
}
@Test
public void test3() {
String str = "HelloWorld";
boolean b1 = str.startsWith("He");//判断是不是以指定字符开头的
System.out.println(b1);
boolean b2 = str.endsWith("d");//判断是否以指定字符结尾的
System.out.println(b2);
boolean b3 = str.startsWith("ll",2);//判断是否以指定索引出开头的
System.out.println(b3);
}
4-3 字符串缓冲区(可变的字符序列)
StringBuffer:(线程安全的，效率较低)
增：append() 删：delete() 改：setCharAt()/replace()
插：insert() 长度：length() 遍历：for + charAt()/toString
@Test public void test() { StringBuffer sb = new StringBuffer("abc"); sb.append(1);//添加(相当于追加拼接) sb.append('1'); sb.append('2').append('3'); System.out.println(sb); // System.out.println(sb.delete(0, 1));//删除指定位置内容 // System.out.println(sb.replace(2, 3, "D"));//转换指定内容 System.out.println(sb.insert(2, false));//插入指定位置内容 System.out.println(sb.length());//字符序列长度 System.out.println(sb.reverse());//反转 }
StringBuilder:(线程不安全的，效率较高)
效率排行：StringBuilder - StringBuffer - String
4-4
概述：
BigInteger可以表示不可变的任意精度的整数
BigDecimal要求数字精度比较高(精度不会损失)
5-1 比较器
概述：
java中的对象正常情况下我们只能进行比较操作：== 或 != 不能使用><的
如果对对象进行排序比较大下需要使用
Comparable或Comparator
* 使用：Comparable接口
* 像String，包装类实现了Comparable接口，重写了compareTo方法
* 重写compareto方法，默认从小到大排序
* 如果当前对象this大于形参对象obj，返回正整数
* 如果当前对象this小于形参独享obj，返回负整数
* 如果当前对象this等于形参对象obj，返回0
* 自然排序：
自定义类需要实现comparable接口重写compareto(obj)方法，需要指明如何排序
public int compareTo(Object o) { if(o instanceof Goods) { Goods good = (Goods)o; if(this.price > good.price) { return 1; }else if(this.price < good.price) { return -1; }else { return 0; } } /*return 0;*/ throw new RuntimeException("类型不一样");
定制排序
/** * Comparator接口的使用： *定制排序 *按照字符串从大到小排序 */ public void test3() { String []arr = new String[] {"AA","FF","BB","CC","DD","EE"}; Arrays.sort(arr, 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); } throw new RuntimeException("类型不匹配"); }}); System.out.println(Arrays.toString(arr)); }
6-1 System类
常用方法；
currentTimeMillis()：一般用于计时
exit(int status)：退出程序
gc()：调用垃圾回收
getProperty(String key)：获取系统中的属性
7-1 Math类
package Math; public class MathTest { public static void main(String[] args) { System.out.println(Math.PI);//3.1415926 System.out.println(Math.sqrt(16)); //4.0 System.out.println(Math.cbrt(8)); //2.0 System.out.println(Math.pow(3,2)); //9.0 System.out.println(Math.max(2.3,4.5));//4.5 System.out.println(Math.min(2.3,4.5));//2.3 /** * abs求绝对值 */ System.out.println(Math.abs(-10.4)); //10.4 System.out.println(Math.abs(10.1)); //10.1 /** * ceil天花板的意思，就是返回大的值 */ System.out.println(Math.ceil(-10.1)); //-10.0 System.out.println(Math.ceil(10.7)); //11.0 System.out.println(Math.ceil(-0.7)); //-0.0 System.out.println(Math.ceil(0.0)); //0.0 System.out.println(Math.ceil(-0.0)); //-0.0 System.out.println(Math.ceil(-1.7)); //-1.0 /** * floor地板的意思，就是返回小的值 */ System.out.println(Math.floor(-10.1)); //-11.0 System.out.println(Math.floor(10.7)); //10.0 System.out.println(Math.floor(-0.7)); //-1.0 System.out.println(Math.floor(0.0)); //0.0 System.out.println(Math.floor(-0.0)); //-0.0 /** * random 取得一个大于或者等于0.0小于不等于1.0的随机数 */ System.out.println(Math.random()); //小于1大于0的double类型的数 System.out.println(Math.random()*2);//大于0小于2的double类型的数 System.out.println(Math.random()*2+1);//大于1小于3的double类型的数 /** * rint 四舍五入，返回double值 * 注意.5的时候会取偶数 异常的尴尬=。= */ System.out.println(Math.rint(10.1)); //10.0 System.out.println(Math.rint(10.7)); //11.0 System.out.println(Math.rint(11.5)); //12.0 System.out.println(Math.rint(10.5)); //10.0 System.out.println(Math.rint(10.51)); //11.0 System.out.println(Math.rint(-10.5)); //-10.0 System.out.println(Math.rint(-11.5)); //-12.0 System.out.println(Math.rint(-10.51)); //-11.0 System.out.println(Math.rint(-10.6)); //-11.0 System.out.println(Math.rint(-10.2)); //-10.0 /** * round 四舍五入，float时返回int值，double时返回long值 */ System.out.println(Math.round(10.1)); //10 System.out.println(Math.round(10.7)); //11 System.out.println(Math.round(10.5)); //11 System.out.println(Math.round(10.51)); //11 System.out.println(Math.round(-10.5)); //-10 System.out.println(Math.round(-10.51)); //-11 System.out.println(Math.round(-10.6)); //-11 System.out.println(Math.round(-10.2)); //-10 } }
8-1 枚举类 (这里我也是借鉴一下，我自己也不是太能使用明白)
类的对象只有有限个，确定的，当需要定义一组常量时，强烈建议使用枚举类
例如：星期：星期一...星期日
自定义枚举类：
package 枚举类; /* * 1.枚举类的使用： * 类的对象有有限个，确定的我们称此类为枚举类 * 2.如何定义枚举类； * 2.1：jdk5.0之前自定义枚举类 * 2.2：jdk5.0时可以使用enum关键字定义枚举类 * eunm常用方法： * values()：返回枚举类型的对象数组，遍历所有值 * valueOf()：可以把一个字符串转换为对应的枚举类对象，字符串必须是枚举类对象的名字 * toString()：返回当前枚举类对象常量的名字 */ public class Test01 { public static void main(String[] args) { System.out.println(Season.AUTUMU); } } //自定义枚举类 class Season {//季节 //1.声明Season对象的属性,定义成常量 private final String name; private final String desc; //2.私有化类的构造器,给对象赋值 private Season(String name,String desc){ this.name = name; this.desc = desc; } //3.提供当前枚举类的多个对象，声明为公共的 public static final Season SPRING = new Season("春天","春暖花开"); public static final Season SUMMER = new Season("夏天","夏日炎炎"); public static final Season AUTUMU = new Season("秋天","秋风徐徐"); public static final Season WINTER = new Season("冬天","冰天雪地"); //4.获取对象的属性 public String getName() { return name; } public String getDesc() { return desc; } //提供toString方法 public String toString() { return "Season [name=" + name + ", desc=" + desc + "]"; } }
使用关键字enum
package 枚举类; /* * 使用enum * 定义的枚举类默认继承class java.lang.Enum */ public class Test02 { public static void main(String[] args) { Season1 summer = Season1.SUMMER; System.out.println(summer.toString()); //System.out.println(summer.getClass().getSuperclass()); System.out.println(); //values() Season1[] values = Season1.values(); for (int i = 0; i < values.length; i++) { System.out.println(values[i]); } System.out.println(); //valueOf(),根据参数返回与之相同的参数名 Season1 valueOf = Season1.valueOf("WINTER"); System.out.println(valueOf); } } //使用enum关键字来定义 enum Season1{//季节 //1.提供当前枚举类的对象，多个对象之间用逗号隔开，末尾分号结束 SPRING ("春天","春暖花开"), SUMMER ("夏天","夏日炎炎"), AUTUMU ("秋天","秋风徐徐"), WINTER ("冬天","冰天雪地"); //1.声明Season对象的属性,定义成常量 private final String name; private final String desc; //2.私有化类的构造器,给对象赋值 private Season1(String name,String desc){ this.name = name; this.desc = desc; } //4.获取对象的属性 public String getName() { return name; } public String getDesc() { return desc; } //提供toString方法 /*public String toString() { return "Season [name=" + name + ", desc=" + desc + "]"; }*/ }