【JavaSE】常用类学习笔记

常用类

-包装类

• 包装类的分类

  1. 针对八种基本定义相应的引用类型—包装类

  2. 有了类的特点，就可以调用类中的方法

     基本数据类型	包装类
     boolean	Boolean
     char	Character
     byte	Byte
     short	Short
     int	Integer
     long	Long
     float	Float
     double	Double

• 包装类的继承关系

  1. Boolean和Character继承Object、实现Serializable和Comparable。
  2. Byte、Short、Integer、Long、Float、Double继承Number，实现Comparable；Number继承Object，实现Serializable

• 包装类和基本数据类型的转换

  1. jdk5前的手动装箱和拆箱方式，装箱：基本类型->包装类型，拆箱反之

     //基本类型->包装类型【手动装箱】
     int i= 10;
     Integer i1 = new Integer();
     Integer i2 =Integer.valueOf(i);
     //包装类型->基本类型【手动拆箱】
     Integer j = new Integer(99);
     int j1 = j.intValueO;
     

  2. jdk5之后的自动装箱和拆箱方式

     int m = 10;
     Integer m2 = m;
     Integer n = new Integer(99);
     int n2 = n;
     System.out.printIn(n + 100);
     System.out.printIn(n * 2);
     if (n > 10) {}
     

  3. 自动装箱底层调用的是valueOf方法，比如Integer.valueOf();

• 八大包装类常用方法

  1. Integer（对应int）

  • parseInt(String s)：将字符串转为int（抛NumberFormatException异常）。

    int num = Integer.parseInt("123"); // 结果：123  
    

  • valueOf(String s)：返回Integer对象（使用缓存，范围：-128~127）。

    Integer obj = Integer.valueOf("456"); // 结果：Integer对象456  
    

  • toString()：返回对象的字符串表示。

    String str = obj.toString(); // 结果："456"  
    

  2. Long（对应long）

  • parseLong(String s)：将字符串转为long

    long l = Long.parseLong("123456"); // 结果：123456L  
    

  • valueOf(String s)：返回Long对象。

    Long lObj = Long.valueOf("7890"); // 结果：Long对象7890  
    

  3. Float（对应float）

  • parseFloat(String s)：将字符串转为float（需以f/F结尾）。

    float f = Float.parseFloat("3.14f"); // 结果：3.14f  
    

  • isNaN()：判断是否为非数字（NaN）。

    boolean isNaN = Float.isNaN(Float.NaN); // 结果：true  
    

  4. Double（对应double）

  • parseDouble(String s)：将字符串转为double。

    double d = Double.parseDouble("3.14"); // 结果：3.14  
    

  • isInfinite()：判断是否为无穷大（Infinity）。

    boolean isInfinite = Double.isInfinite(Double.POSITIVE_INFINITY); // 结果：true  
    

  5. Character（对应char）

  • isUpperCase(char ch)：判断是否为大写字母。

    boolean isUpper = Character.isUpperCase('A'); // 结果：true  
    

  • toUpperCase(char ch)：转为大写字母（小写转大写，其他不变）。

    char upper = Character.toUpperCase('b'); // 结果：'B'  
    

  • isDigit(char ch)：判断是否为数字字符（0-9）。

    boolean isDigit = Character.isDigit('5'); // 结果：true  
    

    6. Boolean（对应boolean）

  • valueOf(String s)：将字符串转为Boolean（“true” 忽略大小写为true，否则false）。

    Boolean bool = Boolean.valueOf("TrUe"); // 结果：true  
    

  • booleanValue()：返回对应的基本类型boolean。

    boolean primitive = bool.booleanValue(); // 结果：true  
    

  7. Short（对应short）

  • parseShort(String s)：将字符串转为short（范围：-32768~32767）。

    short num = Short.parseShort("100"); // 结果：100  
    

  • valueOf(String s)：返回Short对象。

    Short sObj = Short.valueOf("200"); // 结果：Short对象200  
    

  8. Byte（对应byte）

  • parseByte(String s)：将字符串转为byte（范围：-128~127）。

    byte b = Byte.parseByte("127"); // 结果：127  
    

  • valueOf(String s)：返回Byte对象（使用缓存，范围：-128~127）。

    Byte bObj = Byte.valueOf("100"); // 结果：Byte对象100  
    

