String

String的特性

String：字符串，使用一对“ ”引起来表示。

1. String声明为final的，不可被继承
2. String实现了Serializable接口：表示String可以比较大小
3. 实现了Comparable接口：表示String可以比较大小
4. String内部定义了final char[] value用于存储字符串数组
5. String：代表不可变的字符序列。简称：不可变性
   体现：1. 当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。2. 当对现有的字符串进行链接操作时，也需要重新指定内存区域赋值。3. 当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值。
6. 通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。字符串常量池中是不会存储相同的字符串的

String对象的创建

方式一：字面量定义的方式

方式二：通过new + 构造器的方式

String str = "hello";

//本质上this.value = new char[0];
String s1 = new String();

//this.value = original.value;
String s2 = new String(String original);

//this.value = Arrays.copyOf(value, value.length);
String s3 = new String(char[] a);

String s4 = new String(char[] a,int startIndex,int count);

字符串对象的存储

String str1 = “abc”;与String str2 = new String(“abc”);的区别？

面试题：String s1 = new String("abc");方式创建对象，在内存中创建了几个对象？——两个：一个时对空间中new结构，另一个时char[]对应的常量池中的数据"abc"

字符串的特性

1. 常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
2. 只要被拼接的内容其中有一个是变量，结果就在堆中。
3. 如果拼接的结果调用intern()方法，返回值就在常量池中。

String s1="javaEEhadoop";
String s2="javaEE";
String s3=s2+"hadoop";
sout(s1==s3);//false

final String s4="javaEE";//常量
String s5=s4+"hadoop";
sout(s1==s5);//true

String常用方法

int length()：返回字符串的长度： return value.length

char charAt(int index)： 返回某索引处的字符return value[index]

boolean isEmpty()：判断是否是空字符串：return value.length == 0

String toLowerCase()：使用默认语言环境，将 String 中的所有字符转换为小写

String toUpperCase()：使用默认语言环境，将 String 中的所有字符转换为大写

String trim()：返回字符串的副本，忽略前导空白和尾部空白

boolean equals(Object obj)：比较字符串的内容是否相同

boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大小写

String concat(String str)：将指定字符串连接到此字符串的结尾。 等价于用“+”

int compareTo(String anotherString)：比较两个字符串的大小

String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。

String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。左闭右开。

#### 前缀后缀

boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束

boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始

boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始

查找子串

boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true

int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引

int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始

int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引

int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索

注：indexOf和lastIndexOf方法如果未找到都是返回-1

替换

String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。

String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。

String replaceAll(String regex, String replacement) ： 使用给定的replacement 替换此字符串所有匹配给定的正则表达式的子字符串。

String replaceFirst(String regex, String replacement) ： 使用给定的replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。

匹配

boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。

切片

String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。

String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。

正则表达式有关例子

String str = "12hello34world5java7891mysql456";
//把字符串中的数字替换成,，如果结果中开头和结尾有，的话去掉
String string = str.replaceAll("\\d+", ",").replaceAll("^,|,$", "");
System.out.println(string);

String str = "12345";
//判断str字符串中是否全部有数字组成，即有1-n个数字组成
boolean matches = str.matches("\\d+");
System.out.println(matches);
String tel = "0571-4534289";
//判断这是否是一个杭州的固定电话
boolean result = tel.matches("0571-\\d{7,8}");
System.out.println(result);

String str = "hello|world|java";
String[] strs = str.split("\\|");
for (int i = 0; i < strs.length; i++) {
    System.out.println(strs[i]);
}
System.out.println();
String str2 = "hello.world.java";
String[] strs2 = str2.split("\\.");
for (int i = 0; i < strs2.length; i++) {
    System.out.println(strs2[i]);
}

String与基本数据类型转换

字符串与基本数据类型、包装类：parseXxx(str)、valueOf(xxx)

字符串与字符数组：String的构造器String(char[])、toCharArray()方法

编码与解码

字符串与字节数组：

编码：getBytes() 与 getBytes(String charsetName)

解码：解码时，要求解码使用的字符集不许与编码时一致

String(byte[]) 与 String(byte[] , charsetName)

StringBuffer、StringBuilder

String、StringBuffer、StringBuilder的异同的？

String：不可变的字符序列

StringBuffer：可变的字符序列；线程安全的，效率低

StringBuilder：可变的字符序列；jdk5.0新增的，线程不安全的，效率高

相同点：底层使用char[]存储

对比三者的效率？StringBuilder > StringBuffer > String

源码分析

String str = new String();//char[] value = new char[e];
String str1 = new String("abc");//char[] value = new char[]{'a', 'b', 'c'};

