java学习笔记-常用类(韩顺平)

1. 包装类Wrapper

• 包装类的分类

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

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

     

  3. 类图如下

     

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

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

  2. jdk5 以后(含jdk5) 的自动装箱和拆箱

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

     package com.mdklea.wrappertype;
     ​
     public class Integer01 {
         public static void main(String[] args) {
             int n1 = 100;
             //手动装箱
             //Integer integer = new Integer(n1);
             Integer integer1 = Integer.valueOf(n1);
     ​
             //手动拆箱
             int i = integer1.intValue();
     ​
             //jdk5以后,就可以自动装拆箱了
             int n2 = 200;
             Integer integer2 = n2;
             int n3 = integer2;
     ​
         }
     }

     

  4. package com.mdklea.usuallyclass;
     ​
     public class Wrapper {
         @SuppressWarnings({"all"})
         public static void main(String[] args) {
             Object obj1 = true ? Integer.valueOf(1) : Double.valueOf(2.0);
             System.out.println(obj1); // 1.0
         }
     }

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

  package com.mdklea.wrappertype;
  ​
  public class WrapperString {
      public static void main(String[] args) {
          //包装类 ->String
          //方式一
          Integer i = 100;
          String str1 = i + "";//获得一个新对象，而不是指向原来哪个
          //方法2
          String str2 = i.toString();
          //方法3
          String str3 = String.valueOf(i);
  ​
          //String -> 包装类
          String str4 = "1234";
          Integer i2 = Integer.parseInt(str4);
          //Integer integer = new Integer(str4);
      }
  }

• Integer和Charater类的常用方法

  

• 练习题

  

2.String类

• String类的理解和创建对象

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

  2. 字符串常量是用双引号括起来的字符序列。

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

  4. String类较常用的构造方法：

     
  5. 

  6. String实现了接口Serializable[String 可以串行化：可以在网络传输]

     接口Comparable[String对象可以比较大小]

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

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

  9. 一定要注意 final 是一个final类型，一旦赋值不可修改(地址)

     

• 两种创建String对象的区别

  1. 直接赋值String s = "mdk";

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

     

  2. 调用构造器 String s2 = new String("mdk");

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

     

  String.intern()是一个Native方法,它的作用是:如果字符常量池中已经包含一个等于此String对象的字符串,则返回常量池中字符串的引用,否则,将新的字符串放入常量池,并返回新字符串的引用’

  

• 字符串的特性

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

  2. 字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的。

• 题目

  

• String类的常用方法

  • 
  • 

3.StringBuffer类

• 基本介绍

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

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

  • StringBuffer是一个容器。

• 继承关系

  

  1. StringBuffer的直接父类是AbstractStringBuilder

  2. StringBuffer实现了Serializable，即StringBuffer的对象可以串行化

  3. 在父类AbstractStringBuilder中，有属性 char[] value,不是final

     该value数组存放字符串内容，因此存放在堆中

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

• String VS StringBuffer

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

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

     char[] value;这个放在堆

• StringBuffer构造器

  

• StringBuffer常用方法

  

• 练习

  

4.StringBuilder

• 基本介绍

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

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

• StringBuilder继承关系图

  

  1. StringBuilder继承AbstractStringBuilder类

  2. 实现了Serializable,说明StringBuilder对象是可以串行化的(对象可以网络传输，可以保存到文件)

  3. StringBuilder是final类，不能被继承

  4. StringBuilder对象字符序列仍然是存放在其父类 AbstractStringBuilder中的char[] value;

  5. StringBuilder的方法没有做互斥的处理，即没有synchronized 关键字

• 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

5.Math类

• 基本介绍

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

• 方法一览

  

6.Arrays类

