Java笔记（常用类01）

最新推荐文章于 2024-04-18 19:54:16 发布

逆夏*光年

最新推荐文章于 2024-04-18 19:54:16 发布

阅读量143

点赞数

分类专栏：笔记

本文链接：https://blog.csdn.net/Mmaoi/article/details/108046424

版权

笔记专栏收录该内容

16 篇文章 0 订阅

订阅专栏

包装类

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

包装类均位于java.lang包，八种包装类和基本数据类型的对应关系如表所示

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

在这八个类名中，除了Integer和Character类以外，其它六个类的类名和基本数据类型一致，只是类名的第一个字母大写而已。除了Character和Boolean以外，其他的都是“数字型”，“数字型”都是java.lang.Number的子类。Number类是抽象类，因此它的抽象方法，所有子类都需要提供实现。Number类提供了抽象方法：intValue()、longValue()、floatValue()、doubleValue()，意味着所有的“数字型”包装类都可以互相转型。

包装类的用途：

作为和基本数据类型对应的类型存在，方便涉及到对象的操作，如Object[]、集合等的操作。

包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法(这些操作方法的作用是在基本数据类型、包装类对象、字符串之间提供相互之间的转化!)。

package day08;
/**
 * 测试Integer的用法，其他包装类类似
 * @author Administrator
 *
 */

public class Testclass {

	public static void main(String[] args) {
		//基本类型转换为Integer对象
		Integer in1=new Integer(10);
		Integer in2=Integer.valueOf(20);//官方推荐这种怪写法
		//Integer对象转换成int
		int a=in1.intValue();
		//字符串转换成Integer对象
		Integer in3=Integer.parseInt("234");
		Integer in4=new Integer("888");
		
		//Integer对象转换成字符串
		String str1=in3.toString();
		//一些常见int类型相关的常量
		System.out.println("int能表示的最大整数："+Integer.MAX_VALUE);
	}

}

自动装箱和自动拆箱

自动装箱：基本类型的数据处于需要对象的环境中时，会自动转为“对象”。自动装箱调用的是valueOf()方法，而不是new Integer()方法。

自动拆箱：每当需要一个值时，对象会自动转成基本数据类型，自动拆箱调用的xxxValue()方法。

public class Test2 {
    /**
     * 测试自动装箱和拆箱 结论：虽然很方便，但是如果不熟悉特殊情况，可能会出错！
     */
    public static void main(String[] args) {
        Integer b = 23; // 自动装箱,编译器的写法是：Integer b = Integer.ValueOf(23);
        int a = new Integer(20); //自动拆箱
        // 下面的问题我们需要注意：
        Integer c = null;
        int d = c; // 此处其实就是：c.intValue(),因此抛空指针异常。 null表示i没有指向任何对象的实体，但作为对象名称是合法的(不管这个对象名称存是否指向了某个对象的实体)。由于实际上i并没有指向任何对象的实体，所以也就不可能操作intValue()方法
    }
}

包装类的缓存问题

整型、char类型所对应的包装类，在自动装箱时，对于-128~127之间的值会进行缓存处理，其目的是提高效率。缓存处理的原理为：如果数据在-128~127这个区间，那么在类加载时就已经为该区间的每个数值创建了对象，并将这256个对象存放到一个名为cache的数组中。每当自动装箱过程发生时(或者手动调用valueOf()时)，就会先判断数据是否在该区间，如果在则直接获取数组中对应的包装类对象的引用，如果不在该区间，则会通过new调用包装类的构造方法来创建对象。
包装类在自动装箱时为了提高效率，对于-128~127之间的值会进行缓存处理。超过范围后，对象之间不能再使用==进行数值的比较，而是使用equals方法。

String类

String 类对象代表不可变的Unicode字符序列，因此我们可以将String对象称为“不可变对象”。即是对象内部的成员变量的值无法再改变。

在遇到字符串常量之间的拼接时，编译器会做出优化，即在编译期间就会完成字符串的拼接。因此，在使用==进行String对象之间的比较时，我们需要特别注意，

String常用的方法:

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

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

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

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

StringBuffer和StringBuilder

用法类似，均为可变字符序列，区别：

. StringBuffer：可变字符序列，并且线程安全，但是效率低。

. 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() 返回此序列中数据的字符串表示形式

package day08;
/**
 * 测试StringBuilderBuffer常用方法
 * @author Administrator
 *
 */
public class TestStringBuilderBuffer01 {

