Java API

String類

String類概述

- 字符串是一個特殊的對象。
- 字符串一旦初始化就不可以被改變。
- String s1 = “abc”;//存放在方法區的常量池中，內存中只有一個對象
  String s2 = new String(“abc”);//內存中有兩個對象
- String類覆寫了Object類的的equals()方法，用於比較兩個字符串的內容是否相同。
- 例如：
```
package cn.itcast.heima;

public class Test {
	public static void main(String[] args) {
		String s1 = "abc";
		String s2 = new String("abc");
		String s3 = "abc";//s3和s1指向同一個對象
		
		System.out.println(s1 == s2);
		System.out.println(s1 == s3);
	}
}
```
  打印結果：

String類部分方法

- 獲取：
  1. 字符串的長度：
    - int length();
  2. 根據位置獲取某個字符：
    - char charAt(int index);
  3. 根據字符獲取在字符串中的位置：
    - int indexOf(int ch);返回ch在此字符串中第一次出現處的索引。
    - int indexOf(int ch, int fromIndex);從fromIndex指定位置開始，獲取ch在此字符串中第一次出現處的索引。
    - int indexOf(String str);返回str在此字符串中第一次出現處的索引。
    - int indexOf(String str, int fromIndex);從fromIndex指定位置開始，獲取str在此字符串中第一次出現處的索引。
    - int lastIndexOf(int ch);返回ch在此字符串中最後一次出現處的索引。
  4. 根據位置獲取子串：
    - String substring(int beginIndex);//從指定位置開始到結尾
    - String substring(int beginIndex, int endIndex);//包含頭，不包含尾
- 判斷：
  1. 字符串中是否包含某一子串:：
    - boolean contains(CharSequence s);
    - indexOf方法也可以判斷是否包含，如果返回-1，表示s不在字符串中存在。同時還可以獲取第一次出現的位置。
  2. 字符串中是否有內容：
    - boolean isEmpty();
  3. 字符串中是否以指定內容開頭：
    - boolean startsWith(String str);
  4. 字符串中是否以指定內容結尾：
    - boolean endsWith(String str);
  5. 字符串的內容是否相同：
    - boolean equals(Object anObject);//重寫了Object類中的equals方法
  6. 字符串的內容是否相同，並忽略大小寫：
    - boolean equalsIgnoreCase(String anotherString);
- 轉換：
  1. 將字符數組轉成字符串：
    - 構造函數
      - Sting(char[] value);
      - String(char[] value, int offset, int count);
    - 靜態方法
      - static String copyValueOf(char[] data);
      - static String copyValueOf(char[] data, int offset, int count);
      - static String valueOf(char[] data);
      - static String valueOf(char[] data, int offset, int count);
  2. 將字符串轉成字符數組：
    - char[] toCharArray();
  3. 將字節數組轉成字符串：
    - 構造函數
      - Sting(byte[] bytes);
      - String(byte[] bytes, int offset, int count);
  4. 將字符串轉成字節數組：
    - byte[] getBytes();
  5. 將基本數據類型轉成字符串：
    - 靜態valueOf方法
- 替換：
  - String replace(char oldChar, char newChar);
  - String replace(CharSequence target, CharSequence replacement);
- 切割：
  - String[] split(String regex);
- 大小寫轉換，去除空格，比較：
  1. 將字符串轉成大寫或者小寫：
    - String toUpperCase();
    - String toLowerCase();
  2. 將字符串兩端的多個空格去除：
    - String trim();
  3. 對兩個字符串進行自然順序的比較：
    - int compareTo(String anotherString);
    - int compareToIgnoreCase(String str);

StringBuffer類

StringBuffer類概述

- StringBuffer是字符串緩衝區，是一個容器。
- String類型變量初始化後不能改變，StringBuffer初始化後還可以改變。
- StringBuffer對象調用成員方法後返回的StringBuffer對象還是該對象本身，String對象調用成員方法後返回的String對象爲另一個新的對象。
- StringBuffer長度可變化，可以操作不同數據類型，最終可以通過toString方法轉成字符串。

StringBuffer部分方法

- 存儲：
  - StringBuffer append(int x);//將指定數據作爲參數添加到已有數據的結尾處
  - StringBuffer insert(int index,String str);//將數據插入到指定位置
