Java中的常用类详细笔记及其代码

最新推荐文章于 2023-06-14 22:15:01 发布

@小半

最新推荐文章于 2023-06-14 22:15:01 发布

阅读量422

点赞数

分类专栏： java的常用类文章标签： java

本文链接：https://blog.csdn.net/weixin_53331942/article/details/114892420

版权

java的常用类专栏收录该内容

1 篇文章 0 订阅

订阅专栏

成员内部类—调用内部类的方法

（1）.先创建外部类对象
（2）.在创建内部类对象

在这里插入图片描述

(3). 或者合并起来

在这里插入图片描述

  (4).如果内部类与外部类属性名字相同，优先访问内部类成员，想要访问外部类的属性，需要使用 ，outer.this.属性名
      System.out.println(Outer.this.name);
  
  (5).成员内部类不能定义静态成员，但是可以定义静态常量  final
      private final static int num=1;

静态内部类（相当于外部类,不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员）

 (1).静态内部类实际上与外部类相同
 (2).在静态内部类中调用外部类属性需要和正常调用类中的属性一样
 (3).调用内部类属性直接调用就可以
 (4).调用静态内部类的静态属性,使用  “类名.属性名”,静态成员通过类名来访问

在这里插入图片描述

(5).

在这里插入图片描述

(6).只有静态内部类才可以用static修饰，普通类不可以
(7).静态内部类就是在定义成员内部类之前加上static

在这里插入图片描述
局部内部类(定义在外部类的方法中)

(1).局部内部类前面不可以加任何访问修饰符，局部变量也是
(2).局部内部类可以直接访问外部类的属性,也可以  “outer.this.属性名”
(3).局部内部类可以访问内部类的属性

在这里插入图片描述

(4).想要执行 show()2，需要在局部内部类所在的方法内，创建局部内部类对象，再调用show()2

在这里插入图片描述

(5).测试局部内部类，先创建外部类对象，在调用外部类的方法(存在局部内部类的方法)

在这里插入图片描述

(6).在局部内部类中访问所在方法内的局部变量需要注意，该局部变量必须是常量

在这里插入图片描述

(7).局部内部类不能定义静态成员，但是可以定义静态常量  final

在这里插入图片描述

(8).局部内部类只能在当前的方法内使用

匿名内部类

(1).没有类名的局部内部类（一切特征与局部内部类相同）
(2).必须继承一个父类或者一个接口
(3).是定义类，实现类，常见对象的语法合并
在这里插入图片描述

在这里插入图片描述

Object 类

(1).Object类是所有类的父类
(2).Object类中所定义的方法，是所有对象都具备的方法

getclass方法
(1).返回引用中存储的实际对象类型
(2).应用：通常用于判断两个引用中实际存储对象的类型是否一致
在这里插入图片描述

hashCode方法

public int hashCode()

1.public int hashCode(){}
2.返回对象的哈希码值
3.哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值
4.一般情况下相同对象的返回相同的哈希码值

System.out.println(l.hashCode());
System.out.println(l1.hashCode());

toString()方法

public String toString()

1.返回对象的字符串表示形式
2.可以根据程序需要覆盖该方法，如：展现对象的属性值

package practice;
//一个项目中只能有一个main方法
public class Application {
    public static void main(String[] args) {
        Usbs l = new Usbs("l", 88);
        Usbs l1= new Usbs("li", 80);
        System.out.println(l.toString());
        System.out.println(l1.toString());
    }
}


