Scanner sc=new Scanner(System.in);//创建方法
//常用方法
String s=sc.next();//获取字符串，但是遇到空格，回车，tab制表符就停止了
//比如说123 abc就只能读取到123
String s1=sc.netxLine();//遇到回车才停止，解决了next的不足
 
nextInt();
nextDouble();
nextXXX;
//获取对应的基本数据类型

public int length() // 返回该字符串的长度

public char charAt(int index)   //   返回字符串中指定位置的字符；注意字符串中第一个字符索引是0，最后一个是length()-1。

// 用String类的substring方法可以提取字符串中的子串，该方法有两种常用参数:
public String substring(int beginIndex) // 该方法从beginIndex位置起，从当前字符串中取出剩余的字符作为一个新的字符串返回。
public String substring(int beginIndex, int endIndex) // 该方法从beginIndex位置起，从当前字符串中取出到endIndex-1位置的字符作为一个新的字符串返回。

public int compareTo(String anotherString)
 //该方法是对字符串内容按字典顺序进行大小比较，通过返回的整数值指明当前字符串与参数字符串的大小关系。若当前对象比参数大则返回正整数，反之返回负整数，相等返回0。
    
public int compareToIgnore(String anotherString)//与compareTo方法相似，但忽略大小写。
    
public boolean equals(Object anotherObject)//比较当前字符串和参数字符串，在两个字符串相等的时候返回true，否则返回false。
    
public boolean equalsIgnoreCase(String anotherString)//与equals方法相似，但忽略大小写。

public String concat(String str) // 将参数中的字符串str连接到当前字符串的后面，效果等价于"+"。

public int indexOf(int ch/String str)//用于查找当前字符串中字符或子串，返回字符或子串在当前字符串中从左边起首次出现的位置，若没有出现则返回-1。
public int indexOf(int ch/String str, int fromIndex)//改方法与第一种类似，区别在于该方法从fromIndex位置向后查找。
    
    
public int lastIndexOf(int ch/String str)//该方法与第一种类似，区别在于该方法从字符串的末尾位置向前查找。
public int lastIndexOf(int ch/String str, int fromIndex)//该方法与第二种方法类似，区别于该方法从fromIndex位置向前查找。

public String toLowerCase()//返回将当前字符串中所有字符转换成小写后的新串
public String toUpperCase()//返回将当前字符串中所有字符转换成大写后的新串

public String replace(char oldChar, char newChar) //用字符newChar替换当前字符串中所有的oldChar字符，并返回一个新的字符串。
public String replaceFirst(String regex, String replacement)//把第一个符合正则表达式的子字串替换为replacement,并返回新的字符串
public String replaceAll(String regex, String replacement)//把符合正则表达式的字符串全部替换为replacement,并返回新的字符串

public String trim() //将字符串前后空白字符减去,并返回新的字符串
public boolean isEmpty()  // 判断字符串是否为空,为空就返回true
public boolean contains(String str)  //判断是否包含Str.是就返回true
public char[] toCharArray() // 将字符串返回为字符数组
public boolean startsWith(String prefix) // 测试此字符串是否以指定的子串开始，是就返回true
public boolean endsWith(String prefix) // 测试此字符串是否以指定的子串结束，是就返回true
public String[] split(String regex,int limit) // 根据匹配给定的正则表达式来拆分此字符串，并且返回字符串数组
public byte[] getBytes();//将字符串转化为字节数组

int [] arr1={1,2,3,4,5,6,7,8,9,10};
int[] arr2=new int[10];
//把arr1数组数据拷贝到arr2中
System.arraycopy(arr1,0,arr2,0,10);
//参数一：数据源：要拷贝的数据从哪个数组来
//参数二：从数据源数组中第几个索引开始拷贝
//参数三：目的地：我要把拷贝的数组拷贝到哪个数组中
//参数四：目的地数组的索引
//参数五：拷贝的个数

//java规定了runtime只能有一个对象
Runtime r1=Runtime.getRuntime();
Runtime r2=Runtime.getRuntime();
//r1和r2是同一个对象

public Object()//只有空参构造

//把对象转换成字符串，对象的字符串是地址值，，一般会自己重写打印对象的属性值
//如果我们打印一个对象，想看到对象内的属性值，需要重写toString方法
public String toString();

public boolean equals(Object b);//比较俩个对象的地址值是否相等

portected Object clone();//对象克隆，把A对象的属性值完全拷贝给B对象(浅拷贝)

System.out.println(0.09+0.01);
System.out.println(0.216-0.1);
System.out.println(0.226*0.01);

public Date();//创建Date对象，这个对象表示当前时间
public Date(long date);//创建时间对象，表示指定时间
Date d=new SimpleDateFormat("yyyy年MM月dd日").parse("2000年1月1日");//新写法

public void setTime(long time);//设置/修改毫秒值
public long getTime();//获取时间的毫秒值

public SimpleDateFormat();//构造一个SimpleDateFormat，使用java默认格式
public SimpleDateFormat(String pattern);//构造一个SimpleDateFormat，使用指定的格式

