概念及实例见一下代码
1.Collection基础相关：
package com.atguigu.java_collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import org.junit.Test;
/*
* 1.存储对象可以考虑：①数组 ②集合
* 2.数组存储对象的特点：Student[] stu = new Student[20]; stu[0] = new Student();...
* >弊端：①一旦创建，其长度不可变；②真实的数组存放的对象个数不可知。
* 3.集合
* Collection接口:方法：①add(Object obj),addAll(Collection coll),size(),clear(),isEmpty();
* ②remove(Object obj),removeAll(Collection coll),retainAll(Collection coll),
* equals(Object obj),contain(Object obj),containAll(Collection coll),hashCode();
* ③iterator(),toArray();
* ------List接口：存储有序的，可以重复的元素（"动态"数组）--新增的方法：删除remove(int index) 修改set(int index,Object obj)
* 获取get(init index) 插入add(int index,Object obj)
* 添加进List集合中的元素（或对象）所在的类一定要重写equals()方法
* ------ArrayList(主要的实现类)、LinkedList(对于频繁的插入、删除操作)、Vector(古老的实现类、线程安全的、效率低)
* ------Set接口：存储无序的，不可重复的元素（类似高中的"集合"）
* ------HashSet、LinkedHashSet、TreeSet
*
* Map接口:存储"键-值"对的数据(函数y=f(x))
* key不可重复，使用set存放，value可以重复，使用Collection来存放。
* 一个key-value对构成一个entry(Map.Entry),entry使用set存放
* ------HashMap、LinkedHashMap、TreeMap、Hashtable(子类：Properties)
*/
public class TestCollection {
@Test
public void testCollection2(){
Collection coll = new ArrayList();
coll.add(123);
coll.add("aa");
coll.add(new Date());
coll.add("bb");
//6.contains(Object obj):判断集合中是否包含指定的obj元素，包含返回true，反之false
//判断依据：根据元素所在的类的equals()方法进行判断
//明确：如果存入集合中的元素是自定义的对象。要求：自定义类要求重写equals()方法
boolean b1 = coll.contains(123);
System.out.println(b1);
//7.containsAll(Collection coll):判断当前集合中是否包含coll中所有元素
Collection coll1 = new ArrayList();
coll1.add(123);
coll1.add(new String("aa"));
boolean b2 = coll.containsAll(coll1);
System.out.println(b2);
// coll1.add(456);
//8.retainAll(Collection coll):求当前集合与coll的共有元素，返回给当前元素
// coll.retainAll(coll1);
// System.out.println(coll);
//9.remove(Object obj):删除集合中的obj元素。若删除成功返回true反之false
boolean b3 = coll.remove("cc");
System.out.println(b3);
//10.removeAll(Collection coll):从当前集合中删除包含在coll中的元素
coll.removeAll(coll1);
System.out.println(coll);
//11.equals(Object obj):判断两个集合元素是否完全一样
System.out.println(coll.equals(coll1));
//12.hashCode():
System.out.println(coll.hashCode());
System.out.println();
//13.toArray():将集合转成数组
Object[] obj = coll.toArray();
for(int i = 0;i < obj.length;i++){
System.out.println(obj[i]);
}
System.out.println();
//集合遍历
//14.iterator():返回一个Iterator接口实现类的对象
Iterator iterator = coll.iterator();
//方式一：不用
// System.out.println(iterator.next());
// System.out.println(iterator.next());
//方式二：不用
// for(int i = 0;i< coll.size();i++){
// System.out.println(iterator.next());
// }
//方式三：使用
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
@Test
public void testCollection1(){
Collection coll = new ArrayList();
//1.size():返回集合中元素的个数
System.out.println(coll.size());
//2.add(Object obj):向集合中添加一个元素
coll.add(123);
coll.add("aa");
coll.add(new Date());
coll.add("bb");
System.out.println(coll.size());
//3.addAll(Collection coll):将形参coll中包含的所有元素添加到当前集合中
Collection coll1 = Arrays.asList(1,2,3);
coll.addAll(coll1);
System.out.println(coll.size());
//查看集合元素
System.out.println(coll);
//4.isEmpty():判断集合是否为空
System.out.println(coll.isEmpty());
//5.clear():清空集合元素
coll.clear();
System.out.println(coll.isEmpty());
}
}
2.Iterator遍历以及增强For循环
package com.atguigu.java_collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import org.junit.Test;
public class TestIterator {
//使用增强for循环实现数组的遍历,注意数组没有迭代器
@Test
public void testFor1(){
String[] str = new String[]{"ss","dd","ff"};
for(String i:str){
System.out.println(i);
}
}
//使用增强for循环实现集合的遍历
@Test
public void testFor(){
Collection coll = new ArrayList();
coll.add(123);
coll.add("aa");
coll.add(new Date());
coll.add("bb");
for(Object i:coll){
System.out.println(i);
}
}
//错误写法
@Test
public void test2(){
Collection coll = new ArrayList();
coll.add(123);
coll.add("aa");
coll.add(new Date());
coll.add("bb");
Iterator i = coll.iterator();
while((i.next()) != null){
System.out.println(i.next());
}
}
//正确写法:使用迭代器Iterator实现集合的遍历
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add(123);
coll.add("aa");
coll.add(new Date());
coll.add("bb");
//iterator():返回一个Iterator接口实现类的对象
Iterator iterator = coll.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
3.List相关
package com.atguigu.java_collection;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
public class TestList {
//ArrayList:List的主要实现类
/*
* List中相对于Collection新增加的方法
* void add(int index, Object ele):在指定的索引位置index添加元素ele
boolean addAll(int index, Collection eles)
Object get(int index):获取指定索引的元素
Object remove(int index):删除指定索引位置的元素
Object set(int index, Object ele):设置指定（修改）索引位置的元素
int indexOf(Object obj):返回obj在集合中首次出现的位置,没有返回-1
int lastIndexOf(Object obj):返回obj在集合中最后一次出现的位置,没有返回-1
List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex结束的左闭右开一个子list
List常用的方法：增(add(Object obj)) 删(remove) 改(set(int index, Object ele))
查(get(int index)) 插(add(int index, Object ele)) 长度(size())
*/
@Test
public void testList2(){
List list = new ArrayList();
list.add(123);
list.add(456);
list.add(new String("aa"));
list.add(new String("ss"));
list.add(456);
System.out.println(list.indexOf(456));//1
System.out.println(list.lastIndexOf(456));//4
System.out.println(list.indexOf(123) == list.lastIndexOf(123));//true
System.out.println(list.indexOf(444));//-1
List list1 = list.subList(0, 3);//左闭右开
System.out.println(list1);
}
@Test
public void testList1(){
List list = new ArrayList();
list.add(123);
list.add(456);
list.add(new String("aa"));
list.add(new String("ss"));
System.out.println(list);
list.add(0, 111);
System.out.println(list);
Object obj = list.get(1);
System.out.println(obj);
list.remove(0);
System.out.println(list.get(0));
list.set(0, 222);
System.out.println(list.get(0));
}
}
4.Set相关
先建Person、Customer两个类，set和map要用
Person类
package com.atguigu.java_collection;
public class Person implements Comparable{
private String name;
private Integer age;
public Person() {
super();
}
public Person(String name, Integer age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Person [age=" + age + ", name=" + name + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((age == null) ? 0 : age.hashCode());
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 == null) {
if (other.age != null)
return false;
} else if (!age.equals(other.age))
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
//当向TreeSet中添加Person类的对象时，依据此方法确定按照哪个属性排序
@Override
public int compareTo(Object o) {
if(o instanceof Person){
Person p = (Person)o;
return this.name.compareTo(p.name);
}
return 0;
}
}
Customer类：
package com.atguigu.java_collection;
public class Customer {
private String name;
private Integer id;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Customer(String name, Integer id) {
super();
this.name = name;
this.id = id;
}
public Customer() {
super();
}
@Override
public String toString() {
return "Customer [name=" + name + ", id=" + id + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((id == null) ? 0 : id.hashCode());
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;
Customer other = (Customer) obj;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.id))
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
Set相关
package com.atguigu.java_collection;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;
import org.junit.Test;
/*
* Collection接口：
* ------List接口：存储有序的，可以重复的元素
* ------ArrayList(主要的实现类)
* ------LinkedList(对于频繁的插入、删除操作)
* ------Vector(古老的实现类、线程安全的、效率低)
* ------Set接口：存储无序的，不可重复的元素。Set中常用的方法都是Collection中定义的
* ------HashSet(主要实现类)
* ------LinkedHashSet
* ------TreeSet
*/
public class TestSet {
@Test
public void testTreeSet3() {
TreeSet set = new TreeSet(new Comparator() {
public int compare(Object o1, Object o2) {
if (o1 instanceof Customer && o2 instanceof Customer) {
Customer c1 = (Customer) o1;
Customer c2 = (Customer) o2;
int i = c1.getId().compareTo(c2.getId());
if (i == 0) {
return c1.getName().compareTo(c2.getName());
}
return i;
}
return 0;
}
});
set.add(new Customer("AA", 1003));
set.add(new Customer("BB", 1002));
set.add(new Customer("GG", 1004));
set.add(new Customer("CC", 1001));
set.add(new Customer("DD", 1001));
for (Object str : set) {
System.out.println(str);
}
}
/*
* TreeSet的定制排序： 见下面的步骤 compare()与hashCode()以及equals()三者保持一致！
*/
@Test
public void testTreeSet2() {
// 1.创建一个实现了Comparator接口的类对象
Comparator com = new Comparator() {
// 向TreeSet中添加Customer类的对象，在此compare()方法中，指明是按照Customer
// 的哪个属性排序的。
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof Customer && o2 instanceof Customer) {
Customer c1 = (Customer) o1;
Customer c2 = (Customer) o2;
int i = c1.getId().compareTo(c2.getId());
if (i == 0) {
return c1.getName().compareTo(c2.getName());
}
return i;
}
return 0;
}
};
// 2.将此对象作为形参传递给TreeSet的构造器中
TreeSet set = new TreeSet(com);
// 3.向TreeSet中添加Comparator接口中的compare方法中涉及的类的对象。
set.add(new Customer("AA", 1003));
set.add(new Customer("BB", 1002));
set.add(new Customer("GG", 1004));
set.add(new Customer("CC", 1001));
set.add(new Customer("DD", 1001));
for (Object str : set) {
System.out.println(str);
}
}
/*
* TreeSet:
* 1.向TreeSet中添加的元素必须是同一个类的。
* 2.可以按照添加进集合中的元素的指定的顺序遍历。
* 如String、包装类等默认按照从小到大的顺序遍历。
* 3.当向TreeSet中添加自定义类的对象时，有两种排序方法：①自然排序②定制排序
* 4.自然排序：要求自定义类实现java.lang.Comparable接口并重写其compareTo(Object obj)的抽象方法
* 在此方法中，指明按照自定义类的哪个属性进行排序。
*
* 5.向TreeSet中添加元素时，首先按照compareTo()进行比较，一旦返回0，虽然仅是两个对象的此
* 属性值相同，但是程序会认为这两个对象是相同的，进而后一个对象就不能添加进来。
*
* >compareTo()与hashCode()以及equals()三者保持一致！
*/
@Test
public void testTreeSet1(){
Set set = new TreeSet();
// set.add("aa");
// set.add("ss");
// set.add("ff");
// set.add("kk");
// 当Person类没有实现Comparable接口时，当向TreeSet中添加Person对象时，报ClassCastException
set.add(new Person("cc",22));
set.add(new Person("ff",23));
set.add(new Person("aa",25));
for(Object str:set){
System.out.println(str);
}
}
/*
* LinkedHashSet:使用链表维护了一个添加进集合中的顺序，导致当遍历LinkedHashSet集合
* 元素时，是按照添加进去顺序遍历的！
*
* LinkedHashSet插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。
*
*/
@Test
public void testLinkedHashSet(){
Set set = new LinkedHashSet();
set.add(123);
set.add(456);
set.add("aa");
set.add("ss");
set.add(null);
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
/*
* Set:存储的元素是无序的，不可重复的！
* 1.无序性：无序性!=随机性。真正的无序性指的是元素在底层存储的位置是无序的。
* 2.不可重复性：当向Set中添加进相同的元素的时候，后面的这个不能添加进去。
*
* 说明：要求添加进Set中的元素所在的类，一定要重写equals()和hashCode()犯法
* 进而保证Set中元素的不可重复性！
*
* Set中的元素是如何存储的？--使用哈希算法。
* 当向Set中添加对象时，首先调用此对象所在类的hashCode()方法，计算此对象的哈希值，
* 此哈希值决定了此对象在Set中存储位置。若此位置之前没有对象存储，则这个对象直接存储
* 在此位置。若此位置已有对象存储，再通过equals()比较这两个对象是否相同。如果相同，
* 后一个对象就不能再添加进来。
* 万一返回false，都存储（不建议如此）
* >要求：hashCode()方法要与equals()方法一致。
*/
@Test
public void testHashSet(){
Set set = new HashSet();
set.add(123);
set.add(456);
set.add("aa");
//set.add("aa");
set.add("ss");
set.add(null);
Person p1 = new Person("gg", 25);
Person p2 = new Person("gg", 25);
set.add(p1);
set.add(p2);
System.out.println(set.size());
System.out.println(set);
}
}
5.Map相关
package com.atguigu.java_collection;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.TreeMap;
import org.junit.Test;
/*
* Collection接口
*
* Map接口：存储"键-值"对的数据(函数y=f(x))
* key不可重复，使用set存放，value可以重复，使用Collection来存放。
* 一个key-value对构成一个entry(Map.Entry),entry使用set存放
* |-----HashMap:Map的主要实现类
* |-----LinkedHashMap:使用链表维护添加进Map中的顺序。故遍历Map时，是按添加的顺序遍历的。
* |-----TreeMap:按照添加进Map中的元素的key的指定属性进行排序。要求：key必须是同一个类的对象！
* 针对key：自然排序 vs 定制排序
* |-----Hashtable:古老的实现类，线程安全，不建议使用。
* |----Properties:常用来处理属性文件。键和值都为String类型的
*/
public class TestMap {
//使用Properties处理属性文件
@Test
public void test6() throws FileNotFoundException, IOException{
Properties pros = new Properties();
pros.load(new FileInputStream(new File("jdbc.properties")));
String user = pros.getProperty("user");
System.out.println(user);
String password = pros.getProperty("password");
System.out.println(password);
}
// 定制排序
@Test
public void test5() {
Comparator com = new Comparator() {
public int compare(Object o1, Object o2) {
if (o1 instanceof Customer && o2 instanceof Customer) {
Customer c1 = (Customer) o1;
Customer c2 = (Customer) o2;
int i = c1.getId().compareTo(c2.getId());
if (i == 0) {
return c1.getName().compareTo(c2.getName());
}
return i;
}
return 0;
}
};
TreeMap map = new TreeMap(com);
map.put(new Customer("AA", 1001), 87);
map.put(new Customer("CC", 1001), 67);
map.put(new Customer("MM", 1004), 77);
map.put(new Customer("GG", 1002), 97);
Set set1 = map.keySet();
for (Object obj : set1) {
System.out.println(obj + "----->" + map.get(obj));
}
}
// 自然排序
@Test
public void test4(){
Map map = new TreeMap();
map.put(new Person("AA", 23), 89);
map.put(new Person("MM", 22), 79);
map.put(new Person("GG", 23), 99);
map.put(new Person("JJ", 13), 69);
Set set = map.keySet();
for(Object obj:set){
System.out.println(obj + "----->" + map.get(obj));
}
}
@Test
public void test3() {
Map map = new LinkedHashMap();
map.put("AA", 213);
map.put("BB", 45);
map.put(123, "CC");
map.put(null, null);
map.put(new Person("DD", 23), 89);
Set set1 = map.keySet();
for (Object obj : set1) {
System.out.println(obj + "----->" + map.get(obj));
}
}
/*
* 如何遍历Map
* Set keySet()
* Collection values()
* Set entrySet()
*/
@Test
public void test2(){
Map map = new HashMap();
map.put("AA", 123);
map.put("BB", 456);
map.put(123, "CC");
map.put(null, null);
map.put(new Person("DD",22), 656);
//1.遍历key集
Set set = map.keySet();
for(Object obj:set){
System.out.println(obj);
}
//2.遍历values集
Collection values = map.values();
Iterator i = values.iterator();
while(i.hasNext()){
System.out.println(i.next());
}
//3.如何遍历key-value对
//方式一：
Set set1 = map.keySet();
for(Object obj:set1){
System.out.println(obj + "---->" + map.get(obj));
}
//方式二：
Set set2 = map.entrySet();
for(Object obj:set2){
Map.Entry entry = (Map.Entry)obj;
//System.out.println(entry.getKey() + "---->" +entry.getValue());
System.out.println(entry);
}
}
/*
* Object put(Object key,Object value):向Map中添加一个元素
* Object remove(Object key):按照指定的key删除此key-value
* void putAll(Map t)
* void clear():清空 Object
* get(Object key)：获取指定key的value值。若无此key，则返回null
* boolean containsKey(Object key)
* boolean containsValue(Object value)
* int size():返回集合的长度
* boolean isEmpty()
* boolean equals(Object obj)
*
* HashMap： 1.key是用Set来存放的，不可重复。value是用Collection来存放的，可重复
* 一个key-value对，是一个Entry。所有的Entry是用Set存放的，也是不可重复的。
* 2.向HashMap中添加元素时，会调用key所在类的equals()方法，判断两个key是否相同。若相同 则只能添加进后添加的那个元素。
*/
@Test
public void test1(){
Map map = new HashMap();
map.put("AA", 123);
map.put("BB", 456);
map.put("BB", 45);
map.put(123, "CC");
map.put(null, null);
map.put(new Person("DD",22), 656);
map.put(new Person("DD",22), 565);
System.out.println(map.size());
System.out.println(map);
map.remove("BB");
System.out.println(map);
}
}
6.Collections:操作Collection和Map的工具类
package com.atguigu.java_collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.junit.Test;
/*
* 操作Collection以及Map的工具类：Collections
*/
public class TestCollections {
/*
* Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection,Object)：返回指定集合中指定元素的出现次数
void copy(List dest,List src)：将src中的内容复制到dest中
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
*/
@Test
public void testCollections2(){
List list = new ArrayList();
list.add(123);
list.add(456);
list.add(12);
list.add(78);
list.add(456);
Object obj = Collections.max(list);
System.out.println(obj);
int count = Collections.frequency(list, 456);
System.out.println(count);
//实现List的复制
//List list1 = new ArrayList();//错误的实现方式
List list1 = Arrays.asList(new Object[list.size()]);
Collections.copy(list1, list);
System.out.println(list1);
//通过如下的方法保证list的线程安全性。
List list2 = Collections.synchronizedList(list);
System.out.println(list2);
}
/*
* reverse(List)：反转 List 中元素的顺序
shuffle(List)：对 List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
*/
@Test
public void testCollections1(){
List list = new ArrayList();
list.add(123);
list.add(456);
list.add(12);
list.add(78);
System.out.println(list);
Collections.reverse(list);
System.out.println(list);
Collections.shuffle(list);
System.out.println(list);
Collections.sort(list);
System.out.println(list);
Collections.swap(list, 0, 1);
System.out.println(list);
}
}
相关推荐
### Java集合容器知识点详解 #### 一、集合容器概述 - **定义**：集合容器是Java平台提供的标准组件，主要用于存储对象。集合框架提供了一套统一的接口和实现，使得开发者能够灵活地处理不同类型的数据集合。 ####...
Java集合容器概述、集合框架、List、Set、Map接口、Iterator、ArrayList、LinkedList、Vector、HashSet、HashMap、Queue、BlockingQueue、ConcurrentHashMap等。 Java 集合容器概述 Java 集合容器是用于存储数据...
Java集合容器是Java编程中非常重要的一个概念，它主要用于存储和管理对象。集合框架是Java提供的标准接口和类，使得开发者能够以一种统一的方式处理不同类型的数据集合，如列表、集和映射。以下是对Java集合容器相关...
### Java集合容器面试题知识点详解 #### 集合容器概述 - **定义**：集合容器是一种用于存储数据的容器，其设计目的是为了提供一种统一且标准的方式来进行数据的存储和操作。 - **组成**：集合框架主要包括对外的...
Java集合容器是Java编程中非常重要的一个概念，它主要用于存储和操作对象。集合框架是Java提供的一个标准体系结构，用于表示和操作数据集合。这个框架包括接口、接口的实现以及集合操作的算法。 1. 接口：集合框架...
首先，集合框架的核心接口是Collection，它是所有单值集合的父接口。Collection接口定义了添加、删除、查找和遍历元素的基本方法。它的两个主要子接口是Set和List。Set接口不允许元素重复，并且不保证元素的顺序；而...
本篇文章将详细讲解容器的分类，重点探讨Java中的集合框架，包括List、Set以及重写toString方法的重要性，同时也会简单提及Collections类的使用。 首先，我们来了解容器的分类。在Java中，容器主要分为两大类：集合...
在给定的文件中，我们重点关注的是Java集合框架、常用类以及String的相关知识。 首先，集合（Collections）是Java中用于存储一组对象的容器，其长度可变，允许存放不同类型的元素。集合类都位于`java.util`包下，...
在bada2.0的Base Collection框架中，集合被定义为相同类型对象的聚合，这里的重点在于容器而非容器内的元素。这些集合不仅能够高效地存储数据，还提供了添加、删除和修改元素的通用API，确保了代码的可重用性和可...
在编程中，矩阵集合可以被理解为一个容器，它存储了一系列的矩阵并提供对它们进行操作的接口。"matrix-collection-template"就是这样一个专为创建和管理矩阵集合设计的模板。 这个模板的目的是简化开发者的任务，让...
本篇文章将重点介绍Java容器类中Collection接口、Map接口、Iterator接口以及List、Set和Map的实现类。 首先，Collection接口是容器类层次结构的核心，它是单列集合的主要根接口。Collection接口的主要方法包括add...
3. **集合框架**：ArrayList、LinkedList、HashMap、HashSet、TreeMap等容器的使用、性能分析及其内部实现原理。面试中常问的问题包括它们之间的区别、线程安全性、迭代器的使用等。 4. **内存管理**：理解JVM内存...
- **Collection**：Java集合框架的基础接口，定义了集合的基本行为。常用的实现包括Set和List。 - **Collections**：一个工具类，提供了一系列静态方法来操作和控制集合，例如排序、搜索等。 ### 8. HashMap与...
在Java编程中，集合是用来存储多个对象的容器，它们提供了比数组更灵活的操作方式。集合框架是Java中一个重要的部分，它包括多种数据结构，如List、Set和Map等。本篇将重点讨论泛型、匿名内部类以及集合的基本概念和...
- `Collection`接口定义了集合的基本行为，而`Collections`类提供了一系列静态方法来操作集合。 - **面试技巧**：讨论`Collection`和`Collections`的用途，特别是`Collections`提供的实用工具方法。 3. **并发...
### 黑马程序员入学Java知识 #### Java概述与基础知识 1. **何为编程？** - 编程是通过特定的计算机语言来编写指令，让...1. **集合类&容器** - 集合类用于存储一组对象。 - 常见的有`List`、`Set`和`Map`。 ...
在Java编程语言中，泛型是一种强大的特性，它允许我们在编写代码时指定容器（如接口、类或方法）能够操作的数据类型。这有助于确保类型安全，减少运行时错误，并提高代码的可读性。在标题提到的“泛型接口Inter”中...
2. **集合（Collection）**：集合是一组相关的模型对象的容器，它通常包含了一个模型数组，并且提供了对这个数组的操作方法，如添加、删除和排序模型。集合也有自己的URL，可以用来同步数据到服务器。在演示中，你...
- `Collection`：顶层接口，分为`List`和`Set`两大类。 - `Map`：键值对集合。 **集合转换：** - 使用`Collections`工具类中的方法，如`asList()`、`sort()`等。 - 通过`toArray()`方法将集合转换为数组。 **泛型...
集合容器是Java编程中不可或缺的部分，考生需熟悉Java集合框架，包括Collection、List、ArrayList、LinkedList、Set、HashSet、Map及HashMap等容器的使用。深入理解hashCode()和equals()方法的重要性，以及...