//覆盖
@Override
    public String toString() {
        return "Usbs{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

equals方法

1.比较两个对象的地址是否相同。f比较两个字符串的值

System.out.println(l.equals(l1));

2.可以进行重写覆盖，比较两对象的内容是否相同。

//覆盖


@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Usbs usbs = (Usbs) o;

        if (age != usbs.age) return false;
        return name != null ? name.equals(usbs.name) : usbs.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

finalize 方法

1.当对象被判定为垃圾对象时，有JVM自动调佣此方法
2.垃圾对象：没有有效引用指向此对象时，为垃圾对象
3.手动回收机制：使用System.gc()；通知JVM执行垃圾回收

@Override
    protected void finalize() throws Throwable {
        System.out.println(this.name+"121");
    }

==================================================================

package practice;

public class student {
    public static void main(String[] args) {
          new Usbs("aaa",20);
         new Usbs("bbb",20);
          new Usbs("ccc",20);
         new Usbs("ddd",20);
        System.gc();
        System.out.println("回收垃圾");
    }
}

包装类

在这里插入图片描述

1.基本数据类型所对应的引用数据类型
2.Object可以统一所有数据，包装类默认值为null
3.JDK帮助文档

类型转化与装箱，拆箱

1.查询JDK帮助文档

		//装箱：把基本数据类型转换为引用数据类型
		int num=20;
        Integer integer =new Integer(num);
        Integer integer1=Integer.valueOf(num);

		//拆箱：把引用数据类型转换为基本数据类型
        Integer integer2=new Integer(10);
        int num1 =integer2.intValue();

		//JDK1.5 以后   自动装箱和拆箱
		Integer integer3=num;
        int num4=integer3;

        //基本类型转成字符串
        int num=255;
        //1.num+""
        String s =num+"";

        //2.Integer中的toString方法

        String s1=Integer.toString(num);
        //toString的重载方法  进制形式 radix
        String s2=Integer.toString(num,16);

        System.out.println(s);
        System.out.println(s2);

        //字符串转成基本类型

        String s4="255";

        //使用Integer中的 parseXXX();

        int i=Integer.parseInt(s4);
        System.out.println(i);

        //boolean字符串形式转成成基本类型，“true”--->true,非“true”--->false

        String a= "true";
        boolean vs= Boolean.parseBoolean(a);
        //  注意：要是用Boolean的包装类
        System.out.println(vs);

3.注意：保证类型兼容

String类

1.字符串是常量，创建之后不可改变
2.字符串字面值储存在字符串池中，可以共享
3.String s = “hello”; 产生一个对象，字符串池中存储
4.String s =new String(“Hello”);产生两个对象，堆，池各存储一个
5.字符串比较用 equals方法

String常用方法（1）

	   //1.length();返回字符串长度
	   
       String s= "java是世界上最好的编程语言";
       System.out.println(s.length());//15

       //2.charAt(int index);  返回某个位置的字符
       System.out.println(s.charAt(s.length()-1));//言

       //3.contains(String str); 判断是否包含某个字符串
       System.out.println(s.contains("Java")); //false
       System.out.println(s.contains("Php")); //false

String常用方法（2）

       //4.toCharArray();  返回字符串对应的数组 ;  Arrays.toString() --->打印数组
       System.out.println(Arrays.toString(s.toCharArray()));

       //5.indexOf();  返回子字符串  首次  出现的位置
       System.out.println(s.indexOf("1"));
       
       //6.从那个位置开始找
       System.out.println(s.indexOf("java",4));
       
       //7.lastIndexOf();  返回子字符串  最后一次  出现的位置
       System.out.println(s.lastIndexOf("java"));

String常用方法（3）

     //8.trim();去掉字符串前后的空格
     System.out.println(s.trim());
     
     //9.toUpperCase();把小写转成大写；toLowerCase()把大写转成小写
     System.out.println(s.toUpperCase());
     System.out.println(s.toLowerCase());
     //10.endWith(str)判断是否已经已str结尾，startWith(str)判断是否已经已str开头
     
     System.out.println(s.endsWith("ajva "));
     System.out.println(s.startWith(" java"));

String常用方法（4）

       //11.replace(char old,char new);用新的字符或字符串替换旧的字符或字符串
       System.out.println(s.replace("java","php"));
       
       //12.split();对字符串进行拆分
       String a="h e l l o  w o, r l d";
       String v[]=a.split("[ ,]+");
       for (String s1 : v) {
           System.out.println(s1);

用两个拆分符号的话 “[第一个，第二个]+” ， + 代表每个符号连续出现不止一个

      	//13.equals方法
 	    String i="HELLO";
        String i1="hello";
        // 14.忽略大小写的比较
        System.out.println(i.equalsIgnoreCase(i1));  
        System.out.println(i.equals(i1));

      //15.compareTo()方法，字符个数相同：一个一个比较，前面的减去后面的；
      //字符个数不同：前面的字符串个数减去后面的字符串个数
      
	  String i="AELLO";
      String i1="aello";
      System.out.println(i.compareTo(i1));   //-32
      String m="abc";
      String m1="abcchu";
      System.out.println(m1.compareTo(m));  //-3

练习：把“this is a text”中单词首字母大写？

public class student {
    public static void main(String[] args) {
        String str ="this is a text";
        String s5="";
       //首先将字符串劈分开变成字符串数组 a
        String[] a=str.split(" ");
        //在for循环遍历每个单词
        for (int i = 0; i < a.length; i++) {
        	//取出数组中每个单词a[i],在用charAt()取出每个单词的第一个字母
            char s=a[i].charAt(0);
            //使用Character.toUpperCase()；方法将单词的第一个字母变成大写
            char uppers=Character.toUpperCase(s);
            //使用substring();方法将每个单词从第二个往后进行截取，之后拼接
            String s4=uppers+a[i].substring(1)+" ";
            //合并每个单词
            s5=s5+s3;
        }
         //输出每个合并后的单词
        System.out.println(s5);
    }
}

总结String

public int length()：返回字符串长度
public char charAt(int index)：返回某个位置字符串
public char[] contains(String str)： 判断是否包含每个字符串
public char[] toCharArray(String str)：将字符串转换成数组
public int indexOf(String str):查找str首次出现的下标，存在，则返回改下标，不存在，则返回-1。
public int lastIndexOf(String str)：查找字符串在当前字符串中最后一次出现的下标位置
public String trim()：去掉字符串前后的空格。
public String toUpperCase()：将小写转成大写。
public boolean endWith(String str)：判断字符串是否以str结尾。
public String replace (char oldChar,char newChar)：将旧字符串替换成为新字符串。
public String[] split(String str)：根据str做拆分。
compare()：比较大小。

可变字符串

package practice;

public class Student {
    public static void main(String[] args) {
        StringBuilder sb=new StringBuilder();
        //1.append();  追加
        sb.append("java世界第一");
        //2.insert(); 在    指定位置  添加
        sb.insert(0,"最好的java");
        //3.replace();在指定位置替换
        sb.replace(1,2,"php");
        //4.delete();在在指定位置删除
        sb.delete(2,4);
        //5.使用delete();清空
        sb.delete(0,sb.length());
    }
}

检验效率

package practice;

/**
 * 验证StringBuilder的效率高于String
 */


public class student {
    public static void main(String[] args) {
        long start=System.currentTimeMillis();
        String a="";
        for (int i = 0; i < 9999; i++) {
            a+=i;
        }
        //获取时间System.currentTimeMillis();
        long end =System.currentTimeMillis();
        System.out.println("用时"+(end-start));  //  用时296


        StringBuilder sb=new StringBuilder();
        long start1=System.currentTimeMillis();
        for (int i = 0; i < 99999; i++) {
            sb.append(i); //此处需要使用append();方法把i追加进来
        }
        long end1=System.currentTimeMillis();
        System.out.println("用时"+(end1-start1)); //用时8

    }
}

BigDecimal

1.位置在java.math包中。
2.作用：精确计算浮点数。
3.创建方式: BigDeciaml r1= new BigDecimal(“19”);
4.类的运算就应该调用方法，不用改直接用运算符了
5.要特别注意除法运算

		double a=1.0;
        double b=0.9;
        System.out.println(a-b);//0.09999999999999998

        //面试题
        double c=(1.4-0.5)/0.9;
        System.out.println(c); //0.9999999999999999

        //BigDecimal,大的浮点数精确计算
        //使用BigDecimal创建一个对象 ，要用字符串
        BigDecimal r1=new BigDecimal("1.0");
        BigDecimal r2=new BigDecimal("0.9");
        //减法 subtract();
        //r1.subtract(r2);返回类型也为BigDeciaml
        BigDecimal r3 = r1.subtract(r2);
        System.out.println(r3);  //0.1

        //加法  add();方法
        BigDecimal r4 = r1.add(r2);
        System.out.println(r4);  //1.9

        //乘法  multiply();方法
        BigDecimal r5 = r1.multiply(r2);
        System.out.println(r5);  //0.90

        //除法  divide(); 方法
        BigDecimal r6 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));
        System.out.println(r6);   //1

        //除不尽会报错，所以使用； 保留两位小数：2 ；四舍五入：BigDecimal.ROUND_HALF_UP
        BigDecimal r7 = new BigDecimal("20").divide(new BigDecimal("3"), 2,BigDecimal.ROUND_HALF_UP);
        System.out.println(r7);  //6.67

