心得体会
- 有些时候学过的东西，若不反复去记得话，真的会忘的，而且如果时间隔得太远，就像新的一样。今天上课的过程中，发现自己好几个知识点都不记得了，哭唧唧~~
今日所学
集合
-
1.集合基础框架（Collection、Map）
-
2.collection集合方法
-
3.List集合的三种遍历方式以及优缺点
-
4.ArrayList相关方法及操作
-
5.Lambda表达式
-
6.基础练习小demo
-
7.ArrayList自定义排序
具体操作
1.集合基础框架
以下框架只显示我认为常用的^^：
image.png
image.png
>---|Collection: 单列集合
---|List: 有存储顺序, 可重复
---|ArrayList: 数组实现, 查找快, 增删慢
由于是数组实现, 在增和删的时候会牵扯到数组增容, 拷贝元素. 所以慢。数组是可以直接按索引查找, 所以查找时较快
---|LinkedList: 链表实现, 增删快, 查找慢
由于链表实现, 增加时只要让前一个元素记住自 己就可以, 删除时让前一个元素记住后一个元 素, 后一个元素记住前一个元素. 这样的增删效率较高但查询时需要一个一个的遍历, 所以效率较低
---|Vector: 和ArrayList原理相同, 但线程安全, 效率略低
和ArrayList实现方式相同, 但考虑了线程安全问
题, 所以效率略低
---|Set: 无存储顺序, 不可重复
---|HashSet
---|TreeSet
---|LinkedHashSet
---| Map: 键值对
---|HashMap
---|TreeMap
---|HashTable
---|LinkedHashMap
2.collection集合方法
增加：
1：add() 将指定对象存储到容器中, add 方法的参数类型是Object 便于接收任意对象
2：addAll() 将指定集合中的元素添加到调用该方法和集合中
删除：
3：remove() 将指定的对象从集合中删除
4：removeAll() 将指定集合中的元素删除
获取
5: size() 获取元素个数
判断
6：isEmpty() 判断集合是否为空
7：contains() 判断集合何中是否包含指定对象
8：equals() 集合进行比较
9：containsAll() 判断集合中是否包含指定集合
修改
10：clear() 清空集合中的所有元素
转成数组
10： toArray() 集合转换数组
public class Myclass {
public static void main(String[] args){
//定义一个可变数组
Collection t1=new ArrayList();
//向可变数组里面添加元素
t1.add("Jack");
t1.add("Merry");
System.out.println(t1);
System.out.println("---------------");
//删除一个对象
t1.remove("Jack");
System.out.println(t1);
System.out.println("---------------");
//获取元素个数
System.out.println(t1.size());
System.out.println("---------------");
//判断是否包含一个元素
if(t1.contains("Merry")){
System.out.println("有Merry");
}else{
System.out.println("没有Merry");
}
System.out.println("---------------");
//判断是否为空
if(t1.isEmpty()){
System.out.println("是空的");
}
//判断两个集合是否相同
Collection t2=new ArrayList<>();
t2.add("Merry");
t2.add("Jack");
t2.add("1");
t2.add("2");
if(t1.equals(t2)){
System.out.println("两个集合相同");
}else{
System.out.println("两个集合不相同");
}
System.out.println("---------------");
//清空
t1.clear();
System.out.println(t1);
}
}
运行结果：
image.png
用toArray()方法将集合转化为数组：
Collection t1=new ArrayList();
//向可变数组里面添加元素
t1.add("Jack");
t1.add("Merry");
System.out.println(t1);
System.out.println("---------------");
//将集合转化为数组
Object[] objects=new String[t1.size()];
t1.toArray(objects);
System.out.println(objects);
3.List集合的三种遍历方式以及优缺点
-
1.集合遍历常用方法
hasnext():判断是否有元素
next(): 获取下一个对象
remove(): 删除当前遍历过后的对象
-
2.第一种遍历方法---使用迭代器（Iterator）来遍历
优点：迭代器提供了操作元素的方法 可以在遍历中相应地操作元素
缺点：运行复杂，性能稍差，效率相对其他两种遍历方式较低
public class Myclass {
public static void main(String[] args){
Collection t2=new ArrayList<>();
t2.add("Merry");
t2.add("Jack");
t2.add("John");
t2.add("Cindy");
Iterator iterator=t2.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
运行结果：
image.png
-
迭代器错误的遍历方式：!!!!
public class Myclass {
public static void main(String[] args){
Collection t2=new ArrayList<>();
t2.add("Merry");
t2.add("Jack");
t2.add("John");
t2.add("Cindy");
Iterator iterator=t2.iterator();
while(iterator.next()!=null){
System.out.println(iterator.next());
}
System.out.println("-------------------");
image.png
-
3.第二种遍历方法---For
优点：效率最高，遍历快，可以根据自定计数器操作元素
缺点：不适用所有集合，每次都需要在应用程序中手动强转和额外的获得list.size,还有一个缺点就是遍历过程中不允许删除元素
public static void main(String[] args){
Collection t2=new ArrayList<>();
t2.add("Merry");
t2.add("Jack");
t2.add("John");
t2.add("Cindy");
for(int i=0;i) t2).get(i));
}
}
运行结果：
image.png
-
3.第三种遍历方法---For-each
优点：代码简洁，不易出错。
缺点：只能做简单的遍历，不能在遍历过程中操作（删除、替换）数据集合。
public static void main(String[] args){
Collection t2=new ArrayList<>();
t2.add("Merry");
t2.add("Jack");
t2.add("John");
t2.add("Cindy");
//3.for-each 增强for循环 快速循环
for(String obj:t2){
System.out.println(obj);
}
}
运行结果：
image.png
4.ArrayList相关方法及操作
-
温馨小贴士（以下操作原本是连贯的，我把它分割了，但下面代码的结果受上面代码的影响^^）
1
add(e)：将指定的元素添加到此列表的尾部
add(int index,element):将制定的元素插入此列表的指定位置
ArrayList score=new ArrayList<>();
//add(e)
score.add(2);
score.add(3);//在末尾添加
System.out.println(score);
System.out.println("-------------------------");
//add(int index,element),"add(0,1)"表示将整数1添加到列表的第一位
score.add(0,1);
System.out.println(score);
image.png
2
get(int index):访问指定元素
set(int index,element):用指定的元素替代此列表中指定位置上的元素
//访问指定元素
score.get(1);
System.out.println(score.get(1));
System.out.println("-------------------------");
//修改一个元素
score.set(0,0);//改第几个 用什么去替换
System.out.println(score);
System.out.println("-------------------------");
image.png
3
remove(int index):移除此列表中指定位置上的元素
remove(Object o):移除此列表中首次出现的指定元素
clear():删除所有，清空
//移除此列表中指定位置上的元素
score.remove(0);
System.out.println(score);
System.out.println("-------------------------");
//删除指定的对象,下面一段demo表示删除列表中所有的整数3
score.remove((Integer)3);
System.out.println(score);
System.out.println("-------------------------");
score.clear();//删除所有，清空
System.out.println(score);
image.png
4
addAll():从指定的位置开始，将指定Collection中所有的元素插入到此列表中，可以用来将另一个集合里面的内容添加到当前集合里
retainAll(Collection c)： 两个集合求交集，只保留交集数据
ArrayList a2=new ArrayList<>();
a2.add(1);
a2.add(2);
a2.add(3);
//将另一个集合里面的内容添加到当前集合里
score.addAll(a2);
System.out.println(score);
System.out.println("-------------------------");
ArrayList a3=new ArrayList<>();
a3.add(1);
a3.add(2);
score.retainAll(a3);//取两个集合的交集
System.out.println(score);
image.png
5
indexOf(object o):访问此列表中首次出现的指定元素的索引，或如果不包含指定元素，则返回-1
lastIndexOf(object o):访问此列表中最后一次出现的指定元素的索引，或如果此列表不包含改索引，则返回-1
//访问某个对象在集合里面的索引
ArrayList 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));//最后一次出现的位置 //如果没有 返回值是-1
System.out.println("----------------------------------------------------");
image.png
6
toArray():按适当顺序（从第一个到最后一个）返回包含此列表中所有元素的数组
//将ArrayList转化为普通数组
Object[] objects=new Integer[a4.size()];
a4.toArray(objects);
System.out.println(objects);//输出的是地址
System.out.println("----------------------------------------------------");
Object[] objects1=a4.toArray();
for(Object i:objects1){
System.out.println(i);
}
image.png
7
subList():获取某个范围内的子集和
//获取某个范围内的子集和
List integers=a4.subList(1,2);
System.out.println(integers);
image.png
5.Lambda表达式
-
1.removeif()方法
remove():清除满足条件的元素
-
2.Lambda表达式的语法
基本语法:
(parameters) -> expression
或
(parameters) ->{ statements; }
-
3.关于Lambda表达式的一个简单例子
ArrayList nums=new ArrayList<>() ;
nums.add(1);
nums.add(2);
nums.add(3);
nums.add(4);
//Lambda表达式
nums.removeIf(obj ->obj % 2==0);
System.out.println(nums);
image.png
nums.removeIf(obj ->obj % 2==0);
remove()方法里面使用了Lambda表达式,上面句话表示将数组里面能被2整除的数清除
nums里面的数依次被取出，%2判断是否能够整除，如果整除，就移除那个数
由于【2,4】能够整除【2】，所以【2,4】被移除数组，数组里面就只剩下【1,3】
-
4.Lambda表达式的定义
Lambda表达式也可以成为闭包，把函数作为一个方法的参数
-
5.使用Lambda表达式的要求
1.必须是接口， 这个接口里面只能有一个方法
-
6.使用Lambda表达式案例
class ArrayClass{
public void test(int[] target,Show s){
for(int obj:target){
s.customShow(element);
}
}
}
//必须是接口， 这个接口里面只能有一个方法
Interface Show{
void customShow(int element);
}
main函数里
如何使用上诉功能？:
- 1.定义一个类实现接口
//写一个类实现上段代码的接口
class PXDClass implements Show{
@Override
public void customShow(int element) {
System.out.println(element);
}
}
main函数里
//1.使用方式 定义一个类实现接口
ArrayClass ac=new ArrayClass();
int[] num={1,2,3,4,5,6};
PXDClass pc=new PXDClass();
ac.test(num,pc);
- 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);});
//如果只有一个参数 参数类型可以省略
ArrayClass ac=new ArrayClass();
int[] num={1,2,3,4,5,6};
ac.test(num, element ->
{System.out.println(element);});
// 如果代码块里面只有一行语句 大括号可以省略
ArrayClass ac=new ArrayClass();
int[] num={1,2,3,4,5,6};
ac.test(num, element ->System.out.println(element));
上述代码执行的结果是一样的
image.png
6.基础练习小demo
1.创建一个类Person:name age属性
2.创建ArrayList对象保存多个Person对象
3.统计年龄大于30的人数
4..统计姓张的人的人数
public class LittleDemo {
public static void main(String[] args){
ArrayList person=new ArrayList<>();
Person p1=new Person("张三",28);
Person p2=new Person("李四",33);
Person p3=new Person("王二",34);
Person p4=new Person("张四",20);
person.add(p1);
person.add(p2);
person.add(p3);
person.add(p4);
int ageCount=0;
int nameCount=0;
for(Person person1:person){
if(person1.age>30){
ageCount++;
}
if(person1.name.contains("张")){
nameCount++;
}
}
System.out.println(ageCount+" "+nameCount);
}
}
class Person {
String name;
int age;
public Person(String name,int age){
this.name=name;
this.age=age;
}
}
image.png
7.ArrayList自定义排序
1.系统自定义方法排序
ArrayList a1=new ArrayList<>();
a1.add(2);
a1.add(1);
a1.add(4);
a1.add(3);
a1.sort(Comparator.comparingInt(Integer::intValue));
System.out.println(a1);
2.手动创建比较器
1.继承一个类
public class LittleDemo {
public static void main(String[] args){
ArrayList a1=new ArrayList<>();
a1.add(2);
a1.add(1);
a1.add(4);
a1.add(3);
a1.sort(new PXDCompare());
System.out.println(a1);
}
}
class PXDCompare implements Comparator{
//什么时候需要自己手动创建比较器
//如果系统默认提供的方法不能完成我们的比较
@Override
public int compare(Object o, Object t1) {
int mo=(int)o;
int mt1=(int)t1;
return mo-mt1;
}
}
2.使用匿名类
public class LittleDemo {
public static void main(String[] args){
ArrayList a1=new ArrayList<>();
a1.add(2);
a1.add(1);
a1.add(4);
a1.add(3);
a1.sort(new Comparator() {
@Override
public int compare(Integer integer, Integer t1) {
return integer-t1;
}
});
System.out.println(a1);
}
}
public class LittleDemo {
public static void main(String[] args){
ArrayList a1=new ArrayList<>();
a1.add(2);
a1.add(1);
a1.add(4);
a1.add(3);
a1.sort((Integer i1,Integer i2)->{
return i1-i2;
});
System.out.println(a1);