StringBuffer sb1 = new StringBuffer();//char[] value = new char[16]; 底层创建了一个长度是16的数组
sb1.append( 'a');//value[0] = 'a';
sb1.append( 'b');//value[1] = 'b';

StringBuffer sb2 = new StringBuffer("abc");//char[] value = new char[ "abc". length() + 16 ];

每次创造都会额外空出16个char的位置

问题一：System.out.println(sb2.length());//3

问题二：扩容问题：如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。默认情况下，扩容为原来容量的2倍+2，同时将原有数组中的元素复制到新的数组中。

指导意义：开发中建议大家使用：StringBuffer(int capacity)或StringBuilder(int capacity)

常用方法

StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接
StringBuffer delete(int start,int end)：删除指定位置的内容
StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str
StringBuffer insert(int offset, xxx)：在指定位置插入xxx
StringBuffer reverse() ：把当前字符序列逆转

public int indexOf(String str)
public String substring(int start,int end)
public int length()
public char charAt(int n)
public void setCharAt(int n ,char ch)

增：append(xxx)

删：delete(int start,int end)

改：setCharAt(int n ,char ch) / replace(int start, int end, String str)

查：charAt(int n)

插：insert(int offset, xxx)

长度：length()

遍历：for() + chatAt() / toString()

JDK8之前常用的日期和时间API

System类中的currentTimeMillis()

当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差，称为时间戳

Date类

java.util.Date类

　　　　|-----------java.sql.Date类

构造器一：Date()：创建一个对应当前时间的Date对象

构造器二：创建之地当毫秒数的Date对象

toString()：显示当前的年、月、日、时、分、秒

getTime()：获取当前Date对象对应的毫秒数（时间戳）

java.sql.Date类对应着数据库中日期类型的变量

//如何转换成util的Date类
Date date6=new Date();
java.sql.Date date7=new java.sql.Date(date6.getTime());

java.text.SimpleDateFormat类

格式化：日期--->字符串

解析：字符串--->日期

SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
//格式化
Date date=new Date();
String format=sdf.format(date);
System.out.println(format);
//解析：要求字符串必须时符合SimpleDateFormat识别的格式（通过构造器体现），否则抛异常
Date date2=sdf.parse("2020-02-18 11:48:27")
System.out.println(date2);

练习：字符串“2020-09-08”转换为java.sql.Date

String birth="2020-09-08";

SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
Date date=sdf.parse(birth);

java.sql.Date birthDate=new java.sql.Date(date.geetTime());
System.out.println(birthDate);

java.util.Calendar(日历)类

实例化：

方式一：调用它的子类GregorianCalendar的构造器

方式二：调用其静态方法Calendar.getInstance()

Calendar ca=Calender.getInstance();

System.out.println(ca.getClass);//class java.util.GregorianCalendar

常用方法：

//get()
//get(int field)方法来取得想要的时间信息。比如YEAR、MONTH、DAY_OF_WEEK、HOUR_OF_DAY 、MINUTE、SECOND
int days=ca.get(Calender.DAY_OF_MONTH);

//set()
ca.set(Calender.DAY_OF_MONTH,22);

//add()
ca.add(Calender.DAY_OF_MONTH,-3);

//getTime()：日历类-->Date
Date date=ca.getTime();

//setTime()：Date-->日历类
Date date=new Date();
ca.setTime(date);

注意:
获取月份时：一月是0，二月是1，以此类推，12月是11
获取星期时：周日是1，周二是2 ， 。。。。周六是7

JDK8中新日期时间API

新日期时间API出现的背景

Calendar并不比Date好多少。它们面临的问题是：

可变性：像日期和时间这样的类应该是不可变的。
偏移性：Date中的年份是从1900开始的，而月份都从0开始。
格式化：格式化只对Date有用，Calendar则不行。
此外，它们也不是线程安全的；不能处理闰秒等。

LocalDateTime、LocalDate、LocalTime

Java 8 吸收了 Joda-Time 的精华，以一个新的开始为 Java 创建优秀的 API。新的 java.time 中包含了所有关于本地日期（LocalDate）、本地时间（LocalTime）、本地日期时间（LocalDateTime）、时区（ZonedDateTime）和持续时间（Duration）的类。历史悠久的 Date 类新增了 toInstant() 方法，用于把 Date 转换成新的表示形式。

//now():获取当前的日期、时间、日期+时间
LocalDateTime localDateTime=LocalDateTime.now();

//of():设置指定的年月日时分秒，没有偏移量
LocalDateTime localDateTime1=LocalDateTime.of(2022,4,29,10,36,0);