	public static void main(String[] args) {
		StringBuilder sb=new StringBuilder();
		for (int i = 0; i < 26; i++) {//26个大小写字母
			sb.append((char)('a'+i));//往后追加	
		}
		System.out.println(sb);
		
		sb.reverse();//倒序
		System.out.println(sb);
		
		sb.setCharAt(3, '#');//替换
		System.out.println(sb);
		
		System.out.println(sb.toString());//转换成String输出
		sb.append(",26个字母");
		
		System.out.println(sb.toString());
		sb.insert(0, "小").insert(0, "大");//插入字符
		
		System.out.println(sb);
		
		sb.delete(0, 2);
		System.out.println(sb);
		 sb.deleteCharAt(0).deleteCharAt(0);//删除某个字符
		 System.out.println(sb);
		 System.out.println(sb.charAt(0));//获取某个字符
		
		
		
		

	}

}

运行结果：

ABCDEFGHIJKLMNOPQRSTUVWXYZ
ZYXWVUTSRQPONMLKJIHGFEDCBA
ZYX#VUTSRQPONMLKJIHGFEDCBA
ZYX#VUTSRQPONMLKJIHGFEDCBA
ZYX#VUTSRQPONMLKJIHGFEDCBA,26个字母
大小ZYX#VUTSRQPONMLKJIHGFEDCBA,26个字母
ZYX#VUTSRQPONMLKJIHGFEDCBA,26个字母
X#VUTSRQPONMLKJIHGFEDCBA,26个字母
X

事件处理相关类

我们用long类型的变量来表示时间，从基准时间往前几亿年，往后几亿年都能表示。如果想获得现在时刻的“时刻数值”，可以使用： long now = System.currentTimeMillis(); 这个“时刻数值”是所有时间类的核心值，年月日都是根据这个“数值”计算出类来的。

Date时间类(java.util.Date)

在标准Java类库中包含一个Date类。它的对象表示一个特定的瞬间，精确到毫秒。

1. Date() 分配一个Date对象，并初始化此对象为系统当前的日期和时间，可以精确到毫秒)。

2. Date(long date) 分配 Date 对象并初始化此对象，以表示自从标准基准时间(称为“历元(epoch)”，即 1970 年 1 月 1 日 00:00:00 GMT)以来的指定毫秒数。

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

4. booleanbefore(Date when) 测试此日期是否在指定日期之前。

5. boolean equals(Object obj) 比较两个日期的相等性。

6. long getTime() 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。

7. String toString() 把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun、 Mon、Tue、Wed、 Thu、 Fri、 Sat)。

DateFormat类和SimpleDateFormat类

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

package day08;
/**
 * SimpleDateFormat格式时间
 */

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class TestDateFormat {

	public static void main(String[] args) throws ParseException {
		SimpleDateFormat s1=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		SimpleDateFormat s2=new SimpleDateFormat("yyyy-MM-dd");
		//将军时间转换为字符串
		String dayTime=s1.format(new Date(0));
		System.out.println(dayTime);
		System.out.println(s2.format(new Date())); 
		
		System.out.println(new SimpleDateFormat("hh:mm:ss").format(new Date())); 
		
		String time="2002-10-7"; 
		//将字符串转换为时间格式输出
		Date date=s2.parse(time); 
		System.out.println("date1:"+date);  
		time="2002-10-7 20:14:30";	
		date=s1.parse(time);	
		System.out.println("date2:"+date);
		
		

	}

}

运行结果：

1970-01-01 08:00:00
2020-08-17
01:07:14
date1:Mon Oct 07 00:00:00 CST 2002
date2:Mon Oct 07 20:14:30 CST 2002

简单的DateFormat格式化编码

时间模式字符串用来指定时间格式。在此模式中，所有的ASCII字母被保留为模式字母，定义如下：

字母	描述	示例
G	纪元标记	AD
y	四位年份	2001
M	月份	July or 07
d	一个月的日期	10
h	A.M./P.M. (1~12)格式小时	12
H	一天中的小时 (0~23)	22
m	分钟数	30
s	秒数	55
S	微妙数	234
E	星期几	Tuesday
D	一年中的日子	360
F	一个月中第几周的周几	2 (second Wed. in July)
w	一年中第几周	40
W	一个月中第几周	1
a	A.M./P.M. 标记	PM
k	一天中的小时(1~24)	24
K	A.M./P.M. (0~11)格式小时	10
z	时区	Eastern Standard Time
'	文字定界符	Delimiter
"	单引号	`

Calendar日历类

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

注意：注意月份的表示，一月是0，二月是1，以此类推，12月是11。因为大多数人习惯于使用单词而不是使用数字来表示月份，这样程序也许更易读，父类Calendar使用常量来表示月份：JANUARY、FEBRUARY等等

package day08;

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

import javax.xml.crypto.Data;

