09.Java常用基础类

今年花胜去年红。可惜明年花更好，知与谁同？

——欧阳修《浪淘沙》

[TOC]

Java中常用基础类

1. API

API(Application Programming Interface)，应用程序编程接口。Java API是一本程序员的 字典 ，是JDK中提供给我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。所以我们可以通过查询API的方式，来学习Java提供的类，并得知如何使用它们。

• Java中的API，就是JDK提供的各种功能的Java类。
• JDK帮助文 JAVA_API_CN.chm
• 官网地址：http://www.oracle.com/technetwork/java/api-141528.html

2. Scanner类

1. Scanner类一个可以解析基本类型和字符串的简单文本扫描器,扫描控制台的输入,带入到程序中。(输入的内容，不管你输入的是什么，扫描器拿到的全部都是字符串，然后进行的强制的类型转换.)

2. 我们在使用Idea开发的时候，常用的junit的测试但是IntelliJ IDEA控制台junit不能用Scanner输入。如果想要使用它，需要进行一下配置：解决IntelliJ IDEA控制台junit不能用Scanner输入

3. System.in获取键盘输入的数据流 系统输入指的是通过键盘录入数据。

4. Scanner类常用的方法：

   1. scanner.nextInt(); 获取一个整型的数据
   2. scanner.next(); 获取的是字符串–next()方法读取到空白符就结束；
   3. scanner.nextLine(); nextLine一次读取一行–nextLine()读取到回车结束也就是“\r”

public static void main(String[] args) {
    
    //创建一个扫描器。System.in获取键盘输入的数据流
    Scanner scanner = new Scanner(System.in);
    
    int num = scanner.nextInt();//获取一个整型的数据
    System.out.println("num = " + num);
    
    String str = scanner.next();//.next获取的是字符串。
    System.out.println("str = " + str);
    
    /**   
    next()方法读取到空白符就结束；nextLine()读取到回车结束也就是“\r”
    */
    
    String str1 = scanner.nextLine();//nextLine一次读取一行。
    System.out.println("str1 = " + str1);

}

3. Random类

Random类常用方法:

1. random.nextInt(); 在int值范围生成随机数
2. random.nextInt(521); [0,521)
3. random.nextInt(10) + 20; [20,30)

/**
 * Random r = new Random();
 * 获取一个int类型的随机数，（作用范围是int的范围） int num = r.nextInt();
 * 如果获取一个int类型的随机数（作为范围0-3之间。[0,3)） int num = r.nextInt(3);
 */

public static void main(String[] args) {
    //创建一个Random对象，注意Math有一个random()方法
    Random random = new Random();
    
    int num1 = random.nextInt();//在int值范围生成随机数
    System.out.println("num1 = " + num1);
    
    int num2 = random.nextInt(521);//[0,521)
    System.out.println("num2 = " + num2);

    for (int i = 0; i < 10; i++) {
        int num = random.nextInt(10);//[0,10)
        System.out.println("num = " + num);
     }
    
   
    //3-8 [3,8)  -3   [0,5) random.nextInt(5) + 3;
    int num3 = random.nextInt(5) + 3;
    System.out.println("num3 = " + num3);
    
    //20-30     [20,30)
    int num4 = random.nextInt(10) + 20;
    System.out.println("num4 = " + num4);
    
}

二分法猜数字：1-100以内的一个数字。

public static void main(String[] args) {
    
    Random random = new Random();
    int num1 = random.nextInt(100) + 1;//[1,100)
    Scanner scanner = new Scanner(System.in);
    
    int i = 1;
    while (true) {
        System.out.println("请输入你第" + (i++) + "次猜测的值：");
        int num2 = scanner.nextInt();
        if (num1 == num2) {
            System.out.println("恭喜你猜了" + i + "猜对了，随机值为：" + num1);
            break;
        } else if (num1 > num2) {
            System.out.println("猜小了");
        } else {
            System.out.println("猜大了");
        }
    }
}

4. String类

String 类代表字符串，Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。程序中所有用双引号引起来的字符串，都是String的对象。（就算没有写new ,也是String类的对象）

特点：

1. 字符串的内容永不可变。

2. 因为字符串的内容不可以改变。所以字符串是可以共享使用的。

3. 字符串从效果上来说的话有点类似于char[],但是底层的实现用的是byte[];

4.1 创建字符串对象的方式

