[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yD9yqQo8-1689126408167)(Snipaste_2023-07-05_09-10-26.png)]
单列集合collection接口
元素孤立存在，一个一个元素存储
共性方法：
Public Boolean add(E e) 把给定的对象添加到当前集合中
Public void clear() 清空集合中所有的元素
Public Boolean remove(E e) 把给定的对象在当前集合中删除
Public Boolean contains(E e) 判断当前集合中是否包含给定的对象
Public Boolean isEmpty() 判断当前集合是否为空
Public int size() 返回集合中元素的个数
Public object[] toArray() 把集合中的元素存储到数组中（也就是集合转为数组）
package collection.list;
import java.util.ArrayList;
import java.util.Collection;
public class Test {
public static void main(String[] args) {
//首先创建集合对象 用arrayList距离，使用多态形式
Collection<String> coll = new ArrayList<String>();
//Public Boolean add(E e) 把给定的对象添加到当前集合中
boolean b1 = coll.add("张三");
System.out.println(b1);
System.out.println(coll);
coll.add("李四");
coll.add("wangwu");
// Public Boolean remove(E e) 把给定的对象在当前集合中删除
/*boolean b2 = coll.remove("张三");
System.out.println(b2);
boolean b3 = coll.remove("李四");
System.out.println(b3);*/
// Public Boolean contains(E e) 判断当前集合中是否包含给定的对象
boolean b4 = coll.contains("张三");
boolean b5 = coll.contains("李四");
System.out.println(b4);
System.out.println(b5);
// Public Boolean isEmpty() 判断当前集合是否为空
//System.out.println(coll.isEmpty());
//coll.clear();
//System.out.println(coll.isEmpty());
// Public int size() 返回集合中元素的个数
System.out.println(coll.size());
//Public void clear() 清空集合中所有的元素
// Public object[] toArray() 把集合中的元素存储到数组中（也就是集合转为数组）
Object[] array = coll.toArray();
for(int i=0;i<array.length;i++){
System.out.println(array[i]);
}
}
}
迭代器
概述
在程序开发中，经常需要便利集合中的所有元素，因为有的集合没有索引，不能使用普通for循环遍历，针对这种需求，jdk专门提供了一个接口java.util.Iterator。Iterator接口也是java集合中的一员，iterator主要是用于迭代访问集合，因此iterator对象也被称为迭代器。
1.1迭代的概念
迭代：即collection集合元素的通用获取方式，在取元素之前要先判断集合中有没有元素，如果有，就把这个元素取出来，继续再判断，如果还有就再取出来，一直把集合中的所有元素全部取出，这种取出方式专业术语叫迭代。
1.2 获取迭代器的方法
Public Iterator iterator() 获取集合对应的迭代器，用来遍历集合中的元素
1.3 iterator接口常用的方法
public E next() 判断集合中还有没有下一个元素，有就返回该元素没有就报异常
public Boolean hasNext() 如果仍有元素可以迭代则返回true
package collection.list;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Test {
public static void main(String[] args) {
//创建集合对象(d)
Collection<String> coll = new ArrayList<>();
//往集合中添加元素
coll.add("科比");
coll.add("麦迪");
coll.add("卡特");
coll.add("艾佛森");
//多态方式创建Iterator对象
Iterator<String> it = coll.iterator();
//取出一个数据
String s = it.next();
//System.out.println(s);
//System.out.println(coll);
//循环取出所有数据
while (it.hasNext()){
String e = it.next();
System.out.println(e);
}
System.out.println("----------------------------------------");
for(Iterator<String> it2 =coll.iterator();it2.hasNext();){
String e = it2.next();
System.out.println(e);
}
}
}
集合工具类collection
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
//原来的写法
//list.add(12);
//list.add(14);
//list.add(15);
//list.add(100);
//采用工具类 完成往集合中添加元素
Collections.addAll(list,5,222,1,2);
System.out.println(list);
//排序
Collections.sort(list);
System.out.println(list);
//打乱
Collections.shuffle(list);
System.out.println(list);
}
List接口
1.1 List接口特点：
① 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
② 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
③ 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。
1.2 List接口中带索引的方法(特有)：
① public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
② public E get(int index):返回集合中指定位置的元素。
③ public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
④ public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值为更新前的元素。
实现类
ArrayList
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jMoi8sc8-1689126408168)(集合方法.png)]
LinkedList
底层双向链表
① `public void addFirst(E e)`:将指定元素插入此列表的开头。
② `public void addLast(E e)`:将指定元素添加到此列表的结尾。
③ `public E getFirst()`:返回此列表的第一个元素。
④ `public E getLast()`:返回此列表的最后一个元素。
⑤ `public E removeFirst()`:移除并返回此列表的第一个元素。
⑥ `public E removeLast()`:移除并返回此列表的最后一个元素。
⑦ `public E pop()`:从此列表所表示的堆栈处弹出一个元素。
⑧ `public void push(E e)`:将元素推入此列表所表示的堆栈。
⑨ `public boolean isEmpty()`：如果列表不包含元素，则返回true。
public static void main(String[] args) {
LinkedList<String> link = new LinkedList<String>();
//添加元素(头插法)
link.addFirst("abc1");
link.addFirst("abc2");
link.addFirst("abc3");
System.out.println(link);
// 获取元素
System.out.println(link.getFirst());
System.out.println(link.getLast());
// 删除元素
System.out.println(link.removeFirst());
System.out.println(link.removeLast());
while (!link.isEmpty()) { //判断集合是否为空
System.out.println(link.pop()); //弹出集合中的栈顶元素
}
System.out.println(link);
}
Set接口
set接口特点
1 不允许存储重复元素
2.没有索引，没有带索引的方法，也不能使用普通for循环遍历，可以采用迭代器，或者增强for循环。
实现类
Hash Set
set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的（即存取顺序不一致）。HashSet底层的实现其实是一个hashMap
public static void main(String[] args) {
//创建一个set接口
Set<Integer> set = new HashSet<>();
//添加
set.add(1);
set.add(3);
set.add(2);
System.out.println(set);
set.add(1); //已经存在的元素，不会被存储
System.out.println(set);
//使用迭代器遍历
Iterator<Integer> it = set.iterator();
while (it.hasNext()){
Integer n = it.next();
System.out.println(n);
}
System.out.println("---------------------------------");
//使用增强for循环遍历
for(Integer i :set){
System.out.println(i);
}
}
LinkedHashSet
底层是一个哈希表（数组+链表/红黑树）+链表，多了一个链表，用来记录元素的存储顺序，保证元素有序。
public static void main(String[] args) {
Set<String> set = new LinkedHashSet<>();
set.add("bbb");
set.add("aaa");
set.add("abc");
set.add("bbc");
System.out.println(set);
Iterator<String> it = set.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}
TreeSet
双列集合Map接口
元素成对出现，键值对形式
常用方法
1. public V put(K key,V value) 把指定的键与指定的值添加到map集合
2. public V remove(Object key) 把指定的键所对应的键值对元素在Map集合中删除，返回的是被删除元素的值。
3. public V get(Object key)根据指定的键，获取对应的值
4. Boolean containsKey(Object key) 判断集合中是否包含指定的键
5. Public Set<K> keySet() 获取map集合中所有的键，存储到set集合中
Public Set<Map.Entry<K,V>> entrySet() 获取
Map集合不能直接使用迭代器或者foreach进行遍历，但是转成Set之后就可以使用了。
常用实现类
HashMap<k,v>
1. public V put(K key,V value) 把指定的键与指定的值添加到map集合
2. public V remove(Object key) 把指定的键所对应的键值对元素在Map集合中删除，返回的是被删除元素的值。
3. public V get(Object key)根据指定的键，获取对应的值
4. Boolean containsKey(Object key) 判断集合中是否包含指定的键
5. Public Set<K> keySet() 获取map集合中所有的键，存储到set集合中
6. Public Set<Map.Entry<K,V>> entrySet() 获取map集合中所有的键值对对象的集合
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
public class Test2 {
public static void main(String[] args) {
//创建map对象
HashMap<String,String> map=new HashMap<>();
//添加元素
map.put("11","1");
map.put("22","2");
map.put("33","3");
map.put("44","4");
System.out.println(map);//{11=1, 22=2, 33=3, 44=4}
//移除元素
map.remove("11");
System.out.println(map);
//修改
map.put("22","99");//若存在则修改
System.out.println(map);
//查看
System.out.println(map.get("33"));
// 1. 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键
// 2. 遍历Set集合，得到每一个键
// 3. 根据键获取键所对应的值
//遍历
//1.获取键来找值
//获取所有的键
Set<String > set=map.keySet();
//遍历键集合，得到每一个键
for(String key:set)
{
//通过键获取对应的值
String value=map.get(key);
System.out.println(key+"对应的是"+value);
}
//2.获取键值对，来找值
//获得键值对对象 集合
Set<Map.Entry<String,String>> entryset=map.entrySet();
//遍历得到每一个键值对对象集合
for(Map.Entry<String,String> k:entryset)
{
String key=k.getKey();
String value=k.getValue();
System.out.println(key+"对应的是"+value);
}
}
}
LinkedHashMap<k,v>
有序
public static void main(String[] args) {
LinkedHashMap<String, String> map = new LinkedHashMap<>();
map.put("邓超","孙俪");
map.put("李晨","范冰冰");
map.put("刘德华","朱丽倩");
//System.out.println(map);
Set<Map.Entry<String, String>> entrySet = map.entrySet();
for(Map.Entry<String,String> entry:entrySet){
System.out.println(entry.getKey()+" "+entry.getValue());
}
}
2997
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