-String类

• String类的理解和创建对象

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

2. 字符串常量对象是用双引号括起的字符序列。例如：“你好”、“12.97”、“b0y”等

3. 字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节。

4. String类较常用构造方法（其它看手册）：

   Strings1 = new String():
   String s2 = new String(String original);
   String s3 = new String(char[] a);
   String s4 = new String(char[] a,int startlndex,int count) 
   

5. String类实现了接口Serializable【String可以串行化:可以在网络传输】接口Comparable[String对象可以比较大小]

6. String是final类，不能被其他的类继承

7. String有属性private final char value[];用于存放字符串内容

8. 一定要注意：value是一个final类型，不可以修改（需要功力)：即value不能指向新的地址，但是单个字符内容可以变化

• 创建String对象的两种方式

  1. 方式一：直接赋值String s=“abc”;

  2. 方式二：调用构造器String s=new String(“abc”);

     方式一：先从常量池查看是否有“hsp”数据空间，如果有，直接指向；如果
     没有则重新创建，然后指向。s最终指向的是常量池的空间地址

     方式二：先在堆中创建空间，里面维护了value属性，指向常量池的hsp空间。
     如果常量池没有“hsp”，重新创建，如果有，直接通过value指向。最终指向
     的是堆中的空间地址。

• String字符串的特性

1. String是一个final类，代表不可变的字符序列
2. 字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的。
3. 在String c=a+b时，底层是 StringBuilder sb=new StringBuilderO;sb.append(a);sb.append(b)；sb是在堆中，并且append是在原来字符串的基础上追加的。重要规则，String c=“ab”+“cd”;常量相加，看的是池。String c=a
   +b；变量相加，是在堆中

• String类的常用方法
  1. equals//区分大小写，判断内容是否相等
  2. equalslgnoreCase//忽略大小写的判断内容是否相等
  3. length//获取字符的个数，字符串的长度
  4. indexOf//获取字符或字符串在字符串中第1次出现的索引，索引从0开始，如果找不到，返回-1
  5. lastlndexOf//获取字符在字符串中最后1次出现的索引，索引从0开始，如找不到，返回-1
  6. substring//截取指定范围的子串
  7. trim//去前后空格
  8. charAt：获取某索引处的字符，注意不能使用Str[index]这种方式.
  9. toUpperCase：转换为大写
  10. toLowerCase：转换为小写
  11. concat：拼接字符串
  12. replace：替换字符串中的字符
  13. split：分割字符串，对于某些分割字符，我们需要转义比如|等
  14. compareTo//比较两个字符串的大小
  15. toCharArray//转换成字符数组
  16. format//格式字符串，%s字符串%c字符%d整型%.2f浮点型

-StringBuffer类

• 基本介绍

  • java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删。
  • 很多方法与String相同，但StringBuffer是可变长度的。
  • StringBuffer是一个容器。
  • StringBuffer的直接父类是AbstractStringBuilder
  • StringBuffer实现了Serializable，即StringBuffer的对象可以串行化
  • 在父类中AbstractStringBuilder有属性char[]value,不是final，该value数组存放字符串内容
  • StringBuffer是一个final类，不能被继承

• String VS StringBuffer

  • String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率较低//private final char value[];
  • StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用更新地址，效率较高//char[] value; //这个放在堆
  • 因为StringBuffer字符内容是存在char[]value，所有在变化（增加/删除）不用每次都更换地址（即不是每次创建新对象），所以效率高于String

• StringBuffer的构造器

  • StringBuffer()
    构造一个其中不带字符的字符串缓冲区，其初始容量为16个字符。
  • StringBuffer(CharSequence seq)
    public java.lang.StringBuilder(CharSequence seq)构造一个字符串缓冲区，它包含与指定的CharSequence相同的字符。
  • StringBuffer(int capacity) //capacity [容量]
    构造一个不带字符，但具有指定初始容量的字符串缓冲区。即对char[]大小进行指定
  • StringBuffer(String str)
    构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。