//getXxx()
System.out.println(localDateTime.getDayOfMonth());//18
System.out.println(localDateTime.getDayOfWeek());//MONDAY
System.out.println(localDateTime.getMonth());//FEBRUARY
System.out.println(localDateTime.getMonthValue());//2
System.out.println(localDateTime.getMinute());//18

withXxx():设置相关属性，体现不可变性

withDayOfMonth()/withDayOfYear()/withMonth()/withYear()
将月份天数、年份天数、月份、年份修改为指定的值并返回新的对象

plusXxx()

plusDays(), plusWeeks(),plusMonths(), plusYears(),plusHours()
向当前对象添加几天、几周、几个月、几年、几小时

minusXxx()

minusMonths() / minusWeeks()/minusDays()/minusYears()/minusHours()
从当前对象减去几月、几周、几天、几年、几小时

瞬时：Instance

//now():获取本初子午线对应的标准时间
Instant instant = Instant.now();
System.out.println(instant);//2019-02-18T07:29:41.719Z

//添加时间的偏移量
OffsetDateTime offsetDateTime = instant.at0ffset (ZoneOffset.ofHours(8));
System.out.println(offsetDateTime);//2019-02- 18T15:32:50.611+08:00

//toEpochMilli():获取自1970年1月1日e时白分日秒(UTC)开始的毫秒数 ---> Date类的getTime()
long milli = instant.toEpochMilli();
System.out.print1n(milli);

//ofEpochMilli():通过给定的毫秒数，获取Instant实例-->Date(long millis)
Instant instant1 = Instant.ofEpochMilli(1550475314878L);
System.out.println(instant1);

java.time.format.DateTimeFormatter 类

格式化或解析日期、时间

//重点:方式三:自定义的格式。如: ofPattern("yyyy-MM-dd hh: mm:ss')
DateTimeFormatter formatter3 = DateTimeFormatter . ofPattern("yyyy-MM-dd hh:mm:ss");

//格式化
String str4 = formatter3 . format (LocalDateTime . now());
System. out. print1n(str4);//2019-02-18 03:52:09

//解析
TemporalAccessor accessor = formatter3. parse( text: "2019-02-18 03:52:09");
System. out. print1n(accessor);

参考：与传统日期处理的转换

类	To遗留类	From遗留类
java.time.Instant与java.util.Date	Date.from(instant)	date.toInstant()
java.time.Instant与java.sql.Timestamp	Timestamp.from(instant)	timestamp.toInstant()
java.time.ZonedDateTime与 java.util.GregorianCalendar	GregorianCalendar.from(zonedDateTime)	cal.toZonedDateTime()
java.time.LocalDate与java.sql.Time	Date.valueOf(localDate)	date.toLocalDate()
java.time.LocalTime与java.sql.Time	Date.valueOf(localDate)	date.toLocalTime()
java.time.LocalDateTime与 java.sql.Timestamp	Timestamp.valueOf(localDateTime)	timestamp.toLocalDateTime()
java.time.ZoneId与java.util.TimeZone	Timezone.getTimeZone(id)	timeZone.toZoneId()
java.time.format.DateTimeFormatter与 java.text.DateFormat	formatter.toFormat()	无

Java比较器

Java实现对象排序的方式有两种：

自然排序：java.lang.Comparable

定制排序：java.util.Comparator

一、说明： Java中的对象，正常情况下，只能进行比较: ==或!=。不能使用>或<的。但是在开发场景中，我们需要对多个对象进行排序，言外之意，就需要比较对象的大小。

如何实现？使用两个接口中的任何一个: Comparable 或Comparator

二、Comparable 接口与Comparator的使用的对比

Comparable接口的方式一旦一定，保证Comparable 接口实现类的对象在任何位置都可以比较大小。

Comparator接口属于临时性的比较。

Comparable接口：自然排序

1. 像String、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方式
2. 像String、包装类等重写了compareTo(obj)方法以后，进行了从小到大的排列
3. 重写compareTo(obj)的规则：
   如果当前对象this大于形参对象obj，则返回正整数；小于则返回负数；等于则返回0
4. 对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo(obj)方法，在compareTo(obj)方法中指明如何排序

//指明商品比较大小的方式:按照价格从低到高排序
@Override
public int compareTo(0bject o) {
    if(o instanceof Goods){
        Goods goods = (Goods)o;
        //方式一:
        if(this.price > goods. price){
            return 1;
        }else if(this.price < goods . price){
            return - 1;
        }else{
            return 0;
            // return this.name.compareTo(goods.name);
            //再按照商品名称从低到高
        }
        //方式二:
        return Double . cinpare( this.price, goods.price);
    }

    throw new RuntimeException("传入的数据类型不一致! ");
}