Date date=new Date();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//把Date格式化为指定格式的String
String format = sdf.format(date);
System.out.println(format);
//把指定字符串格式化为Date
Date parseDate = sdf.parse("2020-07-01 00:00:00");
System.out.println(parseDate);

public static Calendar getInstance();//获取当前时间的日历对象

//这里的field写的就是上面的数字了
public void set(int field,int value);//修改日历的某个字段信息
//如果我们在set方法中设置比如说13月，那么会自动12进制进位加1年加1月这样的方式哦
public void add(int field,int amount);//为某个字段增加/减少指定值      
//amount负数就是减，正数就是加
public void get(int field);//获取日历类数组中的数据

LocalDateTime date = LocalDateTime.now();
int year = date.getYear();//年
int monthValue = date.getMonthValue();//月（1-12）
int dayOfMonth = date.getDayOfMonth();//日
int dayOfYear = date.getDayOfYear();//一年中的第几天
int value = date.getDayOfWeek().getValue();//星期几

LocalDateTime date = LocalDateTime.now();
LocalDateTime ld1 = date.withYear(2099);//修改年
LocalDateTime ld2 = date.withMonth(12);//修改月
LocalDateTime ld3 = date.withDayOfMonth(22);//修改日
LocalDateTime ld4 = date.withDayOfYear(2);//修改一年中的第几天
LocalDateTime ld5 = date.withHour(12);//修改时
LocalDateTime ld6 = date.withMinute(30);//修改分
LocalDateTime ld7 = date.withSecond(2);//修改秒
LocalDateTime ld8 = date.withNano(3);//修改纳秒

//减就是将plus改成minus
LocalDateTime date = LocalDateTime.now();
LocalDateTime ld1 = date.plusYears(2);//加年
LocalDateTime ld2 = date.plusMonths(2);//加月
LocalDateTime ld3 = date.plusDays(20);//加日
LocalDateTime ld4 = date.plusWeeks(3);//加星期
LocalDateTime ld5 = date.plusHours(3);//加时
LocalDateTime ld6 = date.plusMinutes(3);//加分
LocalDateTime ld7 = date.plusSeconds(3);//加秒
LocalDateTime ld8 = date.plusNanos(3);//加纳秒

LocalDateTime ld1 = LocalDateTime.now();
LocalDateTime ld2 = LocalDateTime.of(2019, 1, 1, 0, 0, 0)
System.out.println(ld1.equals(ld2));//判断ld1是否等于ld2
System.out.println(ld1.isEqual(ld2));//判断ld1是否等于ld2
System.out.println(ld1.isAfter(ld2));//判断ld1是否在ld2之后
System.out.println(ld1.isBefore(ld2));//判断ld1是否在ld2之前

//LocalDateTime可以转化成LocalDate或LocalTime
LocalDateTime ld = LocalDateTime.now();
LocalDate localDate = ld.toLocalDate();
LocalTime localTime = ld.toLocalTime();

ZoneId zoneId = ZoneId.systemDefault();//获取系统默认时区
Set<String> availableZoneIds = ZoneId.getAvailableZoneIds();//获取所有java支持的时区集合
ZoneId zoneId1 = ZoneId.of("America/New_York");//获取指定时区的zoneId对象

ZoneId zoneId = ZoneId.of("America/New_York");
ZonedDateTime zonedDateTime = ZonedDateTime.now(zoneId);//获取美国纽约的时间（带时区)
ZonedDateTime now = ZonedDateTime.now(Clock.systemUTC());//获取世界标准时间
ZonedDateTime now2 = ZonedDateTime.now();//获取系统默认时区的时间

//1.获取，年月日时分秒
int year = zonedDateTime.getYear();
int month = zonedDateTime.getMonthValue();
int day = zonedDateTime.getDayOfMonth();
int hour = zonedDateTime.getHour();
int minute = zonedDateTime.getMinute();
int second = zonedDateTime.getSecond();
int dayOfMonth = zonedDateTime.getDayOfMonth();//获取当前是这个月的第几天
int value = zonedDateTime.getDayOfWeek().getValue();//获取当前是这周的第几天
int dayOfYear = zonedDateTime.getDayOfYear();//获取当前这个年的第几天
//2.修改(plusXXX加，minusXXX减法，withXXX修改)
ZonedDateTime zonedDateTime1 = zonedDateTime.plusYears(1);
ZonedDateTime zonedDateTime2 = zonedDateTime.plusMonths(1);
ZonedDateTime zonedDateTime3 = zonedDateTime.plusDays(1);
ZonedDateTime zonedDateTime4 = zonedDateTime.plusHours(1);
ZonedDateTime zonedDateTime5 = zonedDateTime.plusMinutes(1);
ZonedDateTime zonedDateTime6 = zonedDateTime.plusSeconds(1);
ZonedDateTime zonedDateTime7 = zonedDateTime.plusNanos(1);