• String和StringBuffer的转换

  // String——>StringBuffer
  String s = "hello";
  ∥方式1:
  StringBuffer b1 = new StringBuffer(s);
  /方式2:
  StringBuffer b2 = new StringBuffer();
  b2.append(s):
  // StringBuffer——>String
  ∥方式1:
  String s2 = b1.toString(); //b1 [StringBuffer]
  ∥方式2:
  String s3 = new String(b1);
  

• StringBuffer类常用方法

  1. 增 append
  2. 删 delete(start,end)
  3. 改 replace(start,end,string)//将start----end间的内容替换掉，不含end
  4. 查indexOf//查找子串在字符串第1次出现的索引，如果找不到返回-1
  5. 插入insert
  6. 获取长度length

-StringBuilder类

• 基本介绍

  1. 一个可变的字符序列。此类提供一个与StringBuffer兼容的API，但不保证同步（线程不安全）。该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer要快
  2. 在StringBuilder上的主要操作是append和insert方法，可重载这些方法，以接受任意类型的数据。
  3. StringBuilder 是final，继承了AbstractStringBuilder；属性char[]value，内容存到value；实现了Serializable接口，序列化（所谓序列化即可以保存类型和数据本身）

• StringBuilder常用方法

  StringBuilder和StringBuffer均代表可变的字符序列，方法是一样的，所以使用和StringBuffer一样

• String、StringBuffer 和StringBuilder的比较

  1. StringBuilder和StringBuffer非常类似，均代表可变的字符序列，而且方法也一样
  2. String：不可变字符序列，效率低，但是复用率高。
  3. StringBuffer：可变字符序列、效率较高（增删）、线程安全
  4. StringBuilder：可变字符序列、效率最高、线程不安全
  5. String使用注意说明：
     string s=“a”;//创建了一个字符串
     s+=“b”；//实际上原来的”a"字符串对象已经丢弃了，现在又产生了一个字符串s+"b”（也就是"ab”)。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能=>结论：如果我们对String做大量修改，不要使用String

• String、StringBuffer 和StringBuilder的选择

  使用的原则，结论：

  1. 如果字符串存在大量的修改操作，一般使用StringBuffer或StringBuilder
  2. 如果字符串存在大量的修改操作，并在单线程的情况，使用StringBuilder
  3. 如果字符串存在大量的修改操作，并在多线程的情况，使用StringBuffer
  4. 如果我们字符串很少修改，被多个对象引用，使用String，比如配置信息等

-Math类

• Math类常见方法

  1. abs 绝对值

  2. pow 求幂

  3. ceil向上取整

  4. floor向下取整

  5. round 四舍五入

  6. sqrt 求开方

  7. random求随机数//思考：

     请写出获取a-b之间的一个随机整数，a，b均为整数？2-7

     int num = (int)(a +Math.random()*(b-a+1)

  8. max求两个数的最大值

  9. min求两个数的最小值

-Arrays类

• Arrays类常见方法

  Arrays里面包含了一系列静态方法，用于管理或操作数组（比如排序和搜索）。

  1. toString返回数组的字符串形式
     Arrays.toString(arr)
  2. sort排序（自然排序和定制排序）
     Integer arr[]={1,-1,7,0,89);
  3. binarySearch通过二分搜索法进行查找，要求必须排好序
     int index = Arrays.binarySearch(arr, 3);
  4. copyOf数组元素的复制
     Integer[] newArr = Arrays.copyOf(arr, arr.length);
  5. fill数组元素的填充
     Integer[] num = new Integer;
     Arrays.fill(num, 99);
  6. equals比较两个数组元素内容是否完全一致
     boolean equals = Arrays.equals(arr, arr2):
  7. asList将一组值，转换成list
     List asList = Arrays.asList(2,3,4,5,6,1);
     System.out.println(“asList=”+ asList);

-System类

• System类常用方法

  1. exit退出当前程序

  2. arraycopy：复制数组元素，比较适合底层调用，一般使用Arrays.copyOf完成复制数组.

     int[] src={1,2,3);
     int[] dest = new int[3];
     System.arraycopy(src, 0, dest, 0, 3):
     

  3. currentTimeMillens:返回当前时间距离1970-1-1的毫秒数

  4. gc:运行垃圾回收机制 System.gcO;

-BigInteger&BigDicimal

• BigInteger和BigDecimal介绍

  应用场景：

  1. BigInteger适合保存比较大的整型
  2. BigDecimal适合保存精度更高的浮点型（小数）

• BigInteger和BigDecimal常见方法

  1. add 加
  2. subtract减
  3. multiply乘
  4. divide除

• 注意

  BigDecimal类进行除法操作时容易出现无限循环小数异常，可通过限制小数位数来解决

-日期类

• 第一代日期类

  1. Date：精确到毫秒，代表特定的瞬间

  2. SimpleDateFormat:格式和解析日期的类。SimpleDateFormat格式化和解析日期的具体类。它允许进行格式化（日期->文本）、解析（文本->日期）和规范化。

  3. 应用实例

     Date d1 =new Date();//获取当前系统时间
     Date d2=new Date（9234567);//通过指定毫秒数得到时间
     System.out.printin(d1.getTimeO);//获取某个时间对应的毫秒数
     SimpleDateFormat sdf =newSimpleDateFormat("yyyy年MM月dd日hh:mm:ssE");
     String format =sdf.format（d1);//format：将日期转换成指定格式的字符串
     Strings="1996年01月01日10:20:30星期一”；
     Date parse = sdf.parse(s);
     

