Map,Set基礎代碼

1. 概述

Set	Map
HashSet,LinkedHashSet,TreeSet	HashMap, LinkedHashMap,TreeMap

2. Set

(1).HashSet

特點：元素唯一，元素無序。

下面分別以String,Integer,自定義類型做例

String

public class demo {
public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add("張曼玉");
        set.add("王祖賢");
        set.add("鐘楚紅");
        set.add("林青霞");
        set.add("楊超越");
        set.add("張曼玉");
        set.add("王祖賢");
        set.add("鐘楚紅");
        set.add("林青霞");
        set.add("楊超越");
for (String s : set) {
// System.out.println(set);
            System.out.println(s);//set是集合，集合啊
}
}
}

```java
林青霞
楊超越
王祖賢
鐘楚紅
張曼玉

Integer

```java
public class demo2 {
public static void main(String[] args) {
        HashSet<Integer> set = new HashSet<>();
        set.add(123);
        set.add(123);
        set.add(1234);
        set.add(1234);
        set.add(111);
        set.add(11);
for (Integer integer : set) {
            System.out.println(integer);
}
        System.out.println(set);
}
}

1234
123
11
111
[1234, 123, 11, 111]

自定義類型

public class demo3 {
public static void main(String[] args) {
        HashSet<Student> student = new HashSet<>();
        student.add(new Student("楊",20));
        student.add(new Student("桑",20));
        student.add(new Student("李",20));
        student.add(new Student("李",20));
        student.add(new Student("鄭",21));
        student.add(new Student("明",20));
        student.add(new Student("楊",20));
        student.add(new Student("桑",20));
        student.add(new Student("李",20));
        student.add(new Student("李",20));
        student.add(new Student("鄭",21));
        student.add(new Student("明",20));


for (Student student1 : student) {
            System.out.println(student1.getName()+"=="+student1.getAge());
}
}
}

```java
桑==20
楊==20
李==20
李==20
明==20
鄭==21

（2）.LinkedHashSet

特點：元素唯一且有序,是集合

public class demo {
public static void main(String[] args) {
        LinkedHashSet<String> set = new LinkedHashSet<>();//唯一且有序,是集合


       set.add("楊");
       set.add("桑");
       set.add("李");
       set.add("李");
       set.add("鄭");
       set.add("明");

        set.add("楊");
        set.add("桑");
        set.add("李");
        set.add("李");
        set.add("鄭");
        set.add("明");

for (String s : set) {
            System.out.println(s);
}
        System.out.println(set);
        ArrayList<String> strings = new ArrayList<>();
        strings.add("楊");
        strings.add("李");
        strings.add("桑");
        strings.add("李");
        strings.add("鄭");
        strings.add("明");

        strings.add("楊");
        strings.add("李");
        strings.add("桑");
        strings.add("李");
        strings.add("鄭");
        strings.add("明");


for (String string : strings) {
            System.out.println(string);
}
//作用，對list集合去重
        LinkedHashSet<String> strings1 = new LinkedHashSet<>(strings);
        System.out.println(strings1);
for (String s : strings1) {
            System.out.println(s);
}
        HashSet<String> strings2 = new HashSet<>(strings);
        System.out.println(strings2);
}
}

```java
楊
桑
李
鄭
明
[楊, 桑, 李, 鄭, 明]
楊
李
桑
李
鄭
明
楊
李
桑
李
鄭
明
[楊, 李, 桑, 鄭, 明]
楊
李
桑
鄭
明
[楊, 李, 明, 桑, 鄭]

(3).TreeSet

特點：有排序功能,是集合。元素唯一

public class demo {
public static void main(String[] args) {
        TreeSet<Integer> i = new TreeSet<>();//有排序功能,是集合。元素唯一。
        i.add(18);
        i.add(17);
        i.add(23);
        i.add(22);
        i.add(21);
        i.add(20);
        i.add(19);

        i.add(18);
        i.add(17);
        i.add(23);
for (Integer integer : i) {
            System.out.println(integer);
}
        System.out.println(i);
}
}

