phpdsmapputJava聚集入门看这篇就够了

List的特点：

List 代表一个元素有序、且可重复的凑集，凑集中的每个元素都有其对应的顺序索引。
List 许可利用重复元素，可以通过索引来访问指定位置的凑集元素。
List 默认按元素的添加顺序设置元素的索引。
List 凑集里添加了一些根据索引来操作凑集元素的方法

Set的特点：存取无序，元素不可以重复

List凑集:

下面有ArrayList，LinkedList，Vector(已过期)

凑集的的最大目的便是为了存取；List凑集的特点便是存取有序，可以存储重复的元素，可以用下标进行元素的操作。

ArrayList:

底层是利用数组实现，以是查询速率快，增删速率慢

public static void main(String[] args) { // 利用ArrayList进行添加和遍历 List<String> list = new ArrayList<String>(); list.add(&#34;a"); list.add("b"); list.add("c"); // 第一种遍历办法,利用迭代器 Iterator<String> it = list.iterator(); while(it.hasNext()){ String next = it.next(); System.out.println(next); } System.out.println("-------------------"); // 第二种遍历办法，利用foreach for (String str : list){ System.out.println(str); } }复制代码LinkedList:

是基于链表构造实现的，以是查询速率慢，增删速率快，供应了分外的方法，敌人尾的元素操作（进行增删查）。

利用LinkedList来实现栈和行列步队；栈是前辈后出，而行列步队是前辈先出

package org.example.test;import java.util.LinkedList;/ 利用LinkedList来仿照栈 栈的特点：前辈后出 /public class Test12 { private LinkedList<String> linkList = new LinkedList<String>(); // 压栈 public void push(String str){ linkList.addFirst(str); } // 出栈 public String pop(){ return linkList.removeFirst(); } // 查看 public String peek(){ return linkList.peek(); } // 判断是否为空 public boolean isEmpty(){ return linkList.isEmpty(); }}class Test13 { public static void main(String[] args) { // 测试栈 Test12 test12 = new Test12(); test12.push("我是第1个进去的"); test12.push("我是第2个进去的"); test12.push("我是第3个进去的"); test12.push("我是第4个进去的"); test12.push("我是第5个进去的"); // 取出 while (!test12.isEmpty()){ String pop = test12.pop(); System.out.println(pop); } // 打印结果 /我是第5个进去的 我是第4个进去的 我是第3个进去的 我是第2个进去的 我是第1个进去的/ }}复制代码

LinkedList实现Queue:

package org.example.test;import java.util.LinkedList;/ 利用linkedList来实现行列步队 行列步队: 前辈先出 /public class Test12 { private LinkedList<String> link = new LinkedList<String>(); // 放入 public void put(String str) { link.addFirst(str); } // 获取 public String get() { return link.removeLast(); } // 判断是否为空 public boolean isEmpty() { return link.isEmpty(); }}class Test13 { public static void main(String[] args) { // 测试行列步队 Test12 queue = new Test12(); queue.put("我是第1个进入行列步队的"); queue.put("我是第2个进入行列步队的"); queue.put("我是第3个进入行列步队的"); queue.put("我是第4个进入行列步队的"); // 遍历行列步队 while (!queue.isEmpty()) { String str = queue.get(); System.out.println(str); } // 打印结果 /我是第1个进入行列步队的 我是第2个进入行列步队的 我是第3个进入行列步队的 我是第4个进入行列步队的/ }}复制代码Vector:

由于已经由时，被ArrayList取代了；它还有一种迭代器通过vector.elements()获取，判断是否有元素和取元素的方hasMoreElements()nextElement()。

public static void main(String[] args) { Vector<String> vector = new Vector<>(); vector.add("a"); vector.add("v"); vector.add("d"); Enumeration<String> elements = vector.elements(); while (elements.hasMoreElements()) { String nextElement = elements.nextElement(); System.out.println(nextElement); }}复制代码

还有一些基本操作：

public static void main(String[] args) { List<String> list = new ArrayList<String>(); list.add("b");//第一个，索引下标0 list.add("d");//索引下标1 list.add("c");//索引下标2 list.add("a");//索引下标3 list.add("d");//许可利用重复元素 System.out.println(list);//结果：[b, d, c, a, d] System.out.println(list.get(2));//通过索引来访问指定位置的凑集元素.结果：c list.add(1,"f");//在指定索引下标的位置插入数据 System.out.println(list);//结果：[b, f, d, c, a, d] List<String> m = new ArrayList<String>(); m.add("123"); m.add("456"); list.addAll(2, m);//在指定索引下标的位置插入凑集 System.out.println(list);//结果：[b, f, 123, 456, d, c, a, d] System.out.println(list.indexOf("d"));//获取指定元素在凑集中第一次涌现的索引下标.结果：4 System.out.println(list.lastIndexOf("d"));//获取指定元素在凑集中末了一次涌现的索引下标.结果：7 list.remove(2);//根据指定的索引下标移除元素 System.out.println(list);//结果：[b, f, 456, d, c, a, d] list.set(1, "ff");//根据指定的索引下标修正元素 System.out.println(list);//结果：[b, ff, 456, d, c, a, d] //根据索引下标的起始位置截取一段元素形参一个新的凑集，截取的时候，包含开始的索引不包含结束时的索引 List<String> sublist = list.subList(2, 4);//取索引下标在大于即是2,小于4的元素 System.out.println(sublist);//结果：[456, d] System.out.println(list.size());//凑集的长度.结果：7}复制代码set凑集：

Set凑集下面有：HashSet，LinkedHashSet，TreeSet

Set凑集的特点：元素不重复，存取无序，无下标

HashSet:

public static void main(String[] args) { // 利用HashSet来存取 Set<String> set = new HashSet<String>(); set.add("a"); set.add("b"); set.add("b"); set.add("c"); // 遍历 第一种办法 迭代器 Iterator<String> it = set.iterator(); while(it.hasNext()){ String str = it.next(); System.out.println(str); } System.out.println("--------------"); for (String str : set){ System.out.println(str); } // 打印结果，重复的已经去掉了 / a b c -------------- a b c/ }复制代码

HashSet 按 Hash 算法来存储凑集中的元素，因此具有很好的存取和查找性能。
HashSet 具有以下特点：

不能担保元素的排列顺序不可重复（hashcode不相同）HashSet 不是线程安全的凑集元素可以使 null

当向 HashSet 凑集中存入一个元素时，HashSet 会调用该工具的 hashCode() 方法来得到该工具的 hashCode 值，然后根据 hashCode 值决定该工具在 HashSet 中的存储位置，存在set凑集哪个位置由这个值的hashcode决定，而不是按先来后到。
如果两个元素的 equals() 方法返回 true，但它们的 hashCode() 返回值不相等，hashSet 将会把它们存储在不同的位置，但依然可以添加成功。

演示HashSet来存储自定义工具：

package org.example.test;public class Person { // 属性 private String name; private int age; // 布局方法 public Person() { super(); } public Person(String name, int age) { super(); this.name = name; this.age = age; } // 要让哈希表存储不重复的元素，就必须重写hasCode和equals方法 @Override public int hashCode() { final int prime = 31; int result = 1; result = prime result + age; result = prime result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Person other = (Person) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } @Override public String toString() { return "Person [name=" + name + ", age=" + age + "]"; } // getter & setter 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; } }复制代码

public static void main(String[] args) { // 利用HashSet来存取自定义工具 Person Set<Person> set = new HashSet<Person>(); set.add(new Person("张三", 12)); set.add(new Person("李四", 13)); set.add(new Person("王五", 22)); set.add(new Person("张三", 12)); // 遍历 for (Person p : set){ System.out.println(p); } // 结果：向凑集中存储两个张三工具，但是凑集中就成功存储了一个 /Person [name=王五, age=22] Person [name=李四, age=13] Person [name=张三, age=12]/}复制代码

以是在向HashSet凑集中存储自定义工具时，为了担保set凑集的唯一性，那么必须重写hashCode和equals方法。

LinkedHashSet:

是基于链表和哈希表共同实现的，以是具有存取有序，元素唯一

public static void main(String[] args) { // 利用LinkedHashSet来存取自定义工具 Person LinkedHashSet<Person> set = new LinkedHashSet<Person>(); set.add(new Person("张三", 12)); set.add(new Person("李四", 13)); set.add(new Person("王五", 22)); set.add(new Person("张三", 12)); // 遍历 for (Person p : set){ System.out.println(p); } // 结果：向凑集中存储两个张三工具，但是凑集中就成功存储了一个, // 并且存进的顺序，和取出来的顺序是同等的 /Person [name=张三, age=12] Person [name=李四, age=13] Person [name=王五, age=22]/}复制代码TreeSet：TreeSet 是 SortedSet 接口的实现类TreeSet 特点：存取无序，元素唯一，可以进行排序（排序是在添加的时候进行排序）TreeSet 支持两种排序方法：自然排序和定制排序。
默认情形下，TreeSet 采取自然排序

TreeSet凑集存储String工具

public static void main(String[] args) { TreeSet<String> treeSet = new TreeSet<String>(); treeSet.add("a"); treeSet.add("c"); treeSet.add("d"); treeSet.add("b"); for (String str : treeSet){ System.out.println(str); } // 结果：取出来的结果是经由排序的 / a b c d/ }复制代码

TreeSet担保元素的唯一性是有两种办法：

1、自定义工具实现Comparable接口，重写comparaTo方法，该方法返回0表示相等，小于0表示准备存入的元素比被比较的元素小，否则大于0；

2、在创建TreeSet的时候向布局器中传入比较器Comparator接口实现类工具，实现Comparator接口重写compara方法。

如果向TreeSet存入自定义工具时，自定义类没有实现Comparable接口，或者没有传入Comparator比较器时，会涌现ClassCastException非常。

下面便是演示用两种办法来存储自定义工具

package org.example.test;import java.util.TreeSet;public class Person implements Comparable<Person> { // 属性 private String name; private int age; // 布局方法 public Person() { super(); } public Person(String name, int age) { super(); this.name = name; this.age = age; } // 要让哈希表存储不重复的元素，就必须重写hasCode和equals方法 @Override public int hashCode() { final int prime = 31; int result = 1; result = prime result + age; result = prime result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Person other = (Person) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } @Override public String toString() { return "Person [name=" + name + ", age=" + age + "]"; } // getter & setter 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(Person o) { int result = this.age - o.age; if (result == 0) { return this.name.compareTo(o.name); } return result; } public static void main(String[] args) { // 利用TreeSet来存储自定义类Person工具 TreeSet<Person> treeSet = new TreeSet<Person>(); // Person类实现了Comparable接口，并且重写comparaTo方法 // 比较规则是先按照 年事排序，年事相等的情形按照姓名排序 treeSet.add(new Person("张山1", 20)); treeSet.add(new Person("张山2", 16)); treeSet.add(new Person("张山3", 13)); treeSet.add(new Person("张山4", 17)); treeSet.add(new Person("张山5", 20)); for (Person p : treeSet) { System.out.println(p); } // 结果：按照comparaTo方法内的逻辑来排序的 / Person [name=张山3, age=13] Person [name=张山2, age=16] Person [name=张山4, age=17] Person [name=张山1, age=20] Person [name=张山5, age=20] / }}复制代码

另一种办法：利用比较器Comparator

package org.example.test;import java.util.Comparator;import java.util.TreeSet;public class Person { // 属性 private String name; private int age; // 布局方法 public Person() { super(); } public Person(String name, int age) { super(); this.name = name; this.age = age; } // 要让哈希表存储不重复的元素，就必须重写hasCode和equals方法 @Override public int hashCode() { final int prime = 31; int result = 1; result = prime result + age; result = prime result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Person other = (Person) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } @Override public String toString() { return "Person [name=" + name + ", age=" + age + "]"; } // getter & setter 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; } public static void main(String[] args) { // 利用TreeSet来存储自定义类Person工具 // 创建TreeSet工具的时候传入Comparator比较器，利用匿名内部类的办法 // 比较规则是先按照 年事排序，年事相等的情形按照姓名排序 TreeSet<Person> treeSet = new TreeSet<Person>(new Comparator<Person>() { @Override public int compare(Person o1, Person o2) { if (o1 == o2){ return 0; } int result = o1.getAge() - o2.getAge(); if (result == 0){ return o1.getName().compareTo(o2.getName()); } return result; } }); treeSet.add(new Person("张山1", 20)); treeSet.add(new Person("张山2", 16)); treeSet.add(new Person("张山3", 13)); treeSet.add(new Person("张山4", 17)); treeSet.add(new Person("张山5", 20)); for (Person p : treeSet){ System.out.println(p); } // 结果：按照compara方法内的逻辑来排序的 / Person [name=张山3, age=13] Person [name=张山2, age=16] Person [name=张山4, age=17] Person [name=张山1, age=20] Person [name=张山5, age=20] / }}复制代码三、Map凑集

map凑集下面有HashMap，LinkedHashMap和TreeMap

Map 用于保存两组具有映射关系的数据，一组值用于保存 Map 里的 Key，其余一组用于保存 Map 里的 ValueMap 中的 key 和 value 都可以是任何引用类型的数据Map 中的 Key 不许可重复，即同一个 Map 工具的任何两个 Key 通过 equals 方法比较中返回 falseKey 和 Value 之间存在单向一对一关系，即通过指定的 Key 总能找到唯一的，确定的 Value。
HashMap:

是基于哈希表构造实现的，以是存储自定义工具作为键时，必须重写hasCode和equals方法，存取无序的。

下面演示HashMap以自定义工具作为键：

public static void main(String[] args) { // 利用HashMap存储，自定义工具Person作为键 // 为了担保键的唯一性，必须重写hashCode和equals方法 HashMap<Person,String> map = new HashMap<Person,String>(); map.put(new Person("张三", 12), "JAVA"); map.put(new Person("李四", 13), "IOS"); map.put(new Person("小花", 22), "JS"); map.put(new Person("小黑", 32), "PHP"); map.put(new Person("张三", 12), "C++"); Set<Entry<Person, String>> entrySet = map.entrySet(); Iterator<Entry<Person, String>> it = entrySet.iterator(); while (it.hasNext()){ Entry<Person, String> entry = it.next(); System.out.println(entry.getKey() + "---" + entry.getValue()); } // 结果：存入的时候添加了两个张三，如果Map中键相同的时候，当后面的值会覆盖掉前面的值 / Person [name=李四, age=13]---IOS Person [name=张三, age=12]---C++ Person [name=小黑, age=32]---PHP Person [name=小花, age=22]---JS /}复制代码LinkedHashMap:

用法跟HashMap基本同等，它是基于链表和哈希表构造的以是具有存取有序，键不重复的特性。

下面演示利用LinkedHashMap存储，把稳存的顺序和遍历出来的顺序是同等的:

public static void main(String[] args) { // 利用LinkedHashMap存储，自定义工具Person作为键 // 为了担保键的唯一性，必须重写hashCode和equals方法 LinkedHashMap<Person,String> map = new LinkedHashMap<Person,String>(); map.put(new Person("张三", 12), "JAVA"); map.put(new Person("李四", 13), "IOS"); map.put(new Person("小花", 22), "JS"); map.put(new Person("小黑", 32), "PHP"); map.put(new Person("张三", 12), "C++"); // foreach遍历 for (Entry<Person,String> entry : map.entrySet()){ System.out.println(entry.getKey()+"==="+entry.getValue()); } // 结果：存入的时候添加了两个张三，如果Map中键相同的时候，当后面的值会覆盖掉前面的值 // 把稳：LinkedHashMap的特点便是存取有序，取出来的顺序便是和存入的顺序保持同等 / Person [name=张三, age=12]===C++ Person [name=李四, age=13]===IOS Person [name=小花, age=22]===JS Person [name=小黑, age=32]===PHP /}复制代码TreeMap:

给TreeMap凑集中保存自定义工具，自定义工具作为TreeMap凑集的key值。
由于TreeMap底层利用的二叉树，个中存放进去的所有数据都须要排序，要排序，就哀求工具具备比较功能。
工具所属的类须要实现Comparable接口。
或者给TreeMap凑集通报一个Comparator接口工具。

利用TreeMap存入自定义工具作为键：

public static void main(String[] args) { // 利用TreeMap存储，自定义工具Person作为键 // 自定义工具实现Comparable接口或者传入Comparator比较器 TreeMap<Person,String> map = new TreeMap<Person,String>(new Comparator<Person>() { @Override public int compare(Person o1, Person o2) { if (o1 == o2){ return 0; } int result = o1.getAge() - o2.getAge(); if (result == 0){ return o1.getName().compareTo(o2.getName()); } return result; } }); map.put(new Person("张三", 12), "JAVA"); map.put(new Person("李四", 50), "IOS"); map.put(new Person("小花", 32), "JS"); map.put(new Person("小黑", 32), "PHP"); map.put(new Person("张三", 12), "C++"); // foreach遍历 for (Entry<Person,String> entry : map.entrySet()){ System.out.println(entry.getKey()+"==="+entry.getValue()); } // 结果：存入的时候添加了两个张三，如果Map中键相同的时候，当后面的值会覆盖掉前面的值 // 把稳：TreeMap 取出来的顺序是经由排序的，是根据compara方法排序的 / Person [name=张三, age=12]===C++ Person [name=小花, age=32]===JS Person [name=小黑, age=32]===PHP Person [name=李四, age=50]===IOS /}复制代码结尾

我是一个正在被打击还在努力提高的码农。
如果文章对你有帮助，记得点赞、关注哟，感激！

作者：初念初恋链接：https://juejin.cn/post/7002171097831440414来源：掘金著作权归作者所有。
商业转载请联系作者得到授权，非商业转载请注明出处。