注意除法会出现的问题

Data

1.Data表示特定的瞬间，精确到毫秒。
2.1秒=1000毫秒；1毫秒=1000微秒；1微妙=1000纳秒
3.要用java.util中的包
4.获取的毫秒值都是从1970年开始到现在的毫秒值

     //1创建Data对象
     //今天
     Date data1 =new Date();
     System.out.println(data1.toString());//Mon Mar 22 20:29:48 CST 2021
     System.out.println(data1.toLocaleString());//2021-3-22 20:32:46
     //昨天  get.time() 获取毫秒值
     Date data2= new Date(data1.getTime()-(60*60*24*1000));
     System.out.println(data2.toLocaleString());//2021-3-21 20:32:46

     //2 方法 after before  判断时间在前还是在后
     boolean a= data1.after(data2);
     System.out.println(a);    //true
     boolean b= data1.before(data2);
     System.out.println(b);    //false

     //3 compareTo方法   毫秒值相减  正为1  负为-1  相等为0
     int v=data1.compareTo(data2);
     System.out.println(v);   //1
     int v1=data2.compareTo(data1);
     System.out.println(v1);  //-1
     int v3=data2.compareTo(data2);
     System.out.println(v3);  //0

     //equals方法  判断两个时间是否相等
     boolean n= data1.equals(data2);
     System.out.println(n);  //false

