包装类（wrapper）

八大基本数据类型的封装类：

boolean—>Boolean
char—>Character
byte–>Byte
int–>Integer
long–>Long
float–>Float
double–>Double
short–>Short

装箱和拆箱:

jdk5以前的都是手动装箱和拆箱。jdk5以后是自动装箱和拆箱。

自动装箱底层调用的是valueOf方法。比如，Integer.valueof(),其他包装类的用法类似。

Integer包装类：

public class Wrapper01 {
    
    
   public static void main(String[] args) {
    
    
      Integer integer = new Integer(1);//通过new出来的都是新的对象。
      Integer integer1 = new Integer(1);
      System.out.println(integer==integer1);//false
      Integer i=1;//自动调用valueOf方法。
      Integer j=1;//自动调用valueOf方法。
      System.out.println(i==j);//true
      Integer i1=128;
      Integer j2=128;
      System.out.println(i1==j2);//false
   }
}

//valueOf方法。
//This method will always cache values in the range -128 to 127,
public static Integer valueOf(int i) {
    
    
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

通过底层代码可知，在通过valueOf方法创建对象时，如果数值在-128-127之间，便返回IntegerCache.cache中已经存在的对象引用；否则创建一个新的对象。

Integer i2=127;
      int j3=127;
      System.out.println(i2==j3);//true.

只要有基本数据类型，则判断的是数值是否相等。

String

String对用于保存字符串，也就是一组字符序列。

String类有很多构造器，例如：

String s=new String(String original);
String s1=new String(char[] a);
String s2=new String(char[] a,int starIndex,int count);
String s3=new String(byte[] b);

String实现了接口Serializable,可以在网络传输。
String是final类，不能被其他类继承。
String有属性private final char value[] ，用于存放字符串内容。
value是一个final类型，不可以修改，即: 地址是不能修改的，但是单个字符内容是可以变化的。

两种创建String的区别：

方式一：String n1=“zhang”;

方式二：String n2=new String(“zhang”)；

第一种方式先从常量池中看是否有"zhang"的数据空间，如果有直接指向，如果没有则要创建然后指向。n1最终指向的是常量池的地址。

第二种方式先在堆中创建空间，指向常量池的的zhang空间，如果常量池没有，则重新创建，如果有直接通过value指向，最终指向的是堆中的空间。

在这里插入图片描述

例题：

      String n3="zhang";//指向常量池。
      String n4 = new String("zhang");//指向堆中对象。
      System.out.println(n3.equals(n4));//true.
      System.out.println(n3==n4);//false。
      System.out.println(n3==n4.intern());//true

注意：b4.intern()方法最终返回的是常量池的地址。

面试题：

String是一个final类，代表不可变的字符序列。

String n1="hello";
n1="hi";
//先后在常量池中创建了"hello"对象和"hi"对象，最终n1指向的是"hi"对象。

String a="hello";
String b="abc";
//先创建一个StringBulider sb=new StringBuilder();
//执行 sb.append("hello"),在执行sb.append("abc")。
//String c=sb.toString(查看底层发现其实toString方法是new了一个新的对象。)
//最后c指向堆中的对象，对象中的value指向常量池中的"helloabc".
String c=a+b;

注意：String c=a+b;

String c=“hello”+“abc”;

两者区别: 前者是变量相加,看的是堆，后者是常量相加，看的是池。

public class StringExercise02 {
    
    
   public static void main(String[] args) {
    
    
      Test ex = new Test();
      ex.change(ex.str,ex.ch);//调方法会产生一个新栈，当方法调用完毕就被销毁了。
      System.out.print(ex.str+" and"+"\t");
      System.out.print(ex.ch);
   }
}
class Test{
    
    
   String str=new String("hsp");
   final char[] ch={
    
    'j','a','v','a'};
   public void change(String str,char[] ch){
    
    
      str="java";
      ch[0]='h';
   }
}
//hsp and hava

内存分布图如下:

在这里插入图片描述

String类的常用方法：

     String s=new String("zhangz");
     System.out.println(s.equalsIgnoreCase("ZHANG"));//大小写。false;
     System.out.println(s.charAt(1));//获取某索引处的字符。h
     System.out.println(s.indexOf("z"));//获取字符在字符串中第一次出现的索引位置。0
     System.out.println(s.lastIndexOf("z"));//获取字符在字符串中最后出现的索引位置。5
     System.out.println(s.substring(1));//截取索引后面的字符：hangz
     System.out.println(s.substring(0,4));//从第0个开始截，截到第三个。zhan
     



    
     String s="zhang";
     System.out.println(s.toUpperCase());//转化成大写。ZHANG
     System.out.println(s.toLowerCase());//转化成小写。zhang
     System.out.println(s.concat("jian").concat("handsome").concat("great"));
//字符串拼接。zhangjianhandsomegreat
     System.out.println(s.replace("zhang","jian"));//替代。jian
     System.out.println("===================");
     String poem="锄禾日当午，汗滴禾下土，谁之盘中餐，粒粒皆辛苦";
     String[] split = poem.split("，");//分割字符串。以","为标准分割。
     for (String s1 : split) {
    
    
        System.out.println(s1+"\t");
     }
     String n="\\aaa\\bbb\\ccc\\ddd";
     String[] split1 = n.split("\\\\");//在对字符串进行分割时，如果有特殊字符，需要加入转义字符"\"
     for (String s1 : split1) {
    
     
        System.out.println(s1);
     }\\aaa
       \\bbb
       \\ccc
       \\ddd
     String s1="zhang";
     char[] chars = s1.toCharArray();//转化成字符数组。
     for (char aChar : chars) {
    
    
        System.out.println(aChar);
     }
     String n1="zhnge";
     String n2="zhang";
     System.out.println(n1.compareTo(n2));//比较两个字符串的大小，如果长度相同，并且每个字符串都相同，就返回零；如果长度不相同或者相同，在进行比较时，当出现第一个不相同的字符时，ASCII值相减即为结果;如果前面的部分相同，就返回n1.length-n2.length

String name="张瑊";
    int age=21;
    double score=99.0;
    char gender='男';
    String format = String.format("我的名字是：%s ,年龄是：%d ,得分是：%.2f ,性别是：%c",           name, age, score, gender);
    //%s,%d,%.2f，%c,这些都称之为占位符，由后面的变量替代，%s表示后面由字符串替代，%d是整数替代，%.2f表示使用小数替代，保留两位小数，并且进行四舍五入。%c使用char类型替代。
    System.out.println(format);

StringBuffer类

StringBuffer的直接父类是AbstractStringBuilder。

StringBuffer实现了Serializable,即对象可以串行化。

在父类中AbstractStringBuilder有属性char[] value,不是final,该value存放的字符串内容存放在栈中。

StringBuffer是一个final类，不能被继承。

例题：

//小数点的前面每三位用逗号隔开。
public static void main(String[] args) {
    
    
        String s = "121343455.44";
        StringBuffer stringBuffer = new StringBuffer(s);
        for (int i1 = stringBuffer.lastIndexOf(".") - 3; i1 > 0; i1 -= 3) {
    
    
            stringBuffer.insert(i1, ",");
        }
        System.out.println(stringBuffer);
    }

String和StringBuffer对比：

String保存的是字符串常量，里面的值不能修改，每次String的更新实际上就是更该地址，效率比较低。

//private final char[] value 指向常量池。

StringBuffer保存的是字符串变量，里面的值可以修改，每次StringBuffer的更新是内容更新，不用更改地址，效率较高。

//char[] value 指向堆。

String和StringBuffer转换：

 //String转StringBuffer
      String s="zhang";
      //1.使用构造器。
      StringBuffer stringBuffer = new StringBuffer(s);
      //2.使用append方法。
      StringBuffer stringBuffer1 = new StringBuffer().append(s);
 //StringBuffer转String。
      StringBuffer stringBuffer2 = new StringBuffer("张瑊不帅");
      //1.使用toString方法创建。
      String string = stringBuffer2.toString();
      //2.使用构造器。
      String s1 = new String(stringBuffer2);

StringBuffer的常用方法：

 StringBuffer stringBuffer = new StringBuffer("张瑊");
      //添加。
      stringBuffer.append(",");
      stringBuffer.append("超级帅。");
      stringBuffer.append("没错。");
      System.out.println(stringBuffer);
      //删除。删除[0,2)之间的字符。
     stringBuffer.delete(0,2);
      System.out.println(stringBuffer)；
      //替换。[0,2)
      stringBuffer.replace(0,2,"陈冠希");
      System.out.println(stringBuffer);
      //查找指定的字串第一次在字符串中出现的索引。如果找不到,就返回-1；
      System.out.println(stringBuffer.indexOf("冠希"));
      //指定位置插入
      System.out.println(stringBuffer.insert(0, "吴彦祖，"));
      //返回长度。
      System.out.println(stringBuffer.length());

   }

