05常用类

最新推荐文章于 2022-09-29 20:49:52 发布

风吹未扬

最新推荐文章于 2022-09-29 20:49:52 发布

阅读量94

点赞数

分类专栏： Java 文章标签：常用类

本文链接：https://blog.csdn.net/u014120081/article/details/102807048

版权

Java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

Java是面向对象的语言，但并不是“纯面向对象”的，因为我们经常用到的基本数据类型就不是对象，为了解决这个不足，Java在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)。

基本数据类型对象的包装类(都在Number类中)
在这里插入图片描述
Integer

//基本数据类型转化为包装类对象
Integer a = new Integer(3);
Integer b = Integer.valueOf(30);	// 官方推荐这种写法

//把包装类对象转化为基本数据类型
int c = b.intValue();
int d = b.doubleValue();

// 字符串转化成Integer对象
Integer int3 = Integer.parseInt("334");	//""内不能由字符，列如ddd，否则会报错。只能是整数
Integer int4 = new Integer("999");	//parse为解析的意思，将int解析为Integer

 // Integer对象转化成字符串
String str1 = int3.toString();
// 一些常见int类型相关的常量
System.out.println("int能表示的最大整数：" + Integer.MAX_VALUE);

自动装箱和拆箱

//自动装箱
Integer i = 100;//自动装箱
//相当于编译器自动为您作以下的语法编译：
Integer i = Integer.valueOf(100);//调用的是valueOf(100)，而不是new Integer(100)

//自动拆箱
Integer i = 100;
int j = i;//自动拆箱
//相当于编译器自动为您作以下的语法编译：
int j = i.intValue();

//空指针是对象为空，你调用了它的方法
Integer  c = null;
int b = c;	//此处报错,NullPointerException,因为默认拆箱,调用c.intValue();

//Integer缓存问题
//缓存[-128,127]之间,底层生成一个Integer cache[]数组,存储-128,127之间的Integer对象，如果对象在缓存范围之内，那么不同对象在栈中保存的地址都是相同的,指向堆中数组的同一个对象
Integer in1 = -128;
Integer in2 = -128;
System.out.println(in1 == in2);//true 因为123在缓存范围内
System.out.println(in1.equals(in2));//true
Integer in3 = 1234;
Integer in4 = 1234;
System.out.println(in3 == in4);//false 因为1234不在缓存范围内
System.out.println(in3.equals(in4));//true

String（“==”判断是否为一个对象,用equals）
在这里插入图片描述
String 类对象代表不可变的Unicode字符序列，因此我们可以将String对象称为“不可变对象”。那什么叫做“不可变对象”呢?指的是对象内部的成员变量的值无法再改变。

字符串的比较

//编译器做了优化,直接在编译的时候将字符串进行拼接
String str1 = "hello" + " java";//相当于str1 = "hello java";
String str2 = "hello java";
System.out.println(str1 == str2);//true
String str3 = "hello";
String str4 = " java";
//编译的时候不知道变量中存储的是什么,所以没办法在编译的时候优化
String str5 = str3 + str4;
System.out.println(str2 == str5);//false

StringBuilder
在这里插入图片描述
StringBuffer和StringBuilder非常类似，均代表可变的字符序列。这两个类都是抽象类AbstractStringBuilder的子类，方法几乎一模一样。

StringBuilder和StringBuffer的区别

StringBuffer JDK1.0版本提供的类，线程安全，做线程同步检查，效率较低。
StringBuilder JDK1.5版本提供的类，线程不安全，不做线程同步检查，因此效率较高。建议采用该类。

StringBuilder sb = new StringBuilder("abcdefg");
//此方法为地址输出方法
System.out.println(Integer.toHexString(sb.hashCode()));	//1b6d3586
System.out.println(sb);	//abcdefg

//String因为是不可变字符序列,所以并没有setCharAt()这个方法
sb.setCharAt(2,'M');	//abcdefg
System.out.println(Integer.toHexString(sb.hashCode()));	//1b6d3586
System.out.println(sb);	//abMdefg

//要想String改变,只能是重新创建一个对象
String s1 = new String("abcdef");
String s2 = s1.substring(2, 4);
// 打印：ab199863
System.out.println(Integer.toHexString(s1.hashCode()));
// 打印：c61, 显然s1和s2不是同一个对象
System.out.println(Integer.toHexString(s2.hashCode()));

StringBuilder里面的常用方法

append();重载方法
reverse();反转
insert();插入----支持链式调用
delete();删除----支持链式调用

insert方法的链式调用，该方法调用了return this，把自己返回
在这里插入图片描述

StringBuilder sb=new StringBuilder("aa");
sb.insert(0,'我').insert(6,'爱').insert(7,'你');	//链式调用

tips:
System.out.println('a'+1);	//98,char类型加上整型，拼接起来的也是整型
char c = (char)'a'+1;
System.out.println(c);	//b	整型强转化就是字字符型依照asicii码

不可变和可变字符序列使用陷阱

String str8 = "";
for (int i = 0; i < 5000; i++) {
    str8 = str8 + i;//相当于产生了10000个对象
}

时间处理类
在这里插入图片描述
Date类(表示一个特定的瞬间，精确到毫秒，制造一个时间)

long now = System.currentTimeMillis();
System.out.println(now);	//1572359764116 返回当前时间（以毫秒为单位）。

Date date = new Date();
System.out.println(date);	//返回计算机中当前时刻 Tue Oct 29 22:28:29 CST 2019

Date date = new Date();
System.out.println(date.getTime());	//1572359764117	返回当前时间（以毫秒为单位）

