import java.util.Date;
public class A01_DateDemo1 {
public static void main(String[] args) {
/*
public Date() 创建Date对象，表示当前时间
public Date(long date) 创建Date对象，表示指定时间
public void settime(long time) 设置/修改毫秒值
public long gettime() 获取时间对象的毫秒值
*/
//1.创建对象表示一个时间
Date d1 = new Date();
//system.out.println(d1);
//2.创建对象表示一个指定的时间
Date d2 = new Date(0L);
System.out.println(d2);
//3.settime 修改时间
//1000毫秒=1秒
d2.setTime(1000L);
System.out.println(d2);
//4.getTime获取当前时间的毫秒值
long time = d2.getTime();
System.out.println(time);
}
}
import java.util.Date;
import java.util.Random;
public class A02_DateDemo2 {
public static void main(String[] args) {
/*
需求1:打印时间原点开始一年之后的时间
需求2:定义任意两个Date对象，比较一下哪个时间在前，哪个时间在后
*/
//需求2:定义任意两个Date对象，比较一下哪个时间在前，哪个时间在后
Random r = new Random();
//创建两个时间对象
Date d1 = new Date(Math.abs(r.nextInt()));
Date d2 = new Date(Math.abs(r.nextInt()));
long time1 = d1.getTime();
long time2 = d2.getTime();
if (time1 > time2) {
System.out.println("第一个时间在后面，第二个时间在前面");
} else if (time1 < time2) {
System.out.println("第二个时间在后面，第一个时间在前面");
} else {
System.out.println("表示两个时间一样");
}
}
private static void method() {
//需求1:打印时间原点开始一年之后的时间
//1.创建一个对象，表示时间原点
Date d1 = new Date(0L);
//2.获取d1时间的毫秒值
long time = d1.getTime();
//3.在这个基础上我们要加一年的毫秒值即可
time = time + 1000L * 60 * 60 * 24 * 365;
//4.把计算之后的时间毫秒值，再设置回d1当中
d1.setTime(time);
//5.打印d1
System.out.println(d1);
}
}
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class A03_SimpleDateFormatDemo1 {
public static void main(String[] args) throws ParseException {
/*
public simpleDateFormat() 默认格式
public simpleDateFormat(String pattern) 指定格式
public final string format(Date date) 格式化(日期对象 ->字符串)
public Date parse(string source) 解析(字符串 ->日期对象)
*/
//1.定义一个字符串表示时间
String str = "2023-11-11 11:11:11";
//2.利用空参构造创建simpleDateFormat对象
// 细节:
//创建对象的格式要跟字符串的格式完全一致
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = sdf.parse(str);
//3.打印结果
System.out.println(date.getTime());//1699672271000
}
private static void method1() {
//1.利用空参构造创建simpleDateFormat对象，默认格式
SimpleDateFormat sdf1 = new SimpleDateFormat();
Date d1 = new Date(0L);
String str1 = sdf1.format(d1);
System.out.println(str1);//1970/1/1 上午8:00
//2.利用带参构造创建simpleDateFormat对象，指定格式
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
String str2 = sdf2.format(d1);
System.out.println(str2);//1970年01月01日 08:00:00
//课堂练习:yyyy年MM月dd日 时:分:秒 星期
}
}
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class A04_SimpleDateFormatDemo2 {
public static void main(String[] args) throws ParseException {
/*
假设，你初恋的出生年月日为:2000-11-11
请用字符串表示这个数据，并将其转换为:2000年11月11日
创建一个Date对象表示2000年11月11日
创建一个SimpleDateFormat对象，并定义格式为年月日把时间变成:2000年11月11日
*/
//1.可以通过2000-11-11进行解析，解析成一个Date对象
String str = "2000-11-11";
//2.解析
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf1.parse(str);
//3.格式化
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日");
String result = sdf2.format(date);
System.out.println(result);
}
}
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class A05_SimpleDateFormatDemo3 {
public static void main(String[] args) throws ParseException {
/* 需求:
秒杀活动开始时间:2023年11月11日 0:0:0(毫秒值)
秒杀活动结束时间:2023年11月11日 0:10:0(毫秒值)
小贾下单并付款的时间为:2023年11月11日 0:01:0
小皮下单并付款的时间为:2023年11月11日 0:11:0
用代码说明这两位同学有没有参加上秒杀活动?
*/
//1.定义字符串表示三个时间
String startstr = "2023年11月11日 0:0:0";
String endstr = "2023年11月11日 0:10:0";
String orderstr = "2023年11月11日 0:01:00";
//2.解析上面的三个时间，得到Date对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
Date startDate = sdf.parse(startstr);
Date endDate = sdf.parse(endstr);
Date orderDate = sdf.parse(orderstr);
//3.得到三个时间的毫秒值
long startTime = startDate.getTime();
long endTime = endDate.getTime();
long orderTime = orderDate.getTime();
//4.判断
if (orderTime >= startTime && orderTime <= endTime) {
System.out.println("参加秒杀活动成功");
} else {
System.out.println("参加秒杀活动失败");
}
}
}
import java.util.Calendar;
import java.util.Date;
public class A06_CalendarDemo1 {
public static void main(String[] args) {
/*
public static Calendar lgetInstance() 获取当前时间的日历对象
public final Date getTime() 获取日期对象
public final setTime(Date date) 给日历设置日期对象
public long getTimeInMillis() 拿到时间毫秒值
public void setTimeInMillis(long millis) 给日历设置时间毫秒值
public int get(int field) 获取日期中的某个字段信息
public void set(int field,int value) 修改日历的某个字段信息
public void add(int field,int amount) 为某个字段增加/减少指定的值
*/
//1.获取日历对象
//细节1:Calendar是一个抽象类,不能直接new,而是通过一个静态方法获取到子类对象
//底层原理:
//会根据系统的不同时区来获取不同的日历对象,默认表示当前时间。
//把会把时间中的纪元,年,月,日,时,分,秒,星期,等等的都放到一个数组当中
//日 :纪元
// 1 :年
// 2 :月
// 3 : 一年中的第几周
// 4:一个月中的第几周
// 5: 一个月中的第几天(日期)
// ....
//细节2:
//月份:范围0~11 如果获取出来的是.那么实际上是1月。
//星期:在老外的眼里,星期日是一周中的第一天
// 1(星期日) 2(星期一) 3(星期二) 4(星期三) 5(星期四) 6(星期五) 7(星期六)
Calendar c = Calendar.getInstance();
//2.修改一下日历代表的时间
Date d = new Date(0L);
c.setTime(d);
System.out.println(c);
//puslic int get(int field) 取日期中的某个字段信息
//public void set(int field,int value) 修改日历的某个字段信息
//public void add(int fieldint amount) 为某个字段增加/减少指定的值
c.set(Calendar.YEAR, 2023);
c.set(Calendar.MONTH, 8);
c.set(Calendar.DAY_OF_MONTH, 10);
//调用方法在这个基础上增加一个月
c.add(Calendar.MONTH, -1);
//java在Calendar类中,把索引对应的数字都定义成常量
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH) + 1;
int date = c.get(Calendar.DAY_OF_MONTH);
int week = c.get(Calendar.DAY_OF_WEEK);
System.out.println(year + "," + month + "," + date + "," + getWeek(week));
}
//查表法://表:容器
//让数据跟索引产生对应的关系
//传入对应的数字: 1 ~7//返回对应的星期
public static String getWeek(int index) {
//定义一个数组,让汉字星期几 跟1~7产生对应关系
String[] arr = {"", "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
//根据索引返回对应的星期
return arr[index];
}
}
import java.time.ZoneId;
import java.util.Set;
public class A01_ZoneIDDemo1 {
public static void main(String[] args) {
/*
static Set getAvailableZoneIds() 获取Java中支持的所有时区
static ZoneId systemDefault() 获取系统默认时区
static Zoneld of(string zoneld) 获取一个指定时区
*/
//1.获取所有的时区名称
Set zoneIds = ZoneId.getAvailableZoneIds();
System.out.println(zoneIds.size());//600
System.out.println(zoneIds);// Asia/Shanghai
//2.获取当前系统的默认时区
ZoneId zoneId = ZoneId.systemDefault();
System.out.println(zoneId);//Asia/Shanghai
//3.获取指定的时区
ZoneId zoneId1 = ZoneId.of("Asia/Pontianak");
System.out.println(zoneId1);//Asia/Pontianak
}
}
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
public class A02_InstantDemo {
public static void main(String[] args) {
/*
static Instant now() 获取当前时间的Instant对象(标准时间)
static Instant ofXxxx(long epochMilli) 根据(秒/毫秒/纳秒)获取Instant对象
ZonedDateTime atZone(ZoneIdzone) 指定时区
boolean isxxx(Instant otherInstant) 判断系列的方法
Instant minusXxx(long millisToSubtract) 减少时间系列的方法
Instant plusXxx(long millisToSubtract) 增加时间系列的方法
*/
//1.获取当前时间的Instant对象(标准时间)
Instant now = Instant.now();
System.out.println(now);
//2.根据(秒/毫秒/纳秒)获取Instant对象
Instant instant1 = Instant.ofEpochMilli(0L);
System.out.println(instant1);//1970-01-01T00:00:00z
Instant instant2 = Instant.ofEpochSecond(1L);
System.out.println(instant2);//1970-01-01T00:00:01Z
Instant instant3 = Instant.ofEpochSecond(1L, 1000000000L);
System.out.println(instant3);//1970-01-01T00:00:027
//3. 指定时区
ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
System.out.println(time);
//4.isXxx 判断
Instant instant4=Instant.ofEpochMilli(0L);
Instant instant5 =Instant.ofEpochMilli(1000L);
//5.用于时间的判断
//isBefore:判断调用者代表的时间是否在参数表示时间的前面
boolean result1=instant4.isBefore(instant5);
System.out.println(result1);//true
//isAfter:判断调用者代表的时间是否在参数表示时间的后面
boolean result2 = instant4.isAfter(instant5);
System.out.println(result2);//false
//6.Instant minusXxx(long millisToSubtract) 减少时间系列的方法
Instant instant6 =Instant.ofEpochMilli(3000L);
System.out.println(instant6);//1970-01-01T00:00:03Z
Instant instant7 =instant6.minusSeconds(1);
System.out.println(instant7);//1970-01-01T00:00:02Z
}
}
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
public class A03_ZoneDateTimeDemo {
public static void main(String[] args) {
/*
static ZonedDateTime now() 获取当前时间的ZonedDateTime对象
static ZonedDateTime ofXxxx(。。。) 获取指定时间的ZonedDateTime对象
ZonedDateTime withXxx(时间) 修改时间系列的方法
ZonedDateTime minusXxx(时间) 减少时间系列的方法
ZonedDateTime plusXxx(时间) 增加时间系列的方法
*/
//1.获取当前时间对象(带时区)
ZonedDateTime now = ZonedDateTime.now();
System.out.println(now);
//2.获取指定的时间对象(带时区)1/年月日时分秒纳秒方式指定
ZonedDateTime time1 = ZonedDateTime.of(2023, 10, 1,
11, 12, 12, 0, ZoneId.of("Asia/Shanghai"));
System.out.println(time1);
//通过Instant + 时区的方式指定获取时间对象
Instant instant = Instant.ofEpochMilli(0L);
ZoneId zoneId = ZoneId.of("Asia/Shanghai");
ZonedDateTime time2 = ZonedDateTime.ofInstant(instant, zoneId);
System.out.println(time2);
//3.withXxx 修改时间系列的方法
ZonedDateTime time3 = time2.withYear(2000);
System.out.println(time3);
//4. 减少时间
ZonedDateTime time4 = time3.minusYears(1);
System.out.println(time4);
//5.增加时间
ZonedDateTime time5 = time4.plusYears(1);
System.out.println(time5);
}
}
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
public class A04_DateTimeForMatterDemo {
public static void main(String[] args) {
/*
static DateTimeFormatter ofPattern(格式) 获取格式对象
String format(时间对象) 按照指定方式格式化
*/
//获取时间对象
ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
// 解析/格式化器
DateTimeFormatter dtf1=DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm;ss EE a");
// 格式化
System.out.println(dtf1.format(time));
}
}
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.Month;
import java.time.MonthDay;
public class A05_LocalDateDemo {
public static void main(String[] args) {
//1.获取当前时间的日历对象(包含 年月日)
LocalDate nowDate = LocalDate.now();
//System.out.println("今天的日期:" + nowDate);
//2.获取指定的时间的日历对象
LocalDate ldDate = LocalDate.of(2023, 1, 1);
System.out.println("指定日期:" + ldDate);
System.out.println("=============================");
//3.get系列方法获取日历中的每一个属性值//获取年
int year = ldDate.getYear();
System.out.println("year: " + year);
//获取月//方式一:
Month m = ldDate.getMonth();
System.out.println(m);
System.out.println(m.getValue());
//方式二:
int month = ldDate.getMonthValue();
System.out.println("month: " + month);
//获取日
int day = ldDate.getDayOfMonth();
System.out.println("day:" + day);
//获取一年的第几天
int dayofYear = ldDate.getDayOfYear();
System.out.println("dayOfYear:" + dayofYear);
//获取星期
DayOfWeek dayOfWeek = ldDate.getDayOfWeek();
System.out.println(dayOfWeek);
System.out.println(dayOfWeek.getValue());
//is开头的方法表示判断
System.out.println(ldDate.isBefore(ldDate));
System.out.println(ldDate.isAfter(ldDate));
//with开头的方法表示修改，只能修改年月日
LocalDate withLocalDate = ldDate.withYear(2000);
System.out.println(withLocalDate);
//minus开头的方法表示减少，只能减少年月日
LocalDate minusLocalDate = ldDate.minusYears(1);
System.out.println(minusLocalDate);
//plus开头的方法表示增加，只能增加年月日
LocalDate plusLocalDate = ldDate.plusDays(1);
System.out.println(plusLocalDate);
//-------------
// 判断今天是否是你的生日
LocalDate birDate = LocalDate.of(2000, 1, 1);
LocalDate nowDate1 = LocalDate.now();
MonthDay birMd = MonthDay.of(birDate.getMonthValue(), birDate.getDayOfMonth());
MonthDay nowMd = MonthDay.from(nowDate1);
System.out.println("今天是你的生日吗? " + birMd.equals(nowMd));//今天是你的生日吗?
}
}
import java.time.LocalTime;
public class A06_LocalTimeDemo {
public static void main(String[] args) {
// 获取本地时间的日历对象。(包含 时分秒)
LocalTime nowTime = LocalTime.now();
System.out.println("今天的时间:" + nowTime);
int hour = nowTime.getHour();//时
System.out.println("hour: " + hour);
int minute = nowTime.getMinute();//分
System.out.println("minute: " + minute);
int second = nowTime.getSecond();//秒
System.out.println("second:" + second);
int nano = nowTime.getNano();//纳秒
System.out.println("nano:" + nano);
System.out.println("------------------------------------");
System.out.println(LocalTime.of(8, 20));//时分
System.out.println(LocalTime.of(8, 20, 30));//时分秒
System.out.println(LocalTime.of(8, 20, 30, 150));//时分秒纳秒
LocalTime mTime = LocalTime.of(8, 20, 30, 150);
//is系列的方法
System.out.println(nowTime.isBefore(mTime));
System.out.println(nowTime.isAfter(mTime));
//with系列的方法，只能修改时、分、秒
System.out.println(nowTime.withHour(10));
//plus系列的方法，只能修改时、分、秒
System.out.println(nowTime.plusHours(10));
}
}
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
public class A07_LocalDateTimeDemo {
public static void main(String[] args) {
// 当前时间的的日历对象(包含年月日时分秒)
LocalDateTime nowDateTime = LocalDateTime.now();
System.out.println("今天是:" + nowDateTime);//今天是：
System.out.println(nowDateTime.getYear());//年
System.out.println(nowDateTime.getMonthValue());//月
System.out.println(nowDateTime.getDayOfMonth());//日
System.out.println(nowDateTime.getHour());//时
System.out.println(nowDateTime.getMinute());//分
System.out.println(nowDateTime.getSecond());//秒
System.out.println(nowDateTime.getNano());//纳秒
// 日:当年的第几天
System.out.println("dayofYear:" + nowDateTime.getDayOfYear());
//星期
System.out.println(nowDateTime.getDayOfWeek());
System.out.println(nowDateTime.getDayOfWeek().getValue());
//月份
System.out.println(nowDateTime.getMonth());
System.out.println(nowDateTime.getMonth().getValue());
LocalDate ld = nowDateTime.toLocalDate();
System.out.println(ld);
LocalTime lt = nowDateTime.toLocalTime();
System.out.println(lt.getHour());
System.out.println(lt.getMinute());
System.out.println(lt.getSecond());
}
}
import java.time.LocalDate;
import java.time.Period;
public class A08_PeriodDemo {
public static void main(String[] args) {
// 当前本地 年月日
LocalDate today = LocalDate.now();
System.out.println(today);
// 生日的 年月日
LocalDate birthDate = LocalDate.of(2000, 1, 1);
System.out.println(birthDate);
Period period = Period.between(birthDate, today);//第二个参数减第一个参数
System.out.println("相差的时间间隔对象:" + period);
System.out.println(period.getYears());
System.out.println(period.getMonths());
System.out.println(period.getDays());
System.out.println(period.toTotalMonths());
}
}
import java.time.Duration;
import java.time.LocalDateTime;
public class A09_DurationDemo {
public static void main(String[] args) {
// 本地日期时间对象。
LocalDateTime today = LocalDateTime.now();
System.out.println(today);
// 出生的日期时间对象
LocalDateTime birthDate = LocalDateTime.of(2000, 1, 1, 0, 0, 0);
System.out.println(birthDate);
Duration duration = Duration.between(birthDate, today);//第二个参数减第一个参数
System.out.println("相差的时间间隔对象:" + duration);
System.out.println("============================================");
System.out.println(duration.toDays());//两个时间差的天数
System.out.println(duration.toHours());//两个时间差的小时数
System.out.println(duration.toMinutes());//两个时间差的分钟数
System.out.println(duration.toMillis());//两个时间差的毫秒数
System.out.println(duration.toNanos());//两个时间差的纳秒数
}
}
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
public class A10_ChronoUnitDemo {
public static void main(String[] args) {
// 当前时间
LocalDateTime today = LocalDateTime.now();
System.out.println(today);
// 生日时间
LocalDateTime birthDate = LocalDateTime.of(2000, 1, 1,
0, 0, 0);
System.out.println(birthDate);
System.out.println("相差的年数:" + ChronoUnit.YEARS.between(birthDate, today));
System.out.println("相差的月数:" + ChronoUnit.MONTHS.between(birthDate, today));
System.out.println("相差的周数:" + ChronoUnit.WEEKS.between(birthDate, today));
System.out.println("相差的天数:" + ChronoUnit.DAYS.between(birthDate, today));
System.out.println("相差的时数:" + ChronoUnit.HOURS.between(birthDate, today));
System.out.println("相差的分数:" + ChronoUnit.MINUTES.between(birthDate, today));
System.out.println("相差的秒数:" + ChronoUnit.SECONDS.between(birthDate, today));
System.out.println("相差的毫秒数:" + ChronoUnit.MILLIS.between(birthDate, today));
System.out.println("相差的微秒数:" + ChronoUnit.MICROS.between(birthDate, today));
System.out.println("相差的纳秒数:" + ChronoUnit.NANOS.between(birthDate, today));
System.out.println("相差的半天数:" + ChronoUnit.HALF_DAYS.between(birthDate, today));
System.out.println("相差的十年数:" + ChronoUnit.DECADES.between(birthDate, today));
System.out.println("相差的世纪(百年)数:" + ChronoUnit.CENTURIES.between(birthDate, today));
System.out.println("相差的千年数:" + ChronoUnit.MILLENNIA.between(birthDate, today));
System.out.println("相差的纪元数:" + ChronoUnit.ERAS.between(birthDate, today));
}
}
public class A01_IntegerDemo1 {
public static void main(String[] args) {
/*
public Integer(int value) 根据传递的整数创建一个Integer对象
public Integer(String s) 根据传递的字符串创建一个Integer对象
public static Integer valueOf(int i) 根据传递的整数创建一个Integer对象
public static Integer valueof(String s) 根据传递的字符串创建一个Integer对象
public static Integer valueof(String s, int radix) 根据传递的字符串和进制创建一个Integer对象
*/
//1.利用构造方法获取Integer的对象(JDK5以前的方式)
/*Integer i1 = new Integer(1);
Integer i2 = new Integer("1");
System.out.println(i1);
System.out.println(i2);*/
//2.利用静态方法获取Integer的对象(JDK5以前的方式)
Integer i3 = Integer.valueOf(123);
Integer i4 = Integer.valueOf("123");
Integer i5 = Integer.valueOf("123", 8);
System.out.println(i3);
System.out.println(i4);
System.out.println(i5);
//3.这两种方式获取对象的区别(掌握)
//底层原理：
//因为在实际开发中，-128~127之间的数据，用的比较多。
//如果每次使用都是new对象，那么太浪费内存了
//所以，提前把这个范围之内的每一个数据都创建好对象
//如果要用到了不会创建新的，而是返回已经创建好的对象。
Integer i6 = Integer.valueOf(127);
Integer i7 = Integer.valueOf(127);
System.out.println(i6 == i7);//true
Integer i8 = Integer.valueOf(128);
Integer i9 = Integer.valueOf(128);
System.out.println(i8 == i9);//false
//因为看到了new关键字，在Java中，每一次new都是创建了一个新的对象
//所以下面的两个对象都是new出来，地址值不一样。
/*Integer i10 = new Integer(127);
Integer i11 = new Integer(127);
System.out.println(i10 == i11);
Integer i12 = new Integer(128);
Integer i13 = new Integer(128);
System.out.println(i12 == i13);*/
}
}
public class A02_IntegerDemo2 {
public static void main(String[] args) {
//在以前包装类如何进行计算
/* Integer i1 = new Integer(1);
Integer i2 = new Integer(2);*/
//需求:要把两个数据进行相加得到结果3
//对象之间是不能直接进行计算的。
//步骤:
//1.把对象进行拆箱，变成基本数据类型
//2.相加
//3.把得到的结果再次进行装箱(再变回包装类)
/* int result = i1.intValue() + i2.intValue();
Integer i3 = new Integer(result);
System.out.println(i3);*/
}
}
public class A03_IntegerDemo3 {
public static void main(String[] args) {
//在JDK5的时候提出了一个机制:自动装箱和自动拆箱
//自动装箱:把基本数据类型会自动的变成其对应的包装类
//自动拆箱:把包装类自动的变成其对象的基本数据类型
//在底层，此时还会去自动调用静态方法valueof得到一个Integer对象，只不过这个动作不需要我们自己去操作了
//自动装箱的动作
//Integer i1 = 10;
//Integer i2 = new Integer(10);
//自动拆箱的动作
//int i = i2;
//结论：在JDK5以后，int和Integer可以看做是同一个东西，因为在内部可以自动转化。
}
}
public class A04_IntegerDemo4 {
public static void main(String[] args) {
/*
public static string tobinarystring(int i) 得到二进制
public static string tooctalstring(int i) 得到八进制
public static string toHexstring(int i) 得到十六进制
public static int parseInt(string s) 将字符串类型的整数转成int类型的整数
*/
//1.把整数转成二进制，十六进制
String str1 = Integer.toBinaryString(100);
System.out.println(str1);//1100100
//2.把整数转成八进制
String str2 = Integer.toOctalString(100);
System.out.println(str2);//144
//3.把整数转成十六进制
String str3 = Integer.toHexString(100);
System.out.println(str3);//64
//4.将字符串类型的整数转成int类型的整数
//强类型语言:每种数据在java中都有各自的数据类型
//在计算的时候，如果不是同一种数据类型，是无法直接计算的。
int i = Integer.parseInt("123");
System.out.println(i);
System.out.println(i + 1);//124
//细节1:
//在类型转换的时候，括号中的参数只能是数字不能是其他，否则代码会报错
//细节2:
//8种包装类当中，除了Character都有对应的parseXxx的方法，进行类型转换
String str = "true";
boolean b = Boolean.parseBoolean(str);
System.out.println(b);
}
}
import java.util.Scanner;
public class A05_IntegerDemo5 {
public static void main(String[] args) {
//键盘录入
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串");
/* String str = sc.next();
System.out.println(str);*/
//弊端:
//当我们在使用next，nextInt，nextDouble在接收数据的时候，遇到空格，回车，制表符的时候就停止了
//键盘录入的是123 123 那么此时只能接收到空格前面的数据
//我想要的是接收一整行数据
//约定:
//以后我们如果想要键盘录入，不管什么类型，统一使用nextLine
//特点:遇到回车才停止
String line = sc.nextLine();
System.out.println(line);
double v = Double.parseDouble(line);
System.out.println(v);
}
}
import java.util.ArrayList;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
/*
键盘录入一些1~10日之间的整数，并添加到集合中。直到集合中所有数据和超过200为止。
*/
//1.创建一个集合用来添加整数
ArrayList list = new ArrayList<>();
//2.键盘录入数据添加到集合中
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请输入一个整数");
String numStr = sc.nextLine();
int num = Integer.parseInt(numStr);//先把异常数据先进行过滤
if (num < 1 || num > 100){
System.out.println("当前数字不在1~100的范围当中，请重新输入");
continue;
}
//添加到集合中//细节:
//num:基本数据类型
//集合里面的数据是Integer
//在添加数据的时候触发了自动装箱
list.add(num);
//统计集合中所有的数据和
int sum = getSum(list);
//对sum进行判断
if(sum > 200){
System.out.println("集合中所有的数据和已经满足要求");
break;
}
}
}
private static int getSum(ArrayList list) {
int sum = 0;
for (int i = 0; i < list.size(); i++) {
//i :索引
//list.get(i);
int num = list.get(i);
sum = sum + num;//+=
}
return sum;
}
}
public class Test2 {
public static void main(String[] args) {
/*
自己实现parseInt方法的效果，将字符串形式的数据转成整数。要求:
字符串中只能是数字不能有其他字符最少一位，最多10位日不能开头
*/
//1.定义一个字符串
String str = "123";
//2.校验字符串
//习惯:会先把异常数据进行过滤，剩下来就是正常的数据。
if (!str.matches("[1-9]\\d{0,9}")) {
//错误的数据
System.out.println("数据格式有误");
} else {
//正确的数据
System.out.println("数据格式正确");
//3.定义一个变量表示最终的结果
int number = 0;
//4.遍历字符串得到里面的每一个字符
for (int i = 0; i < str.length(); i++) {
int c = str.charAt(i) - '0';//把每一位数字放到number当中
number = number * 10 + c;
}
System.out.println(number);
System.out.println(number + 1);
}
}
}
public class Test3 {
public static void main(String[] args) {
/*
定义一个方法自己实现toBinaryString方法的效果，将一个十进制整数转成字符串表示的二进制
*/
}
public static String tobinarystring(int number) {//6
//核心逻辑:
//不断的去除以2，得到余数，一直到商为日就结束。
//还需要把余数倒着拼接起来
//定义一个StringBuilder用来拼接余数
StringBuilder sb = new StringBuilder();
//利用循环不断的除以2获取余数
while (true) {
if (number == 0) {
break;
}
//获取余数 %
int remaindar = number % 2;//倒着拼接
sb.insert(0, remaindar);
//除以2 /
number = number / 2;
}
return sb.toString();
}
}
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.Date;
public class Test4 {
public static void main(String[] args) throws ParseException {
//请使用代码实现计算你活了多少天，用JDK7和JDK8两种方式完成
//JDK7
//规则:只要对时间进行计算或者判断，都需要先获取当前时间的毫秒值
//1.计算出生年月日的毫秒值
String birthday = "2000年1月1日";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
Date date = sdf.parse(birthday);
long birthdayTime = date.getTime();
//2.获取当前时间的毫秒值
long todayTime = System.currentTimeMillis();
//3.计算间隔多少天
long time = todayTime - birthdayTime;
System.out.println(time / 1000 / 60 / 60 / 24);
//JDK8
LocalDate ld1 = LocalDate.of(2000, 1, 1);
LocalDate ld2 = LocalDate.now();
long days = ChronoUnit.DAYS.between(ld1, ld2);
System.out.println(days);
}
}
import java.time.LocalDate;
import java.util.Calendar;
public class Test5 {
public static void main(String[] args) {
/*
判断任意的一个年份是闰年还是平年要求:用JDK7和JDK8两种方式判断提示:
二月有29天是闰年一年有366天是闰年
*/
//jdk7
//我们可以把时间设置为2000年3月1日
Calendar c = Calendar.getInstance();
c.set(2000, 2, 1);
//月份的范围:0~11
//再把日历往前减一天
c.add(Calendar.DAY_OF_MONTH, -1);
//看当前的时间是28号还是29号?
int day = c.get(Calendar.DAY_OF_MONTH);
System.out.println(day);
//jdk8
//月份的范围:1~12
//设定时间为2000年的3月1日
LocalDate ld = LocalDate.of(2001, 3, 1);
//把时间往前减一天
LocalDate ld2 = ld.minusDays(1);
//获取这一天是一个月中的几号
int day2 = ld2.getDayOfMonth();
System.out.println(day2);
//true:闰年
//false:平年
System.out.println(ld.isLeapYear());
}
}
单词