//第一种创建字符串等方式：创建一个空白字符串 
String  str  =  new  String();

//第二种创建字符串的方式：创建一个byte[]的字符串
byte[] bytes = new byte[]{97, 98, 99, 100};
 String str1 = new String(bytes);

//第三种创建字符串的方式： 根据字符数组的内容，创建一个对应的字符串。
char[] chars = new char[] {'a', 'b', 'c', 'd'};
 String str2 = new String(chars);

//第四种创建字符串的方式：字面量的方式创建,右边直接使用双引号的形式
String  str = "hello"； 

4.2 字符串常量

字符串常量池：程序中直接写上上引号的字符串，就存储在字符串常量池中。

• 如果是基本数据类型：== 比较的数值

• 如果是引用数据类型：== 比较的是内存地址。

• String 专门给我们提供了一个方法用于字符串的比较：

  • 使用equals方法来完成字符串的比较。字符串使用equals比较的时候，比较是字符串里面的每一个字符。

4.3 字符串类常用方法

• .length(); //获得字符串的长度

• str1.concat(String str2); //字符串的拼接一般不用，因为和“+”效果一样

• .charAt (int index); //获取某个索引处的字符

• .indexOf(String str); //查找str在字符串中的首次出现的位置。如果没有查找到对应的字符串，那么返回的索引号为**-1**

String str = "mmaiddd";
//.length()获取字符串的长度
System.out.println("str.length = " + str.length());//7

//concat();字符串的拼接
String str1 = "520";
//String concat = str.concat(str1);//
String concat = str + str1;//推荐使用字符串拼接用  +
System.out.println("concat = " + concat);

//charAt(); 获取指定索引号位置的字符；
char c = "mmaiddd".charAt(1);
System.out.println("c = " + c);//m

//indexOf();查找某字符串在本字符串中第一次出现的位置的索引
//如果没有查找到对应的字符串，那么返回的索引号为-1
int mmIndex = "mmanddd,mmanddd,ddandmm,ddandmm".indexOf("mm");
System.out.println("mmIndex = " + mmIndex);//0

• .substring(int index); // 截取字符串，从字符串索引为index的位置开始截取，一直截取到最后, 原始的字符串没有发生任何变化。

• substring(int begin, int end); //字符串截取, 包前不包后[ begin , end )

String str = "Hello justweb";
//截取字符串，从字符串索引为6的位置开始截取，一直截取到最后。
String subString = str.substring(6);
System.out.println("subString = " + subString);//justweb

//原始的字符串没有发生任何变化。
System.out.println("str = " + str);//Hello justweb


String str2 = "Hello world";
//包前不包后[3,4)
String substring1 = str2.substring(3, 4);
System.out.println("substring1 = " + substring1);//l

• .toCharArray(); //将当前的字符串拆分成字符数组并返回。
• .getBytes(); //将字符串转成字节数组。
• .replace (oldString,newString); //替换字符串
• public String[] split(String regex) //将此字符串按照给定的regex（规则）拆分为字符串数组

  public static void main(String[] args) {
      String str1 = "hello justweb";

      // 将字符串转成字节数组
      char[] chars = str1.toCharArray();
      // Arrays.toString(chars) = [h, e, l, l, o,  , j, u, s, t, w, e, b]
      System.out.println("Arrays.toString(chars) = " + Arrays.toString(chars));
      
      // 将字符串转成字节数组
      byte[] bytes = str1.getBytes();
      // Arrays.toString(bytes) = [104, 101, 108, 108, 111, 32, 106, 117, 115, 116, 119, 101, 98]
      System.out.println("Arrays.toString(bytes) = " + Arrays.toString(bytes));
      
      // 替换文本replace
      String str2 = "你好，帮我问候一下你的家人。";
      String str3 = str2.replace("家人", "**");
      // str3 = 你好，帮我问候一下你的**。
      System.out.println("str3 = " + str3);
      
      String s = "aa|bb|cc"; 
      // ["aa","bb","cc"]
String[]  strArray  = s.split("|");  
  }

5. Arrays类

1. 工具类

2. java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单。

3. 操作数组的方法：

   1. boolean equals(int[] a,int[] b); 判断两个数组是否相等
   2. void fill(int[] a,int val); 填充到数组中
   3. void sort(int[] a); （快速排序）对数组进行排序。
   4. int binarySearch(int[] a,int key); 对排序后的数组进行二分法检索指定的值
   5. String toString(int[] a); 输出数组信息。

