常用类

标签：常用 String int System println public out

内部类

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

public class Body {
    //也会生成一个独立的字节码编译class文件:Body$Head.class
    public class Head{
        public void show(){
        System.out.println(name);
        }
    }
}

• 编译之后可生成独立的字节码文件
• 内部类课直接访问外部类的私有成员，而不破坏封装性
• 可以为外部类提供必要的功能组件

成员内部类

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

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

• 成员内部类不能定义静态成员，但是可以包含静态常量

private static final String country = "China";

静态内部类

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

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

局部内部类

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

匿名内部类

• 没有类名的局部内部类（一切特征都与内部类相同）
• 必须继承一个父类或者实现一个接口

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个共性方法（拆箱）

装箱

栈放堆：基本类型转为引用类型,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);
}

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