首页 > 其他分享 >常用类

常用类

时间:2022-09-22 16:35:30浏览次数:58  
标签:常用 String int System println public out

内部类

在一个类的内部再定义一个类

public class Body {
    //也会生成一个独立的字节码编译class文件:Body$Head.class
    public class Head{
        public void show(){
        System.out.println(name);
        }
    }
}
  • 编译之后可生成独立的字节码文件
  • 内部类课直接访问外部类的私有成员,而不破坏封装性
  • 可以为外部类提供必要的功能组件

成员内部类

  • 在类的内部定义,与实例变量、实例方法同级别的类
  • 外部类的一个实例部分,创建内部类对象时,必须依赖外部类对象

image-20220921100726449

  • 当外部类、内部类存在重名属性时,会优先访问内部类属性。打印外部类属性,要加Body.this.

image-20220921101156279

  • 成员内部类不能定义静态成员,但是可以包含静态常量
private static final String country = "China";

静态内部类

  • 不依赖外部类对象,可以直接创建或通过类名访问,可以声明静态成员,和外部类差不多
  • 使用外部类要先实例一个外部类对象

image-20220921103839161

  • 只有内部类可以用static修饰,其他类不可以

局部内部类

  • 定义在外部类方法中,作用范围和创建对象范围仅限于当前方法
  • 局部内部类访问外部类当前方法中的局部变量时,因无法保障变量的生命周期与自身相同,变量必须修饰final

image-20220921105658111

匿名内部类

  • 没有类名的局部内部类(一切特征都与内部类相同)
  • 必须继承一个父类或者实现一个接口
public class Application {
    public static void main(String[] args) {
        //创建接口类型的变量
        USB usb = new Mouse();
        usb.service();
        //局部内部类
        class Fan implements USB{
            @Override
            public void service() {
                System.out.println("fan success");
            }
        }
        Fan fan = new Fan();
        fan.service();
        //匿名内部类,只调用一次,相当于创建了一个局部内部类
        USB usb1 = new USB() {
            @Override
            public void service() {
                System.out.println("success too");
            }
        };
        usb1.service();
    }
}
  • 定义类、实现类、创建对象的语法合并,只能创建一个该类对象
  • 优点:减少代码量
  • 缺点:可读性较差

Object类

  • 超类、基类、所有类的直接或者间接父类,位于继承树的最顶层
  • 没有书写extends显示继承某个类,都是继承自object类
  • object类中定义的所有方法,是所有对象都具备的方法
  • object类型可以存储任何对象
    • 作为参数,可接受任何对象
    • 作为返回值,可以返回任何对象

常用方法

getClass()

public final Class<?> getClass(){}

  • 返回引用中存储的实际对象类型
  • 通常用于判断两个引用中实际存储对象类型是否一致
public class Application {
    public static void main(String[] args) {
        Student s1= new Student("Jodie",22);
        Student s2 = new Student("Jodier",22);
        //返回类型时Class
        Class<? extends Student> aClass = s1.getClass();
        Class<? extends Student> aClass1 = s2.getClass();
        if (aClass == aClass1){
            System.out.println("True");
        }else {
            System.out.println("False");
        }
    }
}

hashCode()

public int hashCode(){}

  • 返回该对象的哈希码值
  • 哈希值根据对象的地址字符串数字使用hash算法计算出来的int类型数值
  • 一般情况下,相同对象返回相同哈希码
Student s3 = s1;
System.out.println(s1.hashCode());//460141958
System.out.println(s2.hashCode());//1163157884
System.out.println(s3.hashCode());//460141958

toString()

public String toString(){}

  • 返回该对象的字符串表示(表现形式)
  • 可以根据程序需要覆盖该方法(方法重写)

equals()