public static void main(String[] args) {

    int[] arr1 = new int[]{1, 2, 3, 4};
    int[] arr2 = new int[]{1, 2, 3, 4};
    
    // 判断两个数组是否相等
    boolean flag = Arrays.equals(arr1, arr2);
    // true
    System.out.println("flag = " + flag);


    int[] arr3 = new int[5];
    //填充到数组中
    Arrays.fill(arr3, 6);
    //6 6 6 6 6
    System.out.println(Arrays.toString(arr3));
    
    //自己也可以封装,[1 , 3)
    Arrays.fill(arr3, 1, 3, 8);//6 8 8 6 6
    System.out.println(Arrays.toString(arr3))

        
    int[] arr4 = new int[]{1, 4, 5, 2, 3, 6};
    
    //底层是经过调优的快速排序法
    Arrays.sort(arr4);
    System.out.println(Arrays.toString(arr4));

    //使用二分查找，数据基本有序。
    int[] arr5 = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
    int i = Arrays.binarySearch(arr5, 8);
    System.out.println("i = " + i);

}

1. Arrays.sort();

   1. 对基本数据类型数组的排序

      1. 数字排序：

         int[] intArray = new int[]{1,56,-5,33};
         Arrays.sort(intArray);
         System.out.println(Arrays.toString(intArray));

      2. 反向排序

         // Arrays类之只是提供了默认的升序排列，没有提供相应的降序排列方法
         Arrays.sort(strArray, Collections.reverseOrder());

   2. 对对象数组的排序：要实现对对象数组的排序，要先实现Comparable或者Comparator接口。下面先简单了解以下这两个接口以及它们的差别，后面会再接触到。

      1. Comparable 是排序接口,若一个类实现了Comparable接口，就意味着“该类支持排序”。
      2. 即然实现Comparable接口的类支持排序，假设现在存在“实现Comparable接口的类的对象的List列表(或数组)”，则该List列表(或数组)可以通过 Collections.sort（或 Arrays.sort）进行排序。

6. Math类

1. 工具类
2. java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。
3. 基本运算的方法:
   1. Math.abs(‐5); 取绝对值
   2. Math.ceil(a); 向上取整
   3. **Math.floor(a);**向下取整
   4. **Math.round(a);**四舍五入
   5. Math.PI π

7. ArrayList类

1. java.util.ArrayList 是大小可变的数组的实现，存储在内的数据称为元素。此类提供一些方法来操作内部存储的元素。 ArrayList 中可不断添加元素，其大小也自动增长.

7.1 引入——数组的特点

1. 数组的长度是固定的，无法适应数据变化的需求
2. 为了解决这个问题，Java提供了另一个容器 java.util.ArrayList 集合类,让我们可以更便捷的存储和操作对
   象数据。
3. 引入ArrayList，模拟其底层实现：

public class DemoArrayList {
    // 数组初始长度
    public static int initNum = 8;
    // 扩展为原来长度的1.5倍。
    public static int initExtend;
    // 初始化数组
    public static int[] arr2 = new int[initNum];

    // 数组下标
    public static int index = 0;

    public static void main(String[] args) {
        //定义一个数组，将 1,3,5,7,9,11,15个数字添加到数组中。
        extend(1);
        extend(3);
        extend(5);
        extend(7);
        extend(9);
        extend(11);
        // 添加第7个数
        int[] arr4 = extend(15);
        System.out.println("Arrays.toString(arr4) = " + Arrays.toString(arr4));

    }

	/**
	* 我们发现实现数组的动态扩容，其实是根据我们添加到数组的具体情况来进行适当扩容的
	* 当然我们也可以根据自己的情况和需求来改变扩容策略。
    */
    public static int[] extend(int num) {
        // 数组初始长度为initNum = 8
        // 当数组的长度等于或大于初始长度的时候，进行以下操作 
        if (size >= initNum) {
            // 对数组进行扩容1.5倍
            initNum = initNum + initNum >> 2;
            // 新建数组
            int[] arr3 = new int[initNum];

            // 将原来的数组复制到新数组中
            for (int i = 0; i < arr2.length; i++) {
                arr3[i] = arr2[i];
            }
            
            //让arr2指向新数组
            arr2 = arr3;
        }
        // 向数组中添加数据
        arr2[size++] = num;
        // 返回数组
        return arr2;
    }
}

