list / map / set 的区别
list / map / set 的区别
collection大致分为标题上的三类, 他们一般有其较为稳定的存储场景
如List的自动扩展
set无法存储重复元素
自动排序的组数--TreeSet,TreeList,Tree**
list 和 set 是collection的子类, map不是
Map集合和Collection集合的区别
Map集合是有Key和Value的，Collection集合是只有Value。
Collection集合底层也是有Key和Value，只是隐藏起来。
分类
list常用方法
package test;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListDemo {
public static void main(String[] args) {
// 创建一个新集合
List list = new ArrayList<>();
// 1. 向集合中追加元素
list.add("cc");
// 2. 往集合的指定位置追加元素
list.add(0 , "bbb");
// 3. 向集合追加一个collection，只可追加collection，由于java不提供collection的实现，由它的下级接口来实现
list.addAll(list);
// 4. 往集合的指定位置追加collection
list.addAll( 4 ,list);
// 5. 获取集合长度
int size = list.size();
// 6. 根据元素下标来取集合中的元素
list.get(0);
// 7. 根据元素下标来删除集合中的元素
list.remove(2);
// 8. 集合间做对比
/*
* 此方法是用来比较的，与equals比较相似，现在list的元素中有[a, b, a, b, a, b, a],来和"a,b,c"比较会返回false，
* 但是注意再用来比较String字符串的时候会进行局部的比较，两组字符串部分相同的情况下会返回true
*/
boolean contains = list.contains("a,b,c");
// 9. List -> 数组
// 为了将List转为数组，JDK提供了toArray
// 9.1
String [] array=(String[]) list.toArray(new String[list.size()]);
for(String arrays: array) {
System.out.println(arrays);
}
// 9.2
String [] arr=new String [list.size()];
list.toArray(arr);
for(String arrs: arr) {
System.out.println(arrs);
}
// 10. 在集合中判断是否为空
// 在集合中判断是否为空 ，不空返回false，空会返回true，常常会与null！=list来共同判定集合是否为空，
// null！=list和list.isempty最大的区别是：一个人要喝水，前者判断是否有水杯，后者判断的是水杯是否有水
System.out.println(list.isEmpty()); //false
System.out.println(null!=list); //true
// 11. 在集合中查找元素，如果有 ,返回所查找元素的下标,如果不存在则返回-1
list.indexOf("a");
// 12. 打印集合元素
// 12.1：
Iterator it=list.iterator();
while(it.hasNext()) {
String string=(String) it.next();
System.out.println(string);
}
// 12.2：
for (Object o:list) {
System.out.println(o);
}
// 12.3：
for(int s=0;s<list.size();s++) {
System.out.println(list.get(s));
}
// 13. 将list释放，元素清空，且无返回值
list.clear();
System.out.println(list);
}
}
map常用方法
package test;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapTest {
public static void main(String[] args) {
// 创建一个新 map
Map map = new HashMap<>();
// 1. 添加元素
/*
V put(K key, V value)
向map集合中添加Key为key，Value为value的元素，当集合中没有这个key时返回null，当集合中有这个key时返回前一个value。
就是说Map集合中的Key是不能重复的，这就类似于Set集合中元素不能重复，但是Map集合中的Value是可以重复。
*/
map.put("1" , "demo1");
map.put("2" , "demo1");
map.put("1" , "demo2");
System.out.println(map); // 输出 {1=demo2, 2=demo1}
// 2. 添加集合的所有元素
/*
void putAll(Map<? extends K,? extends V> m)
向map集合中添加指定集合的所有元素
*/
Map map2 = new HashMap<>();
map2.put("71" , "zuan");
map2.putAll(map);
System.out.println(map2); // 输出 {1=demo2, 2=demo1, 71=zuan}
// 3. 把map集合中所有的键值删除void clear()
map2.clear();
System.out.println(map); // 输出 {1=demo2, 2=demo1}
System.out.println(map2); // 输出 {}
// 4. 检出map集合中有没有包含Key为key的元素，
// 如果有则返回true，否则返回false。boolean containsKey(Object key)
boolean b1 = map.containsKey("1"); // true
boolean b2 = map.containsKey("71"); // false
// 5. boolean containsValue(Object value)
// 检出map集合中有没有包含Value为value的元素，如果有则返回true，否则返回false。
boolean b3 = map.containsValue("demo1"); // true
boolean b4 = map.containsValue("zuan"); // false
// 6. Set<Map.Entry<K,V>> entrySet()
// 返回map到一个Set集合中，以map集合中的Key=Value的形式返回到set中。
Set set = map.entrySet();
System.out.println(set); // 输出[1=demo2, 2=demo1]
// 7. boolean equals(Object o)
// 判断两个map集合的元素是否相同
Map map3 = new HashMap<>();
map3.put("1" , "demo1");
map3.put("2" , "demo1");
Map map4 = new HashMap<>();
map4.put("1" , "demo1");
map4.put("2" , "demo1");
boolean equals = map3.equals(map4);
System.out.println(equals); // 输出true
// 8. V get(Object key)
// 根据map集合中元素的Key来获取相应元素的Value
Object o = map.get("1");
System.out.println(o); // 输出demo2
// 9. boolean isEmpty()
// 检出map集合中是否有元素，如果没有则返回true，如果有元素则返回false
boolean mapIsEmpty = map.isEmpty();
System.out.println(mapIsEmpty); // false
Map map5 = new HashMap<>();
boolean map5IsEmpty = map5.isEmpty();
System.out.println(map5IsEmpty); // true
// 10. Set<K> keySet()
// 返回map集合中所有Key
Set keySet = map.keySet();
System.out.println(keySet); // [1, 2]
// 11. V remove(Object key)
// 删除Key为key值的元素
map.remove("1");
System.out.println(map); // {2=demo1}
// 12. int size()
// 返回map集合中元素个数
int size = map.size();
System.out.println(size); // 1
// 13. Collection<V> values()
// 返回map集合中所有的Value到一个Collection集合
map.put("5" , "demo2");
map.put("6" , "demo5");
Collection collection = map.values();
System.out.println(collection); // [demo1, demo2, demo5]
}
}
Set常用方法
package test;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class SetTest {
public static void main(String[] args) {
// 先创建一个set
Set<String> ss = new HashSet<String>();
// 1. 新增：重复新增的值会被覆盖
ss.add("a");
ss.add("a");
ss.add("a");
ss.add("a");
ss.add("b");
ss.add("b");
ss.add("b");
ss.add("b");
ss.add("c");
ss.add("d");
ss.add("");
ss.add("");
ss.add(" ");
ss.add(" ");
for (String s : ss) {
System.out.println("循环值为：" + s);
}
System.out.println("Set长度为：" + ss.size());
/*
打印结果：
循环值为：
循环值为：
循环值为：a
循环值为：b
循环值为：c
循环值为：d
Set长度为：6
*/
// 2. 删除：remove(Object) 和removeAll（Set）
ss.remove("a");
System.out.println(ss); // [, , b, c, d]
// 先创建一个set
Set<String> s2 = new HashSet<String>();
s2.add("b");
s2.add("c");
ss.removeAll(s2);
System.out.println(ss); // [, , d]
// 3. 查询
System.out.print("循环方法1：");
for (String s : ss) {
System.out.print(s + ", ");
}
System.out.println();
System.out.print("循环方法2：");
Iterator<String> iterator = ss.iterator();
while (iterator.hasNext()) {
System.out.print(iterator.next() + ", ");
}
System.out.println();
System.out.print("循环方法3：");
String[] strs = new String[ss.size()];
ss.toArray(strs);
for (String s : strs) {
System.out.print(s + ", ");
}
}
}
浙公网安备 33010602011771号