Collection集合：
集合是一种容器，用来装数据的，类似于数组，但集合的大小可变，开发中也常常用。
| 1 | Collection 接口 Collection 是最基本的集合接口，【单列集合，每个元素（数据）只包含一个值】一个 Collection 代表一组 Object，即 Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)。 Collection 接口存储一组不唯一，无序的对象。 |
| 2 | List 接口 List接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。 List 接口存储一组不唯一，有序（插入顺序）的对象。 |
| 3 | Set Set 具有与 Collection 完全一样的接口，只是行为上不同，Set 不保存重复的元素。 Set 接口存储一组唯一，无序的对象。 |
| 4 | SortedSet 继承于Set保存有序的集合。 |
| 5 | Map 双列集合，每个元素包含两个值（键值对） Map 接口存储一组键值对象，提供key（键）到value（值）的映射。 |
| 6 | Map.Entry 描述在一个Map中的一个元素（键/值对）。是一个 Map 的内部接口。 |
| 7 | SortedMap 继承于 Map，使 Key 保持在升序排列。 |
| 8 | Enumeration 这是一个传统的接口和定义的方法，通过它可以枚举（一次获得一个）对象集合中的元素。这个传统接口已被迭代器取代。 |
ArrayList<String> list = new ArrayList<>();//有序 可重复，有索引
list.add("java1");
list.add("java2");
list.add("java1");
list.add("java2");
System.out.println(list);
System.out.println(list.get(0));
//输出
// [java1, java2, java1, java2]
//java1
HashSet<String> set = new HashSet<>();//无序 不可重复 不支持索引
set.add("java1");
set.add("java2");
set.add("java1");
set.add("java2");
set.add("java3");
System.out.println(set);
//输出
// [java3, java2, java1]方法：
https://doc.qzxdp.cn/jdk/17/zh/api/java.base/java/util/Collection.html遍历集合：
迭代器
迭代器是用来遍历集合的专用方式（数组没有迭代器），在java中迭代器的代表为Iterator
Collection集合获取迭代器的方法：
Iterator<E> iterator() 返回集合中的迭代器对象，该迭代器对象默认指向当前集合的第一个元素。
Iterator迭代器中的常用方法：
增强for循环
Lambda表达式
package CollectionTest;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo01 {
public static void main(String[] args) {
Collection<String> c = new ArrayList<>();
c.add("hello");
c.add("hello1");
c.add("hello2");
c.add("hello3");
System.out.println(c);
//输出 [hello, hello1, hello2, hello3]
//使用迭代器遍历集合
//1.从集合对象中获取迭代器对象
Iterator<String> it =c.iterator();
System.out.println(it.next());
System.out.println(it.next());
System.out.println(it.next());
System.out.println(it.next());
// System.out.println(it.next());//异常
//hello
//hello1
//hello2
//hello3
//2.使用循环结合迭代器遍历集合
while (it.hasNext()){
String s = it.next();
System.out.println(s);
}
//3.lambda表达式
c.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
//相当于
c.forEach(s -> System.out.println(s));
//相当于（方法引用）
c.forEach(System.out::println);
}
}List类集合
1.ArrayList
遍历：
- for循环（fori+tab快速生成一个for循环）
- 迭代器
- 增强for循环
- Lambda表达式
//for循环
for (int i = 0; i < list.size(); i++) {
String s1 = list.get(i);
System.out.println(s1);
}
//迭代器
Iterator<String> ii = list.iterator();
while (ii.hasNext()){
String s2 = ii.next();
System.out.println(s2);
}
//增强for循环
for (String si : list) {
System.out.println(si);
}
//Lambda表达式
list.forEach(s3 -> System.out.println(s3));2.LinkedList
应用场景：
- 设计队列（先进先出，后进后出）
- 设计栈（后进先出，先进后出）
//创建一个队列
LinkedList<String> queque = new LinkedList<>();
queque.addLast("张三");
queque.addLast("李四");
queque.addLast("王五");
queque.addLast("赵六");
queque.addLast("田七");
System.out.println(queque);
//出队
System.out.println(queque.removeFirst());
System.out.println(queque.removeFirst());
System.out.println(queque);
//2.创建一个栈对象
LinkedList<String> stack = new LinkedList<>();
//入栈(push)
stack.addLast("张三");
stack.push("张三1");
stack.addLast("李四");
stack.addLast("王五");
System.out.println(stack);
//出栈(pop)
System.out.println(stack.removeFirst());
System.out.println(stack.pop());
System.out.println(stack.removeFirst());
System.out.println(stack.removeFirst());
System.out.println(stack);push = addLast pop = removeFirst
Set类集合
//创建一个set集合对象
// Set<Integer> set =new HashSet<>();
// Set<Integer> set = new LinkedHashSet<>();
Set<Integer> set = new TreeSet<>();
set.add(111);
set.add(222);
set.add(363);
set.add(333);
set.add(455);
set.add(455);
set.add(455);
System.out.println(set);
//HashSet 输出[455, 363, 333, 222, 111]--无序 不重复 无索引
//LinkedHashSet 输出[111, 222, 363, 333, 455]--有序 不重复 无索引
//TreeSet 输出[111, 222, 333, 363, 455]]--可排序(升序) 不重复 无索引1.HashSet
2.LinkedHashSet
3.TreeSet
方法一：
Test.java:
Set<Student> students = new TreeSet<>();
students.add(new Student("张三",100,20));
students.add(new Student("李四",90,30));
students.add(new Student("王五",80,40));
students.add(new Student("王五5",80,40));
students.add(new Student("赵六",70,50));
System.out.println(students);
//输出[Student{name='赵六, age=70, height=50.0}, Student{name='王五, age=80, height=40.0}, Student{name='张三, age=100, height=20.0}, Student{name='李四, age=750, height=30.0}]
//王五5没存进去，因为比较年龄相等则不存Student.java:
package set;
public class Student implements Comparable<Student>{
private String name;
private int age;
private double height;
public Student(String name,int age,double height)
{
this.name=name;
this.age=age;
this.height=height;
}
public void setName(String name) {
this.name = name;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//this o
//this.age：表示当前对象（调用compareTo方法的对象）的年龄。
//o.age：表示传入参数对象o的年龄。
//this.age - o.age：计算当前对象的年龄与参数对象的年龄之差
@Override
public int compareTo(Student o) {
//如果认为左边对象大于右边对象，返回正整数
//如果认为左边对象小于右边对象，返回负整数
//如果认为左边对象等于右边对象，返回0，此时TreeSet集合指挥保留一个元素，认为两者重复
//需求：按照年龄升序排列
return this.age - o.age;
}
@Override
public String toString() {
return "Student{" +
"name='" + this.name +
", age=" + this.age +
", height=" + this.height +
'}';
}
}
方法二：
//设置comparator对象
//两个比较方法都存在会就近选择自己自带的比较器对象进行排序
Set<Student> students = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
//按照身高升序排序
return Double.compare(o1.getHeight(),o2.getHeight());
}
});
students.add(new Student("张三",100,55.5));
students.add(new Student("李四",750,53.3));
students.add(new Student("王五",80,40.5));
students.add(new Student("王五5",80,40.5));
students.add(new Student("赵六",70,50.7));
System.out.println(students);
//输出[Student{name='王五, age=80, height=40.5}, Student{name='赵六, age=70, height=50.7}, Student{name='李四, age=750, height=53.3}, Student{name='张三, age=100, height=55.5}]集合的并发修改异常问题
package collection_exception;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class CollectionTest {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("王麻子");
list.add("李小龙");
list.add("小李子");
list.add("张三");
list.add("李爱华");
list.add("王李虎");
list.add("李于呷");
System.out.println(list);
//[王麻子, 李小龙, 小李子, 张三, 李爱华, 王李虎, 李于呷]
//需求：找出集合中全部含“李”的名字，并从集合中删除
// Iterator<String> it = list.iterator();
// while (it.hasNext()){
// String name = it.next();
// if(name.contains("李")){
// list.remove(name);
// }
// }
// System.out.println(list);
//会报错
//使用for循环删除“李”的名字
// list.fori+enter快速生成
// for (int i = 0; i < list.size(); i++) {
// String name = list.get(i);
// if (name.contains("李")){
// list.remove(name);
// }
// }
// System.out.println(list);
//输出[王麻子, 小李子, 张三, 王李虎]
//因为当i走到第二个"李小龙"时，第二个删除，i继续走到第三个，已经到”张三“并验证张三是否含李，所以漏筛选
//Iterator会报错原因一样
System.out.println("出现并发修改错误，如何解决？？？？？");
//for循环
// for (int i = 0; i < list.size(); i++) {
// String name = list.get(i);
// if (name.contains("李")){
// list.remove(name);
// i--; //解决并发修改错误
// }
// }
// System.out.println(list);
//[王麻子, 张三]
//迭代器
// Iterator<String> it = list.iterator();
// while (it.hasNext()){
// String name = it.next();
// if(name.contains("李")){
list.remove(name);//会发生并发修改错误
// it.remove();//删除迭代器当前遍历到的数据，每删除一个数据后，相当于也在底层做了i--
// }
// }
// System.out.println(list);
//[王麻子, 张三]
//增强for循环
//list.for+enter快速生成
// for (String name : list) {
// if(name.contains("李")){
// list.remove(name);
// }
// }
// System.out.println(list);
//并发修改报错，且无法解决
//lambda表达式
list.forEach(name -> {
if (name.contains("李")){
list.remove(name);
}
});
System.out.println(list);
//同增强for循环，报错且无法解决并发修改错误
}
}
扫一扫
201
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