• 常见方法案例

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

  1. toString 返回数组的字符串形式

  2. sort 排序(自然排序和定制排序) Integer arr[] = {1,-1,7,0,89};

     package com.mdklea.arraysort;
     import java.util.Arrays;
     import java.util.Comparator;
     ​
     public class BubbleSort {
         public static void main(String[] args) {
             int[] arr = {7,3,8,2,1,9,12,32,22,11,21};
              Bubble.bubbleSortage(arr, new Comparator() {
                  @Override
                  public int compare(Object o1, Object o2) {
                      int i1 = (Integer)o1;
                      int i2 =   (Integer)o2;
                      return i2 - i1;
                  }
              });
             System.out.println(Arrays.toString(arr));
         }
     }
     class Bubble {
     ​
         public static void bubbleSortage(int[] arr, Comparator c) {
             int temp = 0;
             for (int i = 0; i < arr.length - 1; i++) {
                 for (int j = 0; j < arr.length - 1 - i; j++) {
                     if (c.compare(arr[j],arr[j + 1]) > 0){
                         temp = arr[j];
                         arr[j] = arr[j + 1];
                         arr[j + 1] = temp;
                     }
                 }
             }
         }
     }

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

     1. 使用binarySearch 二叉查找

     2. 要求数组是有序的

     3. 如果数组中不存在该元素，返回return -(low + 1)

  4. copyOf 数组元素的复制

     Integer[] newArr = Arrays.copyOf(arr,arr.length);

     1. 从arr数组中，拷贝arr.length个元素到newArr数组中

     2. 如果拷贝的长度 > arr.length 就在新数组的后面，增加 null

     3. 如果拷贝长度 < 0 就抛出异常 NegativeArraySizeException

     4. 该方法底层使用的是 System.arraycopy()

  5. fill 数组元素的填充

     Integer[] num = new Integer[]{9,3,2};

     Arrays.fill(num,99);

     使用99 去填充 num 中的元素

  6. equals 比较两个数组元素是否完全一致

     boolean equals = Arrays.equals(arr,arr2);

  7. asList 将一组值，转换成list

     List<Integer> asList = Arrays.asList(2,3,4,5,6,1);

     System.out.println("asList = " + asList);

     1. 返回的asList编译类型List(接口)

     2. asList 运行类型 java.util.Arrays$ArrayList

• 练习

  package com.mdklea.arraysort;
  ​
  import java.util.Arrays;
  import java.util.Comparator;
  ​
  public class ArraysExercise {
      public static void main(String[] args) {
          Book[] books = new Book[5];
          books[0] = new Book("mdk133",500);
          books[1] = new Book("mdk23",300);
          books[2] = new Book("mdk3",800);
          books[3] = new Book("mdk42222",1100);
          books[4] = new Book("mdk3212345",220);
          Arrays.sort(books, new Comparator<Book>() {
              @Override
              public int compare(Book o1, Book o2) {
                  Integer d1 = (int)o1.getName().length();
                  Integer d2 = (int)o2.getName().length();
                  return d2 - d1;
              }
          });
              System.out.println(Arrays.toString(books));
      }
  }
  class Book {
      private String name;
      private double price;
  ​
      public String getName() {
          return name;
      }
  ​
      public double getPrice() {
          return price;
      }
  ​
      public Book(String name, double price) {
          this.name = name;
          this.price = price;
      }
  ​
      @Override
      public String toString() {
          return "Book{" +
                  "name='" + name + '\'' +
                  ", price=" + price +
                  '}';
      }
  }

7.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.gc();

8.大数处理方案

• BigInteger和BigDecimal介绍

  应用场景

  1. BigInteger适合保存比较大的整数

     public class BigInteger_ {
         public static void main(String[] args) {
             BigInteger bigInteger = new BigInteger("200000000000000000000222");
             BigInteger bigInteger2 = new BigInteger("1111111111111111111");
             System.out.println(bigInteger.add(bigInteger2));
             System.out.println(bigInteger.subtract(bigInteger2));
             System.out.println(bigInteger.multiply(bigInteger2));
             System.out.println(bigInteger.divide(bigInteger2));
         }
     }

  2. BigDecimal适合保存精度更高的浮点数(小数)

     

9.日期类[知道怎么查，怎么用就可，不用每个方法都背]

• 第一代日期类

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

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

     默认输出是国外的方式，不方便，因此通常要对格式进行转换。

  

