一、數據類型

包裝類型

包裝類型是對基本數據類型不足之處的補充。

基本數據類型的傳遞方式是值傳遞，而包裝類型是引用傳遞，同時提供了很多數據類型間轉換的方法。

Java1.5 以后可以自動裝箱和拆箱

二、集合

List：有序、可重復?？梢酝ㄟ^索引快速查找，但進行增刪操作時后續的數據需要移動，所以增刪速度慢。?List 接口的大小可變數組的實現,即：可以直接指定容量大小

|--ArrayList:底層數據結構是 數組結構.是線程不同步的(不安全的).查詢速度很快，但是增刪較慢。

? ? ? ? ? ? ?構造一個初始容量為 10 的空列表，當放滿了10個元素后，以50%的長度加長集合容器的長度。

|--LinkedList:底層數據結構是 鏈表結構。對元素的增刪速度很快。但是查詢速度很慢。線程是不同步的。

|--Vector:底層數據結構也是數組結構，是線程同步的(安全的),效率低,被ArrayList替代了。1.2版本以后的集合都是不同步的；當放滿了10個元素后，以100%的長度加長集合容器的長度。

Vector的特有功能

1、添加功能

public void addElement(Object obj)

2、獲取功能

public Object elementAt(int index)

public Enumeration elements()

?

LinkedList的特有功能

1、添加功能

public void addFirst(Object e)

public void addLast(Object e)

2、獲取功能

public Object getFirst()

public Object getLast()

3、刪除功能

public Object removeFirst()

public Object removeLast()

ArrayList和LinkedList的區別

ArrayList擴容是將就得數組復制到新的數組的過程，所以會時間損耗是復制移動的時間，空間損耗是新的數組是按1.5倍擴容，復制移動完數據可能會有剩余空間浪費

1.ArrayList是實現了基于動態數組的數據結構，每個元素在內存中存儲地址是連續的；LinkedList基于鏈表的數據結構，每個元素內容包擴previous, next, element（其中，previous是該節點的上一個節點，next是該節點的下一個節點，element是該節點所包含的值），也是由于這一性質支持了每個元素在內存中分布存儲。

2.為了使得突破動態長度數組而衍生的ArrayList初始容量為10，每次擴容會固定為之前的1.5倍，所以當你ArrayList達到一定量之后會是一種很大的浪費，并且每次擴容的過程是內部復制數組到新數組；LinkedList的每一個元素都需要消耗一定的空間

3.對于每個元素的檢索，ArrayList要優于LinkedList。LinkedList不 支持高效的隨機元素訪問；因為ArrayList從一定意義上來說，就是復雜的數組，所以基于數組index的? 檢索性能顯然高于通過for循環來查找每個元素的LinkedList。

4.元素插入刪除的效率對比，要視插入刪除的位置來分析，各有優劣

在列表首位添加（刪除）元素，LnkedList性能遠遠優于ArrayList,原因在于ArrayList要后移（前移）每個元素的索引和數組擴容（刪除元素時則不需要擴容）。（測試的時候當然插入一次是看不出來什么的，我自己測試插入十萬次，就會有數組擴容arraycopy的因素）而LinkedList則直接增加元素，修改原第一元素該節點的上一個節點即可，刪除同理

在列表中間位置添加（刪除）元素，總的來說位置靠前則LnkedList性能優于ArrayList，靠后則相反。出現這種情況的原因在于ArrayList性能主要損耗在后移（前移）該位置之后的元素索引，而LinkedList損耗在for循環從第一位檢索該位置的元素。這個性能反轉的臨界點不固定，我自己測試插入十萬次，在15000次左右損耗時間相比出現變化

在列表末尾位置添加（刪除）元素，性能相差不大。

Set：無序、不可重復。

Collection
|--List
有序(存儲順序和取出順序一致),可重復
|--Set
無序(存儲順序和取出順序不一致),唯一

HashSet：它不保證 set 的迭代順序；特別是它不保證該順序恒久不變。
注意：雖然Set集合的元素無序，但是，作為集合來說，它肯定有它自己的存儲順序，
而你的順序恰好和它的存儲順序一致，這代表不了有序，你可以多存儲一些數據，就能看到效果。

HashSet的唯一性

問題：為什么存儲字符串的時候，字符串內容相同的只存儲了一個呢?

