java基础-常用类

java基础-常用类

包装类

• 包装类的分类

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

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

  • Byte/Short/Integer/Long/Float/Double的父类：Number

  • 

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

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

  • 演示 包装类和基本数据类型的相互转换，这里以int和Integer演示

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

    • jdk5以后（含jdk5）的自动装箱和拆箱方式

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

    • 其他类似

    • 案例演示

    • package com.lyn.wrapper_;
      
      /**
       * @author L.yn
       * @version 1.0
       * @date 2022/1/3 12:10
       */
      public class Integer01 {
          public static void main(String[] args) {
              //演示int  <--> Integer的装箱和拆箱
              //jdk5以前是手动装箱和拆箱
              //手动装箱
              int n1 = 100;
              Integer integer = new Integer(n1);
              Integer integer1 = Integer.valueOf(n1);
              //手动拆箱  Integet --> int
              int i = integer.intValue();
      
              //jdk5后,就可以自动装箱和自动拆箱
              int n2 = 200;
              //自动装箱
              Integer integer2 = n2;//底层使用的是Integet.valueOf(n2);
              //自动拆箱 Integer --> int
              int n3 = integer2;//底层使用的是intValue()方法
          }
      }
      

• 包装类型和String类型的相互转换

  • 案例演示，以Integer和String转换为例，其他类似

  • package com.lyn.wrapper_;
    
    /**
     * @author L.yn
     * @version 1.0
     * @date 2022/1/3 12:19
     */
    public class WrapperVSString {
        public static void main(String[] args) {
            //包装类 -> String
            Integer i = 100;//自动装箱
            //方式一
            String str1 = i + "";
            //方式二
            String str2 = i.toString();
            //方式三
            String str3 = String.valueOf(i);
    
            //String -> 包装类
            String str4 = "12345";
            //方式一
            Integer i1 = Integer.parseInt(str4);//自动装箱
            //方式二
            Integer i2 = new Integer(str4);
        }
    }
    

• Integer 和 Character的常用方法

  • Integer.MIN_VALUE：返回最小值
  • integet.MAX_VALUE：返回最大值
  • Character.isDigit(‘a’)：判断是不是数字
  • Character.isLetter(‘a’)：判断是不是字母
  • Character.isUpperCase(‘a’)：判断是不是大写
  • Character.isLowerCase(‘a’)：判断是不是小写
  • Character.isWhitespace(‘a’)：判断是不是空格
  • Character.toUpperCase(‘a’)：转成大写
  • Character.toLowerCase(‘a’)：转成小写

String类

String类的理解和创建对象

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

2. 字符串常量对象是用双引号括起来的字符序列，例如：“你好”

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

4. String类较常用构造方法

   1. String s1 = new String();
      String s2 = new String(String original);
      String s3 = new String(char[] a);
      String s4 = new String(char[] a,int startIndex,int count)
      

5. 

6. package com.lyn.string_;
   
   /**
    * @author L.yn
    * @version 1.0
    * @date 2022/1/3 13:14
    */
   public class String01 {
       public static void main(String[] args) {
           //一、String对象用于保存字符串，也就是一组字符序列
           // "jack"字符串常量，双引号括起来的字符序列
           //二、字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节
           //三、String类有很多构造器，构造器重载
           //常用的有：
           // String s1 = new String();
           //String s2 = new String(String original);
           //String s3 = new String(char[] a);
           //String s4 = new String(char[] a,int startIndex,int count)
           //String s5 = new String(byte[] b);
           //四、String实现了接口 Serializable【String可以串行化：可以在网络传输的】
           //            接口 Comoarable【String对象可以比较大小】
           //五、String 是一个final类，不能被其他类继承
           //六、String中有属性private final char value[];用于存放字符串内容
           //七、一定要注意：value是一个final类型，不可修改（指的是value的指向地址不能修改，但是单个字符内容是可以改变的）
           String name = "jack";
           name = "tom";
       }
   }
   

