集合
目的
1.清楚java中集合的含义
2.明白集合与数组的区别
3.了解集合中的一些方法
技术
数组：存储多个对象
int[] score = {1,2,3};
int[] score = new int[10];
弊端：数组的长度不可变 内容可变
实际开发中需要一个能够随时改变的数组 -> 集合 Collection
数组：有序 可重复
集合：无序性 互异性
映射：一对一 多对一
Collection 抽象的接口 定义集合的相关操作
1.List(接口) 列表 数组
ArrayList
LinkedArrayList
2.Set(集合）
HashSet
Map接口 映射关系 Key-Value 键值对 键不能相同 值可以相同
集合的元素个数是可变的
添加元素
add
addAll
删除元素
插入元素
访问元素
技术运用
- Collection接口的方法
Collection<String> list = new ArrayList();
list.add("Jack");
list.add("Merry");
System.out.println(list);
删除一个对象
list.remove("Jack");
System.out.println(list);
获取元素个数
System.out.println(list.size());
判断是否包含一个元素
if (list.contains("Merry")){
System.out.println("有Merry");
}else {
System.out.println("没有Merry");
}
判断是否为空
if (list.isEmpty()){
System.out.println("是空的");
}else {
System.out.println("不为空");
}
判断两个集合是否相同
Collection<String> t2 = new ArrayList<>();
t2.add("Merry");
t2.add("Jack");
if (list.equals(t2)){
System.out.println("两个集合相同");
}else{
System.out.println("两个集合不相同");
}
清空
list.clear();
System.out.println(list);
- 集合的遍历
1.使用Iterator来遍历
hasNext 判断是否有元素
next 获取下一个对象
remove 删除当前遍历过后的对象
Iterator iterator = t2.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
- forEach
for (String obj:t2){
System.out.println(obj);
}
- for i
for (int i = 0;i < t2.size(); i++){
System.out.println(((ArrayList<String>) t2).get(i));
}
- List接口 extends Collection
// ArrayList 连续的内存空间
// 优点;访问方便 get(0); 缺点：删除 添加
// LinkedArrayList 内部使用链表实现 不一定连续 （基本不连续）
// 优点：增加 删除 效率高 缺点：访问
// 集合里面只能存放对象 不能存放基本数据类型
// byte char int long float double boolean （八种基本数据类型）
// 包装类
// Byte Char Integer Long Float Double Boolean
// 自动将基本数据类型包装为对应的类
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> a2 = new ArrayList<>();
a2.add(1);
a2.add(2);
a2.add(3);
System.out.println("---------------");
将一个集合里面的内容添加到当前集合中
score.addAll(a2);
System.out.println(score);
取两个集合的交集
ArrayList<Integer> a3 = new ArrayList<>();
a3.add(1);
a3.add(2);
score.retainAll(a3); // 取两个集合的交集
System.out.println(score);
访问某个对象在集合里面的索引
ArrayList<Integer> a4 = new ArrayList<>();
a4.add(1);
a4.add(2);
a4.add(2);
a4.add(1);
System.out.println(a4.indexOf(1)); // 第一次出现
System.out.println(a4.lastIndexOf(1)); // 最后一次出现
System.out.println(a4.indexOf(5)); // 不存在则返回 -1
将ArrayList转化为普通数组
Integer[] objects = new Integer[a4.size()];
a4.toArray(objects);
for (Integer i:objects) {
System.out.println(i);
}
Object[] objects1 = a4.toArray();
for(Object i:objects1){
System.out.println(i);
}
Iterator iterator = a4.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
获取集合某个范围的子集合
List<Integer> integer = a4.subList(1,3);
System.out.println(integer);
- Lambda表达式
ArrayList<Integer> nums = new ArrayList<>();
nums.add(1);
nums.add(2);
nums.add(3);
nums.add(4);
nums.removeIf( ele -> ele % 2 == 0);
System.out.println(nums);
1.使用方式:定义一个类实现接口
ArrayClass ac = new ArrayClass();
int[] num = {1,2,3,4,5,6};
aaClass aa = new aaClass();
ac.test(num,aa);
// 闭包 enclosure 把函数作为一个方法的参数
class ArrayClass{
public void test(int[] target, Show show) {
for (int element:target){
show.customShow(element);
}
}
}
// 必须是接口 这个接口里面只有一个方法
interface Show{
void customShow(int element);
}
class aaClass 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};
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));
- sort方法的使用及自己创建一个比较器
自己创建一个比较器
//什么时候需要自己创建一个比较器
// 如果系统提供的方法不能完成我们的比较
class abCompare implements Comparator{
@Override
public int compare(Object o, Object t1) {
int mo = (int)o;
int mt1 = (int)t1;
return mo - mt1;
}
}
sort方法的使用
ArrayList<Integer> a1 = new ArrayList<>();
a1.add(2);
a1.add(1);
a1.add(4);
a1.add(3);
// a1.sort(Comparator.comparingInt(Integer::intValue));
// a1.sort(new abCompare());
// a1.sort(new Comparator<Integer>() {
// @Override
// public int compare(Integer integer, Integer t1) {
// return integer - t1;
// }
// });
a1.sort((Integer i1, Integer i2) ->{
return i1 - i2;
});
System.out.println(a1);
}
}
// 创建一个类Person: name age 属性
// 创建ArrayList对象保存多个Person对象
// 统计年龄大于30的人数
// 统计名字中有张的人数
import java.util.ArrayList;
public class MyClass {
public static void main(String[] args){
ArrayList<Person> people = new ArrayList<>();
Person xw = new Person("小王",16);
Person xl = new Person("小李",39);
Person zs = new Person("张三",35);
people.add(xw);
people.add(xl);
people.add(zs);
int ageCount = 0;
int nameCount = 0;
for (Person p :
people) {
if (p.age > 30){
ageCount++;
}
if (p.name.contains("张")){
nameCount++;
}
}
System.out.println("姓张的人有"+nameCount+"个"+" 年龄大于30岁的有"+ageCount+"个");
}
}
class Person {
String name;
int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
}
心得
今天学习了集合的使用方法，感觉能灵活使用集合与数组的话，在以后编写程序的过程中，必然能够轻松许多。当然首先应该了解其中常用的方法，这样使用起来才能得心应手，虽然有点乏味，但是也没有办法，这是必须经历的过程，挺过去了自然就好了。