StringBuilder类

StringBulider继承了AbstractStringBuilder类。
实现了Serializable,说明StringBulider对象可以串行化。
StringBuilder是final类，不能被继承。
StringBulider对象字符序列仍然是保存在父类的char[] value 中。
StringBulider因为没有synchronized关键字，因此在单线程的情况下使用。

StringBuffer,StringBuilder和String的比较：

StringBuffer和StringBuilder均为可变字符序列，而且方法也一样。
String:不可变字符序列，效率低，但是复用率高。
StringBuffer:可变字符序列，效率高，线程安全。
StringBuilder:可变字符序列，效率高，线程不安全。

Math常用方法：

 int abs = Math.abs(-34);//求绝对值。
      System.out.println(abs);
      double pow = Math.pow(2,4);//幂
      System.out.println(pow);
      double ceil = Math.ceil(-1.89);//向上取整。
      System.out.println(ceil);
      double floor = Math.floor(-4.49);//向下取整。
      System.out.println(floor);
      long round = Math.round(1.2);//四舍五入。
      System.out.println(round);
      double sqrt = Math.sqrt(4);//求开方。
      System.out.println(sqrt);
      for (int i = 0; i < 10; i++) {
    
    
         System.out.println((int)(2+Math.random()*6));//求随机数，返回的是[2,8)上的数。
      }
      System.out.println(Math.max(2,3));
      System.out.println(Math.min(2,3));