• 创建String对象的两种方式
  • 方式一：直接赋值 String s = “jack”;
    • 先从常量池查看是否有“jack”数据空间，如果有，直接指向；如果没有则重新创建，然后指向，s最终指向的是常量池的空间地址
  • 方式二：调用构造器 String s = new String(“jack”);
    • 先从堆中创建空间，里面维护了value属性，指向常量池的jack空间，如果没有则重新创建，如果有，直接通过value指向。最终指向的是堆中的空间地址
• String（字符串）的特性
  • String是一个final类，代表不可变的字符序列
    • 字符串是不可变的，一个字符串对象一旦被分配，其内容是不可变的
• String 类的常用方法
  • 说明：String类是保存字符串常量的。每次更新都需要重新开辟空间，效率较低，因此java设计者还提供了StringBuilder和StringBuffer来增强String的功能，并提高效率
  • String类的常见方法一览
    • equals：区分大小写，判断内容是否相等
    • equalsIgnoreCase：忽略大小写的判断内容是否相等
    • length：获取字符的个数，字符串的长度
    • indexOf：获取字符在字符串中第一次出现的索引，索引从0开始，如果找不到，返回-1
    • lastIndexOf：获取字符在字符串中最后一次出现的索引，索引从0开始，如果找不到，返回-1
    • subString：截取指定返回的子串
    • trim：去前后空格
    • charAt：获取某索引处的字符，注意：不能使用Str[index]这种方式
    • toUpperCase：转换成大写
    • toLowerCase：转换成小写
    • concat：拼接自负床
    • compareTo：比较两个字符串的大小
    • toCharArray：转换成字符数组
    • format：格式字符串，%s字符串，%c字符 %d整型 %.2f浮点型
    • replace：替换字符串中的字符

StringBuffer类

• 基本介绍

  • StringBuffer代表可变的字符序列，可以对字符串内容进行增删

  • 很多方法和String相同，但StringBuffer是可变长度的

  • StringBuffer是一个容器

  • package com.lyn.stringbuffer_;
    
    /**
     * @author L.yn
     * @version 1.0
     * @date 2022/1/11 21:17
     */
    public class StringBuffer01 {
        public static void main(String[] args) {
            /**
             * 一、StringBuffer的直接父类是AbstractStringBuilder
             * 二、StringBuffer实现了Serializable，即StringBuffer的对象可以串行化
             * 三、在父类AbstractStringBuilder中有属性char[] value，不是final
             *     该value数组存放字符串内容，引出存放在堆中
             * 四、StringBuffer是一个final类，不能被继承
             * 五、因为StringBuffer字符内容是存在char[] value ，所以在变化（增加、删除）
             *      不用每次都更换地址（即不是每次创建新对象），所以效率高于String
             */
            StringBuffer stringBuffer = new StringBuffer();
        }
    }
    

  • String VS StringBuffer

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

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

    • package com.lyn.stringbuffer_;
      
      /**
       * @author L.yn
       * @version 1.0
       * @date 2022/1/11 21:29
       */
      public class StringBuffer02 {
          public static void main(String[] args) {
              //构造器的使用
              /**
               * 一、创建一个大小为16的char[]，用于存放字符内容
               */
              StringBuffer stringBuffer = new StringBuffer();
      
              //2、通过构造器指定char[] 大小
              new StringBuffer(100);
      
              //3、通过给一个String创建一个StringBuffer,char[]大小就是str.length() + 16
              new StringBuffer("hello");
          }
      }
      

      package com.lyn.stringbuffer_;
      
      /**
       * @author L.yn
       * @version 1.0
       * @date 2022/1/11 21:34
       */
      public class StringAndStringBuffer {
          public static void main(String[] args) {
              //String -> StringBuffer
              String str = "hello tom";
              /**
               * 方式一、使用构造器
               * 注意：返回的才是StringBuffer对象，对str本身没有影响
               */
              StringBuffer stringBuffer = new StringBuffer(str);
      
              //方式二、使用的是append方法
              StringBuffer stringBuffer1 = new StringBuffer();
              StringBuffer append = stringBuffer1.append(str);
      
              // StringBuffer -> String
              //方式一、使用StringBuffer提供的toString方法
              String s = stringBuffer.toString();
              //方式二、使用构造器来搞定
              String s1 = new String(stringBuffer);
          }
      }
      

  • StringBuffer常见方法

    • 增加：append
    • 删除：delete(start,end)
    • 改：replace(start,end,String)：将start------end间的内容替换掉，不含end
    • 查找：indexOf：查找子串在字符串第一次出现的索引，如果找不到返回-1
    • 插入：insert
    • 获取长度：length

