69期-Java SE-017_集合-3-001-002

時間 2019-11-09

標籤 java 集合欄目 Java 简体版

原文原文鏈接

### TreeMap

TreeMap與HashMap和Hashtable的區別在於能夠按照key值對集合中的數據進行排序。

```java
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;

public class Test2 {
    public static void main(String[] args) {
        TreeMap<User,String> treeMap = new TreeMap();
        treeMap.put(new User(3,"Java"), "Java");
        treeMap.put(new User(5,"JavaME"), "JavaME");
        treeMap.put(new User(1,"Hello"), "Hello");
        treeMap.put(new User(6,"JavaEE"), "JavaEE");
        treeMap.put(new User(2,"World"), "World");
        treeMap.put(new User(4,"JavaSE"), "JavaSE");
        Set keys = treeMap.keySet();
        Iterator iterator = keys.iterator();
        while(iterator.hasNext()) {
            User key = (User) iterator.next();
            String value = treeMap.get(key);
            System.out.println(key+"-"+value);
        }
        System.out.println("集合中的第一個key："+treeMap.firstKey());
        System.out.println("集合中的第一個entry："+treeMap.firstEntry());
        System.out.println("集合中的最後一個key："+treeMap.lastKey());
        System.out.println("集合中的最後一個entry："+treeMap.lastEntry());
        System.out.println(treeMap.higherKey(new User(3,"Java")));
        System.out.println(treeMap.lowerKey(new User(3,"Java")));
        System.out.println(treeMap.higherEntry(new User(3,"Java")));
        System.out.println(treeMap.lowerEntry(new User(3,"Java")));
        System.out.println(treeMap.subMap(new User(3,"Java"), new User(5,"JavaME")));
    }
}

class User implements Comparable{
    private int id;
    private String name;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public User(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + "]";
    }
    
    /**
     * A.compareTo(B)
     * 返回值：
     * 1表示A大於B
     * 0表示A等於B
     * -1表示A小於B
     */
    @Override
    public int compareTo(Object o) {
        // TODO Auto-generated method stub
        User user = (User)o;
        if(this.id > user.id) {
            return 1;
        }else if(this.id == user.id) {
            return 0;
        }else {
            return -1;
        }
    }
}
```

### Collections

Collections封裝了一系列能夠操做集合的方法，與Arrays相似，Arrays是針對數組的工具類，Collections是針對集合的工具類。

Collections經常使用方法：

- sort                                 根據集合泛型對應的類實現的Comparable接口對集合進行排序
- binarySearch                                                 查找元素在集合中的下標，要求集合元素必須是升序排列
- get                                                                   根據下標找到對應的元素
- reverse                                                            將集合中的元素反序輸出
- swap                                                                交換集合中指定位置的兩個元素
- fill                                                                      將集合中全部的元素替換爲一個指定值
- min                                                                  根據Comparable接口找到集合中的最小元素
- max                                                                 根據Comparable接口找到集合中的最大元素
- replaceAll                                                       將集合中全部元素替換爲一個指定值
- addAll                                                              將一個集合中的全部值添加到目標集合中

```java
import java.util.ArrayList;
import java.util.Collections;

public class Test3 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("Hello");
        list.add("World");
        Collections.addAll(list,"Java","JavaSE","JavaEE","Java","Java");
        System.out.println(list);
        Collections.reverse(list);
        System.out.println(list);
        Collections.swap(list, 1, 3);
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
        int index = Collections.binarySearch(list, "JavaEE");
        System.out.println(index);
        Collections.replaceAll(list, "Java", "Collections");
        System.out.println(list);
        Collections.addAll(list, 1,new User(1,"a"),"Str");
        System.out.println(list);
    }
}
```



### 泛型

泛型（Generics）是指在類定義時不指定類中信息的具體數據類型，而是用一個標識符來代替，當外部實例化對象時來指定具體的數據類型。

有了泛型咱們就能夠在定義類或者定義接口時不明確指定類中信息的具體數據類型，在實例化時再來指定，這樣就極大的提高了程序的擴展性，一個類能夠裝載各類不一樣的數據類型，泛型能夠指代類中成員變量的類型，方法的返回值類型以及方法的參數類型。

#### 泛型的應用

咱們除了能夠在實例化集合時指定泛型外，自定義的類也能夠添加泛型，基本語法以下：

訪問權限修飾符 class 類名<泛型標識1，泛型標識2...>{

    訪問權限修飾符 泛型標識 屬性名;

    訪問權限修飾符 泛型標識 方法名(泛型標識 參數...){}

}

```java
public class Time<H,M,S> {
    private H hour;
    private M minute;
    private S second;
    public H getHour() {
        return hour;
    }
    public void setHour(H hour) {
        this.hour = hour;
    }
    public M getMinute() {
        return minute;
    }
    public void setMinute(M minute) {
        this.minute = minute;
    }
    public S getSecond() {
        return second;
    }
    public void setSecond(S second) {
        this.second = second;
    }
}
```

