本人第一次写知识总结 ， 仅看看就好 ，还不能作为参考!!!
一： List 家族 ArrayList LinkedList
二 ： Set 家族 HashSet TreeSet
三 ： Map 家族 HashMap TreeMap
四 ： 关于集合嵌套的理解
List 集合 ：有序 可重复 有索引 有索引可以用for循环遍历
Set 集合 : 无序 不可重复 无索引 无索引不可用for循环遍历 可以用迭代器遍历
Key==>value
集合也可以称之为容器，做增删比较方便
ArrayList 集合常用api
List lists = new ArrayList();
做一些添加元素 lists.add("你好");
插入元素 lists.add(1,"hello world"); 1=index(要插入的索引位置,插入默认是在该元素前一个位置) hello world=内容
删除元素 lists.remove(1); 1=index
取元素 lists.get(1); 1=index
修改元素 lists.set(1,"加油!'); 1=index 把索引是1的元素内容修改为加油
for循环删除集合中的某一元素
List<String> list = new ArrayList<>();
list.add("java");
list.add("html");
list.add("mysql");
list.add("java");
list.add("html");
list.add("html");
//如果遍历到相同的内容会删除相同内容，被删除位置就会空出来,导致后面内容就会补上去，但是索引会一直向前走，最终可能导致漏删。
//所以我们可以倒这遍历删除，就不会出现这种BUG
//list.size()-1 是因为长度等于元素个数 而遍历索引是从0开始
for (int i = list.size()-1; i >= 0; i--) {
//先遍历集合
String ele = list.get(i);
if (ele.equals("html")){
list.remove(ele);
}
}
System.out.println(list);迭代器遍历集合
迭代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。
List<String> list = new ArrayList<>();
list.add("java");
list.add("mysql");
list.add("html");
// 迭代器遍历集合
// 不支持索引,只可以把集合全部内容遍历出,不可以就遍历一个元素出来
// hasNext 判断是不是还有下一个元素
Iterator<String> it = list.iterator();
while (it.hasNext()){
String ele = it.next();
System.out.println(ele);
}LinkedList 是一个双向链表 集合常用api
LinkedListlink = new LinkedList();
添加元素也成为压栈、入栈 先进后出原则
link.push(1)
link.push(2) 控制台显示为 [2,1]
出栈
link.pop() link.removeFirst() 让集合中第一个元素独立出去 2 [1]
队列形式 先进先出
//队列
System.out.println("========================");
LinkedList<String> linked = new LinkedList<>();
//offerLast 添加第一个元素
linked.offerLast("1");
//addLast 在最后添加元素
linked.addLast("2");
linked.addLast("3");
System.out.println(linked);LinkedList 集合案例
public static void main(String[] args) {
final int[] i = {1};
LinkedList<String> a = new LinkedList<>();
a.add("顾客A");
a.add("顾客B");
a.add("顾客C");
a.add("顾客D");
System.out.println(Arrays.toString(a.toArray()));
System.out.println("请按下按钮");
Scanner sc = new Scanner(System.in);
int sum = sc.nextInt();
if (sum==0){
System.out.println(Arrays.toString(a.toArray()));
Runnable runnable1 = new Runnable() {
@Override
public void run() {
System.out.println(a.pop());
a.addLast("顾客"+(i[0]++));
System.out.println(Arrays.toString(a.toArray()));
}
};
ScheduledExecutorService service = Executors
.newSingleThreadScheduledExecutor();
service.scheduleAtFixedRate(runnable1, 10, 1, TimeUnit.SECONDS);
System.out.println(runnable1);
}else {
System.out.println("稍等一会~~~");
}
}
}Set 家族 HashSet
Set stes = new HashSet<>(); 无序 无索引 不重复
（自定义排序记得一定要写hashCode()和equals()方法😖）
只可以存放不重复的数据 只可以存放单个值的数据
案例代码
public class Student {
private String name;
private int age;
private char sex;
public Student() {
}
public Student(String name, int age, char sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
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 char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && sex == student.sex && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age, sex);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", sex=" + sex +
'}';
}
}
public static void main(String[] args) {
// Set<Apple> sets = new TreeSet<>();
//集合自带的比较器对象进行规则定制
// Set<Apple> set = new TreeSet<>(new Comparator<Apple>() {
// @Override
// public int compare(Apple o1, Apple o2) {
// return o2.getWeight()-o1.getWeight()>=0?1:-1;
// // return Double.compare(o1.getWeight(),o2.getWeight()); 根据小数排序调用double API
// }
// });
Set<Apple> set = new TreeSet<>((Comparator<Apple>) (o1, o2) -> {return o2.getWeight()-o1.getWeight()>=0?1:-1;});
set.add(new Apple("香蕉",300,"绿色"));
set.add(new Apple("橘子",500,"蓝色"));
set.add(new Apple("苹果",400,"红色"));
set.add(new Apple("橙子",300,"绿色"));
System.out.println(set);
}- Map集合体系特点
无序 不重复 无索引 值不做要求的键值对集合
Map<E V>maps = new HashMap();
maps.put(key , value);
案例
Map<String,Integer> mapx = new HashMap<>();
mapx.put("ztz",22);
mapx.put("zt",4);
mapx.put("zz",24);
System.out.println(mapx.values());
//根据值取建
System.out.println(getkey(mapx,4));
System.out.println("--------mapx.values获取值-------");
Collection<Integer> values = mapx.values();
System.out.println(values);
System.out.println("-------mapx.keyset获取建--------");
//获取集合的全部见
Set<String> sets = mapx.keySet();
//遍历每个key按key取值 按建取值
for(String ele:sets){
int value = mapx.get(ele);
System.out.println(ele+"===>"+value);
}
}
public static Object getkey(Map maps,Object value) {
List<Object> kk = new ArrayList<>();
for (Object key : maps.keySet()){
if (maps.get(key).equals(value)){
kk.add(key);
}
}
return kk;
}如果要取值map集合必须先把键或者值取出来放到一个集合中去
再通过增强for遍历所需要的值
取值方法 map.values();
Collection<Integer> values = mapx.values();
取键方法 map.keySet();
Set<String> sets = mapx.keySet();
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
