Day12-Java的常用类
Java常用类
内部类
在一个类的内部在定义一个完整的类
特点：1.编译之后可以产生独立的字节码文件
2.可以调用外部类的私有属性，不破坏类的封装性
3.可以为外部类提供必要的内部组件
成员内部类
public class Main{
public static void main(String[] args){
A.B s = new A().new B();
s.in(); //内部类最重要特点，可以调用外部类的私有属性
}
}
public class A{
private int id = 10;
public void say(){
System.out.println("hi");
}
class B{
public void in(){
System.out.println("in");
System.out.println(id);
}
}
}
静态内部类
不依赖外部类，使用与外部类无异，可以直接使用
特点：1.仍然可以调用外部类的私有属性，但需要将外部类实例化再调用
2.在调用时，实例化与正常内部类不同
- 正常：A.B s =new A().new B();
- 静态内部类: A.B s = new A.B(); 表示包含关系
public class Main{
public static void main(String[] args){
A.B s = new A.B();
s.in(); //内部类最重要特点，可以调用外部类的私有属性
}
}
public class A{
private int id = 10;
public void say(){
System.out.println("hi");
}
static class B{ //与外部类相同
static int s = 100;
public void in(){
System.out.println("in");
A a = new A();
System.out.println(a.id);
}
}
}
局部内部类
1.只能在类中的方法定义和调用
2.调用方法的局部变量时，1.8之后默认会为变量加上final修饰符
3.局部内部类不能有任何修饰符
public class Main{
public static void main(String[] args){
A s = new A();
s.say(); //
}
}
public class A{
private int id = 10;
public void say(){
String name = "chenchenchen"
class B{
public void hehe(){
System.out.println(id); //id == A.this.id
System.out.println(name);
}
}
System.out.println("hi");
B b = new B();
b.hehe();
}
}
匿名内部类
1.没有类名的局部内部类（一切特征与局部内部类相同）
2.必须继承一个父类或者在一个接口中实现
3.定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
public class Main{
public static void main(String[] args){
Usb s = new Test();
s.serive;
Usb usb = new Usb(){
public static void serive(){
System.out.println("123"); //不用重写一个输出123的类
};//正常的接口不能直接实例化，可以使用匿名内部类优化（相当于创建了一个局部内部类）
}
}
}
public interface Usb{
void serive();
}
class Test implements Usb{
String name = "chenchenchen";
int id = 10;
public static void serive(){
System.out.println("Test");
}
}
Object类
1.基类，所有类的父类
2.默认继承object类
3.object中定义的方法全部可以直接使用
4.object作为参数，可以储存任何对象，作为返回值，可以返回任何对象
getClass()方法
返回引用中存储的实际对象类型，通常用于判断两个引用中存储的对象类型是否相同
public class Person {
int id;
private String name;
public Person(int id, String name) {
super();
this.id = id;
this.name = name;
}
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
Person p = new Person(1,"zdb");
System.out.println(p.getClass());
System.out.println(p.getClass().getName());
System.out.println(p.getClass().getSimpleName());
System.out.println(p.id);
}
//运行结果
class 基础语法.Person
基础语法.Person
Person
1
hashCode()方法
返回对象的哈希值码
当对象相等时，hashCode返回值也是相同的
class Main {
public static void main(String[] args) {
// Object 使用 hashCode()
Object obj1 = new Object();
System.out.println(obj1.hashCode());
Object obj2 = new Object();
System.out.println(obj2.hashCode());
Object obj3 = new Object();
System.out.println(obj3.hashCode());
}
}
运行结果
225534817
1878246837
929338653
clone
创建并返回一个对象的拷贝
需要重写
public class Main{
String name;
int id;
public static void main(String[] args){
Main a = new Main();
a.name = "陈琛琛";
a.id = 100;
try {
Main b = (Main) a.clone();
System.out.println(b.name+"is "+b.id);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}//报错
equals（）
比较对象是否相等，返回值类型为布尔型
xx.equals(xx)
public class Main{
public static void main(String[] args){
String s1 = new String();
String s2 = new String();
System.out.pritln(s1.equals(s2));//true 初始化都为空
}
}
finalize()
程序员一般不调用，当对象被判定为垃圾对象时，由JVM自动调用此方法
垃圾对象：没有有效引用指向此对象
垃圾回收，由GC销毁垃圾对象，释放数据存储空间
自动回收：JVM的内存耗尽，一次性回收所有对象
手动回收：使用System.gc();通知JVM回收，是否回收由JVM判断
public class Main{
public static void main(String[] args){
new Student("aaa");
new Student("bbb");
new Student("ccc");
new Student("ddd");
new Student("eee");
System.gc();
System.out.println("回收成功")
}
}
class Student{
String name;
public Student(String name){
this.name = name;
}
protected void finalize() throws Throwable{
System.out.println(this.name+"对象被回收了")
}
}
toString()
打印输出数组
public class Main{
public static void main(String[] args){
int[] a={1,5,456,12,566,12,3};
System.out.println(a);//得到的是一个哈希数
System.out.println(Arrays.toString(a));//输出数组a
}
public static void printArray(int [] array){//自己写一个与toString相似的方法
for(int i =0;i<array.length;i++){
if(i==0){
System.out.println("["+array[i]+",")
}else if(i==array.length-1){
System.out.println(array[i]+"]")
}else
System.out.println(array[i]+",")
}
}
}
Arrays类
该类包包含用于操作数组的各种方法（如排序和搜索），此外包括一些静态方法，可以直接调用
toString()
打印输出数组
public class Main{
public static void main(String[] args){
int[] a={1,5,456,12,566,12,3};
System.out.println(a);//得到的是一个哈希数
System.out.println(Arrays.toString(a));//输出数组a
}
public static void printArray(int [] array){//自己写一个与toString相似的方法
for(int i =0;i<array.length;i++){
if(i==0){
System.out.println("["+array[i]+",")
}else if(i==array.length-1){
System.out.println(array[i]+"]")
}else
System.out.println(array[i]+",")
}
}
}
sort()
对数组进行排序，默认为升序
public class Main{
public static void main(String[] args){
int[] a={1,5,456,12,566,12,3};
System.out.println(Arrays.sort(a));//输出从小到大的数组
}
}
fill()
填充数组
public class Main{
public static void main(String[] args){
int[] a= new in[10];
Array.fill(a,0); //将数组全部填充为0
Array.fill(a,2,4,0); //将第二到第四个元素填充为0
}
}
剩余可查看jdk文档
包装类
基本数据类型所对应的引用数据类型，默认值为null 博客
特点：基本类型数据存放在栈中，变成引用类型后，栈中存放的是引用，数据存放在堆中
优点：变成引用类型后，可以使用一些方法对其进行处理
装箱：将基本类型转换为引用类型
public class Main{
public static void main(String[] args){
int num = 10;
Integer a = new Integer(num);
Integer b = Integer.valueOf(num)
}
}
拆箱：将引用类型转换为基本类型
public class Main{
public static void main(String[] args){
int num = 10;
Integer a = new Integer(num);
int b = a.intValue();
}
}
s.xxValue()
以xx形式返回指定的数值s
注意点
public class Main{
public static void main(String[] args){
Integer a = new Integer(100);
Integer b = new Integer(100);
System.out.println(a==b); //false
//new 是创建新的对象，a和b引用指向堆中不同的地址
Integer c = 100;
Integer d = 100;
System.out.println(c==d); //true
//此时c d引用指向同一个地址，返回的是IntegerCache数组，当超过范围时，返回的是对象地址，则会出错
Integer e = 200;
Integer f = 200;
System.out.println(e==f); //false
//因为堆中存放了一个-128-127的IntegerCache数组，直接赋值则先在里面找
}
}
JDK8以后自动拆箱和装箱
基本类型与字符串之间的转换
- 使用加号
- 使用integer中的toString方法
- 使用integer中的parsexxx转换为字符串
注意点：当布尔型转换为字符串时，非true均为false
public class Main{
public static void main(String[] args){
int num = 15;
String s = num + "";
String s1 = Integer.toString(num);
String s2 = "150";
int num1 = Integer.parseInt(s2);
}
}
String类
Java程序中所有的字符串文本都是String类的实例
创建方式
- 字面量赋值
public class Main{
public static void main(String[] args){
String name = "zhangsan";
//name是zhangsan的地址存放在栈中，在方法区中开辟一个常量池，存放zhangsan
name = "hi";
//重新开辟一个空间存放hi，name的地址改变
name2 = "zhangsan"
//不开辟新空间，而是指向之前的张三
}
}
- 使用new创建
public class Main{
public static void main(String[] args){
String s = new String("haha");
//将“haha”作为char数组存放到方法区中，在堆中存放数组地址，s存放的是堆中存放数组地址的变量的地址
String s1 = new String("haha");
System.out.println(s==s1); //false
//s s1中存放的是变量，每次创建都会在堆中开辟一个新的空间存放指向haha这个数组的地址
System.out.println(s.equals(s1)); //true
//此时比较的是数值
}
}
常用方法
legtn()
返回字符串长度
charAt(int index)
返回某个位置的字符
contains(String str)
判断是否包含某个子字符串
public class Main{
public static void main(String[] args){
String s1 = "wwww123";
String s2 = "123";
System.out.println(s1.contains(s2));
}
}
toCharArray()
将字符串转换成数组
public class Main{
public static void main(String[] args){
String s1 = "wwww123";
System.out.println(Array.toString(s1.toCharArray()));
}
}
indexOf lastIndexOf
返回字符串首次出现的位置
public class Main{
public static void main(String[] args){
String s1 = "wwww123";
System.out.println(s1.indexOf("w"));
}
}
trim()
去掉字符串空格,只能去掉前后空格
public class Main{
public static void main(String[] args){
String s1 = " wwww 123 ";
System.out.println(s1.trim());
}
}
replace(new str,old str)
用新的字符或者字符串替换旧的字符或者字符串
public class Main{
public static void main(String[] args){
String s1 = "wwww123";
System.out.println(s1.replace("123","456"));
}
}
split()
拆分字符串
扩展
1.split("[ ,]"),此时遇到空格或者逗号就会拆分
2.split("[ ,]+")此时遇到多个空格或者多个逗号也会拆分
public class Main{
public static void main(String[] args){
String s1 = "www.w12.3";
String[] s = s1.split(".")
System.out.println(s1.indexOf("w"));
}
}
compareTo
比较字典大小
public class Main{
public static void main(String[] args){
String s1 = "abc"; //a为97
String s2 = "xyz"; //x为120
System.out.println(s1.compareTo(s2)); //-23
String s3 = "abc"; //a为97
String s4 = "abcxyz"; //x为120
System.out.println(s3.compareTo(s4)); //-3
//比较完位置之后就比较长度
}
}
案例
public class Main{
public static void main(String[] args){
String s1 = "this is a text";
System.out.println(s1.split(" "));
System.out.println(s1.replace("text","haha"));
System.out.println(s1.replace(" text","easy text"));
}
}
可变字符串
区别
1.效率比String高
public class Main{
public static void main(String[] args){
long start = System.currentTimeMillis();
String s = "";
for (int i = 0; i <99999 ; i++) {
s+=i;
}
long end = System.currentTimeMillis();
System.out.println("String用时："+(end-start));
long start1 = System.currentTimeMillis();
StringBuffer s1 = new StringBuffer();
for (int i = 0; i <99999 ; i++) {
s1.append(i);
}
long end1 = System.currentTimeMillis();
System.out.println("StringBuffer用时："+(end1-start1));
}
}
2.比String节省内存
StringBuffer
运行效率慢，线程安全
StringBuilder
运行效率快，线程不安全
常用方法
append
public class Main{
public static void main(String[] args){
StringBuffer s = new StringBuffer();
System.out.println(s.append("hello"));
}
}
insert()
在某个位置添加
public class Main{
public static void main(String[] args){
StringBuffer s = new StringBuffer();
System.out.println(s.append("hello"));
System.out.println(s.insert(5," world"));
}
}
replace
public class Main{
public static void main(String[] args){
StringBuffer s = new StringBuffer();
System.out.println(s.append("hello"));
System.out.println(s.insert(5," world"));
System.out.println(s.replace(0,5,"he"));
}
}
delete
public class Main{
public static void main(String[] args){
StringBuffer s = new StringBuffer();
System.out.println(s.append("hello"));
System.out.println(s.insert(5," world"));
System.out.println(s.replace(0,5,"he"));
System.out.println(s.delete(0,s.length()));
}
}
BigDecimal类
浮点数类型的数据是相对精确的数据，进行运算时，会出现精度丢失问题
此时BigDecimal就出现了，用于大的浮点数精确计算
import java.math.BigDecimal;
public class Main{
public static void main(String[] args){
double a = 1.0;
double b = 0.9;
System.out.println(a-b);
BigDecimal c = new BigDecimal("1.0"); //使用ab时，输出结果将为更高精度的浮点数，而不是0.1
BigDecimal d = new BigDecimal("0.9");
BigDecimal e = c.subtract(d);
BigDecimal f = c.subtract(d);
System.out.println(e);
}
}
注意点：
使用除法时，主要写舍入模式
c.divide(d,2,BigDecimal.ROUND_HALF_UP) //四舍五入
Date
Date表示特定的瞬间，精确到毫秒，现大部分被Calendar类中的方法所取代
import java.math.BigDecimal;
import java.util.Date;
public class Main{
public static void main(String[] args){
Date a = new Date(); //获取时间
System.out.println(a);
Date b = new Date(a.getTime()-(60*60*24*1000)); //getTime 从1970到现在的毫秒数
System.out.println(b);
boolean c = a.after(b);
System.out.println(c);
int d = a.compareTo(b);
System.out.println(d); //a>b d=1, a<b d=-1
}
}
Calendar
Canlendar提供了获取或者设置各种日历字段的方法
该类的修饰符为protected 所以无法直接创建该对象
import java.math.BigDecimal;
import java.util.Calendar;
import java.util.Date;
public class Main{
public static void main(String[] args){
Calendar a = Calendar.getInstance(); //获取指定时间
System.out.println(a.getTime().toLocaleString());
System.out.println(a.getTimeInMillis());
int year = a.get(Calendar.YEAR); //获取想要的时间数据
int month = a.get(Calendar.MONTH);
int day = a.get(Calendar.DAY_OF_MONTH);
System.out.println(year+" "+(month+1)+" "+day);
Calendar b = Calendar.getInstance();
b.set(Calendar.DAY_OF_MONTH,12); //通过set改变时间，如年月日
System.out.println(b.getTime().toLocaleString());
b.add(Calendar.HOUR,-1); //通过add改变时间，当前为减少一个小时
System.out.println(b.getTime().toLocaleString());
int max = b.getActualMaximum(Calendar.DAY_OF_MONTH); //获取年月日的最大值
int min = b.getActualMinimum(Calendar.DAY_OF_MONTH);
System.out.println(max+" "+min);
}
}
SimpleDateFormat
将日期数据在文本与日期间转换
步骤：
- 创建对象
- 创建Date
- 格式化、
import java.text.SimpleDateFormat;
import java.util.Date;
public class Main {
public static void main(String[] args) throws Exception {
SimpleDateFormat myFmt = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
SimpleDateFormat myFmt1 = new SimpleDateFormat("yy/MM/dd HH:mm");
SimpleDateFormat myFmt2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//等价于now.toLocaleString()
SimpleDateFormat myFmt3 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 E ");
SimpleDateFormat myFmt4 = new SimpleDateFormat("一年中的第 D 天 一年中第w个星期 一月中第W个星期 在一天中k时 z时区");
Date now = new Date();
System.out.println(myFmt.format(now));
System.out.println(myFmt1.format(now));
System.out.println(myFmt2.format(now));
System.out.println(myFmt3.format(now));
System.out.println(myFmt4.format(now));
System.out.println(now.toGMTString());
System.out.println(now.toLocaleString());
System.out.println(now.toString());
Date first = myFmt.parse("2020/12/12");
System.out.println(first);
}
}
System类
系统类，用于获取一些系统的属性数据和其他操作
arraycopy
复制数组
System.arraycopy(原数组，开始位置，目标数组，目标数组开始位置，复制长度)
System.currentTimeMillis();
系统此刻时间，一般用于计算运行时间
public class Main{
public static void main(String[] args){
long start = System.currentTimeMillis();
String s = "";
for (int i = 0; i <99999 ; i++) {
s+=i;
}
long end = System.currentTimeMillis();
System.out.println("String用时："+(end-start));
long start1 = System.currentTimeMillis();
StringBuffer s1 = new StringBuffer();
for (int i = 0; i <99999 ; i++) {
s1.append(i);
}
long end1 = System.currentTimeMillis();
System.out.println("StringBuffer用时："+(end1-start1));
}
}
System.gc
提示jvm回收垃圾，但是否回收由jvm判断
浙公网安备 33010602011771号