public boolean equals(Object obj){}

  • 比较this与obj的地址:s1.equals(s2)-->比较s1和s2

  • 可以进行覆盖

    • 比较两个引用是否指向同一个对象
    • 判断obj是否为null
    • 判断两个引用指向的实际对象类型是否一致
    • 强制类型转换
    • 依次比较各个属性值是否相同
    @Override
    public boolean equals(Object obj) {
        //1判断是否一个引用
        if(this==obj){
            return true
        }
        //2判断obj是否null
        if (obj==null){
            return false
        }
        //3判断是否一个类型
//        if (this.getClass()==obj.getClass())
        //instanceof 判断对象是否是某种类型
        if(obj instanceof Student){
            //4强制类型转换
            Student s = (Student) obj;
            //5比较数据
            if(this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
        return false;
    }
}

finalize()

对象被判断为垃圾对象时,由JVM自动调用

手动回收System.gc()

包装类

基本数据类型放在栈里;引用数据类型放在堆里,对象地址在栈里

object可统一所有数据,包装类的默认值是null,针对八种基本数据类型构造的类(变成了引用类型,可以调用方法),大写首字母(int---Integer|char---Character)

类型转换

Number父类中提供的6个共性方法(拆箱)

image-20220921161543198

装箱

栈放堆:基本类型转为引用类型,jdk1.5后自动装箱

	int num1 = 18;
	Integer integer1 = new Integer(num1);
	Integer integer2 = Integer.valueOf(num1);
	//自动装箱
	Integer integer4 = 10;

拆箱

堆放栈:引用类型转为基本类型,jdk1.5后自动拆箱

    Integer integer3 = Integer.valueOf(10);
    int num2 = integer3.intValue();
    //自动拆箱
    int age2 = integer4;

基本类型和字符串转换

  • 基本类型变字符串
    • +“”
    • toString()
      • 里面有个重载方法,radix参数表示进制
String s2 = Integer.toString(13,12);
System.out.println(s2);//-->11
  • 字符串变基本类型

    parseXXX()静态方法

int n2 = Integer.parseInt(str);
System.out.println(n2);//-->150
  • Boolean字符串转成基本类型
//boolean字符串形式转成基本类型,”true“-->true ,非"true"-->false
String str2 = "true";
boolean b1 = Boolean.parseBoolean(str2);
System.out.println(b1);//==>true
String str3 = "nontrue";
boolean b2 = Boolean.parseBoolean(str3);
System.out.println(b2);//==>false

整数缓存区

  • java预先创建了256个常用的整数包装类型对象(-128~127)
  • 在实际应用当中,对已创建的对象进行复用
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
System.out.println(integer1==integer2);//==>false
Integer integer3 = 100;//自动装箱:在-128~127范围内(整数缓冲区),已存在
Integer integer4 = 100;//Integer.valueof()
System.out.println(integer3==integer4);//==>true
Integer integer5 = 200;//自动装箱
Integer integer6 = Integer.valueOf(200);//不在-128~127范围内(整数缓冲区),所以是重新创建了一个对象
System.out.println(integer5==integer6);//==>false

String类

  • 字符串是常量,创建之后为不可改变序列
  • 字符串字面值存储在字符串池中,可以共享
//两种创建模式
String name = "Jodie";//产生一个对象,字符串池中存储
String s = new String("Hello");//产生两个对象,堆、池里面各存储一个
name = "A";//在字符串池中重新开了一块空间,是替换不是修改
String name2 = "A";//也指向A,字符串常量共享

常用方法

length()

public int length():返回字符串长度

charAt()

public char charAt(int index):根据下标获取字符

contains()

public boolean contains(String str):判断当前字符串是否包含str

toCharArray()

public char[] toCharArray():将字符串转换为数组

indexOf()

public int indexOf(String str):查找str首次出现的下标,存在,则返回该下标;不存在,则返回-1

有方法重载,可以从指定下标开始索引

lastIndexOf()

public int lastIndexOf(String str)):查找str最后一次出现的下标索引,存在,则返回该下标;不存在,则返回-1

trim()

public String trim():去掉字符串前后的空格

toUpper/LowerCase()

public String toUpperCase():将小/大写转为大/小写

end/startWith()

public boolean end/startWith(String str):判断字符串是否翼str结尾/开始

replace()

public String replace(char oldChar,char newChar):将旧的字符或字符串替换成新的字符或字符串

split()

public String[] split(String str):根据str做拆分

如果有多个拆分依据,可以写作split("[ ,]")一个空格和逗号作为分隔符

split("[ ,]+"):任意个数的空格和逗号或者组合也可以做分隔符

String s1 = "Java is the  best     langage,java is,,do you ,know";
String[] arr = s1.split("[ ,]+");
for (String s2 : arr) {
    System.out.println(s2);
}

image-20220922134459772

equals()

比较是否相等

String name1 = "Ab";
String name2 = "aB";
System.out.println(name1.equals(name2));//==>false
System.out.println(name1.equalsIgnoreCase(name2));//==>true  忽略大小写比较内容是否相等