- 刪除：
  - StringBuffer delete(int start, int end );//包含頭，不包含尾
  - StringBuffer deleteCharAt(int index);移除指定位置的char
- 獲取：
  - char charAt(int index);
  - int indexOf(String str);
  - int lastIndexOf(String str);
  - int length();
  - String substring(int start, int end);//該方法返回類型爲String，不是StringBuffer
  - void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin);//將緩衝區中的指定數據存儲到指定字符數組的指定位置中
- 修改：
  - StringBuffer replace(int start, int end, String str);
  - void setCharAt(int index, char ch);//該方法無具體返回值
- 反轉：
  - StringBuffer reverse();

StringBuilder類

- StringBuilder是StringBuffer的一個簡易替換，StringBuffer是同步的，StringBuilder是非同步的。
- 沒有多線程問題時，建議使用StringBuilder，可以提高效率。
- 多線程時，可以使用StringBuffer，或者使用StringBuilder並自己加鎖。
- java版本升級的原則：提高效率，簡化書寫，提高安全性。

基本數據類型對象包裝類

基本數據類型對象包裝類概述

- 將基本數據類型封裝成對象的好處在於可以在對象中定義更多的功能方法操作該數據。
- 常用的操作之一：用於基本數據類型與字符串之間的轉換。
- 基本數據類型與對應的包裝類：
  基本類型包裝類型
  byte Byte
  short Short
  int Integer
  long Long
  boolean Boolean
  float Float
  double Double
  char Character

包裝類的常用操作

- 基本數據類型轉成字符串：
  - Integer.toString(int i);
- 字符串轉成基本數據類型：
  - Integer.parseInt(String s);
- 十進制轉成其他進制：
  - Integer.toBinaryString(int i);
  - Integer.toHexString(int i);
  - Integer.toOctalString(int i);
- 其他進制轉成十進制：
  - Integer.parseInt(String s, int radix);//使用radix指定的基數，將s解析爲有符號的整數。
- 基本數據類型轉成包裝類型：
  - 構造函數：Integer(int value);
- 包裝類型轉成基本數據類型：
  - int intValue();

基本數據類型對象包裝類新特性

- JDK1.5以後，簡化了定義方式。
  - Integer x = 4;//自動裝箱。相當於Integer x = new Interger(4);
  - x = x + 2;//x進行自動拆箱，變成了int類型，運算後的和進行裝箱再賦給x。
- 包裝類型可以賦值爲null
  - 在使用時，Integer x = null;上面的代碼x = x + 2;就會出現NullPointerException。
- 面試問題：
```
package cn.itcast.heima;

public class Test {
	public static void main(String[] args) {
		Integer m = 128;
		Integer n = 128;
		System.out.println(m == n);
		
		Integer a = 127;
		Integer b = 127;
		System.out.println(a == b);
	}
}
```
  打印結果：
  
  解釋：
  當數值在byte範圍內時，對於新特性，如果該數值已經存在，則不會再開闢新的內存空間。
  因此a和b指向了同一個Integer對象。

集合類

體系概述

- 爲什麼出現集合類：
  - 面嚮對象語言對事物的體現都是以對象的形式，所以爲了方便對多個對象的操作，就對對象進行存儲，集合就是存儲對象最常用的一種方式。
- 數組和集合類的比較：
  - 數組長度是固定的；數組中可以存儲基本數據類型；數組只能存單一類型的對象。
  - 集合長度是可變的；集合只能存儲對象；集合可以存儲不同類型的對象。
- 集合框架的構成及分類：
- 爲什麼會出現各種容器：
  - 因爲集合框架下每一個容器對數據的存儲方式都有不同，這個存儲方式稱之爲：數據結構。

迭代器

- 迭代是取出集合中元素的一種方式。
- 因爲Collection中有iterator方法，可以返回Iterator類型接口的子類對象，所以每一個子類集合對象都具備迭代器。
- 迭代器用法：
  
  或者
- 迭代器的原理：
  - 每個容器都有負責判斷元素和取出元素的內部類，這些容器的內部類向上抽取就形成了Iterator接口。
  - 爲了獲取內部類的對象，每個容器都對外提供了iterator()方法。

Collection接口下的兩個子接口

List

- 元素是有序的，元素可以重複。因爲該集合體繫有索引。如果需要去重，需要手動調用方法進行判斷。List集合判斷元素是否相同，依據的是元素的equals方法。