• 第二代日期类

  1. 第二代日期类，主要就是Calender类(日历)

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

  解读

  1. Calendar是一个抽象类，并且构造器是private

  2. 可以通过getInstance() 来获取实例

  3. 提供大量的方法和字段提供给程序员

  4. Calendar没有提供对应的格式化的类，因此需要程序员自己组合来输出

  5. 如果我们希望获取24小时进制的时间，Calender.HOUR -> Calander.HOUR_OF_DAY

     

     Calendar c = Calendar.getInstance();
     System.out.println(c.get(Calendar.YEAR));
     System.out.println(c.get(Calendar.MONTH) + 1);
     System.out.println(c.get(Calendar.DAY_OF_MONTH));

• 第三代日期类

  • 前面两代日期类的不足

    JDK1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK1.1引入Calendar类之后被弃用了，而Calendar也存在问题是：

    1. 可变性，像日期和时间这样的类应该是不可变的

    2. 偏移性，Date中的年份是从1900开始的，而月份都从0开始。

    3. 格式化：格式化只对Date有用，Calendar则不行。

    4. 此外，他们不是线性安全的，不能处理闰秒等(每隔两天，多出一秒)

    

  • 第三代日期方法

    1. 使用now()返回当前日期时间的对象

    2. 使用DateTimeFormatter对象来进行格式化

       

    3. Instant时间戳

       

10.本章练习

• package com.mdklea.homework1;
  ​
  ​
  public class HomeWork01 {
      public static void main(String[] args) {
          String name = "12345";
          try {
              name = Tools.reverse(name,2,4);
          } catch (Exception e) {
              System.out.println(e.getMessage());
              return;
          }
          System.out.println(name);
      }
  }
  class Tools {
      public static String reverse(String str,int start,int end) {
          if(!(str != null && end > start && end < str.length() && start > 0)){
              throw new RuntimeException("参数不正确");
          }
          char[] chars = str.toCharArray();
          for (int i = start,j = end; i < j; i++,j--) {
              char temp = chars[j];
              chars[j] = chars[i];
              chars[i] = temp;
          }
          String s = String.valueOf(chars);
  //        return s;
          return new String(chars);
      }
  }

• package com.mdklea.homework1;
  ​
  ​
  public class HomeWork03 {
      public static void main(String[] args) {
          String name = "Ma De Kang";
          System.out.println(getName(name));;
      }
      public static String getName(String name) {
          //可以提前验证一下字符串的格式
          String[] s = name.split(" ");
          String newName = s[2] + "," + s[0] + "." + s[1].charAt(0);\
          //使用format方法更为方便简单
          return newName;
      }
  }

• package com.mdklea.homework1;
  ​
  ​
  import java.util.Scanner;
  ​
  public class HomeWork02 {
      public static void main(String[] args) {
          try {
              register();
          } catch (Exception e) {
              System.out.println(e.getMessage());
          }
      }
      public static void register() {
          Scanner sc = new Scanner(System.in);
          System.out.print("请输入用户名：");
          String Username = sc.next();
          if (!(Username.length() > 1 && Username.length() < 5)){
              throw new RuntimeException("用户名长度错误！长度应为2、3、4！");
          }
          System.out.print("请输入密码: ");
          String psd = sc.next();
          if (!(psd.length() == 6 &&isDigital(psd))){
              throw new RuntimeException("密码长度或格式错误！要求长度为6，且均为数字！");
          }
          System.out.print("请输入邮箱：");
          String email = sc.next();
          int isdout = email.indexOf(".");
          int isat = email.indexOf("@");
          if (!(isdout != -1 && isat != -1 && isdout - isat > 0)){
              throw new RuntimeException("邮箱的格式错误!");
          }
      }
      public static boolean isDigital(String psd) {
          char[] chars = psd.toCharArray();
          for (int i = 0; i < chars.length; i++) {
              if (chars[i] < '0' && chars[i] > '9'){
                  return false;
              }
          }
          return true;
      }
  }