java基礎（4）---引用數據類型（數組、字符串、集合）

 

一、數組

1、格式：int[] nums;

1. 數據類型[] 數組名稱;

2. 數據類型 數組名稱[]; (不太推薦)

 

2、 動態初始化：new int[4]

　　數據類型[] 數組名稱 = new 數據類型[數組長度]

　　

默認值：

3、靜態初始化：

int[] nums = new int[] {1,2,3,4} /  int[] nums = {1,2,3,4}

 

 4、訪問數組元素：數組名[index]

　　直接訪問數組名，返回 [I@…… ,其中[表明是數組，I表示Int類型，@后面是地址。

 訪問數組中元素: 從0開始，且索引沒有負數。

改變數組元素： 數組名[index] = 賦值

 

5、方法： nums.length

　　獲取數組長度：數組名稱.length

 代碼示例：

// 兩種先聲明后創建的方式（聲明和創建都有2種方式）
int[] list1;
int list2[];
list1 = new int[4];
list2 = new int[] {11,22,33,44};
 
// 第一種：聲明的同時創建（3種方式）
int[] list3 = new int[4];
int[] list4 = new int[] {11,22,33,44};
int[] list5 = {11,22,33,44};
 
// 第二種：聲明的同時創建（3種方式）
int list6[] = new int[4];
int list7[] = new int[] {11,22,33,44};
int list8[] = {11,22,33,44};

 

6、多維數組：int [][] = new int[4][4];

7、數組的排序：Arrays.sort(a);

import java.util.Arrays;
int[] a = { 12,3,19,2,10,13,9};
Arrays.sort(a);  // a為排序之后的值

 

8、Arrays類：

 

import java.util.Arrays;
import java.util.Random;

public class ArraysDemo {
    public static void main(String[] args) {
        int[] arr = new int[10];
        //將數組元素都設為9
        Arrays.fill(arr, 9);
        System.out.println("fill:" + Arrays.toString(arr));
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            //使用100以內的隨機數賦值數組
            arr[i] = random.nextInt(101);
        }
        //重新賦值后的數組
        System.out.println("重新賦值：" + Arrays.toString(arr));
        //將索引為5的元素設為50
        arr[5] = 50;
        //排序
        Arrays.sort(arr);
        //排序后的數組
        System.out.println("sort排序后：" + Arrays.toString(arr));
        //查找50的位置
        int i = Arrays.binarySearch(arr, 50);
        System.out.println("值為50的元素索引："+i);
        //復制一份新數組
        int[] newArr = Arrays.copyOf(arr, arr.length);
        //比較
        System.out.println("equals:"+Arrays.equals(arr, newArr));
    }
}

 

 

 

 

二、字符串（java.lang.String對象）

 1、創建字符串：

 

①String str1 = new String("a"); //不檢查字符串常量池的

 

②String str2 = "bb"; //檢查字符串常量池的

 

 字符串池：

 

 2、字符串不可變：

　　一旦覺得字符串變了的話，一定是創建了新的字符串，而不是改變了字符串。

 

 

 

 

 

 3、字符串比較方法：equals

 

常量盡量寫在前面：

  

 

 　　equals不忽略大小寫，equalsIgnoreCase忽略大小寫。

 

 4、字符串替換方法：replace

 

 5、字符串切分：split

　　

 

 　　如果一定要使用英文句點，那就使用 " \\. "

 

 6、字符串長度：int len = s.length();

字符串索引：轉成數組訪問 s.toCharArray();

三、StringBuffer和StringBuilder

面試官:String、StringBuffer、StringBuilder有什么區別?

https://www.cnblogs.com/songsongblue/p/9798651.html

 

因為String的不可變性，所以例如拼接字符串時候會產生很多無用的中間對象，如果頻繁的進行這樣的操作對性能有所影響。

StringBuffer就是為了解決大量拼接字符串時產生很多中間對象問題而提供的一個類，提供append和add方法，可以將字符串添加到已有序列的末尾或指定位置，它的本質是一個線程安全的可修改的字符序列，把所有修改數據的方法都加上了synchronized。但是保證了線程安全是需要性能的代價的。

在很多情況下我們的字符串拼接操作不需要線程安全，這時候StringBuilder登場了，StringBuilder是JDK1.5發布的，它和StringBuffer本質上沒什么區別，就是去掉了保證線程安全的那部分，減少了開銷。

StringBuilder：

一、創建Stringbuilder對象
StringBuilder strB = new StringBuilder();

1、append(String str)/append(Char c)：字符串連接
System.out.println("StringBuilder:"+strB.append("ch").append("111").append('c'));
//return "StringBuilder:ch111c"

2、toString()：返回一個與構建起或緩沖器內容相同的字符串
System.out.println("String:"+strB.toString());
//return "String:ch111c"

3、appendcodePoint(int cp)：追加一個代碼點，並將其轉換為一個或兩個代碼單元並返回this
System.out.println("StringBuilder.appendCodePoint:"+strB.appendCodePoint(2));
//return "StringBuilder.appendCodePoint:ch111c"

4、setCharAt(int i, char c)：將第 i 個代碼單元設置為 c（可以理解為替換）
strB.setCharAt(2, 'd');
System.out.println("StringBuilder.setCharAt:" + strB);
//return "StringBuilder.setCharAt:chd11c"

5、insert(int offset, String str) / insert(int offset, Char c)：在指定位置之前插入字符(串)
System.out.println("StringBuilder.insertString:"+ strB.insert(2, "LS"));
//return "StringBuilder.insertString:chLSd11c"
System.out.println("StringBuilder.insertChar:"+ strB.insert(2, 'L'));
//return "StringBuilder.insertChar:chLLSd11c"

6、delete(int startIndex,int endIndex)：刪除起始位置（含）到結尾位置（不含）之間的字符串
System.out.println("StringBuilder.delete:"+ strB.delete(2, 4));
//return "StringBuilder.delete:chSd11c"

 

總結：

1、在字符串不經常發生變化的業務場景優先使用String(代碼更清晰簡潔)。如常量的聲明，少量的字符串操作(拼接，刪除等)。

2、在單線程情況下，如有大量的字符串操作情況，應該使用StringBuilder來操作字符串。不能使用String"+"來拼接而是使用，避免產生大量無用的中間對象，耗費空間且執行效率低下（新建對象、回收對象花費大量時間）。如JSON的封裝等。

3、在多線程情況下，如有大量的字符串操作情況，應該使用StringBuffer。如HTTP參數解析和封裝等。

　　

四、集合（長度可變）

1、ArrayList:

import java.util.ArrayList;

 

創建一個集合：

 

 

 使用集合：add、get、size

 　　

 

 集合存儲基本類型

 

 

為什么要提供包裝類呢？？？

一是為了在各種類型間轉化，通過各種方法的調用。否則 你無法直接通過變量轉化。

 集合存儲自定義類型對象：

 2、HashSet 

https://blog.csdn.net/refusing/article/details/80617783

https://www.cnblogs.com/LiaHon/p/11257805.html#%E4%B8%89-add%E6%96%B9%E6%B3%95

HashSet簡單的理解就是HashSet對象中不能存儲相同的數據，存儲數據時是無序的。

• 它存儲唯一元素並允許空值
• 它由HashMap支持
• 它不保持插入順序
• 它不是線程安全的

（1）創建：

 

 

（2）方法：

//只有當元素尚未存在於集合中時才會添加元素。如果成功添加了元素，則該方法返回true，否則返回false。
hashset.add("String Added");

//contains方法的目的是檢查給定HashSet中是否存在元素。如果找到該元素，則返回true，否則返回false。
hashset.contains("String Added");

//r如果存在，remove方法將從集合中刪除指定的元素。如果集合包含指定的元素，則此方法返回true。
hashset.remove("String Added");

//從集合中刪除所有項目時,clear()方法
hashset.clear();

//size()識別HashSet中存在的元素數量
hashset.size()

//isEmpty（）確定HashSet的給定實例是否為空。如果集合不包含任何元素，則此方法返回true
hashset.isEmpty();

// Iterator（）返回Set中元素的迭代器。這些元素沒有特定的順序訪問，Iterator是fail-fast的。
public void whenIteratingHashSet_shouldIterateHashSet() {
    Set<String> hashset = new HashSet<>();
    hashset.add("First");
    hashset.add("Second");
    hashset.add("Third");
    Iterator<String> itr = hashset.iterator();
    while(itr.hasNext()){
        System.out.println(itr.next());
    }
}

（3） 遍歷：

法一：

 

 

 法二：

 

 

（4）整型：

 3、HashMap

• HashMap是一個散列表，它存儲的是鍵值對（key-value）映射；
• HashMap的實現不是同步的，線程不安全，但是效率高；
• HashMap允許null鍵和null值，是基於哈希表的Map接口實現；
• 哈希表的作用是用來保證鍵的唯一性；

方法：

（1） 插入鍵值對數據： put( key, value)

（2）根據鍵值獲取鍵值對值數據： get(Object key)

（3）獲取Map中鍵值對的個數： size()

（4）判斷Map集合中是否包含鍵為key的鍵值對 ：containsKey(Object key)

（5）判斷Map集合中是否包含值為value的鍵值對： containsValue(Object value)

（6）判斷Map集合中是否沒有任何鍵值對：isEmpty()

（7）清空Map集合中所有的鍵值對： clear()

（8）根據鍵值刪除Map中鍵值對：remove(Object key)

示例：

import java.util.HashMap;
import java.util.Map;

public class Demo01 {

    public static void main(String[] args) {
        // 聲明HashMap對象
        Map<String,Integer> map= new HashMap<>();

        //添加數據
        map.put("ZhangYi",98);
        map.put("WangEr",99);
        map.put("ZhangShan",89);
        map.put("Lisi",92);

        //根據鍵值對鍵值獲取數據‘’
        int value=map.get("Lisi");
        System.out.println("kay:Lisi And value:"+value);

        //獲取Map中鍵值對的個數
        int size=map.size();
        System.out.println("map 中的鍵值對個數為："+size);

        //判斷Map集合中是否包含鍵為key的鍵值對
        boolean b1=map.containsKey("LiSI");
        boolean b2=map.containsKey("Lisi");
        System.out.println("是否包含鍵值為LiSI的鍵值對數據："+b1);
        System.out.println("是否包含鍵值為Lisi的鍵值對數據："+b2);

        //判斷Map集合中是否包含值為value的鍵值對
        boolean b3=map.containsValue(99);
        boolean b4=map.containsValue(100);
        System.out.println("是否包含值為99的鍵值對數據："+b3);
        System.out.println("是否包含值為100的鍵值對數據："+b4);

        //判斷Map集合中是否沒有任何鍵值對

        boolean b5=map.isEmpty();
        System.out.println("map中鍵值對數據是否為空："+b5);

        //根據鍵值刪除Map中鍵值對
        int value2=map.remove("Lisi");
        System.out.println("刪除了鍵為Lisi的鍵值對數據，其值為："+value2);

        boolean b6=map.containsKey("Lisi");
        System.out.println("是否包含鍵值為Lisi的鍵值對數據："+b6);

        //清空Map集合中所有的鍵值對
        map.clear();
        boolean b7=map.isEmpty();
        System.out.println("map中鍵值對數據是否為空："+b7);

    }
}

遍歷：

（1）將Map中所有的鍵裝到Set集合中返回-----鍵

Set<K> set=map. keySet() 

（2）返回集合中所有的value的值的集合-----值

Collection<V> c=map.values()

（3）將每個鍵值對封裝到一個個Entry對象中,再把所有Entry的對象封裝到Set集合中返回----鍵值對

Set<Map.Entry<K,V>> entrys=map.entrySet()

 示例：

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo02 {
    public static void main(String[] args) {
        // 聲明HashMap對象
        Map<String,Integer> map= new HashMap<>();

        //添加數據
        map.put("ZhangYi",98);
        map.put("WangEr",99);
        map.put("ZhangShan",89);
        map.put("Lisi",92);

        //（1）將Map中所有的鍵裝到Set集合中返回
        Set<String> keys=map.keySet();
        for(String key:keys){
            int value=map.get(key);
            System.out.println("key:"+key+"  and  value:"+value);
        }

        //（2）返回集合中所有的value的值的集合
        Collection<Integer> values=map.values();
        for(int value:values){
            System.out.print(value+"   ");
        }
        System.out.println();

        //（3）將每個鍵值對封裝到一個個Entry對象中,再把所有Entry的對象封裝到Set集合中返回
        Set<Map.Entry<String,Integer>> entries=map.entrySet();
        for(Map.Entry<String,Integer> entry :entries){
            String key=entry.getKey();
            int value=entry.getValue();
            System.out.println("key:"+key+"  and  value:"+value);
        }
    }

}