List集合特有方法：凡是可以操作角標的方法都是List的特有方法。

- 增：
  - void add(int index, E element);
  - boolean addAll(int index, Collection<? extends E> c);
- 刪：
  - E remove(int index);
- 改：
  - E set(int index, E element);
- 查：
  - E get(int index);
  - List<E> subList(int fromIndex, int toIndex);
  - ListIterator<E> listIterator();
  - int indexOf(Object o);
  - int lastIndexOf(Object o);

ListIterator

- ListIterator是Iterator的子接口，是List特有的迭代器。
- 在迭代時，由於迭代器和集合同時引用對象，所以不能用集合對象的方法操作集合中的元素，否則會發生ConcurrentModificationException異常，即併發修改異常。
- 在迭代時，只能用迭代器的方法操作元素，而Iterator方法有限，只能對元素進行判斷、取出、刪除的操作，所以定義了其子接口ListIterator，從而實現更多的操作元素的方法，如添加、修改等。
- ListIterator接口只能通過List接口的listIterator方法獲取。
- ListIterator能夠實現在遍歷過程中的增刪改查。

List接口中的常用類（底層的數據結構不同）

ArrayList：底層的數據結構使用的是數組結構。特點：查詢速度快，但是增刪稍慢。線程不同步。
LinkedList：底層使用的是鏈表數據結構。特點：增刪速度快，查詢稍慢。線程不同步。
- LinkedList的特有方法：
  - void addFirst(E e);
  - void addLast(E e);
  - E getFirst();
  - E getLast();
  - E removeFirst();
  - E removeLast();
  - 注：獲取和刪除操作中，集合爲空時拋出異常NoSuchElementException。插入操作中，插入失敗時也會拋出異常。
- JDK1.6出現了相應的替代方法：
  - boolean offerFirst(E e);
  - boolean offerLast(E e);
  - E peekFirst();
  - E peekLast();
  - E pollFirst();
  - E pollLast();
  - 注：這些方法不會拋出異常。
Vector：底層的數據結構使用的是數組結構。線程同步，但速度慢，已被ArrayList替代。

Vector中的枚舉

Enumeration<E> elements();//枚舉是Vector特有的取出元素方式。
由於枚舉的名稱及其方法名稱都過長，所以被迭代器取代了。

Set：

- 元素是無序的，元素不可以重複。系統自動去重，用戶只需要對自定義的類設置好判斷標準即可。
- Set功能和Collection一致。沒有特有方法。

Set接口中的常用類

HashSet：底層數據結構是哈希表。特點：存取速度快，線程是非同步的。
- HashSet集合判斷元素是否相同，依據的是元素的equals方法和hashCode 方法。
- 數據存入HashSet時，先比較元素的hashCode值，如果不同，直接存入；如果相同，再比較是否爲同一個對象，如果equals方法返回false，也存入集合。
- hashCode函數的作用：
  1. 可以提高查找效率。
  2. 前提是對象存儲在採用hash算法的集合中。
  3. 不能修改參與計算hash值的字段，否則找不到原來的對象，會導致無法刪除對象而內存泄漏。
TreeSet：底層數據結構是二叉樹。特點：可以對Set中的元素進行排序（按照自然順序），線程是非同步的。
1. TreeSet集合判斷元素是否相同，依據的是元素的compareTo方法。當該方法返回0時，表示是重複元素，插入失敗。
  - 所有插入TreeSet的元素都必須實現Comparable接口，覆蓋compareTo方法。
  - 當compareTo方法返回0時，表示是重複元素，插入失敗。
2. 當元素自身不具備比較性，或者具備的比較性不是所需要的，這時需要讓容器自身具備比較性。
  - 在初始化容器時，將比較器作爲參數傳入TreeSet的構造函數。
  - 定義比較器：定義類實現Comparator接口，覆蓋compare方法。
  - 當比較器排序和元素自身排序都存在時，以比較器排序爲準。

注意：自定義類要放入容器中，通常要覆寫hashcode,equals方法，實現Comparable接口。這樣就是可以放入HashSet和TreeSet集合中了。

Map集合

Map概述

- Map集合存儲鍵值對。
- Map集合要保證鍵的唯一性。
- Set底層使用的是Map集合。

Map集合的主要方法