重点：随机数random()

Arrays类：

Integer[] array={1,22323,4,524,50};
System.out.println(Arrays.toString(array));//显示数组。
Arrays.sort(array);//排序数组。
System.out.println(Arrays.toString(array));//再次输出。
//二分查找数组的某个数的索引，数组必须有序。如果数不存在，则返回的是 //return -(low+1)。  
 Integer[] integer={1,3,4,5,};
int i = Arrays.binarySearch(integer, 1);
      System.out.println("index="+i);

      Integer[] array={1,2,34,324,34};
      Integer[] integers =Arrays.copyOf(array,array.length);//数组复制。
      System.out.println(Arrays.toString(integers));

      Integer[] array={
    
    1,2,34,324,34};     
      Arrays.fill(array,10);//数组的填充。
      System.out.println(Arrays.toString(array));
      boolean equals=Arrays.equals(array,integers);//比较两个数组的元素是否一样，是，返回true,否，返回false。
      System.out.println(equals);

例题：

 public static void main(String[] args) {
    
    
      Book[] books = new Book[4];
      books[0]=new Book("红楼梦",100);
      books[1]=new Book("新金瓶梅",90);
      books[2]=new Book("新青年文摘",5);
      books[3]=new Book("java从入门到放弃",300);
      Arrays.sort(books, new Comparator<Book>() {
    
    
         @Override
          //重写compare方法，如果想改变排序方式直接修改return的值。
         public int compare(Book o1, Book o2) {
    
    
            int priceVal= o2.getPrice()-o1.getPrice();
            if(priceVal>0){
    
    
               return 1;
            }else if(priceVal<0){
    
    
               return -1;
            }else {
    
    
               return 0;
            }
         }
      });
      System.out.println(Arrays.toString(books));
     
      System.out.println("=====================");

      Arrays.sort(books, new Comparator<Book>() {
    
    
         @Override
         public int compare(Book o1, Book o2) {
    
    
            return o1.getName().length()-o2.getName().length();
         }
      });
      for (int i = 0; i <books.length ; i++) {
    
    
         System.out.println(books[i].toString());
      }

   }
}
class Book{
    
    
   public String getName() {
    
    
      return name;
   }

   public void setName(String name) {
    
    
      this.name = name;
   }

   public int getPrice() {
    
    
      return price;
   }

   public void setPrice(int price) {
    
    
      this.price = price;
   }

   private String name;
   private int price;

   @Override
   public String toString() {
    
    
      return "书名为："+ name + '\'' +
              ", 价格为：" + price ;
   }

   public Book(String name, int price) {
    
    
      this.name = name;
      this.price = price;
   }
}

System类：

      long l = System.currentTimeMillis();//当前时间
      Integer[] integers={
    
    1,2,4,5};
      Integer[] integers1 = new Integer[3];
      //原数组从第一个元素，新数组第一个元素，复制3个
      System.arraycopy(integers,0,integers1,0,3);
      System.out.println(Arrays.toString(integers1));

BigInteger 类