Comparator接口：定制排序

背景：

当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用 Comparator 的对象来排序

重写compare(Object o1,Object o2)方法，比较o1和o2的大小：

如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。

@Test
public void test3(){
    String[] arr = new String[]{"AA", "CC" , "KK" , "MM", "GG" , "JJ", "DD"};

    Arrays . sort(arr , new Comparator(){
        //按照字符串从大到小的顺序排列
        @Override
        public int compare(0bject 01, Object o2) {
            if(o1 instanceof String && o2 instanceof String){
                String s1 = (String) 01;
                String s2 = (String) o2;
                return -s1. compareTo(s2) ;
            }
            //return 0;
            throw new RuntimeException("输入的数据类型不一致");
        }
    });

    System. out . print1n(Arrays . toString(arr));
}

Arrays . sort(arr, new Comparator() {
    //指明商品比较大小的方式:按照产品名称从低到高排序，再按照价格从高到低排序
    @Override
    public int compare(Object 01， Object o2) {
        if(o1 instanceof Goods && o2 instanceof Goods){
            Goods g1 = (Goods )o1;
            Goods g2 = (Goods)o2;
            if(g1. getName(). equals(g2. getName())){
                return -Doub1e. compare(g1. getPrice(), g2. getPrice());
            }else{
                return g1 . getName() . compareTo(g2. getName());
            }
        }
        throw new RuntimeException("输入的数据类型不一致");
    }
});

System类

System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。

由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用。

成员变量

System类内部包含in、out和err三个成员变量，分别代表标准输入流(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)。

成员方法

native long currentTimeMillis()：

该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。

void exit(int status)：

该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。

void gc()：

该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况。

String getProperty(String key)：

该方法的作用是获得系统中属性名为key的属性对应的值。系统中常见的属性名以及属性的作用如下表所示：

String javaVersion = System.getProperty("java.version");
System.out.println("java的version:" + javaVersion);
String javaHome = System.getProperty("java.home");
System.out.println("java的home:" + javaHome);
String osName = System.getProperty("os.name");
System.out.println("os的name:" + osName);
String osVersion = System.getProperty("os.version");
System.out.println("os的version:" + osVersion);
String userName = System.getProperty("user.name");
System.out.println("user的name:" + userName);
String userHome = System.getProperty("user.home");
System.out.println("user的home:" + userHome);
String userDir = System.getProperty("user.dir");
System.out.println("user的dir:" + userDir);

Math类

java.lang.Math提供了一系列静态方法用于科学计算。其方法的参数和返回值类型一般为double型。

abs	绝对值
acos,asin,atan,cos,sin,tan	三角函数
sqrt	平方根
pow(double a,doble b)	a的b次幂
log	自然对数
exp	e为底指数
max(double a,double b)
min(double a,double b)
random()	返回0.0到1.0的随机数
long round(double a)	double型数据a转换为long型（四舍五入）
toDegrees(double angrad)	弧度—>角度
toRadians(double angdeg)	角度—>弧度

BigInteger与BigDecimal

BigInteger

Integer类作为int的包装类，能存储的最大整型值为231-1，Long类也是有限的，最大为263-1。如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。

java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger 提供所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。

另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作。

构造器

BigInteger(String val)：根据字符串构建BigInteger对象

常用方法

public BigInteger abs()：返回此 BigInteger 的绝对值的 BigInteger。
BigInteger add(BigInteger val) ：返回其值为 (this + val) 的 BigInteger
BigInteger subtract(BigInteger val) ：返回其值为 (this - val) 的 BigInteger
BigInteger multiply(BigInteger val) ：返回其值为 (this * val) 的 BigInteger
BigInteger divide(BigInteger val) ：返回其值为 (this / val) 的 BigInteger。整数相除只保留整数部分。
BigInteger remainder(BigInteger val) ：返回其值为 (this % val) 的BigInteger。
BigInteger[] divideAndRemainder(BigInteger val)：返回包含 (this / val) 后跟(this % val) 的两个 BigInteger 的数组。
BigInteger pow(int exponent) ：返回其值为 (thisexponent) 的BigInteger。

BigDecimal

一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类。
BigDecimal类支持不可变的、任意精度的有符号十进制定点数。

构造器

public BigDecimal(double val)
public BigDecimal(String val)

常用方法

public BigDecimal add(BigDecimal augend)
public BigDecimal subtract(BigDecimal subtrahend)
public BigDecimal multiply(BigDecimal multiplicand)
public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)

