1.收获
今天讲完课后，自己不知道这些知识点是属于哪一部分，就是感觉很杂乱，虽然这些知识是比较好理解的，但是就是乱的，但是自己后来慢慢把它理清楚，才明白这些知识点是属于ArrayList里面的，于是自己慢慢把这些一个个地分清楚，哪部分是哪部分的。这是自己的脑袋里面才有了清晰地逻辑。今天还做了一个以前的demo,因为那个demo有点小bug，但是今天花了一个多小时把他给解决了，利用了今天所学地一点知识，还是蛮高兴的。时间慢慢地流逝，迈着艰难的步子向前走去，那是对未来的期待。加油！！
2.技术
（1）数组与集合地的对比
（2）ArrayList的应用
（3）Lambda表达式的应用
3.技术的实际应用和实践
（1）数组与集合的对比
数组：存储多个对象
int[] score={1,2,3};
int[] score=new int[10];
弊端：数组的长度是不可变的 ，内容可变
但是在实际的应用过程中我们还是需要数组长度是可以改变的
于是就有了可变数组--->实际开发中需要以随时改变的数组 -> 集合（Collection）
ollection抽象的接口 定义了集合相关操作
Colection-> 1.---List 列表 特点：有序 可以重复
----------------------ArrayList
----------------------LinkedArrayList
---------------2.---Set集合 特点：无序 不能重复
-----------------------HashSet
Map接口 映射关系 Key-Vable -键值对 -键不能相同- 值可以相同
---------------------- ---HashMap
语文：98
英语：98
而数组和集合各有优缺点
在用数组时，可以很好地访问元素，因为它在内存上是连续地，但是就是数组的长度是不能改变的
而在用集合时，恰好与数组相反，不能很好地访问元素，因为元素是不连续的，但是集合的长度是可以改变的，所以在使用时要想好自己在使用的过程中是访问元素还是改变长度。
（2）ArrayList的应用
Collections： 集合的元素个数是可变的
Collection是一个接口
集合的定义：
Collection<String> test= new ArrayList();
因为这里的ArrayList实现了接口Collection，所以可以用多态来表示。
在ArrayList有很多的方法
a.添加元素
add * addAll
add是在后面追加
addAll是把一个集合全部内容放在另一个集合里面原来的内容就会被覆盖
test.add("jack");
test.add("merry");
((ArrayList<String>) test).add(1,"hh");
System.out.println(test);
效果：
Collection<String> test1= new ArrayList();
test1.add("ja");
test1.add("m");
((ArrayList<String>) test).add(1,"h");
test.addAll(test1);
System.out.println(test);
效果：
在其中有一个((ArrayList<String>) test).add(1,"h");这是表示在第一个位置插入“h”
效果：
b.删除--remove
//删除一个对象
test.remove("jack");
System.out.println(test);
效果：
c.获取元素个数
.//获取元素个数
System.out.println(test.size());
效果：
d.判断是否包含另一个元素
//判断是否包含另一个元素
if(test.contains("merry")){
System.out.println("有merry");
}else{
System.out.println("没有merry");
}
效果：
e. 判断是否为空
//判断是否为空
if(test.isEmpty()){
System.out.println("是空的");
}else{
System.out.println("不是空的");
}
效果：
f.判断是否相同
//判断是否相同
Collection<String> test1=new ArrayList<>();
test1.add("merry");
test1.add("jack");
if(test1.equals(test)){
System.out.println("两个集合是相同的");
}else{
System.out.println("两个集合不是相同的");
}
效果：
g.清空
//清空
test.clear();
System.out.println(test);
效果：
h. 访问指定的元素
//访问指定的元素
System.out.println(score.get(1));
效果：
i. 修改一个元素
score.set(0,0);
System.out.println(score);
效果：
List 接口 extends Collection
---- ArrayList
---- LinkedArrayList
----集合里面自能存放对象
---- byte char int long float double boolean
----包装类：Byte Integer Long Char Float Double Boolean
----自动将基本的数据类型转化为对应的类
ArrayList<Integer> score=new ArrayList<>();
score.add(2);
score.add(3);//在末尾添加
score.add(0,1);//在指定位置插入
System.out.println(score);
//访问指定的元素
System.out.println(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);
//addAll
ArrayList<Integer> test2=new ArrayList<>();
test2.add(1);
test2.add(2);
test2.add(3);
score.addAll(test2);
System.out.println(score);
//取两个集合交集
ArrayList<Integer> test3=new ArrayList<>();
test3.add(1);
test3.add(2);
score.retainAll(test3);//取两个集合交集
System.out.println(score);
score.add(2);
//访问某个对象在集合里面的索引位置
System.out.println(score.indexOf(2));
System.out.println(score.indexOf(3));//第一次出现的 没有就返回-1
System.out.println(score.lastIndexOf(0));//最后一次出现的 没有就返回-1
//将ArrayList转化为普通数组
Integer[] integers=new Integer[score.size()];
score.toArray(integers);
for(int i=0;i<integers.length;i++){
System.out.println(integers[i]);
}
//获取某个范围类的子集合
List<Integer> it=score.subList(0,3);
System.out.println(it);
最后效果：
对集合进行排序：
首先要有一个集合
ArrayList<Integer> a1=new ArrayList<>();
a1.add(2);
a1.add(1);
a1.add(4);
a1.add(3);
System.out.println(a1);
然后来对年龄进行排序
一共有4种方式
a1.sort(Comparator.comparingInt(Integer::valueOf));
a1.sort(new pxdCompare());
匿名类
a1.sort(new Comparator<Integer>() {
@Override
public int compare(Integer integer, Integer t1) {
return integer-t1;
}
});
1.sort((Integer i1,Integer i2)->{
return i1-i2;});
System.out.println(a1);
这4种方式的效果是一样的
（3）Lambda表达式的应用
遍历数组的两种方式
错误方式：
for(Integer obj:nums){
if(obj%2==0){
nums.remove(obj);
}
}
这种方式之所以错是因为，在遍历过程中是不能够执行增加或修改，删除，这样会出错的
正确的方式：
ArrayList<Integer> nums=new ArrayList<>();
nums.add(10);
nums.add(3);
nums.add(6);
nums.add(1);
for(int i=0;i<nums.size();i++){
Integer obj=nums.get(i);
if(obj%2==0){
nums.remove(i);
i--;
}
}
System.out.println(nums);
Lambda表达式的应用
nums.removeIf( ele -> ele%2==0 );
效果：
Lambda表达式的应用
//闭包 enclusure 把函数作为一个方法的参数
class ArrayClass{
public void test(int[] targer,Show s){
for(int element:targer){
s.customShow(element);
}
}
}
//必须是接口 这个接口里面只有一个方法
interface Show{
void customShow(int element);
}
class pxd implements Show{
@Override
public void customShow(int element) {
System.out.println(element);
}
}
使用方式：
//1.使用方式：定义一个实现接口
ArrayClass ac=new ArrayClass();
int[] num={1,2,3,4,5,6};
pxd pc=new pxd();
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);
});
//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));
这5种方式的效果是一样的
4.小demo
在这小demo 中用了一点今天所学知识
要实现的功能
创建一个类Person:name age属性
创建ArrayList对象保存多个Person类
1.统计年龄大于30的人数
2.统计名字中有张的人数
首先创建一个类Person
public class Person {
int age;
String name;
public Person(String name,int age){
this.age=age;
this.name=name;
}
}
然后创建ArrayList对象保存多个Person类
Person p1=new Person("小张",20);
Person p2=new Person("小李",40);
Person p3=new Person("张三",38);
Person p4=new Person("李四",36);
Person p5=new Person("张思",35);
ArrayList<Person> peoples=new ArrayList<>();
peoples.add(p1);
peoples.add(p2);
peoples.add(p3);
peoples.add(p4);
peoples.add(p5);
统计年龄大于30的人数，统计名字中有张的人数
int agecount=0;
int count=0;
for(int i=0;i<peoples.size();i++){
Person person=peoples.get(i);
if(person.age>30){
agecount++;
}
if(person.name.contains("张")){
count++;
}
}
System.out.println("年龄大于30的人数有："+agecount+"人\n"+"姓名中有'张'的人数为："+count+"人");
组后效果：
