• 【java进阶07：常用类】String类、包装类、日期类Date、数字类、随机数、枚举类型

    目录

    String类

    包装类

    日期类Date

    数字类

    随机数

    枚举

    String类

    1. String类型的字符串存储原理

      在这里插入图片描述

      1. /*
      2.     关于java JDK中内置的一个类：java.util.String
      3.         1、String表示字符串类型，属于引用数据类型，不属于基本数据类型。
      4.         2、在java中随便使用双引号括起来的都是String对象，例如："abc","def","hello" 这是3个String对象
      5.         3、java中规定：双引号括起来的字符串，是不可改变的。也就是说："abc"从创建到释放，不可变，不能变成"abc",也不能变成"ab"
      6.         4、在JDK当中双引号括起来的字符串，例如："abc","def"都是直接存储在“方法区”中的“字符串常量池”当中的
      7.             为什么SUN公司把字符串存储在一个“字符串常量池”中呢？    因为字符串在实际开发中使用太频繁，为了执行效率，所以把字符串放到了方法区中的字符串常量池中
      9.  */
      10. public class StringText01 {
      11.     public static void main(String[] args) {
      12.         //这两行代码表示底层创建了3个字符串对象，都在字符串常量池中。
      13.         String s1 = "abcdef";
      14.         String s2 = "abcdef"+"xy";
      15.  
      16.         //分析：这是使用new的方式创建的字符串对象，这个代码中的"xy"是从哪里来的？
      17.         String s3 = new String("xy");
      18.         //凡是双引号括起来的都在字符串常量池中有一份。new对象的时候一定在堆内存中开辟空间
      19.  
      20.         //i变量中保存的是100这个值
      21.         int i = 100;
      22.         //s变量中保存的是字符串对象的内存地址，s引用中保存的不是"abc",而是0x1111——"abc"字符串对象在“字符串常量池”中的内存地址
      23.         String s = "abc";
      24.  
      25.     }
      26. }
      27.

      在这里插入图片描述

      1. public class User {
      2.     private int id;
      3.     private String name;
      4.     public User(){
      5.  
      6.     }
      7.  
      8.     public User(int id, String name) {
      9.         this.id = id;
      10.         this.name = name;
      11.     }
      12.  
      13.     public int getId() {
      14.         return id;
      15.     }
      16.  
      17.     public void setId(int id) {
      18.         this.id = id;
      19.     }
      20.  
      21.     public String getName() {
      22.         return name;
      23.     }
      24.  
      25.     public void setName(String name) {
      26.         this.name = name;
      27.     }
      28. }
      1. public class UserText {
      2.     public static void main(String[] args) {
      3.         User user = new User(110,"张三");
      4.     }
      5. }

    2. 字符串的比较为什么要使用equals方法

      在这里插入图片描述

      1. public class StringText02 {
      2.     public static void main(String[] args) {
      3.         String s1 = "hello";
      4.         String s2 = "hello";
      5.  
      6.         //分析输出结果是true还是false    == 比较的是变量中保存的内存地址。
      7.         System.out.println(s1 == s2);   //true
      8.         //s1的"hello"是存储在方法区的常量池中，所以s2的"hello"不会新建。(因为这个对象已经存在了)
      9.         //s1和s2都存储的是字符串常量池中"hello"的内存地址。
      10.  
      11.         String x = new String("xyz");
      12.         String y = new String("xyz");
      13.         //分析输出结果是true还是false
      14.         System.out.println(x == y);//false
      15.         //x与y创建字符串对象是通过new出来的，在堆中开辟了两块内存空间，虽然堆中的String保存了字符串常量池中的"xyz"的内存地址
      16.         //但x与y这两个对象的内存地址不一样，是存储在堆中的两个String类型对象，而这两个对象的内存地址不同
      17.  
      18.         //通过本案例学习，我们知道了：字符串对象之间的比较不能使用“==”，“==”不保险，应该使用String类的equals方法
      19.         System.out.println(x.equals(y));//true
      20.         //String类已经重写了equals方法，以上的equals方法调用的是String重写之后的equals方法
      21.  
      22.         String k = new String("textString");
      23.         //因为"textString"是一个String字符串对象。只要是对象，都可以调用方法
      24.         System.out.println("textString".equals(k));//true   建议使用这种方式，因为这个可以避免空指针异常
      25.         System.out.println(k.equals("textString"));//true   如果k为空，就会出现空指针异常。不建议使用这种方式
      26.     }
      27. }

    3. String类的面试题一个

      1. //分析以下程序，一共创建了几个对象   3个
      2. public class StringText03 {
      3.     public static void main(String[] args) {
      4.         /*
      5.             一共三个对象：
      6.                 方法区字符串常量池中一个："hello"
      7.                 堆内存中：两个String类型对象
      8.                 一共三个
      9.          */
      10.         String s1 = new String("hello");
      11.         String s2 = new String("hello");
      12.     }
      13. }

    4. String类中的构造方法

      1. /**
      2.  * 关于String类中的构造方法
      3.  *  第一个：String s = new String("");
      4.  *  第二个：String s = "";    最常用
      5.  *  第三个：String s = new String(byte数组);
      6.  *  第四个：String s = new String(byte数组,起始下标，长度)
      7.  *  第五个：String s = new String(char数组);
      8.  *  第六个：String s = new String(char数组,起始下标,长度);
      9.  */
      10. public class StringText04 {
      11.     public static void main(String[] args) {
      12.         //创建字符串对象最常用的一种方法
      13.         String s1 = "hello world";
      14.  
      15.         //s1这个变量中保存的是一个内存地址，按说以下应该是输出一个内存地址，但却输出了一个字符串。说明String类已经重写了toString()方法
      16.         System.out.println(s1);     //hello world
      17.         System.out.println(s1.toString());      //hello world
      18.  
      19.         //这里只掌握常用的构造方法
      20.         byte[] bytes = {97,98,99}; //97是a ，98 是b，99是c
      21.         String s2 = new String(bytes);
      22.  
      23.         System.out.println(s2.toString());  //abc
      24.         System.out.println(s2); //abc
      25.         //之前说：说出一个引用的时候，会自动调用toString()方法，默认Object的话，会自动输出对象的内存地址
      26.         //通过输出结果我们得出一个结论：String类已经重写了toString方法。输出字符串对象的话，输出的是字符串本身，而不是对象的内存地址。
      27.  
      28.         /**
      29.          * 将byte数组中的一部分转换成字符串
      30.          * String(字节数组,从哪里开始：数组元素的下标，长度)
      31.          */
      32.         String s3 =new String(bytes,0,1);
      33.         System.out.println(s3);
      34.  
      35.         //将char数组全部转换成字符串
      36.         char[] chars = {'我','爱','R','M','币'};
      37.         String s4 = new String(chars);
      38.         System.out.println(s4);
      39.         //将char数组的一部分转换成字符串
      40.         String s5 = new String(chars,2,3);
      41.         System.out.println(s5);
      42.     }
      43. }

    5. String类中需要掌握的一些方法

      1. //String类当中的常用方法
      2. public class StringText05 {
      3.     public static void main(String[] args) {
      4.  
      5.         //1(掌握).char charAt(int index)    输出String对象下标为index的字符
      6.         char c = "人民币".charAt(1);   //“中国人”是一个字符串String对象，只要是对象就能“.”
      7.         System.out.println(c);  //民
      8.  
      9.         //2(了解).int compareTo(String anotherString)
      10.  
      11.         int result = "abc".compareTo("abc");
      12.         System.out.println(result); //0    前后一致 10 - 10 = 0
      13.  
      14.         int result2 = "abcd".compareTo("abce");
      15.         System.out.println(result2);//-1    前小后大    8 - 9 =-1
      16.  
      17.         int result3 = "abcecd".compareTo("abcdce");
      18.         System.out.println(result3);//1     前大后小    9 - 8 = 1
      19.  
      20.         //拿着字符串第一个字母和后面字符串比较。能分出大小就不再比较了。哪个字母的顺序靠后，哪个字母就大
      21.         //如果一个字符串有多个字符，返回值：靠后的字母的顺序-靠前的字母的顺序
      22.         System.out.println("xyz".compareTo("yxz")); //-1
      23.         System.out.println("a".compareTo("z"));//-25
      24.         System.out.println("z".compareTo("a"));//25
      25.         System.out.println("ac".compareTo("zd"));//-25
      26.  
      27.         //3(掌握).boolean contains(CharSequence s)
      28.         //判断前面的字符串中是否包含后面的字符串，包含：返回true 不包含：返回false
      29.         System.out.println("HelloWorld.java".contains(".java"));//true
      30.         System.out.println("http://www.baidu.com".contains("https:"));//false
      31.  
      32.         //4(掌握 ).boolean endsWith(String suffix)
      33.         //判断当前字符串是否以某个字符串结尾
      34.         System.out.println("test.txt".endsWith(".txt"));//true
      35.         System.out.println("test.txt".endsWith(".java"));//false
      36.         System.out.println("dafkhsdlgkjdfglksdfhaiotghjdfgdd".endsWith("gdd"));//true
      37.  
      38.         //5(掌握).boolean equals(Object anObject)
      39.         //比较两个字符串必须使用equals方法，不能使用“==”，那equals方法有没有调用compareTo方法呢？//新版本的JDK中没有调用
      40.         //compareTo方法可以看出是否相等，并且同时还可以看出谁大谁小。
      41.         System.out.println("abc".equals("abc"));
      42.  
      43.         //6(掌握).boolean equalsIgnoreCase(String anotherString)
      44.         //判断两个字符串是否相等，并且同时忽略大小写
      45.         System.out.println("ABc".equalsIgnoreCase("abC"));//true
      46.  
      47.         //7(掌握).byte[] getBytes()
      48.         //将字符串对象转换成字节数组
      49.         byte[] bytes = "abcdef".getBytes();
      50.         for (int i = 0; i 
      51.             System.out.println(bytes[i]);// 97 98 99 100 101 102
      52.         }
      53.  
      54.         //8(掌握).int indexOf(String str)
      55.         //判断某个子字符串在当前字符串中第一次出现的索引(下标)
      56.         System.out.println("oraclejavac++.netc#phppythonjavaoraclec++".indexOf("java"));//6
      57.  
      58.         //9(掌握).boolean isEmpty()
      59.         //判断某个字符串是否为空字符串。当且仅当length为0时为true
      60.         //String s = "";
      61.         String s = "a";
      62.         System.out.println(s.isEmpty());    //false
      63.  
      64.         //10(掌握). int length()
      65.         //面试题：判断数组长度和判断字符串长度不一样
      66.         //判断数组长度和判断字符串长度不一样，判断数组长度的是length属性，判断字符串长度的是length()方法。
      67.         System.out.println("abc".length());//3
      68.         System.out.println("".length());//0     长度为0 即：字符串为：空串
      69.  
      70.         //11(掌握). int lastIndexOf(String str)
      71.         //判断某个子字符串在当前字符串中最后一次出现的索引(下标)
      72.         System.out.println("oraclejavac++.netc#phppythonjavaoraclec++".lastIndexOf("java"));//28
      73.  
      74.         //12(掌握). String replace(CharSequence target , CharSequence replacement)     替换
      75.         //String的父接口是：CharSequence
      76.         String newString ="http://www.baidu.com".replace("http","https");
      77.         System.out.println(newString);      //https://www.baidu.com
      78.  
      79.         //把以下字符串中的“=”替换成“：”
      80.         String newString2 ="name=zhangsan&password=123&age=20".replace("=","：");
      81.         System.out.println(newString2);//name：zhangsan&password：123&age：20
      82.  
      83.         //13(掌握). String[] split(String regex)      拆分字符串,用一个数组接收
      84.         String[] ymd ="1980-08-10".split("-");
      85.         for (int i = 0; i 
      86.             System.out.println(ymd[i]);
      87.         }
      88.  
      89.         String param = "name：zhangsan&password：123&age：20";
      90.         String[] params =param.split("&");
      91.         for (int i = 0; i 
      92.             System.out.println(params[i]);
      93.             //可以继续向下拆分，可以通过“：”拆分
      94.         }
      95.  
      96.  
      97.         //14(掌握). boolean startWith(String prefix)
      98.         //判断某个字符串是否以某个子字符串开始。
      99.         System.out.println("http://www.baidu.com".startsWith("http"));//true
      100.         System.out.println("http://www.baidu.com".startsWith("https"));//false
      101.  
      102.         //15(掌握). String substring(int beginIndex)  参数是起始下标   截取字符串
      103.         System.out.println("http://www.baidu.com".substring(7));    //www.baidu.com
      104.  
      105.         //16(掌握).  String substring(int beginIndex,int endIndex)    截取部分字符串
      106.         //beginIndex 起始位置（包括）   endIndex 结束位置（不包括）
      107.         System.out.println("http://www.baidu.com".substring(7,10));     //www
      108.  
      109.         //17(掌握).  char[] toCharArray()
      110.         //将字符串转换成char数组
      111.         char[] chars = "我是中国人".toCharArray();
      112.         for (int i = 0; i 
      113.             System.out.println(chars[i]);
      114.         }
      115.  
      116.         //18(掌握). String toLowerCase();      全部转换成小写
      117.         System.out.println("ABCDefkXyz".toLowerCase());     //abcdefkxyz
      118.  
      119.         //19(掌握).  String toUpperCase();    全部转换成大写
      120.         System.out.println("ABCDefkXyz".toUpperCase());     //ABCDEFKXYZ
      121.  
      122.         //20(掌握).   String trim();      去除字符串前后空白    但字符串中间的空白不能去
      123.         System.out.println("    hello   world                       ".trim());//hello   world
      124.  
      125.         //21(掌握).   String中只有一个方法是静态的，不需要new对象    这个方法叫：valueOf     作用：将“非字符串”转换为“字符串”
      126.         String s1 = String.valueOf(true);
      127.         String s2 = String.valueOf(100);
      128.         String s3 = String.valueOf(3.14);
      129.         System.out.println(s1+s2+s3);//true1003.14
      130.  
      131.         //这个静态的valueOf()方法，参数是一个对象的时候，会自动调用该对象的toString方法吗?   会的
      132.         String s4 = String.valueOf(new Customer());
      133.         //System.out.println(s4);   //没有重写toString()方法之前是对象内存地址 Customer@1b6d3586
      134.         System.out.println(s4);     //重写之后:"我是一个VIP"
      135.  
      136.         //我们是不是可以研究一下println()方法的源码了
      137.         System.out.println(100);
      138.         System.out.println(3.14);
      139.         System.out.println(true);
      140.         //通过源代码就可以看出：为什么输出一个引用的时候，会调用toString()方法。
      141.         //使用System.out.println();输出引用时，调用了valueOf方法，而valueOf方法里又调用了引用的toString方法，所以输出引用时，与输出这个对象的toString方法相同
      142.         Object obj = new Object();
      143.         System.out.println(obj);
      144.  
      145.         //本质上System.out.println();这个方法在输出任何数据的时候都是先转换成字符串再输出。
      146.         System.out.println(new Customer());//我是一个VIP
      147.  
      148.  
      149.  
      150.     }
      151. }
      152.  
      153. class Customer{
      154.     @Override
      155.     public String toString() {
      156.         return "我是一个VIP";
      157.     }
      158. }

    6. 如果要进行字符串的频繁拼接

      StringBuffer 线程安全

      1. /*
      2.     思考：我们在实际开发中，如果需要进行字符串的频繁拼接，会有什么问题？
      3.         因为java中的字符串是不可变的，每一次拼接都会产生新字符串。这样会占用大量的方法区内存，造成内存空间的浪费。
      4.         String s = "abc";
      5.         s += "hello";
      6.         就以上两行代码，就导致在方法区字符串常量池当中创建了3个对象：
      7.             "abc"
      8.             "hello"
      9.             "abchello"
      10.  */
      11. public class StringBufferText01 {
      12.     public static void main(String[] args) {
      13.         String s = "";
      14.         //这样做会给java的方法区字符串常量池带来很大的压力
      15.         for (int i = 0; i <100 ; i++) {
      16.             s = s + i;
      17.             System.out.println(s);
      18.         }
      19.     }
      20. }
      21.  
      1. /*
      2.     如果以后需要进行大量字符串的拼接操作，建议使用JDK中自带的：
      3.         java.lang.StringBuffer
      4.         java.lang.StringBuilder
      6.     如何优化StringBuffer的性能？
      7.         在创建StringBuffer的时候尽可能给定一个初始化容量。最好减少底层数组的扩容次数，预估计一下，给一个大一些的初始化容量
      8.         关键点：给一个合适的初始化容量，可以提高程序的执行效率
      9.  */
      10.  
      11. public class StringBufferText02 {
      12.     public static void main(String[] args) {
      13.         //创建一个初始化容量为16的byte[]数组，(字符串缓冲区对象)
      14.         StringBuffer stringBuffer = new StringBuffer();
      15.  
      16.         //拼接字符串，以后拼接字符串统一调用append()方法。
      17.         //append是追加的意思。
      18.         stringBuffer.append("a");
      19.         stringBuffer.append("b");
      20.         stringBuffer.append("d");
      21.         stringBuffer.append(3.14);
      22.         stringBuffer.append(true);
      23.  
      24.         //append方法底层在进行追加的时候，如果byte数组满了，会自动扩容
      25.         stringBuffer.append(100L);
      26.  
      27.         System.out.println(stringBuffer);
      28.  
      29.         //执行初始化容量的StringBuffer对象（字符串缓冲区对象）
      30.         StringBuffer sb = new StringBuffer(25);
      31.         sb.append("hello");
      32.         sb.append("world");
      33.         sb.append("hello");
      34.         sb.append("kitty");
      35.  
      36.         System.out.println(sb);
      37.     }
      38.  
      39. }

      StringBuilder 非线程安全

      1. /*
      2.    java.lang.StringBuilder
      3.    StringBuffer和StringBuilder的区别：
      4.         StringBuffer中的方法都 有 ：synchronized关键字修饰。表示StringBuffer在多线程环境下运行是安全的
      6.         StringBuilder中的方法 没有 synchronized修饰，表示StringBuilder在多线程环境下运行是不安全的
      8.         StringBuffer是线程安全的
      9.         StringBuilder是非线程安全的
      10.  */
      11. public class StringBuilderText01 {
      12.     public static void main(String[] args) {
      13.         //使用StringBuilder也是可以完成字符串的拼接
      14.         StringBuilder sb = new StringBuilder();
      15.         sb.append(100);
      16.         sb.append(true);
      17.         sb.append("hello");
      18.         sb.append("kitty");
      19.         System.out.println(sb);//100truehellokitty
      20.     }
      21. }

      String为什么不可变,StringBuffer/StringBuilder为什么可变

      1. /*
      2.     1、面试题：String为什么是不可变的？
      3.         我看过源代码，String类中有一个byte[]数组，这个byte[]数组采用了final修饰，因为数组一旦创建长度不可变。并且被final修饰的引用
      4.         一旦指向某个对象之后，不可再指向其他对象，所以String是不可变的！
      5.             "abc"无法变成"abcd"
      7.     2、StringBuilder/StringBuffer为什么是可变的呢？
      8.         我看过源代码，StringBuffer/StringBuilder内部实际上是一个byte[]数组，这个byte[]数组没有被final修饰，StringBuffer/StringBuilder
      9.         的初始化容量我记得应该是16，当存满之后会进行扩容，底层调用了数组拷贝的方法System.arraycopy()    用来扩容。所以他们适合于使用字符串的频繁拼接操作
      11.  */
      12. public class StringBufferText03 {
      13.     public static void main(String[] args) {
      14.         //字符串不可变是什么意思？
      15.         //是说双引号里面的字符串对象一旦创建不可变
      16.         String s = "abc";   //“abc”放到了字符串常量池当中，“abc”不可变
      17.  
      18.         //s变量是可以指向其他对象的
      19.         //字符串不可变不是说以上变量s不可变。说的是“abc”这个对象不可变
      20.         s = "xyz";  //"xyz"放到了字符串常量池当中。“xyz”不可变
      21.     }
      22. }

    包装类

    1. java为8种基本数据类型又对应准备了8种包装类型。

      1. package integer;
      2. /*
      3.     1、java中为8种基本数据类型又对应准备了8种包装类型。8种包装类型属于引用数据类型，父类是Object
      4.     2、思考：为什么要再提供8种包装类呢？
      5.         因为8种基本数据类型不够用
      6.         所以SUN公司又提供对应的8种包装类型。
      7.  */
      8. public class IntegerText01 {
      9.     //入口
      10.     public static void main(String[] args) {
      11.         //有没有这种需求：调用doSome()方法的时候需要传一个参数进去。
      12.         //但是数字属于基本数据类型，而doSome()方法参数的类型是Object。
      13.         //可见doSome()方法无法接收基本数据类型的数字。那怎么办呢？可以传一个数字对应的包装类进去。
      14.  
      15.         //把100这个数字经过构造方法包装成对象。
      16.         MyInt mi = new MyInt(100);
      17.         //doSome()方法虽然不能直接传100，但是可以传一个100对应的包装类
      18.         doSome(mi);
      19.     }
      20.     public static void doSome(Object obj){
      21.         System.out.println(obj);
      22.     }
      23. }
      1. package integer;
      2. //这种包装类目前是我自己写的，实际开发中我们不需要自己再写。
      3. //八种基本数据类型对应的八种包装类，SUN公司已经写好了。为我们直接用
      4. public class MyInt {
      5.     int value;
      6.     public MyInt(){
      7.  
      8.     }
      9.     public MyInt(int value){
      10.         this.value = value;
      11.     }
      12.  
      13.     @Override
      14.     public String toString() {
      15.         return String.valueOf(value);
      16.     }
      17. }

    2. 八种包装类的名字

      1. package integer;
      2.  
      3. /*
      4.     1、八种基本数据类型对应的包装类型名是什么？
      5.     ------------------------------------------
      6.     byte                    java.lang.Byte（父类：Number）
      7.     short                   java.lang.Short（父类：Number）
      8.     int                     java.lang.Integer（父类：Number）
      9.     long                    java.lang.Long（父类：Number）
      10.     float                   java.lang.Float（父类：Number）
      11.     double                  java.lang.Double（父类：Number）
      12.     boolean                 java.lang.Boolean（父类：Object）
      13.     char                    java.lang.Character（父类：Object）
      15.     2、以上八种包装类，重点以java.lang.Integer为代表进行学习，其他的类型照葫芦画瓢就可以。
      17.     3、八种包装类中其中六个都是数字对应的包装类，他们的父类都是Number，可以先研究一下Number中的公共方法：
      18.         Number是一个抽象类 ，无法实例化对象。
      19.         Number类中有这样的方法：
      20.             byte byteValue()                以 byte 形式返回指定的数值
      21.             abstract double doubleValue()   以 double 形式返回指定数字的值
      22.             abstract float floatValue()     以 float 形式返回指定数字的值
      23.             abstract int intValue()         以 int 返回指定数字的值
      24.             abstract long longValue()       以 long 返回指定数字的值
      25.             short shortValue()              以 short 形式返回指定数字的值
      27.             这些方法其实所有的数字包装类的子类都有，这些方法是负责拆箱的。
      29.  */
      30. public class IntegerText02 {
      31.     public static void main(String[] args) {
      32.         //123这个基本数据类型，进行构造方法的包装达到了：基本数据类型向引用数据类型的转换
      33.         //基本数据类型---转换-->引用数据类型(装箱)
      34.         Integer i = new Integer(123);
      35.  
      36.         //将引用数据类型--转换-->基本数据类型(拆箱)
      37.         float f =  i.floatValue();//i对象调用floatValue方法返回float值后接收。
      38.         System.out.println(f);
      39.  
      40.         //将引用数据类型--转换-->基本数据类型(拆箱)
      41.         int retValue = i.intValue();
      42.         System.out.println(retValue);
      43.  
      44.     }
      45. }

    3. 包装类的构造方法

      1. package integer;
      2. /*
      3.     关于Integer类的构造方法有两个
      4.  */
      5. public class integerText03 {
      6.     public static void main(String[] args) {
      7.         //java9之后不建议使用这个构造方法了。出现横线表示已过时。
      8.         //将数字100转成Integer包装类型(int--->Integer)
      9.         Integer x = new Integer(100);
      10.         System.out.println(x.toString());
      11.  
      12.         //将String类型的数字，转成Integer包装类型(String--->Integer)
      13.         Integer y = new Integer("123");
      14.         System.out.println(y);
      15.  
      16.         //Double类的构造方法
      17.         //double--->Double
      18.         Double d = new Double(1.23);
      19.         System.out.println(d);
      20.  
      21.         //String -->Double
      22.         Double d2 = new Double("3.14");
      23.         System.out.println(d2);
      24.     }
      25. }

    4. 通过访问包装类的常量，来获取最大值和最小值

      1. package integer;
      2.  
      3. public class IntegerText04 {
      4.     public static void main(String[] args) {
      5.         //通过访问包装类的常量，来获取最大值和最小值
      6.         System.out.println("int的最大值："+Integer.MAX_VALUE);
      7.         System.out.println("int的最小值："+Integer.MIN_VALUE);
      8.         System.out.println("byte的最大值："+Byte.MAX_VALUE);
      9.         System.out.println("byte的最小值："+Byte.MIN_VALUE);
      10.     }
      11. }

    5. 自动装箱，自动拆箱

      1. package integer;
      2. //在JDK1.5之后，支持自动拆箱和自动装箱了。
      3. public class IntegerText05 {
      4.     public static void main(String[] args) {
      5.         //900是基本数据类型   x是包装类型
      6.         //基本数据类型--自动转换-->包装类型      自动装箱
      7.         Integer x = 900;
      8.         System.out.println(x);
      9.  
      10.         //x是包装类型    y是基本数据类型
      11.         //包装类型--自动转换-->基本数据类型     自动拆箱
      12.         int y = x;
      13.         System.out.println(y);
      14.  
      15.         //z是一个引用，是一个变量，z还是保存了一个对象的内存地址。
      16.         Integer z = 1000;    //等同于：Integer z = new Integer(1000);
      17.         System.out.println(z+1);    
      18.         //分析为什么这个没有报错呢？
      19.         //+两边要求是基本数据类型的数字，z是包装类，不属于基本数据类型，这里会进行自动拆箱，将z转换成基本数据类型
      20.         //在java5之前这样写，编译器报错。
      21.  
      22.         Integer a = 1000;   //Integer a = new Integer(1000);a是个引用，保存内存地址指向对象
      23.         Integer b = 1000;   //Integer b = new Integer(1000);b是个引用，保存内存地址指向对象
      24.         //==比较的是对象的内存地址，a和b两个引用中保存的对象地址不同。
      25.         // == 这个运算符不会触发自动拆箱机制(只有 + - * / = 运算的时候才会)
      26.         System.out.println(a == b);//false
      27.     }
      28. }
      29.

    6. Integer类的相关面试题

      在这里插入图片描述

      1. package integer;
      2.  
      3. //这个是Integer非常重要的面试题。
      4. public class IntegerText06 {
      5.     public static void main(String[] args) {
      6.         Integer a = 128;
      7.         Integer b = 128;
      8.         System.out.println(a == b);//false
      9.  
      10.         /*
      11.             java中为了提高程序的执行效率，将[-128——127]之间的所有的包装对象提前创建好，放到了一个方法区的“整数型常量池”当中了，
      12.             目的是只要用这个区间的数据就不需要再new了，直接从整数型常量池中取出来。
      14.             原理：x变量中保存的对象的内存地址和y中保存的内存地址是一样的
      15.          */
      16.  
      17.         Integer x = 127;
      18.         Integer y = 127;
      19.         //==永远判断两个兑现的内存地址是否相同
      20.         System.out.println(x == y);//true
      21.  
      22.     }
      23. }
      24.

    7. Integer类当中常用的方法

      1. package integer;
      2. /*
      3.     总结一下之前所学的经典异常：
      4.         空指针异常：NullPointerException
      5.         类型转换异常：ClassCastException
      6.         数组下标越界异常：ArrayIndexOutOfBoundsException
      7.         数字格式化异常：NumberFormatException
      9.     Integer类当中有哪些常用的方法呢？
      10.  */
      11.  
      12. public class IntegerText07{
      13.     public static void main(String[] args) {
      14.         //intValue()
      15.         //手动装箱
      16.         Integer x = new Integer(100);
      17.         //手动拆箱
      18.         int y = x.intValue();
      19.         System.out.println(y);
      20.  
      21.         Integer a = new Integer("123");
      22.         //编译的时候没问题，一切符合java语法，运行时会不会出问题呢?
      23.         //不是一个数字可以包装成Integer吗?不能 ，运行时出现异常。""里面只能是数字
      24.         //Integer b =  new Integer("中文");
      25.         System.out.println(a);
      26.  
      27.  
      28.         //重点方法      static int parseInt(Strings s)  静态方法，传参String 返回int
      29.         //网页上文本框中输入100实际上是"100"字符串。后台数据库中要求存储数字类型的100，此时java程序要将"100"转换成100数字
      30.         int retValue = Integer.parseInt("112");//String --转换--> int
      31.         System.out.println(retValue+138);//250
      32.  
      33.         //照葫芦画瓢
      34.         double retValue2 = Double.parseDouble("3.14");
      35.         System.out.println(retValue2+1);//4.140000000000001
      36.  
      37.         float retValue3 = Float.parseFloat("1.0");
      38.         System.out.println(retValue3+1);//2.0
      39.  
      40.         //----------------以下内容作为了解，不需要掌握-----------------------------
      41.         //static String toBinaryString(int i)   静态的：将十进制抓换成二进制
      42.         String binaryString = Integer.toBinaryString(3);
      43.         System.out.println(binaryString);//"11" 二进制的字符串
      44.  
      45.         //static String toHexString(int i)      静态的：将十进制转换成十六进制的字符串。
      46.  
      47.         String hexString = Integer.toHexString(16);     //10
      48.         System.out.println(hexString);
      49.         System.out.println(Integer.toHexString(17));    //11
      50.  
      51.         //static String toOctalString(int i)    静态的：将十进制转换成八进制的字符串
      52.         System.out.println(Integer.toOctalString(16));  //20
      53.  
      54.         System.out.println(new Object());//java.lang.Object@1b6d3586
      55.  
      56.         //valueOf方法作为了解
      57.         // static Integer valueOf(int i)   静态的：int--->Integer
      58.         Integer i1 = Integer.valueOf(666);
      59.         System.out.println(i1);
      60.         // static Integer valueOf(String s)   静态的：String--->Integer
      61.         Integer i2 = Integer.valueOf("999");
      62.         System.out.println(i2);
      63.  
      64.     }
      65. }

    8. String、int、Integer之间的互相转换

      在这里插入图片描述

      1. package integer;
      2. //String int Integer之间互相转换
      3.  
      4. public class IntegerText08 {
      5.     public static void main(String[] args) {
      6.         //String ---> int
      7.         int i1 = Integer.parseInt("100");
      8.         System.out.println(i1 +1);//101
      9.  
      10.         //int ----> String
      11.         String s2 = i1 +"";
      12.         System.out.println(s2+1);//1001
      13.  
      14.         //int ---> Integer
      15.         Integer x = 1000;   //自动装箱
      16.  
      17.         //Integer ----->  int
      18.         int y = x;      //自动拆箱
      19.  
      20.         //String  ----> Integer
      21.         Integer k = Integer.valueOf("123");
      22.  
      23.         //Integer ----> String
      24.         String e = String.valueOf(k);
      25.     }
      26. }
      27.

    日期类Date

    1. 获取系统当前时间，以及对日期的格式化

      1. package date;
      2.  
      3. import java.text.SimpleDateFormat;
      4. import java.util.Date;
      5. /*
      6.     java中对日期的处理
      7.         主要掌握：1、怎么获取系统当前时间
      8.                  2、String ---->  Date
      9.                  3、Date  ----->  String
      10.  */
      11.  
      12. //java中对日期的处理
      13. public class DateText01 {
      14.     public static void main(String[] args) throws Exception{
      15.         //获取当前时间(精确到毫秒的系统当前时间)
      16.         //直接调用无参数构造方法
      17.         Date nowTime = new Date();
      18.  
      19.         //java.util.Date类的toString()方法已经被重写了。
      20.         //输出的应该不是一个对象的内存地址，应该是一个日期字符串。
      21.         System.out.println(nowTime);    //Sat Jan 16 17:55:05 CST 2021  星期六 一月16   17:55:05 国际标准时间 2021年
      22.  
      23.         //日期可以格式化吗
      24.         //将日期类型Date ，按照指定的格式进行转换：Date --->转换成具有一定格式的字符串-->String
      25.         //SimpleDateFormat 是java.text包下的，专门负责日期格式化的。
      26.         /*
      27.             yyyy    年   年是4位
      28.             MM      月   月是2位
      29.             dd      日   日是2位
      30.             HH      时      2位
      31.             mm      分      2位
      32.             ss      秒      2位
      33.             SSS     毫秒    3位(最高999，1000毫秒代表一秒)
      35.             注意：在日期格式中，除了y M d H m s S 这些字符不能随便写之外，剩下的符号格式自己随意组织
      36.          */
      37.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
      38. //        SimpleDateFormat sdf2 = new SimpleDateFormat("dd/MM/yyyy");
      39. //        SimpleDateFormat sdf3 = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
      40.         String nowTimeStr = sdf.format(nowTime);
      41.         System.out.println(nowTimeStr);
      42.  
      43.         //假设现在有一个日期字符串String 怎么转换为Date类型？
      44.         //String ------>    Date
      45.         String time = "2008-08-08 08:08:08 888";
      46. //        SimpleDateFormat sdf2 = new SimpleDateFormat("格式不能随便写，要和日期字符串格式相同");
      47.         //注意：字符串的日期格式和SimpleDateFormat对象指定的日期格式要一致，不然会出现：java.text.ParseException异常
      48.         SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
      49.         Date dateTime = sdf2.parse(time);
      50.         System.out.println(dateTime);   //Fri Aug 08 08:08:08 CST 2008
      51.  
      52.     }
      53. }

    2. 获取自1970年1月1日 00:00:00 000 到当前系统时间的总毫秒数，以及统计一个方法执行所耗时长

      1. package date;
      2. /*获取自1970年1月1日 00:00:00 000 到当前系统时间的总毫秒数。   1秒 = 1000 毫秒
      3.     简单统计一下System类的相关属性和方法：
      4.         System.out  【out是System类的静态变量】
      5.         System.out.println()    【println()方法不是System类的，是printStream类的方法】
      6.         System.gc() 建议启动垃圾回收器
      7.         System.currentTimeMillis()  获取自1970年1月1日到系统当前时间的总毫秒数
      8.         System.exit(0)  退出JVM
      9.  */
      10. public class DaTeText02 {
      11.     public static void main(String[] args) {
      12.         long nowTimeMillis = System.currentTimeMillis();
      13.         System.out.println(nowTimeMillis);//1610863950844
      14.  
      15.         //统计一个方法耗时
      16.         //在调用目标方法之前记录一个毫秒数
      17.         long begin = System.currentTimeMillis();
      18.         print();
      19.         //在执行完目标方法之后记录一个毫秒数
      20.         long end = System.currentTimeMillis();
      21.         System.out.println("耗费时长："+(end-begin)+"毫秒");
      22.     }
      23.  
      24.     //需求：统计一个方法执行所耗费的时长
      25.     public static void print(){
      26.         for(int i = 0 ; i<100000 ;i++){
      27.             System.out.println("i ="+i);
      28.         }
      29.     }
      30. }

    3. Date的参数

      1. package date;
      2.  
      3. import java.text.SimpleDateFormat;
      4. import java.util.Date;
      5.  
      6. public class DateText03  {
      7.     public static void main(String[] args) {
      8.         //这个时间是什么时间？
      9.         //1970-01-01 00:00:00 001
      10.         Date time = new Date(1);//注意：参数是一个毫秒
      11.  
      12.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
      13.         //北京是东8区，差八个小时。
      14.         System.out.println(sdf.format(time));//1970-01-01 08:00:00 001
      15.  
      16.         //获取昨天的此时的时间
      17.         Date time2 = new Date(System.currentTimeMillis() - 1000*60*60*24);
      18.         System.out.println(sdf.format(time2));//2021-01-16 16:32:14 315
      19.  
      20.         //获取去年的今天的时间
      21.         Date time3 = new Date(System.currentTimeMillis() - 1000*60*60*24*365);
      22.         System.out.println(sdf.format(time3));
      23.     }
      24. }

    数字类

    1. 格式化数字

      1. package number;
      2.  
      3. import java.text.DecimalFormat;
      4.  
      5. public class DecimalFormatText01 {
      6.     public static void main(String[] args) {
      7.         //java.text.DecimalFormat专门负责格式化的
      8.         //Decimal df = new DecimalFormat("数字格式")
      9.  
      10.         /*
      11.             数字格式有哪些
      12.                 # 代表任意数字
      13.                 , 代表千分位
      14.                 . 代表小数点
      15.                 0 代表不够时补0
      16.                 ###,###.##
      17.                     表示：加入千分位，保留两位小数
      18.          */
      19.         DecimalFormat df = new DecimalFormat("###,###.##");
      20.         System.out.println(df.format(1234.4));//1,234.4
      21.         System.out.println(df.format(6542.468));//6,542.47
      22.         System.out.println(df.format(546542.468));//546,542.47
      23.         System.out.println(df.format(52343446542.468));//52,343,446,542.47
      24.  
      25.         DecimalFormat df2 = new DecimalFormat("###,###.0000");//保留4个小数位，不够补上0
      26.         System.out.println(df2.format(8766.9));//8,766.9000
      27.         System.out.println(df2.format(8766.93436));//8,766.9344
      28.     }
      29. }
      30.

    2. 专门用来处理财务数据的：BigDecimal

      1. package number;
      2.  
      3. import java.math.BigDecimal;
      4.  
      5. /*
      6.     1、BigDecimal 属于大数据，精度极高。不属于基本数据类型，属于java对象(引用数据类型)
      7.         这是SUN提供的一个类，专门用在财务软件当中
      9.     2、注意：财务软件中，double是不够的。处理财务数据，用哪一种数据类型？
      10.         千万别说double，说java.math.BigDecimal
      11.  */
      12. public class BigDecimalText01 {
      13.     public static void main(String[] args) {
      14.         //这个100不是普通的100，是精度极高的100
      15.         BigDecimal bg = new BigDecimal(100);
      16.         //精度极高的200
      17.         BigDecimal bg2 = new BigDecimal(200);
      18.         //求和
      19.         //bg + bg2  这样不行，bg和bg2都是引用，不能直接使用+求和
      20.         BigDecimal bg3 = bg.add(bg2);//使用方法求和
      21.         System.out.println(bg3);//300
      22.  
      23.         System.out.println(bg2.divide(bg));//2
      24.     }
      25. }
      26.

    随机数

    1. 如何生成随机数

      1. package random;
      2.  
      3. import java.util.Random;
      4.  
      5. //随机数
      6. public class RandomText01 {
      7.     public static void main(String[] args) {
      8.         //创建随机数对象
      9.         Random random = new Random();
      10.         //随机产生一个int类型取值范围内的数字
      11.         int num1 = random.nextInt();
      12.         System.out.println(num1);
      13.  
      14.         //产生[0~100]之间的随机数，不能产生101
      15.         //nexInt翻译为：下一个int类型的数据是101，表示只能取到100
      16.         int num2 = random.nextInt(101);//不包括101
      17.         System.out.println(num2);
      18.     }
      19. }
      20.

    2. 生成5个不重复的随机数[0~100]，如果重复，则重新生成，然后放到数组当中，要求这5个随机数不能重复

      1. package random;
      2.  
      3. import java.util.Arrays;
      4. import java.util.Random;
      5.  
      6. /*
      7.     编写程序，生成5个不重复的随机数[0~100]，重复的话重新生成。 最终生成的5个随机数放到数组当中，要求数组中这5个随机数不重复
      8.  */
      9. public class RandomText02 {
      10.     public static void main(String[] args) {
      11.         //创建随机数对象
      12.         Random random = new Random();
      13.         //定义一个长度为5的一维数组
      14.         int[] arr = new int[5];
      15.         //给数组中每个元素的默认值为-1。
      16.         for (int i = 0; i 
      17.             arr[i] = -1;
      18.         }
      19.  
      20.         //定义一个变量用来模拟数组下标
      21.         int index = arr.length-1;
      22.         //因为还要判断是不是有重复的数字，用for循环次数比较固定，所以用while循环，里面再加判断
      23.         //在排序出现bug之后，采用倒序赋值。index为数组元素下标，从最后一个开始赋，下标为：数组长度-1
      24.         while( index >= 0){//下标<数组长度，为每一个元素赋值，如生成的数字与已经放入的重复，则赋值失败，再次循环，直到数组中每个元素都不相同
      25.             //生成随机数
      26.             int num = random.nextInt(101);//    [0-100]范围有点大。
      27. //            int num = random.nextInt(6);//  只能生成[0-5]的随机数
      28. //            int num = random.nextInt(4);//  只能生成[0-3]的随机数 //当数组长度大于可生成的随机数范围(不能重复)时，会进入死循环
      29.             System.out.println("生成的随机数："+num);
      30.  
      31.             //判断arr数组中有没有这个num，如果没有的话，再放进去，如果有，则不执行赋值操作以及数组下标+1//
      32.             //从后面开始赋，修改为数组下标-1。
      33.             //if(数组中不包含这个num){赋值，赋值后index要加1，再次循环时为下一个数组元素放入数}//赋值后-1
      34.             if(!contains(arr,num)){//contains方法返回一个布尔值，为true时包含，如果包含，则不执行。所以取非运算
      35. //                arr[index] = num;
      36. //                index++;
      37.                 //合并：赋值后，index+1，然后进行下一次循环。属于赋值后才+1，++运算符可以写在后面//修改为-1.
      38.                 arr[index--] = num;
      39.             }
      40.         }
      41.         for (int i = 0; i 
      42.             System.out.println(arr[i]);
      43.         }
      44.     }
      45.  
      46.     /**
      47.      *  单独编写一个方法，这个方法专门用来判断数组中是否包含某个元素
      48.      * @param arr   数组
      49.      * @param key   元素
      50.      * @return      true表示包含，false表示不包含
      51.      */
      52.     public static boolean contains(int[] arr,int key){
      53.         /*
      54.         //先对数组进行排序
      55.         Arrays.sort(arr);
      56.         //使用二分法进行查找     二分法查找的结果 >=0说明：这个元素找到了，找到了表示存在！
      57.         return Arrays.binarySearch(arr,key) >= 0;
      59.         这个写法有bug：每当一个值进去，就会重新排一次顺序，如：arr[0]经过循环赋上值后，经过排序：这个值就排在了最后一位，
      60.         然后为第二个元素赋值，第二个赋上值之后也排在了后面。然后为第三个赋值，为第四个第五个赋值时，这里已经是赋值了的三个元素中的两个。
      61.         所以第一个第二个元素永远赋不上值，永远都是-1.
      62.          */
      63.         Arrays.sort(arr);
      64.         return Arrays.binarySearch(arr,key) >= 0;
      65.  
      66.         //如果从数组下标为0开始放入数据，则使用以下方法判断是否包含，以避免重复
      67.         /*或者使用for循环判断是否包含。
      68.         for (int i = 0; i 
      69.             if(arr[i] == key){
      70.                 return true;//判断是否有相同，如相同，则发生包含。
      71.             }
      72.             //反之，不包含
      73.             return false;
      74.         }
      76.          */
      77.     }
      78. }
      79.

    枚举

    1. 枚举的引出

      1. package enum0;  //标识符，关键字不能做标识符，enum是关键字
      2.  
      3. /*
      4.     分析以下程序，在设计方面有什么缺陷？
      5.         以下代码可以编译，也可以运行。只是设计上有些缺陷
      6.  */
      7. public class EnumText01 {
      8.     public static void main(String[] args) {
      9.         //System.out.println(10/0);   //java.lang.ArithmeticException: / by zero      被0除,除数为0了
      10. /*        int retValue = divide(10,2);
      11.         System.out.println(retValue);//1
      13.         int retValue2 = divide(10,0);
      14.         System.out.println(retValue2);//0*/
      15.  
      16.         boolean success = divide(10,2);
      17.         System.out.println(success?"计算成功":"计算失败");
      18.  
      19.         boolean success2 = divide(10,0);
      20.         System.out.println(success2?"计算成功":"计算失败");
      21.     }
      22.  
      23.     /**
      24.      *  需求(这是设计者说的)：以下程序，计算两个int类型数据的商，计算成功返回1 ，计算失败返回0！
      25.      * @param a     int类型的数据
      26.      * @param b     int类型的数据
      27.      */
      28. /*    public static int divide(int a ,int b){
      29.         try {
      30.             int c = a / b;
      31.             //程序执行到这里表示以上代码没有发生异常。表示执行成功。
      32.             return 1;
      33.         } catch(Exception e) {
      34.             //程序执行到这里表示以上程序出现了异常，表示执行失败
      35.             return 0 ;
      36.         }
      37.     }*/
      38.  
      39.     //设计缺陷：在这个方法的返回值上，返回一个int不恰当。
      40.     // 既然最后的结果只是成功和失败，最好使用布尔类型。因为布尔类型true和false正好可以表示两种不同的状态
      41. /*        public static int divide(int a ,int b){
      42.         try {
      43.             int c = a / b;
      44.             //有可能这里一个失误，返回了10，已经偏离了需求，但是编译器没有检查出来。我们一直想追求的是：所有的错误尽可能让编译器找出来，所有的错误越早发现越好
      46.             return 1;
      47.         } catch(Exception e) {
      48.             //程序执行到这里表示以上程序出现了异常，表示执行失败
      49.             return 0 ;
      50.         }
      51.     }*/
      52.  
      53.     //这种设计就很不错
      54.     public static boolean divide(int a ,int b){
      55.         try {
      56.             int c = a / b;
      57.             return true;
      58.         } catch (Exception e){
      59.             return false;
      60.         }
      61.     }
      62.  
      63.     /*
      64.         思考：以上这个方法的设计很好，返回true和false两种情况，但是在以后的开发中，有可能遇到一个方法的执行结果可能包括三种情况，四种情况
      65.         五种情况不等。但是每一个都是可以数清楚的，一枚一枚都是可以列举出来的。这时布尔类型就无法满足需求了，此时需要使用java语言中的枚举类型
      66.      */
      67.  
      68. }
      69.

    2. 枚举的使用

      1. package enum0;
      2. //采用枚举的方式改造程序
      3. /*
      4.     总结：
      5.         1、枚举是一种引用类型数据
      7.         2、枚举类型怎么定义，语法是？
      8.             enum 枚举类型名{
      9.                 枚举值1，枚举值2......
      10.             }
      12.         3、结果只有两种情况的，建议使用布尔类型。结果超出两种并且还是可以一枚一枚列举出来的，建议使用枚举类型。
      13.             例如：颜色、四季、星期等都可以使用枚举类型。
      14.  */
      15. public class EnumText02 {
      16.     public static void main(String[] args) {
      17.  
      18.        Result r = divide(10,2);
      19.         System.out.println(r == Result.SUCCESS ? "计算成功":"计算失败");
      20.     }
      21.  
      22.     /**
      23.      * 计算两个int类型数据的商
      24.      * @param a int类型的数据
      25.       * @param b int类型的数据
      26.      * @return  Result.SUCCESS 表示成功 Result.FAIL表示失败！
      27.      */
      28.     public static Result divide(int a,int b){
      29.         try{
      30.             int c = a / b;
      31.             return Result.SUCCESS;
      32.         }catch (Exception e){
      33.             return Result.FAIL;
      34.         }
      35.     }
      36.  
      37. }
      38.  
      39. //枚举：一枚一枚可以列举出来的，才建议使用枚举类型
      40. //枚举编译之后也是生成class文件，枚举也是一种引用数据类型。枚举中的每一个值可以看作是常量
      41. enum Result{
      42.     //SUCCESS 是枚举Result类型中的一个值
      43.     //FAIL  是枚举Result类型中的一个值
      44.  
      45.     //枚举中的每一个值，可以看作是“常量”
      46.     SUCCESS,FAIL
      47. }
      48.

      四季枚举类型

      1. package enum0;
      2. //四季枚举类型
      3. public enum Season {
      4.     //春夏秋冬
      5.     SPRING,SUMMER,AUTUMN,WINTER
      6. }

      颜色枚举类型

      1. package enum0;
      2. //颜色枚举类型
      3. public enum Color {
      4.     //春夏秋冬
      5.     RED,GREEN,GOLD,GREEY,WRITE,BLACK
      6. }

    3. switch语句支持枚举类型

      1. package enum0;
      2.  
      3. import static enum0.Season.SPRING;
      4.  
      5. public class SwitchText {
      6.     public static void main(String[] args) {
      7.         //switch语句支持枚举类型
      8.         //switch也支持String、int。
      9.         //低版本的JDK，只支持int    高版本的JDK，支持int、String、枚举
      10.         //byte、short、char也可以，因为存在自动类型转换。
      11.         switch (Season.WINTER){
      12.             case SPRING:
      13.                 System.out.println("春天");
      14.                 break;
      15.             case SUMMER:
      16.                 System.out.println("夏天");
      17.                 break;
      18.             case AUTUMN:
      19.                 System.out.println("秋天");
      20.                 break;
      21.             case WINTER:
      22.                 System.out.println("冬天");
      23.                 break;
      24.         }
      25.  
      26.     }
      27.  
      28. }

  • 相关阅读:
    Windows 7 联合 eNSP模拟器 配置Snmp
    表单判断0也生效相关方法
    计算机毕业设计(75)php小程序毕设作品之网上销售小程序商城系统
    使用docker创建和运行跨平台的容器化的mssql数据库
    YoloV5训练V3Det数据集实战
    如何实现通达信接口开发？
    全局事件总线概述
    基于FPGA的数字时钟系统设计
    upp(企业统一流程平台)阶段性汇报20220909
    day11_api_Object类_String类
  • 原文地址：https://blog.csdn.net/m0_69066786/article/details/127991843