```java
public class Test5 {
    public static void main(String[] args) {
        Time<String,Integer,Float> time = new Time();
        time.setHour("十點");
        time.setMinute(10);
        time.setSecond(10.0f);
        System.out.println("如今的時間是："+time.getHour()+":"+time.getMinute()+":"+time.getSecond());
    }
}
```



#### 泛型通配符

若是咱們在定義一個參數爲ArrayList類型的方法時，但願該方法便可以接收String類型的參數，也能夠接收Integer類型的參數，應該如何處理？能夠使用多態的思想來定義該方法。

```java
import java.util.ArrayList;

public class Test6 {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList();
        ArrayList<Integer> list2 = new ArrayList();
        test(list1);
        test(list2);
    }
    
    public static void test(ArrayList<?> list) {
        
    }
}
```



#### 泛型上限和下限

咱們在使用泛型時，每每數據類型會有限制，只能使用一種具體的數據類型，能夠經過泛型上限和下限完成對數據類型的擴容。

泛型上限表示實例化的具體數據類型，能夠是上限類型的子類或者上限類型自己，用extends關鍵字來修飾。泛型下限表示實例化的具體數據類型，能夠是下限類型的父類或者下限類型自己，用super關鍵字來修飾。

泛型上限：類名<泛型標識 extends 上限類名>

泛型下限：類名<泛型標識 super 下限類名>

```java
import java.util.ArrayList;

public class Test6 {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList();
        ArrayList<Integer> list2 = new ArrayList();
        test(list1);
        test(list2);
    }
    
    public static void test(ArrayList<?> list) {
        
    }
}
```



#### 泛型接口

不單單在定義類時能夠添加泛型，一樣的在定義接口時也能夠添加泛型，聲明泛型接口的語法和聲明泛型類的語法很類似，在接口名添加<T>便可。

基本語法：訪問權限修飾符 interface 接口名<泛型標識> 

```java
public interface MyInterface<T> {
    public T getValue();
}
```

實現泛型接口有兩種方式，一種是實現類在定義時繼續使用泛型標識，另外一種是實現類在定義時直接給出具體的數據類型。

```java
public class MyInterfaceImpl<T> implements MyInterface<T> {

    @Override
    public T getValue() {
        // TODO Auto-generated method stub
        return null;
    }

}
```



```java
public class MyInterfaceImpl2 implements MyInterface<String> {

    @Override
    public String getValue() {
        // TODO Auto-generated method stub
        return null;
    }

}
```



兩種不一樣實現類的實例化方式也是不一樣的，第一種（實現類在定義時繼續使用泛型）須要在實例化時指定具體的數據類型。

第二種（實現類在定義時指定具體的數據類型）在實例化時不須要指定具體的數據類型。



```java
public class Test7 {
    public static void main(String[] args) {
        MyInterface<String> my = new MyInterfaceImpl<>("接口");
        String value = my.getValue();
        System.out.println(value);
        
        MyInterface my2 = new MyInterfaceImpl2("接口");
        String value2 = (String)my2.getValue();
        System.out.println(value2);
        
    }
}
```

MyInterface.javajava

public interface MyInterface<T> {
    public T getValue();
}

MyInterfaceImpl.java數組

public class MyInterfaceImpl<T> implements MyInterface<T> {

    private T value;
    
    @Override
    public T getValue() {
        // TODO Auto-generated method stub
        return this.value;
    }

    public MyInterfaceImpl(T value) {
        super();
        this.value = value;
    }
    
    

}

MyInterImpl2.javaide

public class MyInterfaceImpl2 implements MyInterface<String> {
    
    private String value;

    @Override
    public String getValue() {
        // TODO Auto-generated method stub
        return this.value;
    }

    public MyInterfaceImpl2(String value) {
        super();
        this.value = value;
    }
    
    

}

Test.java工具

import java.util.Collection;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;

public class Test {
    public static void main(String[] args) {
        TreeMap<Integer,String> treeMap = new TreeMap();
        treeMap.put(3, "Java");
        treeMap.put(5, "JavaME");
        treeMap.put(1, "Hello");
        treeMap.put(6, "JavaEE");
        treeMap.put(2, "World");
        treeMap.put(4, "JavaSE");
        System.out.println(treeMap);
        Set keys = treeMap.keySet();
        Iterator setIter = keys.iterator();
        while(setIter.hasNext()) {
            Integer key = (Integer)setIter.next();
            String value = treeMap.get(key);
            System.out.println(key+"-"+value);
        }
        Collection values = treeMap.values();
        Iterator valueIter = values.iterator();
        while(valueIter.hasNext()) {
            String value = (String)valueIter.next();
            System.out.println(value);
        }
    }
}

