Java周记（第三周）常用类

码码忽忽

已于 2022-05-22 09:38:45 修改

阅读量430

点赞数 3

文章标签： java

于 2022-05-17 16:33:57 首次发布

本文链接：https://blog.csdn.net/qq_62243433/article/details/124776201

版权

第八章

1.包装类

1.包装类基本知识

Java是面向对象的语言，但并不是“纯面向对象”的，因为我们经常用到的基本数据类型就不是对象。但是我们在实际应用中经常需要将基本数据转化成对象，以便于操作。比如：将基本数据类型存储到Object[]数组或集合中的操作等等。为了解决这个不足，Java在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类。

包装类均位于java.lang包

基本数据类型对应的包装类

基本数据类型	包装类
byte	Byte
boolean	Boolean
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double

测试Integer类型

public class testwrappedclass {
	public static void main(String[]args) {
		//基本数据类型转成包装类对象
		Integer a=new Integer(3);
		Integer b=Integer.valueOf(30);
		//把包装类对象转成基本数据类型
		int c=b.intValue();
		double d=b.doubleValue();
		//把字符串转成包装类对象
		Integer e=new Integer("999");
		Integer f=Integer.parseInt("999888");
		//把包装类对象转成字符串类型
		String str=f.toString();//""+f
		//常见的常量
		System.out.println("int类型最大的整数："+Integer.MAX_VALUE);//输出int类型最大的整数：2147483647

	
	}
}

2.自动装箱和拆箱，缓存

自动拆箱和装箱就是将基本数据类型和包装类之间进行自动的互相转化

装箱：实现基本数据类型转换成包装类

拆箱：实现对象转换为基本数据类型

缓存：系统初始的时候，创建了[-128,127]之间的一个缓存数组

public class testautobox {
	public static void main(String[]args) {
		Integer a=220;//自动装箱，相当于Integer a=Integer.valueOf(220);
		int b=a;//自动拆箱，相当于int b=a.intValue();
		Integer c=null;//调用c.intValue();引发空指针异常
		if(c!=null) {
			int d=c;
		}
		
		//缓存[-128,127]之间的数字，实际就是系统初始的时候，创建了[-128,127]之间的一个缓存数组
		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
	}
}

2.String类

1.String

Sting类对象代表不可变的Unicode字符序列

public class teststring {
	public static void main(String[]args) {
		String str="aaaabbbccc";
		String st=str.substring(2,5);//substring()是对字符串的截取操作，但本质是读取原字符串内容生成了新的字符串
		System.out.println(str);
		System.out.println(st);
		 //编译器做了优化,直接在编译的时候将字符串进行拼接
        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
	}
}

String类的常用方法：

1. String类的下述方法能创建并返回一个新的String对象: concat()、 replace()、substring()、 toLowerCase()、 toUpperCase()、trim()。

2. 提供查找功能的有关方法: endsWith()、 startsWith()、 indexOf()、lastIndexOf()。

3. 提供比较功能的方法: equals()、equalsIgnoreCase()、compareTo()。

4. 其它方法: charAt() 、length()。

2.StringBuilder

是一个可变的序列

1.构造方法：

public StringBuilder();创建一个空白可变字符串对象，不含有任何内容

