一、Collection接口的方法
是抽象接口， 定义集合的相关操作，存储元素集合
-
添加一个元素
Collection<String> list = new ArrayList();
list.add("Merry");
list.add("Jack");
System.out.println(list); //重写了toString方法
-
删除一个元素
list.remove("Jack");
-
获取元素的个数
System.out.println(list.size());
-
判断是否包含一个元素
if (list.contains("Jack")){
System.out.println("有这个元素");
}else{
System.out.println("没有这个元素");
}
-
判断是否为空
if (list.isEmpty()){
System.out.println("是空的");
}
-
判断是否包含一个元素
if (list.contains("Jack")){
System.out.println("有这个元素");
}else{
System.out.println("没有这个元素");
}
-
判断两个集合是否相同
Collection<String > list2 = new ArrayList<>();
list2.add("Android");
list2.add("Jack");
list2.add("Tom");
list2.add("Merry");
if (list.equals(list2)){
System.out.println("两个集合相同");
}else{
System.out.println("两个集合不相同");
}
-
清空
list.clear();
System.out.println(list);
image.png
二、集合的遍历
集合框架：Iterator
- Iterator（迭代器）用于遍历集合元素，获取迭代器可以使用Collection定义的方法：-Iterator iterator()
- 迭代器Iterator是一个接口，集合在重写Collection的iterator()方法时利用内部类提供了迭代器的实现
- Iterator提供了统一的遍历集合元素的方式，其提供了用于遍历集合的方法（一般结合while()使用）：
boolean hasNext():判断集合是否还有元素可以遍历
E next():返回迭代的下一个元素
Object next()：返回迭代器刚越过的元素的引用，返回值是Object，需要强制转换成自己需要的类型
void remove()：删除迭代器刚越过的元素- Iterator有一个很大的优点,就是我们不必知道集合的内部结果,集合的内部结构、状态由Iterator来维持，
- 通过统一的方法hasNext()、next()来判断、获取下一个元素，
1. 使用Iterator来遍历
//hasNext 判断是否有元素
//next 获取下一个对象
//remove 删除当前遍历后的对象
Iterator iterator = list2.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
2. for-each 增强for循环 快速循环
for (String string:list2){
System.out.println(string+" ");
}
3. for 循环
for (int i = 0;i < list2.size();i++){
System.out.println(((ArrayList<String>) list2).get(i));
}
三、List接口 （extends Collection）
| ArrayList | LinkedArrayList |
|---|---|
| 连续的内存空间 | 内部使用链表实现 ,基本不连续 |
| 优点：访问方便 get() 缺点：删除 添加 不高效 | 优点：增加 删除效率高 |
集合里面只能放对象,自动的将基本数据类型包装为对应的类
基本数据类型: byte short int long float double char boolean
包装类: Byte Short Integer Long Float Double Char Boolean
常见方法：
- add(element)在末尾添加；
- add(i,element)在指定位置插入
- 访问指定元素
- 修改一个元素
- 删除指定位置的元素
- 删除指定的对象
- 删除所有 清空
- 将一个集合的内容添加到当前集合中
- 取两个集合的交集
- 访问某个对象在集合里面的索引 第一次 / 最后一次 出现的位置
- 将ArrayList 转化为普通数组
- 获取某个范围的子集合
代码示例：
ArrayList<Integer> score = new ArrayList<>();
score.add(2);
score.add(3); //在末尾添加
score.add(0,1);//在指定位置插入
System.out.println(score);
//访问指定元素
score.get(1);
//修改一个元素
score.set(0,0);
System.out.println(score);
//删除
score.remove(0); //删除指定位置的元素
System.out.println(score);
score.remove((Integer)2); //删除指定的对象
System.out.println(score);
score.clear(); //删除所有 清空
System.out.println(score);
ArrayList<Integer> a1 = new ArrayList<>();
a1.add(1);
a1.add(2);
a1.add(3);
//将一个集合的内容添加到当前集合中
score.addAll(a1);
System.out.println(score);
ArrayList<Integer> a2 = new ArrayList<>();
a2.add(2);
a2.add(3);
score.retainAll(a2); //取两个集合的交集
System.out.println(score);
//indexOf 访问某个对象在集合里面的索引
ArrayList<Integer> a3 = new ArrayList<>();
a3.add(1);
a3.add(2);
a3.add(2);
a3.add(1);
System.out.println(a3.indexOf(2)); //第一次出现的位置
System.out.println(a3.lastIndexOf(2)); //最后一次出现的位置
//将ArrayList 转化为普通数组
Integer[] objects = new Integer[a3.size()];
a3.toArray(objects);
for (Integer integer:objects){
System.out.print(integer);
}
System.out.println("\n----------------------------");
Object[] objects1 = a3.toArray();
for (Object ob:objects1){
System.out.print(ob);
}
System.out.println(" \n----------------------------");
Iterator iterator = a3.iterator();
while (iterator.hasNext()){
System.out.print(iterator.next());
}
// 获取某个范围的子集合
List<Integer> integers = a3.subList(1,3);
System.out.println("\n"+integers);
四、Lambda表达式
ArrayList<Integer> nums = new ArrayList<>();
nums.add(1);
nums.add(2);
nums.add(3);
nums.add(4);
//Lambda表达式
nums.removeIf(element -> element % 2 == 0);
for (int i = 0;i < nums.size();i++){
Integer obj = nums.get(i);
if (obj % 2 == 0){
nums.remove(i);
i--; //管理好i的指向 防止跳过某个元素
}
}
System.out.println(nums);
使用方式：
1. 使用方式 定义一个类实现接口
ArrayClass ac = new ArrayClass();
int[] num = {1,2,3,4,5,6};
GYLClass gc = new GYLClass();
ac.test(num,gc);
//闭包 closure 把函数作为一个方法的参数
class ArrayClass{
public void test(int[] target,Show show){
for (int element:target){
show.customShow(element);
}
}
}
//必须是接口 这个接口里面只有一个方法
interface Show{
void customShow(int element);
}
class GYLClass implements Show{
@Override
public void customShow(int element) {
System.out.println(element);
}
}
2. 使用匿名类
ArrayClass ac = new ArrayClass();
int[] num = {1,2,3,4,5,6};
GYLClass gc = new GYLClass();
ac.test(num, new Show() {
@Override
public void customShow(int element) {
System.out.println(element);
}
});
3. 使用Lambda表达式
// 如果参数是一个接口对象 且接口里面只有一个方法
// 把这个方法作为参数传递 可以省略方法名
ArrayClass ac = new ArrayClass();
int[] num = {1,2,3,4,5,6};
ac.test(num,(int element) -> {System.out.println(element); } );
4. 如果只有一个参数 参数类型可以省略
ArrayClass ac = new ArrayClass();
int[] num = {1,2,3,4,5,6};
ac.test(num,element -> {System.out.println(element);});
5. 如果代码块里只有一行语句 大括号可以省略
ArrayClass ac = new ArrayClass();
int[] num = {1,2,3,4,5,6};
ac.test(num,element -> System.out.println(element));
Java集合框架：
Java集合框架