```java
17
18
19
20
21
22
23
[17, 18, 19, 20, 21, 22, 23]

3.Map

(1).HashMap

鍵值對，map中只和鍵有關，和值無關，鍵會進行排序,好像是根據大小進行排序的。

public class demo2 {
public static void main(String[] args) {
        HashMap<String, Student> map = new HashMap<>();
        map.put("1",new Student("yangkaibo",17));
        map.put("22222a",new Student("sangdongjie",18));

        map.put("5d",new Student("lizhongjian",17));
        map.put("6c",new Student("lizhaoxiang",18));
        map.put("3we",new Student("mongjiangyuan",20));
        map.put("4f",new Student("zhengwenteng",21));

/*  System.out.println(map);
        new HashSet<String>().add("abc");*/
        System.out.println(map);

}

下面這段代碼，通過兩種方式遍歷輸出

方式1：遍歷 鍵找值
方式2：把鍵值對 對象 統一取出來，再進行輸出

public class demo {
    public static void main(String[] args) {
        HashMap<String, Student> map = new HashMap<>();

        map.put("s001", new Student("張三", 23));
        map.put("s001", new Student("張三3333", 230));
        map.put("s002", new Student("張三", 23));
        map.put("s003", new Student("lisi", 29));
        map.put("s005", new Student("王五", 28));
        map.put("s006", new Student("趙六", 27));
        map.put("s007", new Student("田七", 27));

       
        Set<String> strings = map.keySet();

        for (String string : strings) {
            System.out.println(string+"===="+map.get(string));
        }

        Set<Map.Entry<String, Student>> entries = map.entrySet();
        for (Map.Entry<String, Student> entry : entries) {
            String key = entry.getKey();
            Student value = entry.getValue();
            System.out.println(key+"===="+value);
        }
    }
}

（2）.LinkedHashMap

特點：元素有序 並且唯一

``java
public class demo {
    public static void main(String[] args) {

        LinkedHashMap<String, String> map = new LinkedHashMap<>();
        map.put("賈乃亮", "李小璐");
        map.put("賈乃亮", "李小璐2");
        map.put("王寶強", "蓉兒");
        map.put("陳羽凡", "白百合");
        map.put("王大治", "董潔");
        map.put("大朗", "金蓮");

        map.forEach(new BiConsumer<String, String>() {
            @Override
            public void accept(String s, String s2) {
                System.out.println(s+"=="+s2);
            }
        });
    }
}

```java
賈乃亮==李小璐2
王寶強==蓉兒
陳羽凡==白百合
王大治==董潔
大朗==金蓮

（3）.TreeMap

特點：可排序且鍵唯一

下面這段代碼重寫了Comparator方法，避免了出現同名現象有信息錄入不了

Comparator方法利用的返回值爲0，1，-1進行排序

public class demo {
    public static void main(String[] args) {
        TreeMap<Student, String> map = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int num = o1.getName().length() - o2.getName().length();
                int num2 = num == 0 ? o1.getName().compareTo(o2.getName()) : num;
                int num3 = num2 == 0 ? o1.getAge() - o2.getAge() : num2;
                return num3;
            }
        });
        //鍵值對 一對一，不會出現重複現象。
        map.put(new Student("張三", 23), "s001");
        map.put(new Student("張三", 230), "s002");
        map.put(new Student("張三", 23), "哈哈哈哈");
        map.put(new Student("張三3333", 230), "s001");
        map.put(new Student("張三sdfsfsdfs", 23), "呵呵呵呵呵");
        map.put(new Student("lisi", 29), "s001");
        map.put(new Student("王五sdffffffffffffffffffffffffffffffffff", 28), "s001");
        map.put(new Student("趙六ssss", 27), "s001");
        map.put(new Student("田七", 27), "s001");

        map.forEach(new BiConsumer<Student, String>() {
            @Override
            public void accept(Student student, String s) {
                System.out.println(student.getName()+"---"+student.getAge()+"---"+s);
            }
        });
    }
}

```java
張三---23---哈哈哈哈
張三---230---s002
田七---27---s001
lisi---29---s001
張三3333---230---s001
趙六ssss---27---s001
張三sdfsfsdfs---23---呵呵呵呵呵
王五sdffffffffffffffffffffffffffffffffff---28---s001