public StringBuilder(String str）;根据字符串的内容，来创建可变字符串对象

public class teststringbuild {
	public static void main(String[]args) {
		//1.public StringBuilder();创建一个空白可变字符串对象，不含有任何内容
		StringBuilder sb=new StringBuilder();
		System.out.println("sb:"+sb);
		System.out.println("sb.length():"+sb.length());
		//2.public StringBuilder(String str）;根据字符串的内容，来创建可变字符串对象
		StringBuilder sb2=new StringBuilder("hello");
		System.out.println("sb2:"+sb2);
		System.out.println("sb2.length():"+sb2.length());
	}
}

2.StringBuilder的添加和反转方法

方法名	说明
public StringBuilder append（任意类型）	添加数据，并返回对象本身
public StringBuilder reverse（）	返回相反的字符序列

public class testbuilder {
	public static void main(String[]args) {
		//创建对象
		StringBuilder sb=new StringBuilder();
		//public StringBuilder append（任意类型）	添加数据，并返回对象本身
		StringBuilder sb2=sb.append("hello");
		System.out.println("sb:"+sb);
		System.out.println("sb2:"+sb2);
		System.out.println(sb==sb2);//true,说明返回对象本身
		//所以，下面是可以实现的
		sb.append(" world ");
		sb.append("java");
		System.out.println("sb:"+sb);//sb:hello world java
		//使用链式编程
		sb.append(" nihao ").append("shijie ").append("nice to meet you");
		System.out.println("sb:"+sb);//sb:hello world java nihao shijie nice to meet you
		
		
		//public StringBuilder reverse（）	返回相反的字符序列
		sb.reverse();
		System.out.println("sb:"+sb);//uoy teem ot ecin eijihs oahin avaj dlrow olleh
		
	}
}

3.StringBuilder 的常用方法

1. 重载的public StringBuilder append(…)方法

可以为该StringBuilder 对象添加字符序列，仍然返回自身对象。

2. 方法 public StringBuilder delete(int start,int end)

可以删除从start开始到end-1为止的一段字符序列，仍然返回自身对象。

3. 方法 public StringBuilder deleteCharAt(int index)

移除此序列指定位置上的 char，仍然返回自身对象。

4. 重载的public StringBuilder insert(…)方法

可以为该StringBuilder 对象在指定位置插入字符序列，仍然返回自身对象。

5. 方法 public StringBuilder reverse()

用于将字符序列逆序，仍然返回自身对象。

6. 方法 public String toString() 返回此序列中数据的字符串表示形式。

3.Date时间类

1.Date

Data中的构造函数：

Date():分配一个Date对象并对其进行初始化，以便表示分配的时间，以最接近的毫秒为单位

Date（long date）：分配一个Date对象，并将其初始化为表示从基准时间即1970年1月1日00：00：00起的指定毫秒数

Date中常用的方法：

1.public long getTime():获取的是日期对象从1970年1月1日00：00：00到现在的毫秒值

2.public void setTime(long time):设置时间，给的是毫秒值

3. boolean after(Date when) 测试此日期是否在指定日期之后

2.DateFormat类

作用：把时间对象转化成指定格式的字符串，反之，把指定格式的字符串转化成时间对象，DateFormat是一个抽象类，一般使用它的子类SimpleDateFormat来实现。

import java.util.Date;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
public class testdata {
	public static void main(String[]args) {
		Date d=new Date();
		System.out.println(d);
		DateFormat df=new SimpleDateFormat();
		
	}
}

import java.util.Date;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
public class testdata {
	public static void main(String[]args) throws ParseException {
		Date d=new Date();
		System.out.println(d);
		//把时间对象按照“格式字符串指定的格式”转成相应的字符串
		DateFormat df=new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss");
		String str=df.format(new Date(1000000));
		System.out.println(str);
		//把字符串按照“格式字符串指定的对象”转化成相应的对象
		DateFormat df2=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		Date d1=df2.parse("2022-05-16 14:45:30");
		System.out.println(d1);
		//测试其他
		DateFormat df3=new SimpleDateFormat("D");//今天是本年的第几天
		String str3=df3.format(new Date());
		System.out.println(str3);
		
	}
}

3.Calendar日历类

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

import java.util.Calendar;
import java.util.GregorianCalendar;

public class testCalendar {
	public static void main(String[]args) {
		Calendar ca=new GregorianCalendar(2099,5,16,12,10,30);
		int year=ca.get(Calendar.YEAR);
		int month=ca.get(Calendar.MONTH);
		int day=ca.get(Calendar.DATE);//也可以用DAY_OF_MONTH
		int week=ca.get(Calendar.DAY_OF_WEEK);//周几
		System.out.println(ca);
		System.out.println(year);
		System.out.println(month);
		System.out.println(day);
		System.out.println(week);
		
	}
}

注意：0-11表示月份，0是1月......11是12月。1-7表示星期日-星期六，1是星期日......7是星期六

        //设置日期
		Calendar ca1=new GregorianCalendar();
		ca1.set(Calendar.YEAR, 2089);
		System.out.println(ca1.get(Calendar.YEAR));
		//日期的计算
		Calendar ca2=new GregorianCalendar();
		ca2.add(Calendar.YEAR, 100);//向后100年，向前100年是-100
		System.out.println(ca2.get(Calendar.YEAR));
		//日期对象和时间对象的转化
		Date d=ca2.getTime();//日期对象转化为时间对象
		Calendar ca3=new GregorianCalendar();
		ca3.setTime(new Date());//时间对象转化为日期类
		System.out.println(d);
		System.out.println(ca3);

可视化日历程序（1）

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

//可视化日历
public class testCalendar2 {
	public static void main(String[]args) throws ParseException {
		String str="2022-05-16";//字符串
		DateFormat df=new SimpleDateFormat("yyyy-MM-dd");
		Date date=df.parse(str);//把字符串转化成时间对象
		System.out.println(date);
		Calendar c=new GregorianCalendar();
		c.setTime(date);//把时间对象转化为日期
		//System.out.println(c.get(Calendar.DAY_OF_MONTH));
		System.out.println("日\t一\t二\t三\t四\t五\t六");
		c.set(Calendar.DAY_OF_MONTH,1);
		for(int i=0;i<c.get(Calendar.DAY_OF_WEEK)-1;i++) {//使得
			System.out.print("\t");
		}
		
		for(int i=1;i<=c.getActualMaximum(Calendar.DATE);i++)
		{
			System.out.print(c.get(Calendar.DAY_OF_MONTH)+"\t");
			
			if(c.get(Calendar.DAY_OF_WEEK)==7) {//如果为周六，则换行
				System.out.print("\n");
			}
			c.add(Calendar.DAY_OF_MONTH, 1);//依次加一
		}
	}
		
}

可视化日历程序（2）可输入

package ba;

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

//可视化日历
public class testCalendar2 {
	public static void main(String[]args) throws ParseException {
		System.out.println("请输入日期（格式为XXXX-XX-XX）：");
		Scanner scanner=new Scanner(System.in);
		String str=scanner.nextLine();//字符串
		DateFormat df=new SimpleDateFormat("yyyy-MM-dd");
		Date date=df.parse(str);//把字符串转化成时间对象
		System.out.println(date);
		Calendar c=new GregorianCalendar();
		c.setTime(date);//把时间对象转化为日期
		int day=c.get(Calendar.DAY_OF_MONTH);
		//System.out.println(c.get(Calendar.DAY_OF_MONTH));
		System.out.println("日\t一\t二\t三\t四\t五\t六");
		c.set(Calendar.DAY_OF_MONTH,1);
		for(int i=0;i<c.get(Calendar.DAY_OF_WEEK)-1;i++) {//使得
			System.out.print("\t");
		}
		
		for(int i=1;i<=c.getActualMaximum(Calendar.DATE);i++)//getActualMaximum获得本月最大天数
		{
			if(c.get(Calendar.DAY_OF_MONTH)==day) {
				System.out.print(c.get(Calendar.DAY_OF_MONTH)+"*"+"\t");
			}
			else {
				System.out.print(c.get(Calendar.DAY_OF_MONTH)+"\t");
			}
			
			
			if(c.get(Calendar.DAY_OF_WEEK)==7) {//如果为周六，则换行
				System.out.print("\n");
			}
			c.add(Calendar.DAY_OF_MONTH, 1);//依次加一
		}
	}
		
}

4.Math类

Math类的常用方法：

1. abs 绝对值

2. acos,asin,atan,cos,sin,tan 三角函数

3. sqrt 平方根

4. pow(double a, double b) a的b次幂

5. max(double a, double b) 取大值

6. min(double a, double b) 取小值

7. ceil(double a) 大于a的最小整数

8. floor(double a) 小于a的最大整数

9. random() 返回 0.0 到 1.0 的随机数

10. long round(double a) double型的数据a转换为long型(四舍五入)

11. toDegrees(double angrad) 弧度->角度

12. toRadians(double angdeg) 角度->弧度

5.Random类

public class TestRandom {
    public static void main(String[] args) {
        Random rand = new Random();
        //随机生成[0,1)之间的double类型的数据
        System.out.println(rand.nextDouble());
        //随机生成int类型允许范围之内的整型数据
        System.out.println(rand.nextInt());
        //随机生成[0,1)之间的float类型的数据
        System.out.println(rand.nextFloat());
        //随机生成false或者true
        System.out.println(rand.nextBoolean());
        //随机生成[0,10)之间的int类型的数据
        System.out.print(rand.nextInt(10));
        //随机生成[20,30)之间的int类型的数据
        System.out.print(20 + rand.nextInt(10));
        //随机生成[20,30)之间的int类型的数据（此种方法计算较为复杂）
        System.out.print(20 + (int) (rand.nextDouble() * 10));
    }
}

6.File类

java.io.File类：

代表文件和目录，在开发中，读取文件、生成文件、删除文件、修改文件的属性时会用到本类。

File类常用的构造方法：public File(String pathname)

以pathname为路径创建File对象，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储

import java.io.File;
import java.io.IOException;
import java.util.Date;

public class testFile {
	public static void main(String[]args) throws IOException {
		File f=new File("D:/a.txt");
		//File f=new File("d:\\a.txt");
		System.out.println(f);
		f.renameTo(new File("D:\\dd.txt"));//改名
		System.out.println(System.getProperty("user.dir"));//打印该项目目录
		File f2=new File("dd.txt");
		f2.createNewFile();//在项目路径下创建文件
		
		System.out.println("File是否存在："+f2.exists());//File是否存在：true
        System.out.println("File是否是目录："+f2.isDirectory());//File是否是目录：false
        System.out.println("File是否是文件："+f2.isFile());//File是否是文件：true
        System.out.println("File最后修改时间："+new Date(f2.lastModified()));//File最后修改时间：Tue May 17 16:23:37 CST 2022
        System.out.println("File的大小："+f2.length());//File的大小：0
        System.out.println("File的文件名："+f2.getName());//File的文件名：dd.txt
        System.out.println("File的目录路径："+f2.getPath());//File的目录路径：dd.txt
		
		
	}
}

mkdir不会创建没有目标路径的文件

mkdirs会创建没有目标路径的文件

递归打印目录树

package d;

import java.io.File;

public class testdigui {
	public static void main(String[]args) {
		File f=new File("E:\\python");
		printfile(f,0);
	}
	static void printfile(File file,int level) {
		
		
		int sum = 0;
		//导出层次
		for(int i=0;i<level;i++)
		{
			sum=i;
		}
		System.out.print(sum);
		System.out.println(file.getName());//输出文件名
		
		if(file.isDirectory()) {//测试是否是目录
			File[]files=file.listFiles();//将子文件保存
		for(File temp:files) {//遍历
			printfile(temp,level+1);
		}
		}
	}
}

枚举

package d;

public class testmeiju {
	public static void main(String[]args) {
		System.out.println(season.SPRING);
		season a=season.AUTUMN;
		switch(a) {
		case SPRING:
			System.out.println("春天来了！");
			break;
		case SUMMER:
			System.out.println("夏天来了！");
			break;
		case AUTUMN:
			System.out.println("秋天来了！");
			break;
		case WINTER:
			System.out.println("冬天来了！");
			break;
		}
	}	
}
enum season{
	SPRING,SUMMER,AUTUMN,WINTER
}
enum week{
	星期1,星期2,星期3,星期4,星5,星期6,星期7
}

码码忽忽

关注

3
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java周记（第三周）常用类

第八章1.包装类1.包装类基本知识Java是面向对象的语言，但并不是“纯面向对象”的，因为我们经常用到的基本数据类型就不是对象。但是我们在实际应用中经常需要将基本数据转化成对象，以便于操作。比如：将基本数据类型存储到Object[]数组或集合中的操作等等。为了解决这个不足，Java在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类。包装类均位于java.lang包 ...
复制链接

扫一扫