常用类
Object类
getClass（）方法
public final Class<?> getClass(){}
- 返回引用中存储的实际对象类型
- 应用:通常用于判断两个引用中实际存储对象类型是否一致
public static void main(String[] args) {
Students s1 = new Students("张三",20);
Students s2 = new Students("李四", 21);
//判断s1和s2是否为同一个类型
Class class1 = s1.getClass();
Class class2= s2.getClass();
if (class1 == class2){
System.out.println("属于同一个类型");
}else{
System.out.println("不属于同一个类型");
}
}
hashCode()方法
public int hashCode(){}
- 返回该对象的哈希码值。
- 哈希值根据对象的地址或字符串或数字使用hash算法出来的int类型的数值。
- 一般情况下行头对象返回相同哈希码。
//hashCode方法
System.out.println(s1.hashCode());//21685669
System.out.println(s2.hashCode());//2133927002
Students s3 = s1;
System.out.println(s3.hashCode());//21685669
toString()方法
public String toString(){}
- 返回该对象的字符串表示（表达形式）。
- 可以根据程序需求覆盖方法，如展示对象各个属性值。
System.out.println(s1.toString());//com.dai.common.Students@14ae5a5
System.out.println(s2.toString());//com.dai.common.Students@7f31245a
//可以对方法进行重写显示我们需要看到的 快捷：Alt + insert
/*
@Override
public String toString() {
return "Students{" +
"name='" + name + '\'' +
", age=" + age +
'}';
*/
//方法重写后toString显示的信息
//Students{name='张三', age=20}
//Students{name='李四', age=21}
equals()方法
public boolean equals(Object obj){}
-
默认实现为（this == obj ），比较两个对象地址是否相同。
System.out.println(s1.equals(s2)); -
可以进行覆盖，比较两个对象的内容是否相同。
-
equals方法覆盖步骤：
- 比较两个引用是否指向同一个对象。
- 判断obj是否null。
- 判断两个引用指向的实际对象类型是否为一致。
- 强制转换类型
- 比较各个属性值是否相同。
@Override public boolean equals(Object obj) { //1.判断两个引用是否指向同一个对象 if (this == obj){ return true; } //2. 判断obj是否为null if (obj == null){ return false; } //3.判断两个引用指向的实际对象类型是否为一致, if (obj instanceof Students){ //4.强制转换类型 Students s = (Students)obj; //5.比较各个属性值是否相同 if (this.name.equals(s.getName())&&this.age == s.getAge()){ return true; } } return false; }
包装类
-
当基本类型转成引用类型时称为装箱：
int num = 10; Integer integer = new Integer(num); Integer integer1 = Integer.valueOf(num); System.out.println("装箱"); System.out.println(integer); System.out.println(integer1); -
当引用类型转成基本类型时称为拆箱:
int num2 = integer.intValue(); System.out.println("拆箱"); System.out.println(num2); -
JDK1.5后提供了自动拆箱与装箱，其实在低层编译器帮我们做一些事情,使用的就是1.5前的方法来帮助我们自动装拆
//装箱 Integer intefer3 = age; System.out.println("装箱："+age); //拆箱 int age1 = intefer3; System.out.println("拆箱："+age1); -
基本类型和字符串之间转换
-
基本类型转换成字符串
int n1 = 255; //1.1使用“+”（但是这种方法可以但是不推荐） String s1 = n1+""; //1.2使用Integer中的toString（）方法 String s2 = Integer.toString(n1); String s3 = Integer.toString(n1, 16);//对应几进制,我现在输入对应的是16进制 System.out.println(s1);//255 System.out.println(s2);//255 System.out.println(s3);//ff -
字符串转换成基本类型：
String n2 = "150"; int i = Integer.parseInt(n2);//这边在进行转换是字符串不能包含字符，只能是数字。转化为浮点数时，应用Duoble.parse***() System.out.println(i); -
boolean类型字符串转基本类型 只有是ture时才会是ture，其他都是false:
String b = "true"; boolean b1 = Boolean.parseBoolean(b); System.out.println(b1);
-
-
Integer缓存区：
-
Java预先创建了256常用的整数（-128/127）包装类型对象。
-
为什么要这样设计呢？答：在实际应用中应用比较频繁，对已创建的对象进行复用。
public static void main(String[] args) { //面试题：判断以下对象是否相同 Integer integer = new Integer(100); Integer integer2 = new Integer(100); System.out.println(integer == integer2);//false,它比较的是对象的引用地址 Integer integer3 = 100;//自动包装：底层用的还是这个方法Integer.valueOf() Integer integer4 = 100; System.out.println(integer3 == integer4);//true Integer integer5 = 200; Integer integer6 = 200; System.out.println(integer5 == integer6);//false，整数缓存区（范围：-128--127）溢出 }
-
String类
- 字符串是常量（finnal），创建之后不可以改变
- 字符串字面存储在字符串池，可以共享
String s = "hello" ;//产生一个对象，字符池中存储
String str1 = new String("hello");//产生两个对象，堆、池中各产生一个，运行时合并成一个。
public static void main(String[] args) {
String name1 = "hello" ;//hello 常量存储在字符池中，可以共享
name1 = "world" ;//world赋值给name，给字符串赋值赋值时，并没有修改数据，而是在字符池中重新开辟内存赋值
String name2 = "world";//字符池数据相同时，共享
System.out.println(name1);
System.out.println(name2);
System.out.println(name1 == name2);
String str1 = new String("java");//产生两个对象，堆、池各存储一个，运行时合并成一个
String str2 = new String("java");
System.out.println(str1 == str2);//比较的是内存大小
System.out.println(str1.equals(str2));//字符串比较时使用equals（）
}
常用方法
String content = "java是世界上最好的编程语言，使用java查找首次出现的位置，或使用java查找最后一次出现的位置";
-
length（）返回长度:
System.out.println(content.length());//15：不管输入什么都算一个字符 -
charAt（）返回某个位置的字符:
System.out.println(content.charAt(content.length()-1));//言：下标从0开始 -
contains（）判断字符是否在存在:
System.out.println(content.contains("java"));//true -
toCharArray（）；返回字符串对应的数组:
System.out.println(Arrays.toString(content.toCharArray()));//[j, a, v, a, 是, 世, 界, 上, 最, 好, .....] -
indexOf（）；返回字符首次出现的位置:
System.out.println(content.indexOf("java")); System.out.println(content.indexOf("java",4));//第一个内容输入查找的字符串，第二个内容输入要从第几个开始查找 -
lastIndexOf（）；返回字符最后出现的位置:
System.out.println(content.lastIndexOf("java")); -
trim();去掉str前后的空格:
-
toUpperCase（）；将小写转换为大写/toLowerCase（）；将大写转换为小写:
String content2 = " hello world "; System.out.println(content2.trim());//hello world System.out.println(content2.toUpperCase());// HELLO WORLD System.out.println(content2.toLowerCase());// hello world -
endWith（）；判断是否为str结尾/startsWith（）；判断是否为str开头:
String filename = "hello.java"; System.out.println(filename.endsWith("java"));//true System.out.println(filename.startsWith("hello"));//true -
replace（）；用新的字符或者字符串替换掉老的:
System.out.println(content.replace("java","pyhton")); //old：java是世界上最好的编程语言，使用java查找首次出现的位置，或使用java查找最后一次出现的位置 //new：pyhton是世界上最好的编程语言，使用pyhton查找首次出现的位置，或使用pyhton查找最后一次出现的位置 -
split（）；对字符进行拆分:
String say = "java is the beat programing language.java good"; String[] array = say.split("[ .]+"); //当想使用多个符号（空格或者，）进行拆分时可以使用中阔号:"[ .]" //当语句中有多给空格是可以是用中括号加：“[ ]+” System.out.println(array.length); for (String s : array) { System.out.println(s); } -
补充equals、compareTo：
String s1 = "hello"; String s2 = "HELLO"; System.out.println(s1.equals(s2));//false System.out.println(s1.equalsIgnoreCase(s2));//true:忽略大小写比较 //在string里比较 String s3 = "abc";//97 String s4 = "xyz";//120 System.out.println(s3.compareTo(s4));//-23：从首字母中相对应的asc码减去s4对应首字母的asc码的 String s5 = "abc"; String s6 = "abcxyz"; System.out.println(s5.compareTo(s6));//-3：当首字母相同，字符串长度不相同，这种情况就是按字符串的长度进行减法运算 -
练习题:
public static void main(String[] args) {
/**
* 已知String str = "this is a text";
* 将str中的单词单独获取
* 将str中text替换为practice
* 在text前面插入easy
* 将每一个单词的首子母大写
*/
String str = "this is a text";
//将str中的单词单独获取
String[] s = str.split(" ");
for (String s1 : s) {
System.out.println(s1);
}
//将str中text替换为practice
String s2 = str.replace("text", "practice");
System.out.println(s2);
//在text前面插入easy
String s3 = s2.replace("practice", "easy text");
System.out.println(s3);
//将每一个单词的首子母大写
for (int i = 0; i <s.length ; i++) {
char frist = s[i].charAt(0);
//把首字母转为大写
char upperfrist = Character.toUpperCase(frist);
//将字符拼接输出
String news = upperfrist + s[i].substring(1);
System.out.print(news+" ");
}
}
可变长字符串
-
StringBuffer：可变长字符串，jdk1.0提供，运行效率慢，线程安全。
-
StringBuilder：可边长字符串，jdk5.0提供，运行效率快，线程不安全。
//测试运行时间 public static void main(String[] args) { //开始时间 long start = System.currentTimeMillis(); //String String str = ""; for (int i = 0; i <9999 ; i++) { str+=i; } System.out.println(str);//4 //StringBuffer StringBuffer sb = new StringBuffer(); for (int i = 0; i <9999 ; i++) { sb.append(i); } System.out.println(sb);//3 //StringBuilder StringBuilder sbd = new StringBuilder(); for (int i = 0; i <9999 ; i++) { sbd.append(i); } System.out.println(sbd);//2 //结束时间 long end = System.currentTimeMillis(); System.out.println("用时："+(end-start)); }- 推荐使用：StringBuffer。
-
最主要掌握四个方法，追加： append（）、插入：insert（）、删除：delete（）、替换：replace（）
public static void main(String[] args) { StringBuffer sb = new StringBuffer(); //主要记住四个方法 //1.append（）；追加 sb.append("java真香"); System.out.println(sb); sb.append("java是世界上最好的语言"); System.out.println(sb); //2.replace();替换 sb.replace(0,5,"python"); System.out.println(sb); sb.replace(7,11,"pyhton"); System.out.println(sb); //3.delete()；删除 sb.delete(0,7); System.out.println(sb); //4.insert()；插入 sb.insert(0,"java和"); System.out.println(sb); //清空 sb.delete(0,sb.length()); System.out.println(sb.length());BigDecimal
//面试题 double d1 = 1.0; double d2 = 0.9; System.out.println(d1-d2);//0.09999999999999998 double result =(1.4-0.5)/0.9; System.out.println(result);//0.9999999999999999为什么上面的运算结果会有偏差呢？
答：很多实际应用中需要精确运算，而double是近似值存储，不符合要求，需要借助BigDecimal！
- 位置：java.math包中。
- 作用：精确计算浮点数。
- 创建方式：创建时注意参数要字符串类型
BigDecimal bd1 = new BigDecimal("1.0");public static void main(String[] args) { double d1 = 1.0; double d2 = 0.9; System.out.println(d1-d2);//0.09999999999999998 double result =(1.4-0.5)/0.9; System.out.println(result);//0.9999999999999999 BigDecimal bd1 = new BigDecimal("1.0"); BigDecimal bd2 = new BigDecimal("0.9");//一定要以字符串形式，不然运算出来还是不准确的 //加法运算 BigDecimal add = bd1.add(bd2); System.out.println(add); //减法 BigDecimal subtract = bd1.subtract(bd2); System.out.println(subtract); //乘法 BigDecimal multiply = bd1.multiply(bd2); System.out.println(multiply); //除法 BigDecimal result1 = new BigDecimal("1.4") .subtract(new BigDecimal("0.5")) .divide(new BigDecimal("0.9")); System.out.println(result1); //进行除法运算时，如果不能准确计算出结果时，需要指定保留的位数和取舍方式 BigDecimal d = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP); System.out.println(d); }- 加：add
- 减：subtract
- 乘：multipily
- 除：divide，主要掌握这四个方法
- 除法注意点：
- 除法：divide（BigDecimal bd ， int scal，RoundingMode mode）
- 参数 scal ：指定精确到小数点后几位
- 参数mode：
- 指定小数部分的取舍模式，通常采用四舍五入的模式。
- 取值为BigDecimal.ROUND_HALF_UP。
- 除法注意点：
Date类
Date类（有好多方法被Calendar方法代替）
- Date表示特定的瞬间，精确到毫秒。Date类中大部分方法都已经被Calendar类中的方法取代
- 时间单位：
- 1秒=1000毫秒；
- 1毫秒=1000微秒；
- 1微妙=1000纳秒；
public static void main(String[] args) {
Date date1 = new Date();//要选择java.util这个类
//获取当前时间
System.out.println(date1);//Sun Mar 21 23:21:22 CST 2021这个有点看不惯
System.out.println(date1.toLocaleString());//2021-3-21 23:22:10 这个已经过时了
//获取昨天这个点的时间
Date date2 = new Date(date1.getTime() - (60 * 60 * 24 * 10000));
System.out.println(date2.toLocaleString());//2021-3-11 23:25:39
//2.after/before:判断是否为后/前一天
boolean d1 = date1.after(date2);//date1是date2的后面一天吗？
System.out.println(d1);//true
boolean b1 = date2.before(date1);//date2是date1的前面一天吗？
System.out.println(b1);//true
//3.compareTo（）比较
int i1 = date1.compareTo(date2);//今天比昨天大吗？大时返回正1
System.out.println(i1);//1
int i2 = date2.compareTo(date1);//昨天比今天大吗？小时返回负1
System.out.println(i2);//-1
int i3 = date1.compareTo(date1);//相同时返回0
System.out.println(i3);//0
//4.比较是否相等equals（）
boolean e1 = date1.equals(date2);
System.out.println(e1);//false
}
- 因为很多被Calendar类中的方法取代，暂时只理解这些。
Calendar类
-
Calendar提供了获取或设置各种日历字段的方法。
-
构造方法：
- protected Calendar（）：由于修饰符时protected（受保护的），所以无法直接创建对象。
-
其他方法：
| 方法名 | 说明 |
|---|---|
| static Calendar get Instance() | 使用默认时区和区域获取日历 |
| void set（int year，int month，int date，int hourofday，int minute，int second） | 设置日历的年、月、日、时、分、秒 |
| int get（int field） | 返回给日历字段的值。字段比如年月日等 |
| viod setTime（Date date） | 用给定的Date设置日历的时间。Date- Calendar |
| Date getTime（） | 返回一个Date表示日历时间。Calendar-Date |
| void add（int field，int amount） | 按照日历的规则，给指定字段添加或减少时间量 |
| long getTimeInMillies（） | 毫秒为单位返回该日历的时间值 |
- java月:在月的时候要注意 ，设计是0-11月，所以在输出的时候加1
public static void main(String[] args) {
//1.创建Calendar对象，由与是受保护的不能直接new，使用Calendar方法来获取
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString());//由于toString（）打印出来的不是想要的，使用这样的方法进行打印
System.out.println(calendar.getTimeInMillis()+"毫秒");//获取毫秒值
//2.获取时间信息
//获取年
int year = calendar.get(Calendar.YEAR);
//月:在月的时候要注意 ，设计是0-11月，所以在输出的时候加1
int month = calendar.get(Calendar.MONTH);
//日
int day = calendar.get(Calendar.DAY_OF_MONTH);//Date也是一样的
//小时
int hour = calendar.get(Calendar.HOUR_OF_DAY);//HOUR_OF_DAY是24小时的；HOUR是12小时的
//分钟
int minute = calendar.get(Calendar.MINUTE);
//秒
int second = calendar.get(Calendar.SECOND);
System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);//2021年3月22日1:6:36
//修改时间
Calendar calendar1 = Calendar.getInstance();
calendar1.set(Calendar.YEAR,2022);
System.out.println(calendar1.getTime().toLocaleString());//2022-3-22 1:06:36
//add方法修改时间:add(要修改的时间，加(当前时间加1)/减（当前时间减1）)
calendar1.add(Calendar.HOUR_OF_DAY,-1);
System.out.println(calendar1.getTime().toLocaleString());//2022-3-22 0:06:36
//获取当月最大或者最小的值
int max = calendar1.getActualMaximum(Calendar.DAY_OF_MONTH);
int mini = calendar1.getActualMinimum(Calendar.DAY_OF_MONTH);
System.out.println(max);//31
System.out.println(mini);//1
}
SimpleDateFormat
- SimpleDateFormat是一个以语言环境有关的方式来格式化和解析日期的具体类
- 进行格式化（日期-》文本）、解析（文本——》日期）。
- 常用的时间模式字母：
| 字母 | 日期或时间 | 示例 |
|---|---|---|
| y | 年 | 2019 |
| M | 年中月份 | 08 |
| d | 月中天数 | 10 |
| H | 1天中小时数（0-23） | 22 |
| m | 分钟 | 16 |
| s | 秒 | 59 |
| S | 毫秒 | 367 |
- 转换的时候要注意格式（年/月/日）
public static void main(String[] args) throws ParseException {
//1.创建SimpleDateFormat对象(年月日格式)
//SimpleDateFormat sdf = new SimpleDateFormat("YYYY年MM月dd日 HH:mm：ss");
SimpleDateFormat sdf = new SimpleDateFormat("YYYY/MM/dd");
//2.创建Date
Date date = new Date();
//3.格式化data(将日期转成字符串）
String f1 = sdf.format(date);
System.out.println(f1);//2021/03/22
//解析（将字符串转换为日期）
Date date2 = sdf.parse("2021/08/23");//解析可能有异常，要在方法上抛出
System.out.println(date2);//Sun Dec 27 00:00:00 CST 2020
}
System类
- System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的。
| 方法名 | 说明 |
|---|---|
| static void arraycopy（…）； | 复制数组 |
| stctic long currentTimeMillis（）； | 获取系统当前时间，返回的是毫秒值 |
| static void gc（）； | 建议JVM赶快启动垃圾回收器回收垃圾 |
| static void exit（int staus）； | 建议JVM，如果参数是0表示正常退出JVM，非0表示异常退出JVM |
public static void main(String[] args) {
//arraycopy：数组的复制
/**
* src：源数组
* srcPos：从那个位置开始复制
* dest：目标数组
* destPos：目标数组的位置
* length：长度
*/
int[] array = {10,20,50,44,66,45,65};
int[] dest = new int[7];
System.arraycopy(array,0,dest,0,array.length);
for (int i = 0; i <array.length ; i++) {
System.out.println(dest[i]);
}
//可以用这个方法计时
long start = System.currentTimeMillis();
for (int i = -99999999; i <99999999 ; i++) {
for (int j =-99999999; j < 99999999; j++) {
int result =i+1;
}
}
long end = System.currentTimeMillis();
System.out.println("用时："+(end-start));
//退出JVM
System.exit(0);
System.out.println("程序结束了");
}
2453
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