/**
 * 日历类Celender
 * @author Administrator
 *
 */

public class TestCelender {

	public static void main(String[] args) {
		GregorianCalendar calendar=new GregorianCalendar(2999,10,9,22,10,50);
		int year=calendar.get(Calendar.YEAR);//打印2999
		int month=calendar.get(Calendar.MONTH);//打印10
		int day=calendar.get(Calendar.DAY_OF_MONTH);//打印9
		int day1=calendar.get(Calendar.DATE);//打印9
		//日Calendar.DATE和Calendar.DAY_OF_WEEK同义
		int date=calendar.get(Calendar.DAY_OF_WEEK);//打印7
		//星期几：1-7，周日是1，周六是7
		System.out.println(year);
		System.out.println(month);
		System.out.println(day);
		System.out.println(day1);
		System.out.println(date);
		
		//设置时间
		GregorianCalendar calendar2 =new GregorianCalendar();
		calendar2.set(Calendar.YEAR,2888);
		calendar2.set(Calendar.MONTH,Calendar.FEBRUARY);//月份数：0-11
		calendar2.set(Calendar.DATE,3);
		calendar2.set(Calendar.HOUR_OF_DAY,10);
		calendar2.set(Calendar.MINUTE,20);
		calendar2.set(Calendar.SECOND,23);
		printCalender(calendar2);
		
		
		//日期计算
		GregorianCalendar calendar3 =new GregorianCalendar();
		calendar3.add(Calendar.MONTH, -7);//月份-7
		calendar3.add(Calendar.DATE, 7);//日期+7
		printCalender(calendar3);
		
		
		//日历对象和时间对象转换
		Date d=calendar3.getTime();
		System.out.println(d);
		GregorianCalendar calendar4=new GregorianCalendar();
		calendar4.setTime(new Date());
		
		long g=System.currentTimeMillis();
		System.out.println(g);
	}
	static void printCalender(Calendar calendar) {
		int year=calendar.get(Calendar.YEAR);
		int month=calendar.get(Calendar.MONTH)+1;
		int day=calendar.get(Calendar.DAY_OF_MONTH);
		int date=calendar.get(Calendar.DAY_OF_WEEK)-1;//星期-1
		String week="" +((date ==0)?"日":date);
		int hour=calendar.get(Calendar.HOUR);
		int minute=calendar.get(Calendar.MINUTE);
		int second=calendar.get(Calendar.SECOND);
		
		System.out.println(year+"年"+month+"月"+day+"日\t星期"+week+"\t"+hour+":"+minute+":"+second);



		
		
	}

}

运行结果：

2999
10
9
9
7
2888年2月3日星期2 10:20:23
2020年1月24日星期5 1:14:30
Fri Jan 24 13:14:30 CST 2020
1597641270491

package day08;
/**
 * 打印日历表
 */

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

public class Calender {

	public static void main(String[] args) {
		System.out.println("请输入日期（格式为：2013-3-4）：");
		Scanner scanner=new Scanner(System.in);
		String date=scanner.nextLine();
		//将输入的数字转换为日期类
		System.out.println("您刚刚输入的日期是："+date);
		String[] str=date.split("-");
		int year=Integer.parseInt(str[0]);
		int month=new Integer(str[1]);
		int day=new Integer(str[2]);
		
		GregorianCalendar c=new GregorianCalendar(year,month,day);
		c.set(Calendar.DATE, 1);//设置日历时间，从1开始
		int dow =c.get(Calendar.DAY_OF_WEEK);//week:日一二三四五六
		System.out.println("日\t一\t二\t三\t四\t五\t六");
		for (int i = 0; i < dow-1; i++) {
			System.out.print("\t");
		}
		int maxDate=c.getActualMaximum(Calendar.DATE);
		
		for (int i =1 ; i <= maxDate; i++) {
			StringBuilder stringBuilder=new StringBuilder();
			if (c.get(Calendar.DATE)==day) {
				stringBuilder.append(c.get(Calendar.DATE)+"*\t");
				
			}else {
				stringBuilder.append(c.get(Calendar.DATE)+"\t");
			}
			System.out.print(stringBuilder);
			if (c.get(Calendar.DAY_OF_WEEK)==Calendar.SATURDAY) {
				System.out.print("\n");
				
			}
			c.add(Calendar.DATE, 1);
		} 
		
		
		
		

	}

}

运行结果：

请输入日期（格式为：2013-3-4）：
2020-8-17
您刚刚输入的日期是：2020-8-17
日   一   二   三   四   五   六
       1   2   3   4   5
6   7   8   9   10   11   12
13   14   15   16   17*   18   19
20   21   22   23   24   25   26
27   28   29   30