通過查看add方法的源碼，我們知道這個方法底層依賴 兩個方法：hashCode()和equals()。
步驟：
首先比較哈希值
如果相同，繼續走，比較地址值或者走equals()
如果不同,就直接添加到集合中
按照方法的步驟來說：
先看hashCode()值是否相同
相同:繼續走equals()方法
返回true： 說明元素重復，就不添加
返回false：說明元素不重復，就添加到集合
不同：就直接把元素添加到集合
如果類沒有重寫這兩個方法，默認使用的Object()。一般來說不同相同。
而String類重寫了hashCode()和equals()方法，所以，它就可以把內容相同的字符串去掉。只留下一個

哈希表：是一個元素為鏈表的數組，

LinkedHashSet:底層數據結構由哈希表和鏈表組成。 哈希表保證元素的唯一性。 鏈表保證元素有素。(存儲和取出是一致)

?

TreeSet：能夠對元素按照某種規則進行排序。 排序有兩種方式 A:自然排序 B:比較器排序 TreeSet集合的特點：排序和唯一 通過觀察TreeSet的add()方法，我們知道最終要看TreeMap的put()方法。

A:自然排序(元素具備比較性) 讓元素所屬的類實現自然排序接口 Comparable B:比較器排序(集合具備比較性) 讓集合的構造方法接收一個比較器接口的子類對象 Comparator

自然排序

package cn.itcast_05;

import java.util.TreeSet;

public class TreeSetDemo2 {
public static void main(String[] args) {
// 創建集合對象
TreeSet<Student> ts = new TreeSet<Student>();

// 創建元素
Student s1 = new Student("linqingxia", 27);
Student s2 = new Student("zhangguorong", 29);
Student s3 = new Student("wanglihong", 23);
Student s4 = new Student("linqingxia", 27);
Student s5 = new Student("liushishi", 22);
Student s6 = new Student("wuqilong", 40);
Student s7 = new Student("fengqingy", 22);

// 添加元素
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
ts.add(s5);
ts.add(s6);
ts.add(s7);

// 遍歷
for (Student s : ts) {
System.out.println(s.getName() + "---" + s.getAge());
}
}
}

/*學生類*/
package cn.itcast_05;

/*
* 如果一個類的元素要想能夠進行自然排序，就必須實現自然排序接口
*/
public class Student implements Comparable<Student> {
private String name;
private int age;

public Student() {
super();
}

public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

@Override
public int compareTo(Student s) {
// return 0;
// return 1;
// return -1;

// 這里返回什么，其實應該根據我的排序規則來做
// 按照年齡排序,主要條件
int num = this.age - s.age;
// 次要條件
// 年齡相同的時候，還得去看姓名是否也相同
// 如果年齡和姓名都相同，才是同一個元素
int num2 = num == 0 ? this.name.compareTo(s.name) : num;
return num2;
}
}
---------------------
作者：小峰峰瘋瘋的
來源：CSDN
原文：https://blog.csdn.net/gafeng123456/article/details/50772296
版權聲明：本文為博主原創文章，轉載請附上博文鏈接！

比較器排序

package cn.itcast_07;

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetDemo {
public static void main(String[] args) {
// 創建集合對象
// TreeSet<Student> ts = new TreeSet<Student>(); //自然排序
// public TreeSet(Comparator comparator) //比較器排序
// TreeSet<Student> ts = new TreeSet<Student>(new MyComparator());

// 如果一個方法的參數是接口，那么真正要的是接口的實現類的對象
// 而匿名內部類就可以實現這個東西
TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
// 姓名長度
int num = s1.getName().length() - s2.getName().length();
// 姓名內容
int num2 = num == 0 ? s1.getName().compareTo(s2.getName())
: num;
// 年齡
int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
return num3;
}
});

// 創建元素
Student s1 = new Student("linqingxia", 27);
Student s2 = new Student("zhangguorong", 29);
Student s3 = new Student("wanglihong", 23);
Student s4 = new Student("linqingxia", 27);
Student s5 = new Student("liushishi", 22);
Student s6 = new Student("wuqilong", 40);
Student s7 = new Student("fengqingy", 22);
Student s8 = new Student("linqingxia", 29);

// 添加元素
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
ts.add(s5);
ts.add(s6);
ts.add(s7);
ts.add(s8);