compareTo()

比较大小,在字典表里的顺序

String name1 = "Ab";
String name2 = "aB";
String name3 = "A";
System.out.println(name1.compareTo(name2));//==>-32(一个一个比,顺延,如果相等,为0)
System.out.println(name1.compareTo(name3));//==>1(如果一方包含另一方,则化为比较字符长度)

String类实例

public static void main(String[] args) {
    String str = "This is a text";
    System.out.println("==========1.拆分单词==========");
    String[] arr = str.split(" ");
    for (String s : arr) {
        System.out.print(s+" ");
    }
    System.out.println();
    System.out.println("=========2.替换===========");
    str.replace("text","practice");
    System.out.println(str);
    System.out.println("=========3.添加===========");
    str.replace("text","easy text");
    System.out.println("==========4.单词首字母大写==========");
    for (int i = 0; i < arr.length; i++) {
        char first = arr[i].charAt(0);
        char upperfirst = Character.toUpperCase(first);
        System.out.println(upperfirst+arr[i].substring(1));//截取:指定下标开始,或指定开始与结束,截取片段
    }
}

可变长字符串

比String效率高,节省内存

StringBuffer

增强类,运行慢,线程安全

StringBuffer stringBuffer = new StringBuffer();
//1.append():追加各种类型
stringBuffer.append("java");
System.out.println(stringBuffer.toString());//==>java
//2.insert():在任何位置添加各种类型数据
stringBuffer.insert(0,"wow,");
System.out.println(stringBuffer.toString());//==>wow,java
//3.replace():可以指定替换的位置
stringBuffer.replace(0,3,"hello");
System.out.println(stringBuffer);//==>hello,java
//4.delete():指定位置删除
stringBuffer.delete(5,6);
System.out.println(stringBuffer);//==>hellojava
//5.reverse():反转
System.out.println(stringBuffer.reverse());//==>avajolleh

StringBuilder

增强类,运行快,线程不安全,常用

功能同上,建议用这个

BigDecimal类

  • 位置:java.math包
  • 作用:精确计算浮点数
  • 创建方式:BigDecimao bd = new BigDecimal("1.0");
public class Application {
    public static void main(String[] args) {
        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        System.out.println(bd1.subtract(bd2));//-  ==>0.1
        System.out.println(bd1.add(bd2));//+       ==>1.9
        System.out.println(bd1.multiply(bd2));//×  ==>0.90
        BigDecimal bd3 = new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));
        System.out.println(bd3);//÷                ==>1
        //除不尽的时候参数里可以选择保留小数位数以及舍入模式
        BigDecimal bd4 = new BigDecimal("10")
                .divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);//四舍五入:BigDecimal.ROUND_HALF_UP
        System.out.println(bd4);//                ==>3.33
    }
}

Date类

  • 表示特定的瞬间,精确到毫秒。大部分被Calendar类中的方法取代

Calendar类

  • 提供了获取或设置各种日历字段的方法
  • 构造方法:
    • protected Calendar():修饰符为protected,所以无法直接创建该对象

常用方法

public class Application {
    public static void main(String[] args) {
        //1.创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());//==>2022-9-22 15:16:18
        System.out.println(calendar.getTimeInMillis());//==>1663830978132
        //2.获取时间信息
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH);//月份要+1
        int day = calendar.get(Calendar.DAY_OF_MONTH);//或Date
        int hour = calendar.get(Calendar.HOUR_OF_DAY);
        int minute = calendar.get(Calendar.MINUTE);
        int second = calendar.get(Calendar.SECOND);
        System.out.println(year+"/"+(month+1)+"/"+day+" "+hour+":"+minute+":"+second);//==>2022/9/22 15:22:48
        //3.修改时间
        Calendar calendar1 = calendar.getInstance();
        calendar1.set(Calendar.DATE,21);
        System.out.println(calendar1.getTime().toLocaleString());//==>2022-9-21 15:25:56
        //4.add方法修改时间
        calendar1.add(Calendar.HOUR,1);
        System.out.println(calendar1.getTime().toLocaleString());//==>2022-9-21 16:27:30
        //5.得到某时间域最大/小值
        int max = calendar1.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar1.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max);//==>30
        System.out.println(min);//==>0
    }
}