7.1 ArrayList基础

1. 对于java.util.ArrayList <E>来说 有一个 代表的就是泛型

   1. 泛型：指定在集合中的元素必须是什么数据类型的。
   2. 要求：泛型必须是引用数据类型，不能是基本数据类型，所以，
   3. ==如果填写数值的话要使用对应的数值的包装类作为泛型。==
   4. ArrayList<String>，ArrayList<Student>

2. 查看构造方法

   1. public ArrayList() ：构造一个内容为空的集合。

   2. ~~~~java
      // 基本格式:
      ArrayList list = new ArrayList();

      #### 7.3 常用方法和遍历 
      
      对于元素的操作,基本体现在——增、删、查。常用的方法有：
      
      - `public boolean add(E e) `：将指定的元素添加到此集合的尾部。
      - `public void add(int index, E element)`：在此列表中的指定位置插入指定的元素。  将当前位于该位置的元素（如果有）和任何后续元素（向其索引添加一个）移动。 
      - `public E remove(int index) `：移除此集合中指定位置上的元素。返回被删除的元素。
      - `public E get(int index) `：返回此集合中指定位置上的元素。返回获取的元素。
      - `public E set(int index,E element)`：用指定的元素替换此列表中指定位置的元素。
      - `public int size()` ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。 
      
      
      #### 7.4 如何存储基本数据类型 
      
      1. ArrayList对象不能存储基本类型，只能存储引用类型的数据。类似` <int> `不能写，但是存储基本数据类型对应的包装类型是可以的。所以，想要存储基本类型数据，` <>` 中的数据类型，必须转换后才能编写，转换写法如下：
      2. 我们发现，只有 Integer 和 Character 需要特殊记忆，其他基本类型只是首字母大写即可。 
      
      | **基本类型** | **基本类型包装类** |
      | ------------ | ------------------ |
      | byte         | Byte               |
      | short        | Short              |
      | int          | Integer            |
      | long         | Long               |
      | float         | Float              |
      | double       | Double             |
      | char         | Character          |
      | boolean      | Boolean            |
      
      #### 7.5 ArrayList底层简单分析
      
      其他内容会对其底层进行详细的分析。
      
      ~~~~java
      // 初始容量(添加一个元素后)
      private static final int DEFAULT_CAPACITY = 10;
      
      // 集合刚创建的时候的，元素的数据为{};
      private static final Object[] EMPTY_ELEMENTDATA = {};
      
      // 默认数组元素的内容
      private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}
      
      // 真正存储数据的数组。
      Object[] elementData ;
      
      // 添加的元素的个数。
      int  size

8. Date类

1. 在使用println方法时，会自动调用Data类中的toString方法。Date类对Object类中的toString方法进行了覆··盖重写所以结果为指定格式的字符串。
2. new Date(); 返回的是当前时间–Thu May 14 14:41:13 CST 2020
3. new Date(0); 时间元年CST –Thu Jan 01 08:00:00 CST 1970
   1. 由于我们处于东八区，所以我们的基准时间为1970年1月1日8时0分0秒。
4. date.getTime(); 返回的是定义的时间零点到当前时间的毫秒值–1589438473138

public static void main(String[] args) {
    
    Date date = new Date();
    
    // 返回的是当前时间  
    System.out.println("date = " + date);
    
    // 返回的是定义的时间零点到当前时间的毫秒值
    System.out.println("date.getTime() = " + date.getTime());

    Date date1 = new Date(0);
    // 时间元年CST（China Standard Time）
    System.out.println("date1 = " + date1);
}

9. DateFormat 类

java.text.DateFormat 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转

换,也就是可以在Date对象与String对象之间进行来回转换。由于DateFormat为抽象类，不能直接使用，所以需要常用的子类 java.text.SimpleDateFormat 。

• 格式化：public String format(Date date);按照指定的格式，从Date对象转换为String对象。
• 解析：public Date parse（String source）;按照指定的格式，从String对象转换为Date对象。

SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");

// DateFormat类常用方法
// 把Date对象转换成String
format.format();
// 把String转换成Date对象
format.parse();

9.1 请使用日期时间相关的API，计算出一个人已经出生了多少天。

思路：

1. 获取当前时间对应的毫秒值

2. 获取自己出生日期对应的毫秒值

3. 两个时间相减（当前时间– 出生日期）

