java第15天----泛型，集合中的
阿新 • • 發佈：2018-12-13
知識總結
- List
- Vector
- LinkedList
- List的去重—contains
- Set
- HashSet
- treeSet
泛型
- 泛型：通過<資料型別>接收一種資料型別，在編譯的時候會使用這種型別檢測集合中的元素，如果不是<>中規定的型別，就不允許
- 新增的集合當中（編譯不成立）
- 作用：使用了泛型不再需要進行強制轉換，容錯處理，向下轉型----簡化程式碼
- 2.將執行階段的問題提前到了編譯階段檢查，提高了程式碼的安全性和程式設計的效率，
- 泛型的擦除：泛型只是在編譯階段檢查元素的型別，到執行階段泛型就消失了
- 泛型的使用場景：
- 1.類上 2.介面上 3方法上
//當List制定了具體的String泛型之後，裡面的元素只能是String
ArrayList<String> list = new ArrayList<String>();
list.add("java1");
list.add("java2");
list.add("java5");
list.add("java7");
System.out.println(list);
//獲取迭代器
//當集合的泛型確定之後，讓迭代器的泛型一致即可
Iterator<String> iterator = list.iterator();
//遍歷
while (iterator. 泛型在類上的使用
//這裡通過使用泛型，保證了Student1類的使用靈活性可以簡化程式碼，提高效率
Student1<Computer> student1 = new Student1();
student1.setObj(computer);
Computer computer3 = student1.getObj();
/*
* E代表任意一種資料型別，但<>中不一定是E，可以是任意字元
* 在E的後面加<>就是給類加泛型
* 在類上確定的泛型可以直接使用
*/ 泛型在方法上的使用
方法與類的泛型相同
直接使用
方法與類的泛型不一致
- 泛型在使用之前一定要進行宣告
- 宣告的方式：在方法的最前面加<符號>就行
- 作用：讓方法內與方法的泛型保持一致
靜態方法
- 靜態方法上無法使用類上的泛型，類上的泛型必須通過建立物件才能使用
- 靜態方法的呼叫不需要物件，所以靜態方法如果想要使用泛型，必須自己獨立使用泛型
class Teacher<E>{
// 1.方法上的泛型與類上的泛型一致
public E play(E e) {
return e;
}
// 2.方法上獨立使用泛型
public <F> void show(F f) {
}
// 3.靜態方法上使用泛型
public static <W> void run(W w) {
}
介面上使用泛型
interface Inter<E>{
public void play(E e);
}
子類使用泛型的情況
第一種：
- 介面有泛型，子類沒有遵守對應的泛型 注意：必須給介面制定一個具體的泛型
class Dog implements Inter<String>{
//重寫的方法的泛型與介面一致
@Override
public void play(String e) {
// TODO Auto-generated method stub
}
//自定義的方法可以使用介面的泛型，也可以自定義泛型.
public <F> void show(F f) {
}
}
第二種：
- 介面有泛型，子類遵守了對應的泛型,類上的泛型確定了，介面上的泛型就確定了，重寫的方法的泛型就確定了
class Cat<E> implements Inter<E>{
@Override
public void play(E e) {
// TODO Auto-generated method stub
}
}
- ?:萬用字元，表示一種或幾種資料型別
- 限制上限：<? extends E>限制的是這個<>中可以取得泛型型別是E類及E類的子類
- 限制下限：<? super E>限制的是整個<>中可以取得泛型型別是E類及E類的父類
- 注意點：在取型別的時候，型別之間一定有繼承關係。
public static void main(String[] args) {
//
ArrayList<Student2> list1 = new ArrayList<
list1.add(new Student2("bingbing", 1));
//可以傳參:因為Student2是Person1的子類,可以實現遍
bianli(list1);
ArrayList<Teacher8> list2 = new ArrayList<
list2.add(new Teacher8("bingbing", 1));
//可以傳參:因為Teacher1是Person1的子類,可以實現遍
bianli(list2);
ArrayList<Person1> list3 = new ArrayList<>
list3.add(new Person1("bingbing", 1));
//可以傳參
bianli(list3);
ArrayList<Object> list4 = new ArrayList<>(
list4.add(new Object());
//可以傳參:因為Object是Person1的父類,不可以實現遍歷
//bianli(list4);
}
public static void bianli(Collection<? extends
System.out.println("遍歷了");
}
}
class Person1{
String name;
int age;
public Person1() {
super();
// TODO Auto-generated constructor stub
}
public Person1(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person1 [name=" + name + ", age="
}
}
class Teacher8 extends Person1{
public Teacher8(String name, int age) {
super(name, age);
}
}
class Student2 extends Person1{
public Student2(String name, int age) {
super(name, age);
}
}
public class Demo7 {
public static void main(String[] args) {
//限制下限 <? super E>
//TreeSet(Comparator<? super E> comparator) :這裡的E跟Tre
//建立Student3類的比較器物件
ComWithStu comWithStu = new ComWithStu();
//建立Teacher1類的比較器物件
ComWithTea comWithTea = new ComWithTea();
//建立Person1類的比較器物件
ComWithPerson comWithPerson = new ComWithPerson();
//建立GoodStudent類的比較器物件
ComWithGood comWithGood = new ComWithGood();
TreeSet<Student3> set = new TreeSet<>(comWithStu);//因為
//TreeSet<Student3> set = new TreeSet<>(comWithTea);//
//TreeSet<Student3> set = new TreeSet<>(comWithPerson)
//TreeSet<Student3> set = new TreeSet<>(comWithGood);/
set.add(new Student3("bingbing"));
set.add(new Student3("bingbing1"));
set.add(new Student3("bingbing2"));
}
}
//建立Student3類的比較器
class ComWithStu implements Comparator<Student3>{
public int compare(Student3 o1, Student3 o2) {
return o1.name.compareTo(o2.name);
}
}
//建立Teacher2類的比較器
class ComWithTea implements Comparator<Teacher2>{
public int compare(Teacher2 o1, Teacher2 o2) {
return 0;
}
}
//建立Person2類的比較器
class ComWithPerson implements Comparator<Person2>{
public int compare(Person2 o1, Person2 o2) {
return 0;
}
}
//建立GoodStudent類的比較器
class ComWithGood implements Comparator<GoodStudent>{
public int compare(GoodStudent o1, GoodStudent o2) {
return 0;
}
}
class Person2{
String name;
public Person2(String name) {
super();
this.name = name;
}
public String toString() {
return "Person2 [name=" + name + "]";
}
}
class Teacher2 extends Person2{
public Teacher2(String name) {
super(name);
}
}
class Student3 extends Person2{
public Student3(String name) {
super(name);
}
}
class GoodStudent extends Student3{
public GoodStudent(String name) {
super(name);
}
}
Map：
- 比較Map和Collection
- Collection：是集合，是介面，直接存值
- Map：是結合，是介面，儲存的是鍵值對，一個元素就是一個鍵（key）值（value）對，鍵必須是惟一的，值可以相同.
- Map需要設定兩個泛型，一個是key的，一個是value的
- 設定key時最好使用一個常量作為key比如String ,因為他本身是固定的，從map的底層實現來看，進行存取的效率更高
Map常用方法
- 介紹Map介面的方法
- 1.增加
- V put(K key,V value) - 增加一個鍵值對
- void putAll(Map<? - extends K,? extends V> - map) 增加多個
- 2.刪除
- V remove(Object key) - 根據key刪除元素
- void clear() - 刪除全部
- 3.獲取
- V get(Object key) - 根據key查詢元素
- int size() - 獲取鍵值對的個數
- Set keySet() - 遍歷方法一
- Set<Map.Entry<K,V>> - entrySet() 遍歷方法二
- 4.常用的判斷
- boolean isEmpty()
- boolean - containsKey(K key) - 是否包含當前的key
- boolean - containsValue(V value) - 是否包含當前的value
Map的遍歷
keySet() 遍歷方法一
- 通過這個方法得到所有的key，存放在set中，利用set的迭代器遍歷到所有的key，再利用key得到值
//Set<K> keySet()
//得到Set
Set<String> set1 = map.keySet();
//得到迭代器
Iterator<String> iterator1 = set1.iterator();
//遍歷set，遍歷key，通過可以得到value
while (iterator1.hasNext()) {
String string = (String) iterator1.next();
System.out.println("key:"+string + " value:"+ map.get(string));
}
entrySet() 遍歷方法二
- 通過這個方法得到所有的entry（鍵值對），存放在set中，利用set的迭代器便利得到
- 瞭解：
- 為什麼要將Entry對映關係介面放入Map介面中？ *Entry是Map內的一個靜態介面，因為有了子集和中的鍵值對才有對映關係，而當前的對映關係又是對集合內部的描述，所以 *要將Entry對映關係介面放入Map介面中
//Set<Map.Entry<K,V>> entrySet()
//得到set
Set<Map.Entry<String, String>> set2 = map.entrySet();
Iterator<Map.Entry<String, String>> iterator = set2.iterator();
while (iterator.hasNext()) {
Map.Entry<String, String> entry = (Map.Entry<java.lang.String, java.lang.String>) iterator.next();
//注意：這裡可以通過
System.out.println("key:"+entry.getKey()+" value:"+entry.getValue());