public void testBigInteger() {
    BigInteger bi = new BigInteger("12433241123");
    BigDecimal bd = new BigDecimal("12435.351");
    BigDecimal bd2 = new BigDecimal("11");
    System.out.println(bi);
    // System.out.println(bd.divide(bd2));//除不尽会报错
    System.out.println(bd.divide(bd2, BigDecimal.ROUND_HALF_UP));//默认行为
    System.out.println(bd.divide(bd2, 15, BigDecimal.ROUND_HALF_UP));//保留几位小数
}

枚举类

JDK1.5之前需要自定义枚举类

JDK 1.5 新增的 enum 关键字用于定义枚举类

枚举类的使用：

1. 枚举类的理解:类的对象只有有限个，确定的。我们称此类为枚举类
2. 当需要定义一组常量时，强烈建议使用枚举类
3. 如果枚举类中只有一一个对象，则可以作为单例模式的实现方式。

自定义枚举类

1. 私有化类的构造器，保证不能在类的外部创建其对象
2. 在类的内部创建枚举类的实例。声明为：public static final
3. 对象如果有实例变量，应该声明为private final，并在构造器中初始化

class Season{
    //1.声明Season对象的属性：private final修饰
    private final String SEASONNAME;//季节的名称
    private final String SEASONDESC;//季节的描述

    //2.私有化类的构造器，并给对象属性赋值
    private Season(String seasonName,String seasonDesc){
    this.SEASONNAME = seasonName;
    this.SEASONDESC = seasonDesc;
    }

    //3.提供当前枚举类的多个对象：public static final的
    public static final Season SPRING = new Season("春天", "春暖花开");
    public static final Season SUMMER = new Season("夏天", "夏日炎炎");
    public static final Season AUTUMN = new Season("秋天", "秋高气爽");
    public static final Season WINTER = new Season("冬天", "白雪皑皑");

    //4.其他诉求：获取枚举类对象的属性
    public String get SeasonName(){
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }

    //4.其他诉求：重写toString
}

使用enum定义枚举类

public enum SeasonEnum {
    //1.提供当前枚举类的对象，多个对象之间用“，”隔开，末尾对象“；”结束
    SPRING("春天","春风又绿江南岸"),
    SUMMER("夏天","映日荷花别样红"),
    AUTUMN("秋天","秋水共长天一色"),
    WINTER("冬天","窗含西岭千秋雪");

    //2.声明Season对象的属性：private final修饰
    private final String seasonName;
    private final String seasonDesc;

    //3.私有化类的构造器，并给对象属性赋值
    private SeasonEnum(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //4.其他诉求：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }
}

说明：enum定义的枚举类默认继承与java.lang.Enum类

Enum类的主要方法

values()方法：返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。

valueOf(String str)：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常：IllegalArgumentException。

toString()：返回当前枚举类对象常量的名称

//toString():
SeasonEnum summer=SeasonEnum.SUNMMER;
System.out.println(summer.toString());

//values():
SeasonEnum values=SeasonEnum.values();
for(int i=0;i<values.length;i++){
    System.out.println(values[i]);
}

//valueOf(String objName) :返回枚举类中对象名是objName的对象。
SeasonEnum winter = SeasonEnum.value0f("WINTER");
//如果没有objName的枚举类对象，则抛异常: ILLegalArgumentException
SeasonEnum winter = SeasonEnum.valueOf( "WINTER1");
System.out println(winter);

使用enum关键字定义的枚举类实现接口的情况

情况一：实现接口，在enum类中实现抽象方法

情况二：让枚举类的对象分别实现接口中的抽象方法

interface Show{
    show();
}

public enum SeasonEnum implements Show{
    //1.提供当前枚举类的对象，多个对象之间用“，”隔开，末尾对象“；”结束
    SPRING("春天","春风又绿江南岸"){
        @Override
        public void show(){
            System.out.println("春天在哪里");
        }
    },
    SUMMER("夏天","映日荷花别样红"){
        @Override
        public void show(){
            System.out.println("宁夏");
        }
    },
    AUTUMN("秋天","秋水共长天一色"){
        @Override
        public void show(){
            System.out.println("秋天不回来");
        }
    },
    WINTER("冬天","窗含西岭千秋雪"){
        @Override
        public void show(){
            System.out.println("大约在冬季");
        }
    };

    //2.声明Season对象的属性：private final修饰
    private final String seasonName;
    private final String seasonDesc;

    //3.私有化类的构造器，并给对象属性赋值
    private SeasonEnum(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //4.其他诉求：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }
}

如何在idea中导入eclipse项目

idea中选中工程，右键，点击Show in Explorer，将原eclipse项目的文件夹粘贴

进入Project Structure，点击modules，点击加号，点击Import Module，选中Eclipse，点击Next，Next，勾选项目，Finish