StringBuilder类

• 基本介绍

  • 一个可变的字符序列，此类提供一个与StringBuffer兼容的API，但不保证同步（StringBuilder不是线程安全），该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer要快

  • 在StringBuilder上的主要操作时append和insert方法，可重载这些方法，以接受任意类型的数据

  • package com.lyn.stringbuilder_;
    
    /**
     * @author L.yn
     * @version 1.0
     * @date 2022/1/11 21:51
     */
    public class StringBuilder01 {
        public static void main(String[] args) {
            /**
             * 一、StringBuilder继承AbstractStringBuilder
             * 二、实现了Serializable，即StringBuilder的对象可以串行化（对象可以网络传输，可以保存到文件）
             * 三、StringBuilder是final类，不能被继承
             * 四、StringBuilder对象字符序列仍然是存放在其父类AbstractStringBuilder的char[] value
             *      因此，字符序列是堆中
             * 五、StringBuilder的方法，没有做互斥的处理，即没有synchronized关键字，因此在单线程的情况下使用StringBuilder
             */
            StringBuilder stringBuilder = new StringBuilder();
        }
    }
    

• String、StringBuilder和StringBuffer的比较

  • StrignBuilder和StringBuffer非常类似，均代表可变的字符序列，而且方法也一样

  • String：不可变字符序列，效率低，但是复用率高

  • StringBuffer：可变字符序列、效率较高（增删）、线程安全

  • StringBuilder：可变字符序列、效率最高、线程不安全

  • String使用注意说明

    • String s = "a";//创建了一个字符串
      s += "b";//实际上原来的“a”字符串对象已经丢弃了，现在又产生了一个字符串s+"b"(也就是ab)。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序性能 =>结论：如果我们对String做大量修改，不要使用String
      

• String、StringBuilder和StringBuffer的选择

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

Math类

• 基本介绍

  • Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数

  • Math类常见方法应用

    • abs：绝对值

    • pow：求幂

    • ceil：向上取整

    • floor：向下取整

    • round：四舍五入

    • sqrt：开平方

    • random：求随机数

    • max：求两个数的最大值

    • min：求两个数的最小值

    • package com.lyn.math_;
      
      /**
       * @author L.yn
       * @version 1.0
       * @date 2022/1/13 19:28
       */
      public class MathMethod {
          public static void main(String[] args) {
              //看看math常用的方法（静态方法）
              //abs绝对值
              int abs = Math.abs(9);
              //pow求幂
              double pow = Math.pow(3.4, 4);//3.4的四次方
              //ceil向上取整，返回>=改参数的最小整数
              double ceil = Math.ceil(3.123);
              //floor向下取整
              double floor = Math.floor(3.131);
              //round四舍五入
              long round = Math.round(2.41);
              //sqrt：开平方
              double sqrt = Math.sqrt(9);
              //random：求随机数
              double random = Math.random();
              //max：求两个数的最大值
              int max = Math.max(3, 5);
              //min：求两个数的最小值
              int min = Math.min(3, 4);
          }
      }
      

Arrays类

• Arrays类常见方法应用

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

  • toString：返回数组的字符串形式

  • sort：排序（自然排序和定制排序）

  • binarySearch：通过二分搜索法进行查找，要求必须排好序

  • package com.lyn.arrays_;
    
    import java.util.Arrays;
    
    /**
     * @author L.yn
     * @version 1.0
     * @date 2022/1/13 19:47
     */
    public class ArraysMethod {
        public static void main(String[] args) {
            Integer[] integers = {1, 2, 3, 12, 3};
            String s = Arrays.toString(integers);
            System.out.println(s);
        }
    }