添加：
- V put(K key, V value);//在此映射中關聯指定值與指定鍵。如果該映射以前包含了一個該鍵的映射關係，則舊值被替換。
  //返回與 key 關聯的舊值；如果 key 沒有任何映射關係，則返回null。（返回null 還可能表示該映射之前將null 與key 關聯。）
- void putAll(Map<? extends K,? extends V> m);
刪除：
- void clear();
- V remove(Object key);
判斷：
- boolean containsKey(Object key);
- boolean containsValue(Object value);
- boolean equals(Object o);
- boolean isEmpty();
獲取：
- V get(Object key);
- int hashCode();
- int size();
- Collection<V> values();
- Set<Map.Entry<K,V>> entrySet();
- Set<K> keySet();

Map集合中的常用類

Hashtable：底層是哈希表數據結構，不可以存入null鍵null值。特點：線程同步。JDK1.0 效率低。已被HashMap替代。
HashMap：底層是哈希表數據結構，可以存入null鍵null值。特點：線程不同步。JDK1.2 效率高。
TreeMap：底層是二叉樹數據結構。特點：線程不同步。可以用於給Map集合中的鍵進行排序。

Map集合取出元素的方式：將map集合轉成set集合，再通過迭代器取出。

keySet：
- 將map中所有的鍵存入到Set集合。
- 因爲Set具有迭代器。用迭代方式取出所有的鍵，再根據Map集合的get方法，獲取每一個鍵的值。
entrySet：
- 將Map集合中的映射關係存入到Set集合。這個關係的數據類型是Map.Entry。
- Map.Entry是Map接口中的一個內部接口。
- 因爲Set具有迭代器。用迭代方式取出所有的Map.Entry對象，再根據Map.Entry的getKey和getValue方法，獲取關係中的鍵和值。

Map與Collection的比較

- Map與Collection在集合框架中屬並列存在。
- Map存儲的是鍵值對，是一個雙列集合。Collection是一個單列集合。
- Map存儲元素使用put方法，Collection使用add方法。
- Map集合沒有直接取出元素的方法，而是先轉成Set集合，在通過迭代獲取元素。
- Map集合中鍵要保證唯一性。

泛型

- 泛型概述
  - 泛型是1.5版本後出現的新特性，用於解決安全問題，是一個類型安全機制。
  - 好處：
    - 提高了程序的安全性。
    - 將運行時期可能出現的問題ClassCastException，轉移到了編譯時期。
    - 省去了類型強轉的麻煩。
    - 泛型類的出現優化了程序設計。
- 泛型的泛型使用
  - 泛型的書寫格式：通過<>來定義要操作的引用數據類型。
  - 什麼時候使用泛型：通常在集合框架中很常見，只要見到<>就要定義泛型。
- 自定義泛型類
  - 什麼時候定義自定義泛型類：
    - 當類中要操作的引用數據類型不確定時（基本數據類型不能用泛型）。
    - 早期定義Object類完成擴展，現在定義泛型完成擴展。
- 自定義泛型方法
  - 什麼時候定義自定義泛型方法：
    - 爲了可以讓不同方法操作不同的引用數據類型，而且類型不確定，就可以將泛型定義在方法上。
    - 多次使用同一個對象的同一個泛型方法，可以傳入不同類型的參數。
    - 可以在泛型類中定義泛型方法。類上的泛型和方法上的泛型沒有任何關係。
    - 泛型定義在方法上時，放在修飾符後面，返回類型前面。
  - 靜態方法泛型：
    - 靜態方法不可以訪問類上定義的泛型。
    - 如果靜態方法操作的引用數據類型不確定，可以將泛型定義在靜態方法上，且多次使用可以傳入不同類型的參數。
- 自定義泛型接口
  - 如果繼承泛型接口的類確定類型，可以直接在類繼承的接口後面定義要操作的數據類型。
  - 如果繼承泛型接口的類仍舊不確定類型，可以繼續在類上定義泛型。
- 泛型限定
  - <?>：通配符，也可以理解爲佔位符。
  - 泛型不能使用類型的特有方法，類似於多態。
  - 帶有泛型的賦值行爲，要求左右兩邊的泛型類型一致，子父類之間不能賦值。
  - 泛型限定：
    - <? extends E>:可以接收E類型或者E的子類型。上限。
    - <? super E>:可以接收E類型或者E的父類型。下限。

集合框架中的工具類

Collections