当数据较大时，用BigInteger进行计算。

      
      BigInteger bigInteger = new BigInteger("200000000000"); 
      BigInteger bigInteger1 = new BigInteger("100000000000");
      //相加
      BigInteger add = bigInteger.add(bigInteger1);
      System.out.println(add);
      //相减
      BigInteger subtract = bigInteger.subtract(bigInteger1);
      System.out.println(subtract);
      //相除
      BigInteger divide = bigInteger.divide(bigInteger1);
      System.out.println(divide);
      //相乘。
      BigInteger multiply = bigInteger.multiply(bigInteger1);
      System.out.println(multiply);

BigDecimal类

当小数数据较大时，用BigDecimal类，

 BigDecimal bigDecimal = new         BigDecimal("1.2222222222222222222222222");
      BigDecimal bigDecimal1 = new BigDecimal("7");
      //相加
      System.out.println(bigDecimal.add(bigDecimal1));
      //相减
      System.out.println(bigDecimal.subtract(bigDecimal1));
      //相乘
      System.out.println(bigDecimal.multiply(bigDecimal1));
      //相除。如果无限循环，则在方法里面写BigDeciaml.ROUND_CEILING,即保留除数的位数。
System.out.println(bigDecimal.divide(bigDecimal1,BigDecimal.ROUND_CEILING));

Date类(第一代日期类)

 Date date = new Date();
      System.out.println(date);
      //创建simpleDateFormat对象，可以指定相应的格式，不能乱写。
      SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 E HH:mm:ss");
      String format = simpleDateFormat.format(date);
      System.out.println(format);//2021年10月29日 星期五 16:18:03
      System.out.println("=================");
      //将字符串转化成日期。
      //得到的date仍然是国外的形式，需要转化输出。
      //如果simpleDateFormat的格式和String的格式不一样，需要抛转换异常。
      String s="2024年10月29日 星期五 16:14:54";
      Date parse = simpleDateFormat.parse(s);
      System.out.println(simpleDateFormat.format(parse));
      System.out.println("================");
      //通过指定的毫秒数得到时间
      Date date1 = new Date(123456);
     System.out.println(simpleDateFormat.format(date1));//1970年01月01日 星期四 08:02:03
   }

Calendar 类（第二代日期类）

Calendar类是一个抽象类，并且构造器时private因此要调用getInstance方法获取实例。

Calendar类没有提供对应的格式化，需要程序员自己写格式化。

  Calendar instance = Calendar.getInstance();
//获取年份
      System.out.println(instance.get(Calendar.YEAR));
//获取月份+1
      System.out.println(instance.get(Calendar.MONTH)+1);
//获取第几天。
      System.out.println(instance.get(Calendar.DAY_OF_MONTH));
//获取小时数。
      System.out.println(instance.get(Calendar.HOUR));
//获取分钟数。
       System.out.println(instance.get(Calendar.MINUTE));
//自己写日期格式：
System.out.println(instance.get(Calendar.YEAR)+"-"+(instance.get(Calendar.MONTH)+1)+"-"+instance.get(Calendar.DAY_OF_MONTH)+"\t"+instance.get(Calendar.HOUR_OF_DAY)+":"+instance.get(Calendar.MINUTE)+":"+instance.get(Calendar.SECOND));//2021-10-30	13:1:18

（常用）LocalDateTime类（第三代日期类）

LocalDateTime now = LocalDateTime.now();
      System.out.println(now);//获取当前日期。
      DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 E HH:mm:ss");//格式日期。
      String format = dateTimeFormatter.format(now);
      System.out.println(format);
      //一年后的时间。
       LocalDateTime localDateTime = now.plusYears(1);
     //一年前的时间。
      LocalDateTime localDateTime1 = now.minusYears(1);
      System.out.println("一年前："+dateTimeFormatter.format(localDateTime1));
      System.out.println("一年后："+dateTimeFormatter.format(localDateTime));

习题：

将字符串中指定部分进行反转。

 public static void main(String[] args) {
    
    
        String s = "abcdef";
        System.out.println(reverse(s, 1, 4));//aedcbf 

    }

    public static String reverse(String s, int start, int end) {
    
    
        if(!(s!=null&&start>=0start<end&&end>start&&end<s.length())){
    
    
            throw new ArrayIndexOutOfBoundsException("参数不正确。");
        }
        char[] chars = s.toCharArray();
        char temp;
        for (int i = start, j = end; i < j; i++, j--) {
    
    
            temp = chars[i];
            chars[i] = chars[j];
            chars[j] = temp;
        }
        return new String(chars);
    }

java包装类等其他类