public static void function() throws Exception {
    System.out.println("请输入出生日期 格式 YYYY‐MM‐dd");
    
    // 获取出生日期,键盘输入
    String birthdayString = new Scanner(System.in).next();
    
    // 将字符串日期,转成Date对象
    // 创建SimpleDateFormat对象,写日期模式
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy‐MM‐dd");
    
    // 调用方法parse,字符串转成日期对象
    Date birthdayDate = sdf.parse(birthdayString);
    
    // 获取今天的日期对象
    Date todayDate = new Date();
    
    // 将两个日期转成毫秒值,Date类的方法getTime
    long birthdaySecond = birthdayDate.getTime();
    long todaySecond = todayDate.getTime();
    long secone = todaySecond‐birthdaySecond;
    
    if (secone < 0){
        System.out.println("还没出生呢");
     } else {
        System.out.println(secone/1000/60/60/24);
     }
}

10. Calendar 类

1. java.util.Calendar 是日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。日历类就是方便获取各个时间属性的。

2. 获取方式Calendar为抽象类，由于语言敏感性，Calendar类在创建对象时并非直接创建，而是通过静态方法创建，返回子类对象。

   // 使用默认时区和语言环境获得一个日历
   Calendar calendar = Calendar.getInstance();

3. 常用方法：

   1. public int get(int field) ：返回给定日历字段的值。
   2. public void set(int field, int value) ：将给定的日历字段设置为给定值。
   3. public abstract void add(int field, int amount) ：根据日历的规则，为给定的日历字段添加或减去指定的时间量
   4. public Date getTime() ：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。

字段值	含义
YEAR	年
MONTH	月（从0开始，可以+1使用）
DAY_OF_MONTH	月中的天（几号）
HOUR	时（12小时制）
HOUR_OF_DAY	时（24小时制）
MINUTE	分
SECOND	秒
DAY_OF_WEEK	==周中的天（周几，周日为1，可以使-1 使用）==

get/set方法

1. get方法用来获取指定字段的值
2. set方法用来设置指定字段的值

public class CalendarUtil {
    public static void main(String[] args) {
        
        // 创建Calendar对象
        Calendar cal = Calendar.getInstance();
        
        // 设置年
        int year = cal.get(Calendar.YEAR);
        
        // 设置月
        int month = cal.get(Calendar.MONTH) + 1;
        
        // 设置日
        int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH);
        
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日");
    }
}

public class CalendarMethod {
    public static void main(String[] args) {
        
        Calendar cal = Calendar.getInstance();
        
        cal.set(Calendar.YEAR, 2020);
         // 2020年1月17日
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); 
    }
}

1. add方法可以对指定日历字段的值进行加减操作，如果第二个参数为正数则加上偏移量，如果为负数则减去偏移量。

public class Demo08CalendarMethod {
    public static void main(String[] args) {
        
        Calendar cal = Calendar.getInstance();
        
        // 2018年1月17日
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); 
        // 使用add方法
        cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天
        cal.add(Calendar.YEAR, ‐3); // 减3年
        
         // 2015年1月18日;
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日");
    }
}

Calendar中的getTime方法并不是获取毫秒时刻，而是拿到对应的Date对象。

public class Demo09CalendarMethod {

    public static void main(String[] args) {

        Calendar cal = Calendar.getInstance();

        Date date = cal.getTime();

        System.out.println(date); // Tue Jan 16 16:03:09 CST 2018

    }
}

1. 西方星期的开始为周日，中国为周一。
2. 在Calendar类中，月份的表示是以0-11代表1-12月。
3. 日期是有大小关系的，时间靠后，时间越大。

11. System类

1. java.lang.System 类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作。
2. 在System类的API文档中，常用的方法有：
   1. public static long currentTimeMillis() ：返回以毫秒为单位的当前时间.
   2. public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：**将数组中指定的数据拷贝到另一个数组中**
      1. src ： 数据源
      2. srcPos : 起始位置
      3. dest ： 目标位置
      4. destPos： 起始复制位置
      5. length : 复制长度

public static void main(String[] args) {
    int[] arr1 = {1,2,3,4,5,6};
    int[] arr2 = {7,8,9,10,11};
    System.arraycopy(arr1,0,arr2,0,4);
    // [1, 2, 3, 4, 11]
    System.out.println(Arrays.toString(arr2));
}

☆