// 遍歷
for (Student s : ts) {
System.out.println(s.getName() + "---" + s.getAge());
}
}
}

Map：鍵值對、鍵唯一、值不唯一。Map 集合中存儲的是鍵值對，鍵不能重復，值可以重復。根據鍵得到值，對 map 集合遍歷時先得到鍵的 set 集合，對 set 集合進行遍歷，得到相應的值。
Map集合常用的子類有兩種: HashMap ?TreeMap

1.HashMap集合

注意:

? ? ? ? ? ? ?Map集合都是針對鍵有效,且鍵是唯一的,?如果有相同的鍵，則第二個鍵的值覆蓋掉第一個鍵的值,如果第一次給HashMap添加元素,則put()方法返回值為null,第二次添加相同鍵的元素,則返回第一次添加的元素的值

?存儲自定義對象的兩種方式:

? ? ? ? ? ? ? 自定義對象為鍵 ?:不能重復 ,需要重寫equals()和HashCode()兩個方法

? ? ? ? ? ? ? 自定義對象為值 ?:可以重復

注釋:

? ? ? ? ? ? ? 如果成員變量的值相同則認為是同一個人,即重復
? ? ? ? ? ? ? HashMap底層依賴的是哈希表
? ? ? ? ? ? ? 哈希表依賴于兩個方法:equals()和HashCode();

?//自定義對象作為鍵,必須具有唯一性,輸出不能保證順序

面試題: ?

? ? ?HashMap和HashTable的區別?

? ? ? ? ? ? ? ? ?? ? 共同點:都是基于Map集合的實現類,都是哈希表的實現類
? ? ? ? ? ? ? ? ? ?HashMap集合:線程不安全,執行效率高,不同步,允許null值和null鍵
? ? ? ? ? ? ? ? ? ?HashTable集合:線程安全,執行效率低,同步,不允許null值和null鍵

線程安全的類:
? ? ? ? ? ? ? ? ? ?StringBuffer ? ?:字符串緩沖區
? ? ? ? ? ? ? ? ? ?Vector ? ? ? ? ? ? :List集合的子集合
? ? ? ? ? ? ? ? ? ?HashTable ? ? ? :Map集合的子集合

2.LinkedHashMap集合

? ? ?LinkedHashMap集合是Map接口基于哈希表和鏈表實現的
? ?
? ? 哈希表可保證鍵的唯一性

? ? 鏈表保證了元素的有序性(存儲和取出一致)

3.TreeMap集合

TreeMap集合的兩種排序方式:

自然排序:自定義的類實現Comparable接口,通過無參構造形式創建對象,并且重寫ComparaTo()方法
比較器排序:通過public TreeSet(Comparator<E> comparator)構造方法創建對象,并且重寫了Compare()方法
? ??? ?比較器排序的兩種方式:
? ? ? ? ? ? ? ? ? ? ?1).創建實現類繼承Comparator接口,并且重寫Compare()方法

? ? ? ? ? ? ? ? ? ? ?2).直接使用匿名內部類實現 ,重寫Compare()方法,不用創建實現類

? TreeSet集合保證元素是看ComparaTo()方法或者Compare()方法返回值是否為0;

??TreeSet集合底層依賴于TreeMap集合的方法,存儲方式為紅黑樹結構
4.Collections工具類

?Collections和Collection的區別:
? ? ? ? ?Collection:頂層次單列集合的根接口,它是一個集合,也是一個接口
? ? ? ? ?Collections:是針對集合操作的工具類,里面包含了一些功能,隨機置換,集合里面的二分
? ? ? ? ?查找,將集合的元素進行反轉
? ? ? ??
?Collections集合的常用方法:
? ? ? ? ?public static <T> int binarySearch(List<T> list,T key) ? 二分查找
? ? ? ? ?public static ?T max(Collection coll): 獲取集合中的最大值
? ? ? ? ?public static void reverse(List<?> list) :將集合中的元素順序反轉
? ? ? ? ?public static void shuffle(List<?> list) :將集合中的元素打亂

? ? ? ? ?public static void sort(List<> list) :將集合中的元素進行排序

?

轉載于:https://www.cnblogs.com/h-c-g/p/10391551.html

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

以上是生活随笔為你收集整理的Java基础知识(数据类型和集合)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。