• 第二代日期类

  1. 第二代日期类，主要就是Calendar类（日历)。
     public abstract class Calendar extends Object implementsSerializable,Cloneable,Comparable

  2. Calendar类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAYOFMONTH、HOUR等日历字段之间的转换提供了些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

  3. 应用实例

     Calendar c=Calendar.getlnstance();//创建日历类对象//比较简单，自由
     System.out.println(c);
     112.获取日历对象的某个日历字段
     System.out.printIn("年:"+c.get(Calendar.YEAR));
     System.out.printIn("月:"+(c.get(Calendar.MONTH)+1);
     System.out.printIn("日:"+c.get(Calendar.DAY_OF_MONTH);
     System.out.printIn("小时:"+c.get(Calendar.HOUR);
     System.out.printIn("分钟:"+c.get(Calendar.MINUTE);
     System.out.printIn("秒:"+c.get(Calendar.SECOND);
     //Calender没有专门的格式化方法，所以需要程序员自己来组合显示
     System.out.printIn(c.get(Calendar.YEAR)+"年"+(c.get(Calendar.MONTH)+1)+"月
     "+c.get(Calendar.DAY_OF_MONTH)+"日");
     

• 第三代日期类

​ 前面两代日期类的不足分析
​ JDK1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK1.1引入Calendar类之后被弃用了。而Calendar也存在问题是：

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

• 第三代日期类常用方法

  1. LocalDate(日期)、LocalTime(时间)、LocalDateTime(日期时间)JDK8加入
     LocalDate只包含日期，可以获取日期字段
     LocalTime只包含时间，可以获取时间字段
     LocalDateTime包含日期+时间，可以获取日期和时间字段

  2. 案例演示

     LocalDateTime ldt = LocalDateTime.nowO://LocalDate.now();//LocalTime.now();
     System.out.println(Idt);
     ldt.getYear();
     ldt.getMonthValue();
     ldt.getMonth();
     ldt.getDayOfMonth();
     ldt.getHour();
     ldt.getMinute();
     ldt.getSecond();
     

  3. DateTimeFormatter格式日期类

     类似于SimpleDateFormat

     DateTimeFormat dtf = DateTimeFormatter.ofPattern(格式);
     String str = dtf.format(日期对象);
     

  4. instant时间戳
     类似于Date
     提供了一系列和Date类转换的方式

     //Instant—>Date:
     Date date = Date.from(instant);
     //Date一>Instant:
     Instant instant =date.toInstant();
     

     案例演示：

     Instant now = Instant.now();
     System.out.println(now);
     Date date =Date.from(now);
     Instant instant = date.tolnstant();
     

  5. 更多方法

     1. LocalDateTime类
     2. MonthDay类：检查重复事件
     3. 是否是闰年
     4. 增加日期的某个部分
     5. 使用plus方法测试增加时间的某个部分
     6. 使用minus方法测试查看一年前和一年后的日期