SimpleDateFormat类

  • 是一个以与语言环境有关的方式来格式化和解析日期的具体类
  • 进行格式化(日期-->文本)、解析(文本-->日期)
public class Application {
    public static void main(String[] args) throws ParseException {
        //1.创建一个SimpleDateFormat类
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");//格式
        //2.创建Date
        Date date = new Date();
        //3.格式化date:日期转成字符串
        String str = sdf.format(date);
        System.out.println(str);//==>2022/09/22 15:42:35
        //4.解析:字符串转成日期
        Date date1 = sdf.parse("1990/09/21 13:14:00");
        System.out.println(date1);//==>Fri Sep 21 13:14:00 CST 1990
    }
}

System类

  • 系统类,用于获取系统的属性数据和其他操作,构造方法是私有的,几乎都静态,不需要创造对象,直接System.调用
public class Application {
    public static void main(String[] args) throws ParseException {
        //1.arraycopy():数组的复制  System.arraycopy(src,srcPos,dest,destPos,length);一种本地方法,效率高
        //src:源数组
        //srcPos:从哪个位置开始复制
        //dest:目标数组
        //destPos:目标数组开始放的位置
        //length:复制的长度
        int[] arr = {1,2,10,45,12,89,21,45};
        int[] dest = new int[8];
        System.arraycopy(arr,4,dest,4,3);//Arrays.copyOf(original,newLength);
        for (int i = 0; i < dest.length; i++) {
            System.out.print(dest[i]+" ");//==>0 0 0 0 12 89 21 0
        }
        //2.currentTimeMillis()获取系统运行时间毫秒数
        System.out.println(System.currentTimeMillis());//==>1663834769278
        long start = System.currentTimeMillis();
        for (int i = -99999999; i < 99999999; i++) {
            for (int j = -999999999; j < 99999999; j++) {
                int result = i+j;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("用时:"+(end-start));//==>用时:6
        //3.System.gc():告诉垃圾回收区回收
        //4.System.exit():退出jvm
    }
}

标签:常用,String,int,System,println,public,out
From: https://www.cnblogs.com/J-Hoko/p/16719789.html

相关文章

  • python系列——常用系统模块
    常用系统模块os:与操作系统交互os.name/os.sep/os.linesep.:系统名称/系统路径分隔符/系统换行符os.mkdir()/os.makedirs():建立目录/建立多级目录os.getenv("PAT......
  • JAVA常用工具类
    java开发常用工具类java正则表达式的匹配包括:邮箱,手机,姓名,昵称,身份证号,银行卡号等;生成6位随机数;对url中字符串进行编码和解码;获取客户端ip地址;获取系统当前时间;生......
  • java中String的常用方法
    1、length()字符串的长度例:charchars[]={'a','b'.'c'};Strings=newString(chars);intlen=s.length();2、charAt()截取一个字符例:charch......
  • 数组常用方法总结
    判断数组中是否存在某个值vararrData=['html','css','javascript'];varvalue='css';console.log(arrData.includes(value));console.log(arrData.some(ite......
  • MySQL常用命令
    MySQL基础1.创建数据库createdatabaseshop;#使用库useshop;2.创建表createtableuser(id intprimarykey,namechar(10))ENGINE=InnoDBDEFAULTCHARSET=u......
  • vim常用命令
    vim常用命令进入插入模式移动光标删除,复制和粘贴undo和redo查找单词替换字符串显示行号显示隐藏字符设置文本格式保存退出参考资料vim常用命令vim是在li......
  • HBASE常用命令
    进入HBASE编辑hbaseshell查看命名空间list_namespace创建命名空间create_namespace'命名空间名字'删除命名空间drop_namespace'名字'创建表格create‘命名空......
  • Docker常用命令总结
    Docker常用命令重启docker命令systemctlrestartdocker进入镜像dockerexec-itmysql/bin/bash移除指定容器dockerrm-f<containerid>删除未启动成......
  • Windows常用命令手册
    cmd命令手册端口命令查看端口占用详情netstat-ano查找过滤命令findstr(相似Linux中grep)例如需要查找8080端口占用详情:netstat-ano|findstr可查出对应......
  • Linux常用命令总结
    端口防火墙相关开放指定端口:firewall-cmd--zone=public--add-port=5601/tcp--permanent开启/重启防火墙:systemctlstartfirewalldfirewall-cmd--reload......