- Collections是集合框架的工具類。
- Collections的所有方法都是靜態的。
- Collections類提供了對集合的常用操作。
- Collections的常用操作：
  - 對List集合進行排序：
    - static <T extends Comparable<? super T>> void sort(List<T> list);//要求List中的元素繼承Comparable接口，具有可比性
    - static <T> void sort(List<T> list, Comparator<? super T> c);//當元素自身具備的比較性不符合要求時，可以定義比較器進行比較
  - 取出集合中的最大值，最小值：前提與sort方法一樣，要求元素具備比較性。
    - static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll);
    - static T max(Collection<? extends T> coll, Comparator<? super T> comp);
    - static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll);
    - static T min(Collection<? extends T> coll, Comparator<? super T> comp);
  - 對集合進行二分查找：
    - static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key);
    - static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c);
  - 替換反轉：
    - static <T> void fill(List<? super T> list, T obj);//將集合中所有元素都替換成指定元素
    - static <T> boolean replaceAll(List<T> list, T oldVal, T newVal);
    - static void reverse(List<?> list);
  - 強行逆轉比較器：
    - static <T> Comparator<T> reverseOrder();//返回一個逆序比較器
    - static <T> Comparator<T> reverseOrder(Comparator<T> cmp);//返回強行逆轉的指定比較器
  - 集合同步：
    - static <T> Collection<T> synchronizedCollection(Collection<T> c);
    - static <T> List<T> synchronizedList(List<T> list);
    - static <K,V> Map<K,V> synchronizedMap(Map<K,V> m);
    - static <T> Set<T> synchronizedSet(Set<T> s);
    - static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m);
    - static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s);
  - 其它方法：
    - static <T> void copy(List<? super T> dest, List<? extends T> src);
    - static void swap(List<?> list, int i, int j);
    - static void shuffle(List<?> list);//對集合中的元素進行隨機排列。可以應用到洗牌、拋色子等程序中。

Arrays