Date date1 = new Date(2000);
System.out.println(date1);	//Thu Jan 01 08:00:02 CST 1970 构造器中有参数的话就是从时间原点加上参数开始计时

DateFormat类和SimpleDateFormat类（java.text包下）
事件对象与字符串对象之间的转化
在这里插入图片描述
把时间对象转化成指定格式的字符串。反之，把指定格式的字符串转化成时间对象。（一般使用SimpleDateFormat）

在这里插入图片描述
DateFormat为抽象类(SimpleDateFormat为它的子类)，所以不能直接使用

// 将时间对象转换成字符串
DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
DateFormat df1 = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss");
String sd = df.format(new Date());
String sd1= df1.format(new Date());
System.out.println(sd);	//2019-10-29 10:48:35
System.out.println(sd1);	//2019年10月29日 10:48:35

// 把字符串按照“格式字符串指定的格式”转成相应的时间对象
DateFormat df = new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒");	//指定的格式
Date date = df.parse(“1983年5月10日 10时45分59秒”);
System.out.println(date);	//Tue May 10 10:45:59 CST 1983

Calendar日历类

Calendar 类是一个抽象类，为我们提供了关于日期计算的相关功能，比如：年、月、日、时、分、秒的展示和计算。GregorianCalendar 是 Calendar 的一个具体子类，提供了世界上大多数国家/地区使用的标准日历系统。

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

/**
 * @author Sheye
 * @date 2019-10-29 20:45
 */
public class testString {
    public static void main(String[] args) throws ParseException {
        String str = "2019-10-30";
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        Date date = df.parse(str);

        Calendar c = new GregorianCalendar();
        c.setTime(date);

        int day = c.get(Calendar.DAY_OF_MONTH);
        int days = c.getActualMaximum(Calendar.DATE);
        System.out.println("日\t一\t二\t三\t四\t五\t六");

        // c是你声明的一个变量， 用来存东西的。你先给他设置成了12号，这个时候，c就包含了12号的信息，后面你把他设置成1号了，它里面就只是1号的信息。
        c.set(Calendar.DAY_OF_MONTH ,1); //将给定的日历字段设置为给定的值(把今天设置成1号，c对象中只保存了1号)
        //1号是星期几前面就有几个空格
        for (int i = 0; i <c.get(Calendar.DAY_OF_WEEK)-1 ; i++) {
            System.out.print("\t");
        }
        //DAY_OF_MONTH指定日期是一个月的第几天



        for (int i = 1; i <= days; i++) {
            if (i==day){
                System.out.print(c.get(Calendar.DAY_OF_MONTH)+"*\t");
            }
            System.out.print(c.get(Calendar.DAY_OF_MONTH)+"\t");

            if (c.get(Calendar.DAY_OF_WEEK)==Calendar.SATURDAY){
                System.out.println("");   //如果是周六换行，国外周日才是第一天
            }

            c.add(Calendar.DAY_OF_MONTH,1); //循环一次日期加1
        }
    }
}

File

import java.io.File;
import java.io.IOException;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

/**
 * @author Sheye
 * @date 2019-10-29 20:45
 */
public class testString {
    public static void main(String[] args) throws ParseException, IOException {
        File f = new File("e:/a.txt");
        System.out.println(f);
        f.renameTo(new File("e:/sheye.txt"));

        System.out.println(System.getProperty("user.dir"));
        File f2 = new File("gg.txt");
        f2.createNewFile();

        System.out.println(f2.getAbsolutePath());
        f2.delete();    //删除文件
        
        File f3 = new File(System.getProperty("user.dir")+"sheye");
        boolean flag = f3.mkdir();  //如果文件不存在不会创建整个目录树
        System.out.println("flag = " + flag);
        
        boolean flag1 = f3.mkdirs();
        System.out.println("flag1 = " + flag1); //如果文件不存在会创建整个目录树
    }
}

使用递归生成目录树结构

import java.io.File;
import java.io.IOException;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

/**
 * @author Sheye
 * @date 2019-10-29 20:45
 */
public class testString {
    public static void main(String[] args) throws ParseException, IOException {
        File f = new File("E:\\下载\\01. java300集【北京尚学堂·百战程序员】");
        printFile(f,0);
    }

    static void printFile(File file,int level){
        //level为0则不加,循环直接完毕，level为1开始累加
        for (int i = 0; i <level;i++) {
            System.out.print("-");
        }
        System.out.println(file.getName());
        if (file.isDirectory()){
            File[] files = file.listFiles();

            for (File tmp:files) {
                //此处不能写++level，fies数组每次出来level都是0+1，形参传入的都是1，如果++level那就是level不断在增大
                printFile(tmp,level+1);
            }
        }
    }
}

枚举

所有的枚举类型隐性地继承自 java.lang.Enum。枚举实质上还是类!而每个被枚举的成员实质就是一个枚举类型的实例，他们默认都是public static final修饰的。

System.out.println(Week.星期一);
        Week a = Week.星期一;
        switch (a){
            case 星期一:
                System.out.println("所罗门");break;
            case 星期二:
                System.out.println("啊啊啊");break;
            case 星期三:
                System.out.println(" adad");break;
            case 星期四:
                System.out.println(" 啊啊啊" );break;
        }
    }


    enum Week{
        星期一,星期二,星期三,星期四,星期五,星期六,星期日
    }

风吹未扬

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
05常用类

Java是面向对象的语言，但并不是“纯面向对象”的，因为我们经常用到的基本数据类型就不是对象，为了解决这个不足，Java在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)。基本数据类型对象的包装类(都在Number类中)Integer//基本数据类型转化为包装类对象Integer a = new Integer...
复制链接

扫一扫

专栏目录