Instant now = Instant.now();//创建Instant对象，获取当前时间信息
//获取
long epochSecond = now.getEpochSecond();//获取总秒数
int nano = now.getNano();//获取不够1秒的纳秒值
//加        
Instant instant = now.plusSeconds(1);//加1秒
Instant instant1 = now.plusMillis(1);//加1毫秒
Instant instant2 = now.plusNanos(1);//加1纳秒
//减
Instant instant3 = now.minusSeconds(1);//减1秒
Instant instant4 = now.minusMillis(1);//减1毫秒
Instant instant5 = now.minusNanos(1);//减1纳秒
//判断
boolean after = now.isAfter(instant);//在前
boolean before = now.isBefore(instant);//在后
boolean equals = now.equals(instant);//相同

//1.创建一个日期时间格式化器对象
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
//2.格式化时间
LocalDateTime now1 = LocalDateTime.now();
ZonedDateTime now2 = ZonedDateTime.now();
//使用格式化器的format方法格式化(正向格式化)
String format1 = dtf.format(now1);
String format2 = dtf.format(now2);
System.out.println(format1);
System.out.println(format2);
//使用LocalDateTime，ZonedDateTime的format方法格式化(反向格式化)
String format3 = now1.format(dtf);
String format4 = now2.format(dtf);
System.out.println(format3);
System.out.println(format4);
//3.解析时间：解析时间一般使用LocalDateTime提供的解析方法来解析
String dateStr="2029-12-12 12:12:11";
LocalDateTime parse = LocalDateTime.parse(dateStr, dtf);
System.out.println(parse);

LocalDate start = LocalDate.of(2019, 1, 1);
LocalDate end = LocalDate.of(2019, 12, 31);
//1.创建Period对象，封装俩个日期对象
Period period = Period.between(start, end);
//2.通过Period对象获取俩个日期对象间隔的信息
int years = period.getYears();        
int months = period.getMonths();
int days = period.getDays();

LocalDateTime start = LocalDateTime.of(2020, 1, 1, 10, 10)
LocalDateTime end = LocalDateTime.of(2020, 1, 1, 10, 20);
//1.获取Duration对象
Duration duration = Duration.between(start, end);
//2.获取俩个时间对象间隔的信息
long days = duration.toDays();//间隔多少天
long hours = duration.toHours();//间隔多少小时
long minutes = duration.toMinutes();//间隔多少分钟
long millis = duration.toMillis();//间隔多少毫秒
long nanos = duration.toNanos();//间隔多少纳秒

Integer i1=10;//在底层会自动调用valueOf方法得到Integer对象，自动装箱！
int i2=i1;//自动拆箱
Integer i3=i1+i2;//jdk5的新计算方式
//

//sort排序演示
 以{2,3,1,5,6}为例
此时有序序列为2，无序序列为3，1，5，6
- 遍历无序序列得到3，此时o1=3,o2=2	o1-o2=3-2=1>0故3应该插入在2后面
此时形成了有序序列：2，3	无序序列：1，5，6
- 遍历无序序列得到1，此时o1=1，o2=3，o1-02=1-3=-2<0表式1应该插入到3的前面
再次遍历有序序列此时o1=1，o2=2	o1-o2=-1<0表示1应该插入到2的前面
此时形成了有序序列：1，2，3	无序序列：5，6
- 遍历无序序列得到5，此时o1=5，o2=3	5-3>0故5应该放到3的后面
此时形成有序序列：1，2，3，5	无序序列：6
- 遍历无序序列得到：6，此时o1=6，o2=5	o1-o2=6-5>0故6应该放在5的前面
此时有序序列为：1，2，3，5，6结束遍历！

// 版本1：基于时间戳和MAC地址
UUID uuid1 = UUID.randomUUID();  // 通常是版本4

// 不同版本的区别：
UUID version1 = UUID.nameUUIDFromBytes("test".getBytes());  // 版本3
// 版本1: 时间戳 + MAC地址
// 版本3: MD5哈希命名空间
// 版本4: 随机生成（最常用）
// 版本5: SHA-1哈希命名空间

import java.util.UUID;

// 1. 生成随机UUID（版本4 - 最常用）
UUID uuid = UUID.randomUUID();
String str = uuid.toString();  // "f47ac10b-58cc-4372-a567-0e02b2c3d479"

// 2. 从字符串解析
UUID parsed = UUID.fromString("38400000-8cf0-11bd-b23e-10b96e4ef00d");

// 3. 基于名称生成（版本3/5）
UUID nameBased = UUID.nameUUIDFromBytes("example".getBytes());

// 4. 获取UUID的组成部分
long mostSigBits = uuid.getMostSignificantBits();  // 高64位
long leastSigBits = uuid.getLeastSignificantBits(); // 低64位

// 5. 比较和相等性
UUID uuid1 = UUID.randomUUID();
UUID uuid2 = UUID.fromString(uuid1.toString());
boolean equal = uuid1.equals(uuid2);  // true