- Arrays是用於操作數組的工具類。
- Arrays的所有方法都是靜態的。
- Arrays類提供了對集合的常用操作。
- Arrays的常用操作：
  - 對數組進行排序：sort方法。
  - 對數組進行二分查找：binarySearch方法。
  - 將數組轉成List集合：
    - static <T> List<T> asList(T... a);//將數組變成List集合。好處：可以使用集合的思想和方法來操作數組中的元素。
    - 注意：
      - 不可以使用asList方法返回的List的增刪方法，因爲數組長度是固定的。
      - 使用增刪方法，會拋出UnsupportedOperationException異常。
      - 如果數組中的元素都是對象，那麼變成集合時，數組中的元素直接轉成集合中的元素。
        如果數組中的元素都是基本數據類型，那麼會將該數組作爲集合中的元素存入。
        例如：
        package cn.itcast.heima; import java.util.Arrays; import java.util.List; public class Test { public static void main(String[] args) { String[] str = {"abc", "bbb", "kk"}; List listStr = Arrays.asList(str);//List中元素的類型爲String System.out.println("listStr:" + listStr); int[] num = {3, 5, 4}; List listInt = Arrays.asList(num);//List中元素的類型爲int[] System.out.println("listInt:" + listInt); Integer[] num2 = {3, 5, 4}; List listInteger = Arrays.asList(num2);//List中元素的類型爲Integer System.out.println("listInteger:" + listInteger); } }
        打印結果：

集合轉成數組

- Collection接口的toArray(T[] a)方法：將集合轉成數組。
- 該方法中數組a的長度：
  - 當數組長度小於集合的size，那麼該方法內部會創建一個新的數組，長度爲集合的size。
  - 當數組長度大於集合的size，就不會創建新的數組，而是使用傳遞進來的數組。
  - 所以創建一個剛剛好的數組最優。
- 爲什麼要將集合轉成數組：
  - 爲了限定對元素的操作。當不需要進行增刪操作了，就可以將集合轉成數組。

增強for循環：foreach

- JDK1.5版本出現的新特性。
- Iterable接口：Collection接口的父接口，實現這個接口允許對象成爲 "foreach" 語句的目標。
- foreach語句格式：
- 注意：
  - 只能對集合進行遍歷，不能對Map遍歷。
  - 只能獲取元素，不能對集合進行操作。
- 迭代器和foreach的比較：
  - foreach簡化了對數組，集合的遍歷。
  - 迭代器除了遍歷，還可以remove集合中的元素。
  - ListIterator還可以在遍歷過程中對集合元素增刪改查。
- 傳統for循環和foreach循環的區別：
  - foreach有一個侷限性，必須有被遍歷的目標。
  - 建議遍歷數組的時候，選擇傳統for循環，因爲可以定義角標。

可變參數

- JDK1.5版本出現的新特性。
- 可變參數書寫格式：
- 數組參數的簡寫形式，不用每次手動建立數組對象。
- 只要將要操作的元素作爲參數傳遞即可，隱式地將這些元素封裝成了數組。
- 可變參數一定要定義在參數列表的最後面。

靜態導入

- JDK1.5版本出現的新特性。
- import static java.util.Arrays.*;//導入Arrays類中的所有靜態成員，代碼中調用Arrays類的靜態成員時可以省略前面的類名Arrays
- 當類名重名時，需要指定具體的包名。
  當方法重名時，需要指定所屬的對象或類名。
- Arrays.toString方法中，不能省略Arrays，因爲和Object類中的toString方法重名。

系統類

System類

- System類用於描述一些系統信息，成員都是靜態的。
- 靜態屬性in爲標準輸入流，屬於InputStream類型，默認是鍵盤。
- 靜態屬性out爲標準打印流，屬於PrintStream類型，默認是控制檯。
- System類的一些常用方法：
  - 獲取系統屬性信息：
    - static Properties getProperties();
    - static String getProperty(String key);
  - 設置系統屬性信息：
    - static void setProperties(Properties props);
    - static String setProperty(String key, String value);
  - 退出Java虛擬機：
    - static void exit(int status);
  - 運行垃圾回收器：
    - static void gc();

Properties類

Properties類是Hashtable子類，也就是Map接口子類。
Properties類表示了一個持久的屬性集。
Properties可保存在流中或從流中加載。
相比Hashtable類，它可以在初始化時就加載某個文件中的鍵值對，也可以將內存中的鍵值對保存到文件中。
Properties類的一些常用方法：
- String getProperty(String key);
- Object setProperty(String key, String value);
- void load(InputStream inStream);//從字節輸入流中讀取屬性列表（鍵和元素對）。
- void load(Reader reader);//從字符輸入流中讀取屬性列表（鍵和元素對）。從1.6版本開始
- void list(PrintStream out);//將屬性列表打印到控制檯。
- void list(PrintWriter out);//將屬性列表打印到控制檯。
- void store(OutputStream out, String comments);//將Properties表中的屬性列表（鍵和元素對）寫入輸出流。用於保存到文件。
- void store(Writer writer, String comments);//將Properties表中的屬性列表（鍵和元素對）寫入輸出流。用於保存到文件。從1.6版本開始
- Set stringPropertyNames();//返回此屬性列表中的鍵集。

代碼舉例：

package cn.itcast.heima;
//修改已存在的配置文件，並保存
import java.io.*;
import java.util.*;
class PropertiesDemo
{
	public static void main(String[] args) throws IOException
	{
		loadDemo();
	}

	public static void loadDemo() throws IOException
	{
		Properties prop = new Properties();
		FileInputStream fis = new FileInputStream("info.txt");

		prop.load(fis);
		//System.out.println(prop);
		prop.setProperty("zhangsan","22");
		//System.out.println(prop);
		FileOutputStream fos = new FileOutputStream("info.txt");//如果要在同一文件上操作，需要先加載文件到流，因爲定義輸出流時，會將原文件覆蓋掉
		prop.store(fos,null);
		prop.list(System.out);

		fis.close();
		fos.close();
	}
}

程序執行效果：將info.txt文件中zhangsan的值修改爲22，並保存。

代碼舉例：

//記錄程序運行次數，如果超過規定次數，給出提示，不運行程序
package cn.itcast.heima;
import java.io.*;
import java.util.*;
class RunCount 
{
	public static void main(String[] args) throws IOException
	{
		Properties prop = new Properties();
		File f = new File("count.ini");
		if (!f.exists())
			f.createNewFile();
		FileInputStream fis = new FileInputStream("count.ini");

		prop.load(fis);

		int count = 0;
		String value = prop.getProperty("time");
		if (value != null)
		{
			count = Integer.parseInt(value);
			if (count >= 5)
			{
				System.out.println("超過規定次數，需要註冊！");
				return;
			}
		}
		count++;
		prop.setProperty("time", count+"");

		FileOutputStream fos = new FileOutputStream(f);
		prop.store(fos,"");

		fis.close();
		fos.close();
	}
}

程序執行效果：運行該程序第5次以後，控制檯顯示“超過規定次數，需要註冊！”。

Runtime類

- 每個Java應用程序都有一個Runtime類實例，使應用程序能夠與其運行的環境相連接。Runtime表示系統運行時狀態。
- Runtime類沒有構造函數，應用程序不能創建自己的Runtime類實例，可以通過 getRuntime 方法獲取當前運行時。
- Runtime類是單例設計模式的體現，保證了應用程序在內存中只創建一個對象。
- Runtime類常用方法：
  - Process exec(String command);//執行命令，並返回Process對象，用於管理子進程

Process類

- 調用底層操作，不需要用戶操作。
- 抽象類，沒有子類。方法都是抽象方法。
- Process類常用方法：
  - abstract void destroy();//殺掉子進程

時間類

Date類

用於創建日期對象。
需要使用DateFormat類來進行格式化，才能顯示想符合習慣的格式。

例如：

package cn.itcast.heima;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Test {
	public static void main(String[] args) {
		Date date = new Date();//創建日期對象
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 E HH:mm:ss");//定義格式化規則
		String formatDate = sdf.format(date);//日期對象格式化
		System.out.println(formatDate);
	}
}

打印結果：

Calendar類

- 使用該類對時間進行操作比較方便。
- 通過常量來表示時間的各種值，如一年中的某一天，一個月的某一天等。
- Calendar類常用方法：將對應的常量作爲形參來調用相應的get、add、set方法來操作
  - static Calendar getInstance();//獲取Calendar子類對象
  - int get(int field);//返回給定日曆字段的值。
  - void set(int field, int value);//將給定的日曆字段設置爲給定值。
  - void add(int field, int amount);//爲給定的日曆字段添加或減去指定的時間量。

數學類

Math類

- Math類包含用於執行基本數學運算的方法，如初等指數、對數、平方根和三角函數。
- Math類所有成員都是靜態的。
- Math類的常用方法：
  - static double ceil(double a);//返回最小的double值，該值大於等於參數，並等於某個整數。
  - static double floor(double a);//返回最大的double值，該值小於等於參數，並等於某個整數。
  - static long round(double a);//返回最接近參數的 long。四捨五入。
  - static double pow(double a, double b);//返回a的b次冪的值。
  - static double random();//返回帶正號的double值，該值大於等於0.0且小於1.0。返回值是一個僞隨機選擇的數。
- 例如：
```
package cn.itcast.heima;

public class Test {
	public static void main(String[] args) {
		System.out.println("Math.ceil(5.34):" + Math.ceil(5.34));
		System.out.println("Math.ceil(-5.34):" + Math.ceil(-5.34));
		System.out.println("Math.floor(5.34):" + Math.floor(5.34));
		System.out.println("Math.floor(-5.34):" + Math.floor(-5.34));
		System.out.println("Math.round(5.34):" + Math.round(5.34));
		System.out.println("Math.round(-5.34):" + Math.round(-5.34));
	}
}
```
  打印結果：

Random類

- 此類的實例用於生成僞隨機數流。
- 該類和調用Math.random()方法的使用效果是一樣的。
- 該類封裝了一些用於獲取隨機數的方法。

杭州的 IT 崩盤了麼？

雲原生週刊：Kubernetes 十週年｜ 2024.6.11

開源高性能結構化日誌模塊NanoLog

Python 潮流週刊#55：分享 9 個高質量的技術類信息源！

WinForm應用實戰開發指南 - 表格數據錄入問題解析

Azure Virtual Network (22) 多訂閱使用Azure DNS解析問題 Windows Azure Platform 系列文章目錄

【簡寫Mybatis-02】註冊機的實現以及SqlSession處理

手繪二維碼

.NET藉助虛擬網卡實現一個簡單異地組網工具

包裝類型Integer作爲參數時，爲什麼看起來像值傳遞？

JavaWeb開發

OpenSessionInView

Java API

Java高新技術

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

基本類型	包裝類型
byte	Byte
short	Short
int	Integer
long	Long
boolean	Boolean
float	Float
double	Double
char	Character