接口是 List、Set 和 Queue 接口的父接口，该接口里定义的方法 既可用于操作 Set 集合，也可用于操作 List 和 Queue 集合。JDK不提供此接口的任何直接实现，而是提供更具体的子接口(如：Set和List) 实现。Java 集合会丢失容器中所有对象的数据类型，把所有对象都当成 类型处理； 但可以增加泛型，来实现Java 集合记住容器中对象的数据类型。
1、接口方法
方法
方法说明
add( obj)
添加元素
( coll)
添加整个集合
int size()
获取有效元素的个数
void clear()
清空集合
()
是否是空集合
( obj)
是否包含某个元素，是通过元素的方法来判断是否是同一个对象
( c)
是否包含某个元素， 也是调用元素的方法来拿两个集合的元素挨个比较。
( obj)
通过元素的方法判断是否是要删除的那个元素。只会删除找到的第一个元素
( coll)
删除集合中所有的此元素（取当前集合的词集）
( c)
取两个集合中的交集（把交集的结果存在当前集合中，不影响c）
( obj)
判断集合是否相等
[] ()
转成对象数组
()
获取集合对象的哈希值
()
返回迭代器对象，用于集合遍历
package Collection接口;import org.junit.Test;import java.util.*;public class CollectionTest { @Test public void test1(){ Collection coll= new ArrayList(); coll.add(123); coll.add(456); coll.add(new String("Jerry")); Person p = new Person("Tom",15); coll.add(p); coll.add(true); // 1.contains(object obj):判断当前集合中是否包含obj // 在判断时会调用obj对象所在类的equals() boolean contains = coll.contains(123); System.out.println(contains); //true System.out.println(coll.contains(new String("Jerry"))); //true System.out.println(coll.contains(new Person("Tom", 15))); //false ---> true 进行重写equals方法 System.out.println(coll.contains(p)); //true //2.containsAll(Collection coll1) : 判断形参coll1中的所有元素是否都存在于当前集合中 Collection coll1 = Arrays.asList(123,456); System.out.println(coll.containsAll(coll1)); //true } @Test public void test2(){ //3.remove(Object obj): Collection coll= new ArrayList(); coll.add(123); coll.add(456); coll.add(new String("Jerry")); Person p = new Person("Tom",15); coll.add(p); coll.add(false); coll.remove(1234); System.out.println(coll); //[123, 456, Jerry, Collection接口.For_Iterator.Person{name='Tom', age=15}, false] coll.remove(new Person("Tom",15)); System.out.println(coll); //[123, 456, Jerry, false] //4.removeAll(Collection coll1):从当前的集合中移除从从coll1中的所有元素 Collection coll1 = Arrays.asList(123,456); coll.removeAll(coll1); System.out.println(coll); //[Jerry, false] } @Test public void test3(){ Collection coll = new ArrayList(); coll.add(123); coll.add(456); coll.add(new String("Jerry")); Person p = new Person("Tom",15); coll.add(p); coll.add(false); /* // 5.retainAll(Collection coll): 交集 ：获取当前集合和从coll1集合的交集，并返回给当前集合 Collection coll1 = Arrays.asList(123,456,789); coll.retainAll(coll1); System.out.println(coll); //[123, 456]*/ //6.equals(Object obj) : Collection coll1 = new ArrayList(); //Array是有序的，如果add的顺序不同，依然输出false coll1.add(123); coll1.add(456); coll1.add(new String("Jerry")); coll1.add(new Person("Tom",15)); coll1.add(false); System.out.println(coll.equals(coll1)); //true } @Test public void test4(){ Collection coll= new ArrayList(); coll.add(123); coll.add(456); coll.add(new String("Jerry")); Person p = new Person("Tom",15); coll.add(p); coll.add(false); // 7.hasCode() : 返回当前对象的哈希值 System.out.println(hashCode()); //8.集合 --> 数组 ：toArray() Object[] arr = coll.toArray(); for (int i = 0; i 集合 【注意asList要用包装类，否则将视为一个元素】 List strings = Arrays.asList(new String[]{ "AA", "BB", "CC", "DD"}); System.out.println(strings); //[AA, BB, CC, DD] List ints = Arrays.asList(new int[]{ 12, 34, 56}); System.out.println(ints.size()); // 1 List ints1 = Arrays.asList(new Integer[]{ 12, 34, 56}); System.out.println(ints1.size()); // 3 // 9.iterator(): 返回Iterator()接口的实例，用于遍历集合元素。放在IteratorTest.java 中测试 }}class Person{ private String name; private int age; public Person(){ } public Person(String name, int age) { 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 boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Person person = (Person) o; return age == person.age && Objects.equals(name, person.name); } @Override public String toString() { return "Collection接口.For_Iterator.Person{" + "name='" + name + ''' + ", age=" + age + '}'; }}2、子接口一：List
List：元素有序，可重复的集合。
鉴于Java中数组用来存储数据的局限性java简单实现一个阻塞队列，我们通常使用List替代数组
List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
List接口的主要方法：
【除了从集合继承的方法外，List 集合里添加了一些根据索引来操作集合元素的方法】
方法
方法说明
void add(int index, ele)
在index位置插入ele元素
(int index, eles)
从index位置开始将eles中的所有元素添加进来
get(int index)
获取指定index位置的元素
int ( obj)
返回obj在集合中首次出现的位置
int ( obj)
返回obj在当前集合中末次出现的位置
(int index)
移除指定index位置的元素java简单实现一个阻塞队列，并返回此元素
set(int index, ele)
设置指定index位置的元素为ele
List (int , int )
返回从到位置的子集合
① ⭐
作为List 接口的主要实现类；线程不安全，效率高
类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。 继承了 ，并实现了 List 接口。
是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
package List接口;import org.junit.Test;import java.util.ArrayList;import java.util.Arrays;import java.util.List;/** * 常用方法总结： * 增：add(Object obj) * 删：remove(int index) / remove(Object obj * 改：set(int index,Object ele) * 查：get(int index,Object ele) * 插：add(int index,Object obj) * 长度：size() */public class ListTest { @Test public void test1(){ ArrayList list = new ArrayList(); list.add(123); list.add(456); list.add("AA"); list.add(new Person("Tom",12)); list.add(false); System.out.println(list); //[123, 456, AA, For_Iterator.Person{name='Tom', age=12}, false] //1. void add (int index, Object ele) : 在index位置插入ele元素 list.add(1,"BB"); System.out.println(list); //[123, BB, 456, AA, For_Iterator.Person{name='Tom', age=12}, false] List list1 = Arrays.asList(1,2,3); //list.addAll(list1); //[123, BB, 456, AA, For_Iterator.Person{name='Tom', age=12}, false, 1, 2, 3] list.add(list1); //[123, BB, 456, AA, For_Iterator.Person{name='Tom', age=12}, false, [1, 2, 3]] System.out.println(list); //2.Object get(int index) : 获取指定index位置的元素 System.out.println(list.get(2)); // 456 } @Test public void test2(){ ArrayList list = new ArrayList(); list.add(123); list.add(456); list.add("AA"); list.add(new Person("Tom",12)); list.add(false); //3.int index(Object obj) : 返回obj在集合中首次出现的位置 int index = list.indexOf(123); System.out.println(index); // 0 //4.int lastIndexOf(Object obj) : 返回obj在集合中末次出现的位置 int lastIndexOf = list.lastIndexOf(456); System.out.println(lastIndexOf); // 1 //5.Object remove(int index) : 移除指定index位置的元素，并返回此元素 Object obj = list.remove(0); System.out.println(obj); // 123 System.out.println(list); // [456, AA, For_Iterator.Person{name='Tom', age=12}, false] //6.Object set(int index,Object ele) : 设置指定index位置的元素ele list.set(0,123); System.out.println(list); //[123, AA, For_Iterator.Person{name='Tom', age=12}, false] //7.list subList(int formIndex,int toIndex) : 返回从fromIndex到toIndex位置的左闭右开区间 List subList = list.subList(2, 4); System.out.println(subList); //[For_Iterator.Person{name='Tom', age=12}, false] System.out.println(list); //[123, AA, For_Iterator.Person{name='Tom', age=12}, false] }}②
对于频繁的插入、删除操作、使用此类的效率比高；底层使用的是双向列表存储
链表（）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。
链表可分为单向链表和双向链表。
一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。
一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。
【使用方式与基本相同，在此就不进行代码上的重复】
③
作为List 接口古老实现类；线程安全，效率低；
面试题
和的异同?
二者都线程不安全，相对线程安全的，执行效率高。
此外，是实现了基于动态数组的数据结构，基于链表的数据结构。对于随机访问get和set，优于，因为要移动指针。对于新增和删除操作add(特指插入)和，比较占优势，因为要移动数据。
和的区别?
和几乎是完全相同的,唯一的区别在于是同步类()，属于强同步类。因此开销就比要大，访问要慢。正常情况下,大多数的Java程序员使用而不是,因为同步完全可以由程序员自己来控制。每次扩容请求其大小的2倍空间，而是1.5倍。还有一个子类Stack。
3、子接口二：Set
Set：元素无序，不可重复的集合。 储存无序的 ≠ 随机性，根据数据的hash值顺序进行添加
Set接口是的子接口，set接口没有提供额外的方法。
Set集合不允许包含相同的元素，如果是把两个相同的元素加入同一个 Set 集合中，则添加操作失败。Set 判断两个对象是否相同不是使用 == 运算符，而是根据 () 方法。
①
作为Set接口的主要实现类 ；线程不安全 ，可以存储null值
：作为的子类；遍历其内部数据时，可以按照添加的顺序遍历
import org.junit.Test;import java.util.*;public class SetTest { /* Set接口 ：1. 储存无序的 ≠ 随机性，根据数据的hash值顺序进行添加 2. 不可重复的数据 */ @Test public void HashTest(){ Set set = new HashSet(); set.add(456); set.add(123); set.add(123); set.add("AA"); set.add(new Person("Tom",12)); //set.add(new User("Tom",12)); set.add("cc"); set.add(false); Iterator iterator = set.iterator(); while(iterator.hasNext()){ System.out.print(iterator.next() + " "); //AA cc Collection接口.For_Iterator.Person{name='Tom', age=12} false 456 123 } } @Test public void LinkedHashTest(){ /* LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前后两个数据。 优点 ：对于频繁的遍历操作，LinkedHashSet的效率要高于HashSet */ Set set = new LinkedHashSet(); set.add(456); set.add(123); set.add(123); set.add("AA"); set.add(new Person("Tom",12)); set.add("cc"); set.add(false); Iterator iterator = set.iterator(); while(iterator.hasNext()) { System.out.print(iterator.next() + " "); //456 123 AA Collection接口.For_Iterator.Person{name='Tom', age=12} cc false } }}②
：可以按照对象的指定属性，进行排序。
换言之：可以按照程序员自己的意愿进行排序；排序方法分为自由排序，定制排序
import org.junit.Test;import java.util.*;public class SetTest { @Test public void treeSetTest2() { /* 定制排序:(比较的标准为：compare（）返回0) */ Comparator com = new Comparator() { //按照年龄从大到小排序 @Override public int compare(Object o1, Object o2) { if (o1 instanceof User && o2 instanceof User){ User user1 = (User)o1; User user2 = (User)o2; return Integer.compare(user1.getAge(), user2.getAge()); }else { throw new RuntimeException("输入的数据类型不匹配"); } } /* @Override public boolean equals(Object obj) { return false; }*/ }; TreeSet treeSet = new TreeSet(com); treeSet.add(new User("jerry", 3)); treeSet.add(new User("Mike", 13)); treeSet.add(new User("Shar", 15)); treeSet.add(new User("Tom", 12)); treeSet.add(new User("Tww", 12)); Iterator iterator1 = treeSet.iterator(); while (iterator1.hasNext()) { System.out.println(iterator1.next()); //User{name='jerry', age=3} //User{name='Tom', age=12} //User{name='Mike', age=13} //User{name='Shar', age=15} } } @Test public void test3(){ /** * 【面试题：】 * 注意：重写equals和hashCode方法 */ HashSet set = new HashSet(); User u1 = new User("AA",1001); User u2 = new User("BB",1002); set.add(u1); set.add(u2); System.out.println(set); //[User{name='AA', age=1001}, User{name='BB', age=1002}] u1.name = "CC"; set.remove(u1); System.out.println(set); //[User{name='CC', age=1001}, User{name='BB', age=1002}] set.add(new User("CC",1001)); System.out.println(set); //[User{name='CC', age=1001}, User{name='CC', age=1001}, User{name='BB', age=1002}] set.add(new User("AA",1001)); System.out.println(set); //[User{name='CC', age=1001}, User{name='CC', age=1001}, User{name='AA', age=1001}, User{name='BB', age=1002}] } }//建立一个实现Comparable的User类，用于上面Set的操作class User implements Comparable { String name; int age; public User() { } public User(String name, int age) { 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 String toString() { return "User{" + "name='" + name + ''' + ", age=" + age + '}'; } //按照姓名从小到大排列 @Override public int compareTo(Object o) { if(o instanceof User){ User user = (User) o; return this.name.compareTo(user.name); }else { throw new RuntimeException("输入的类型不匹配"); } } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; User user = (User) o; if (age != user.age) return false; return name != null ? name.equals(user.name) : user.name == null; } @Override public int hashCode() { int result = name != null ? name.hashCode() : 0; result = 31 * result + age; return result; }}三、迭代器接口1、遍历
Java （迭代器）不是一个集合，它是一种用于访问集合的方法，可用于迭代 和 等集合。
是 Java 迭代器最简单的实现， 是 API 中的接口， 它扩展了 接口。
仅用于遍历集合， 本身并不提供承装对象的能力。如果需要创建 对象，则必须有一个被迭代的集合。集合对象每次调用()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
迭代器 的两个基本操作是 next 、 和 。
调用 .next() 会返回迭代器的下一个元素，并且更新迭代器的状态。
调用 .() 用于检测集合中是否还有元素。
调用 .() 将迭代器返回的元素删除。
import org.junit.Test;import java.util.ArrayList;import java.util.Collection;import java.util.Iterator;public class IteratorTest { //迭代器Iterator接口，用于遍历Collection集合中的元素 //1.内部方法 hasNext() next() //2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象 //3.内部定义了remove(),可以在遍历的时候，删除集合中的元素。【不同于集合调用remove()】 @Test public void tes1(){ Collection coll= new ArrayList(); coll.add(123); coll.add(456); coll.add(new String("Jerry")); Person p = new Person("Tom",15); coll.add(p); coll.add(false); Iterator iterator = coll.iterator();/* //方式一 : System.out.println(iterator.next()); //123 System.out.println(iterator.next()); //456 System.out.println(iterator.next()); //Jerry System.out.println(iterator.next()); //Collection接口.For_Iterator.Person{name='Tom', age=15} System.out.println(iterator.next()); //false System.out.println(iterator.next()); //超出集合的范围，报错NoSuchElementException*//* //方式二 : 不推荐 for (int i=0;i< coll.size();i++){ System.out.println(iterator.next()); } */ //方式三 : while(iterator.hasNext()){ System.out.println(iterator.next()); } } //测试Iterator中的remove() @Test public void test2(){ Collection coll= new ArrayList(); coll.add(123); coll.add(456); coll.add(new String("Jerry")); Person p = new Person("Tom",15); coll.add(p); coll.add(false); //删除集合中的“Jerry"数组 Iterator iterator = coll.iterator(); while (iterator.hasNext()){ Object obj = iterator.next(); if ("Jerry".equals(obj)){ iterator.remove(); } } //遍历集合 iterator = coll.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); //此时输出没有了”Jerry“元素 } }//创建一个Person类，来作为集合的一个元素class Person { private String name; private int age; public Person() { } public Person(String name, int age) { 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; }}}遍历的原理：
()：判断是否还有下一个元素
next()：指针下移；将下移以后集合位置上的元素返回2、：增强for循环
Java 5.0 提供了 循环迭代访问 和数组。
遍历操作不需获取或数组的长度，无需使用索引访问元素。遍历集合的底层调用完成操作。还可以用来遍历数组。
package For_Iterator;import org.junit.Test;import java.util.ArrayList;import java.util.Collection;public class ForTest { //foreach循环，用于遍历集合、数组 @Test public void test1(){ Collection coll= new ArrayList(); coll.add(123); coll.add(456); coll.add(new String("Jerry")); Person p = new Person("Tom",15); coll.add(p); coll.add(false); //for(集合元素的类型 局部变量 : 集合对象) for (Object obj : coll){ System.out.println(obj); } } @Test public void test2(){ int[] arr = new int[]{ 1,2,3,4,5,6}; //for(数组元素的类型 局部变量 : 数组对象) for (int i : arr){ System.out.println(i); } } //练习 @Test public void test3(){ String[] arr = new String[]{ "qq","wwe","wear"}; /* //方式一 ： 普通for循环 for (int i = 0; i < arr.length; i++) { arr[i] = "GG"; } for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + " "); // GG GG GG }*/ //方式二 ： 增强for循环 for(String i : arr){ i = "GG"; } for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] +" "); // qq wwe wear } }}四、Map接口
Map接口：双列数据，保存具有映射关系“ key – value对 ”的集合。
Map与是并列的存在；一个单列数据，一个双列数据。
方法
方法说明
put( key, value)
增：将指定key-value添加到(或修改)当前map对象中
( key)
删：移除指定key的key-value对，并返回value
void (Map m)
改：将m中的所有key-value对存放到当前map中
void clear()
清空：清空当前map中的所有数据
get( key)
查：获取指定key对应的value
( key)
查：是否包含指定的key
( value)
查：是否包含指定的Value
()
判断当前map是否为空
( obj)
判断当前map和参数对象obj是否相等
原始图操作的方法
方法
方法说明
Set ()
返回所有key构成的Set集合
()
返回所有value构成的集合
Set ()
返回所有key-value对构成Set的集合
1、、⭐
public class MapTest { @Test public void test1(){ Map map = new HashMap(); //添加 map.put("AA",123); map.put(45,123); map.put("BB",87); //修改 map.put("AA",87); System.out.println(map); // {AA=87, BB=87, 45=123} Map map1 = new HashMap(); map1.put("CC",123); map1.put("DD",234); map.putAll(map1); System.out.println(map); // {AA=87, BB=87, CC=123, DD=234, 45=123} //删除 Object value = map.remove(45); System.out.println(value); // 123 System.out.println(map); // {AA=87, BB=87, CC=123, DD=234} //清空 map.clear(); System.out.println(map); // {} System.out.println(map.size()); // 0 } @Test public void test2(){ Map map = new HashMap(); map.put("AA",123); map.put(45,123); map.put("BB",87); map.put("AA",87); Map map1 = new HashMap(); map1.put("aa",123); map1.put("bb",345); System.out.println(map.get("AA")); // 87 System.out.println(map.containsKey("CC")); //false System.out.println(map.containsValue(123)); //true System.out.println(map.isEmpty()); //false System.out.println(map.size()); //3 System.out.println(map.equals(map1)); //false } @Test public void test3(){ /** * 遍历 * 1.Set keySet():返回所有key构成的Set集合 * 2.Collection values():返回所有value构成的Collection集合 * 3.Set entrySet():返回所有key-value对构成Set的集合 */ Map map = new HashMap(); map.put("AA",123); map.put(45,123); map.put("BB",87); map.put("AA",87); //1.Set keySet():返回所有key构成的Set集合 Set set = map.keySet(); Iterator iterator = set.iterator(); while (iterator.hasNext()){ System.out.print(iterator.next() + " "); //AA BB 45 } //2.Collection values():返回所有value构成的Collection集合 Collection values = map.values(); for(Object obj: values){ System.out.print(obj + " "); // 87 87 123 } //3.Set entrySet():返回所有key-value对构成Set的集合 Set set1 = map.entrySet(); System.out.println(set1); //[AA=87, BB=87, 45=123] }}3、五、工具类
类名
类名解释
(List)
反转List中元素的顺序
(List)
对List集合元素进行随机排序
sort(List)
根据元素的自然模式对指定List 集合元素按升序排序
sort(list,)
根据指定比较器产生的顺序对指定列表进行排序。
swap(List,int,int)
将指定List集合中的 i 处元素和 j 处元素进行交换
max()
根据元素的自然顺序，返回给定集合中的最大元素
max (,)
根据 指定的顺序，返回给定集合中的最大元素
min()
根据元素的自然顺序 返回给定 的最小元素。
min (,)
根据指定比较器产生的顺序，返回给定 的最小元素。
int (,)
返回指定集合中指定元素的出现次数
void copy(List dest,List src)
将src中的内容复制到dest中
(List list, , )
使用新值替换List对应旧值
import org.junit.Test;import java.util.*;/** * Collections工具类的使用演示 */public class CollectionsTest { @Test public void test1(){ List list = new ArrayList(); list.add(123); list.add(43); list.add(-927); list.add(0); System.out.println(list); //[123, 43, -927, 0] //reverse 反转 Collections.reverse(list); System.out.println(list); //[0, -927, 43, 123] //shuffle 随机 Collections.shuffle(list); System.out.println(list); // [43, 123, 0, -927] //sort 排序 Collections.sort(list); System.out.println(list); //[-927, 0, 43, 123] //swap 交换 Collections.swap(list,1,2); System.out.println(list); // [-927, 43, 0, 123] //Object max/min 最大值/最小值 Object max = Collections.max(list); System.out.println(max); // 123 Object min = Collections.min(list); System.out.println(min); // -927 //frequency 频率 int frequency = Collections.frequency(list,123); int frequency1 = Collections.frequency(list,1); System.out.println(frequency); // 1 System.out.println(frequency1); // 0 } @Test public void test2(){ //copy 复制 List list = new ArrayList(); list.add(123); list.add(43); list.add(-927); list.add(0); /* 错误写法：java.lang.IndexOutOfBoundsException: Source does not fit in dest List dest = new ArrayList(); Collections.copy(dest,list); System.out.println(dest); */ List dest = Arrays.asList(new Object[list.size()]); System.out.println(dest.size()); // 4 Collections.copy(dest,list); System.out.println(dest); //[123, 43, -927, 0] //replace 替换 Collections.replaceAll(list,123,321); System.out.println(list); // [321, 43, -927, 0] }}带你了解Java高级编程—–集合_符工爱奇的博客-CSDN博客
本文到此结束，希望对大家有所帮助。
本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至81118366@qq.com举报，一经查实，本站将立刻删除。发布者：简知小编，转载请注明出处：https://www.jianzixun.com/93311.html
微信扫一扫 
支付宝扫一扫 