Test2.javathis

import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;

public class Test2 {
    public static void main(String[] args) {
        TreeMap<User,String> treeMap = new TreeMap();
        treeMap.put(new User(3,"Java"), "Java");
        treeMap.put(new User(5,"JavaME"), "JavaME");
        treeMap.put(new User(1,"Hello"), "Hello");
        treeMap.put(new User(6,"JavaEE"), "JavaEE");
        treeMap.put(new User(2,"World"), "World");
        treeMap.put(new User(4,"JavaSE"), "JavaSE");
        Set keys = treeMap.keySet();
        Iterator iterator = keys.iterator();
        while(iterator.hasNext()) {
            User key = (User) iterator.next();
            String value = treeMap.get(key);
            System.out.println(key+"-"+value);
        }
        System.out.println("集合中的第一個key："+treeMap.firstKey());
        System.out.println("集合中的第一個entry："+treeMap.firstEntry());
        System.out.println("集合中的最後一個key："+treeMap.lastKey());
        System.out.println("集合中的最後一個entry："+treeMap.lastEntry());
        System.out.println(treeMap.higherKey(new User(3,"Java")));
        System.out.println(treeMap.lowerKey(new User(3,"Java")));
        System.out.println(treeMap.higherEntry(new User(3,"Java")));
        System.out.println(treeMap.lowerEntry(new User(3,"Java")));
        System.out.println(treeMap.subMap(new User(3,"Java"), new User(5,"JavaME")));
    }
}

class User implements Comparable{
    private int id;
    private String name;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public User(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + "]";
    }
    
    /**
     * A.compareTo(B)
     * 返回值：
     * 1表示A大於B
     * 0表示A等於B
     * -1表示A小於B
     */
    @Override
    public int compareTo(Object o) {
        // TODO Auto-generated method stub
        User user = (User)o;
        if(this.id > user.id) {
            return 1;
        }else if(this.id == user.id) {
            return 0;
        }else {
            return -1;
        }
    }
}

Test3.javaspa

import java.util.ArrayList;
import java.util.Collections;

public class Test3 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("Hello");
        list.add("World");
        Collections.addAll(list,"Java","JavaSE","JavaEE","Java","Java");
        System.out.println(list);
        Collections.reverse(list);
        System.out.println(list);
        Collections.swap(list, 1, 3);
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
        int index = Collections.binarySearch(list, "JavaEE");
        System.out.println(index);
        Collections.replaceAll(list, "Java", "Collections");
        System.out.println(list);
        Collections.addAll(list, 1,new User(1,"a"),"Str");
        System.out.println(list);
    }
}

Test4.javacode

import java.util.ArrayList;

public class Test4 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList();
        list.add(1);
        list.add(2);
        for(int i = 0; i < list.size();i++) {
            int num = list.get(i);
            System.out.println(num);
        }
    }
}

Test5.java對象

public class Test5 {
    public static void main(String[] args) {
        Time<String,Integer,Float> time = new Time();
        time.setHour("十點");
        time.setMinute(10);
        time.setSecond(10.0f);
        System.out.println("如今的時間是："+time.getHour()+":"+time.getMinute()+":"+time.getSecond());
    }
}

Test6.javablog

import java.util.ArrayList;

public class Test6 {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList();
        ArrayList<Integer> list2 = new ArrayList();
        test(list1);
        test(list2);
    }
    
    public static void test(ArrayList<?> list) {
        
    }
}

Test7.java排序

public class Test7 {
    public static void main(String[] args) {
        MyInterface<String> my = new MyInterfaceImpl<>("接口");
        String value = my.getValue();
        System.out.println(value);
        
        MyInterface my2 = new MyInterfaceImpl2("接口");
        String value2 = (String)my2.getValue();
        System.out.println(value2);
        
    }
}

Time.java

public class Time<H,M,S> {
    private H hour;
    private M minute;
    private S second;
    public H getHour() {
        return hour;
    }
    public void setHour(H hour) {
        this.hour = hour;
    }
    public M getMinute() {
        return minute;
    }
    public void setMinute(M minute) {
        this.minute = minute;
    }
    public S getSecond() {
        return second;
    }
    public void setSecond(S second) {
        this.second = second;
    }
    
}

test\Time.java

package test;

public class Time<T> {
    public static void main(String[] args) {
        test(new Time<Integer>());
//        test(new Time<String>());
        test2(new Time<String>());
//        test2(new Time<Integer>());
    }
    
    /**
     * 參數泛型只能是Number或者子類，Number、Byte、Short
     */
    public static void test(Time<? extends Number> time) {
        
    }
    
    /**
     * 參數泛型只能是String或者其父類，即String和Object
     */
    public static void test2(Time<? super String> time) {
        
    }
}