Calendar类

1.Calendar提供了获取或者设置各种日历字段的方法
2.Calendar的构造方法

protected Calendar（）：由于修饰符是protected,所以无法直接创建该对象对象，所以需要借助getInstance()来创建Calendar来创建
Calendar calendar = Calendar.getInstance()

        //1.创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        //使用get.time（）方法来变为 Date 的
        System.out.println(calendar.getTime().toLocaleString());
        //打印毫秒值
        System.out.println(calendar.getTimeInMillis());



        //2.获取时间信息
        //获取年
        int year = calendar.get(Calendar.YEAR);
        //获取月份   注意：月份是从0开始的    0-11
        int month = calendar.get(Calendar.MONTH);
        //获取日
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        //获取小时
        int hour = calendar.get(Calendar.HOUR_OF_DAY);//HOUR_OF_DAY是24小时制的
        //获取分钟
        int minute =calendar.get(Calendar.MINUTE);
        //获取秒
        int second = calendar.get(Calendar.SECOND);


        //3.修改时间   把天修改成昨天
        Calendar calendar1 = Calendar.getInstance();
        calendar1.set(Calendar.DAY_OF_MONTH,4);
        System.out.println(calendar1.getTime().toLocaleString());



        //4.add方法修改   加上一个小时:1   减去一个小时：-1
        calendar1.add(Calendar.HOUR_OF_DAY,1);
        System.out.println(calendar1.getTime().toLocaleString());



        //5. 补充方法  (getac) 获取当前月份的最大天数和最小天数
        calendar1.add(Calendar.MONTH,-1);
        int a = calendar1.getActualMaximum(Calendar.DAY_OF_MONTH);
        int v= calendar1.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(a);
        System.out.println(v);

SimlieDateFormat类

java 在这里插入图片描述

        //创建SimpleDateFormat对象    设置模板
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日  HH:mm:ss");


        //创建Date
        Date date = new Date();

        //格式化 data（把日期转成字符串）
        String str = sdf.format(date);
        System.out.println(str);

        //解析 （把字符转转成日期）  使用sdf中的parse（）方法
        Date date2 = sdf.parse(str);
        System.out.println(date2);

System类

        //1.arraycopy: 数组的复制
        //src:原数组   srcPos：从哪个位置开始复制   dest：目标数组   destPos：目标数组的位置  length  ：复制的长度
        int[] array ={22,35,23,43,25,43,25,43};
        int[] dest = new int[8];
        System.arraycopy(array,4,dest,4,4);
        for (int i : dest) {
            System.out.println(i);
        }
        

        //2. 打印从1970年到现在的毫秒数   System.currentTimeMillis()  使用此方法可以实现计时功能
        System.out.println(System.currentTimeMillis());



        //3.System.gc() 告诉垃圾回收器回收  可能回收也可能不回收



        //4.System.exit(0)退出jvm   参数0是正常退出jvm  参数非0是异常退出jvm
        System.exit(0);
        // 以下代码不运行  因为已经提前退出了jvm
        System.out.println("程序正常退出了-----");

总结

在这里插入图片描述

欢迎各位小伙伴点赞转发收藏，多多支持哦！

@小半

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java中的常用类详细笔记及其代码

调用内部类的方法1.先创建外部类对象2.在创建内部类对象![在这里插入图片描述](https://img-blog.csdnimg.cn/20210316180849520.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MzMzMTk0Mg==,size_16,color_FFFFFF,t_70)...
复制链接

扫一扫