- 数组：存储多个对象
- 弊端：数组长度不可变 内容可变
- 实际开发中需要一个能够随时改变的数组
- ->集合Collection
- Collection 抽象接口 定义集合相关操作
- --->List接口 列表 数组 特点：有序 可重复
- ------->ArrayList
- ------->LinkedArrayList
- --> Set “集合” 特点：无序 不重复
- ------->HashSet
- Map接口 映射关系 Key-Value 键值对 键不能相同 值可以相同
- HashMap
- 集合的元素个数是可变的
- 操作：添加元素 add addAll
- 删除元素
- 插入元素
- 访问元素
Collection接口的方法
Collection<String> list=new ArrayList();
添加一个对象
list.add("java");
list.add("android");
System.out.println(list);
删除一个对象
list.remove("java");
System.out.println(list);
获取元素个数
int a=list.size(）
System.out.println(a);
判断是否包含一个元素
if (list.contains("ja"))
{
System.out.println("包含");
}else{
System.out.println("不包含");
}
判断是否为空
if (list.isEmpty())
{
System.out.println("为空");
}
判断两个集合是否相同 （比较集合的内容）
添加一个对象
Collection<String> list1=new ArrayList();
list1.add("java");
list1.add("android");
if(list.equals(list1))
{
System.out.println("相同");
}
else{ System.out.println("不相同")；
}
清空
list.clear();
集合的遍历
- hasnext 判断是否有元素
- next 获取下一个对象
- remove 删除当前遍历后的对象
- 定义遍历器 Iterator
- Iterator iterator =list1.iterator();
第一种遍历方式 使用Iterator
while (iterator.hasNext())
{
System.out.println(iterator.next());
}
第二种 for-each 增强for循环 快速循环
for (String obj:list1)
{
System.out.println(obj);
}
第三种
for (int i=0;i<list1.size();i++)
{
System.out.println();
}
- List接口 extends Collection
- ArrayList 优点:访问方便 缺点:插入 删除 不方便
- LinkedArrayList 优点: 插入 删除 方便
- 集合里面只能存放对象
- byte char int long float double boolean
- 包装类
- Byte Char Integer Long Float Double Boolean
- 自动的将基本数据类型包装为对应的类
使用ArrayList 创建数组
ArrayList<Integer>score =new ArrayList<>();
添加数据
score.add(2);
score.add(3);
score.add(1,5);
System.out.println(score);
访问指定元素
score.get(2);
修改一个元素
score.set(0,0);
System.out.println(score);
删除指定位置的数据
score.remove(0);
System.out.println(score);
删除具体的数据
score.remove((Integer) 5);
System.out.println(score);
score.clear();
System.out.println(score);
添加一个集合
ArrayList<Integer> a2=new ArrayList<>();
a2.add(1);
a2.add(2);
a2.add(3);
a2.add(4);
score.addAll(a2);
System.out.println(score);
取交集retainAll
删除交集 removeAll
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(3);
a4.add(1);
System.out.println(a4.indexOf(1));//第一次出现的位置
System.out.println(a4.lastIndexOf(1));//最后一次出现的位置
将ArrayList 转化为普通数组
Integer[] objects=new Integer[a4.size()];
a4.toArray(objects);
for (Integer i:objects)
{
System.out.println(i);
}
获取集合某个范围的子集合
List<Integer> integers=a4.subList(1,3);
System.out.println(integers);
删除某个范围的对象
ArrayList<Integer>nums=new ArrayList<>();
nums.add(2);
nums.add(2);
nums.add(3);
nums.add(4);
for (int i=0;i<nums.size();i++)
{
int ab=nums.get(i);
if (ab%2==0)
{
nums.remove(nums.get(i));
i--;
}
}
System.out.println(nums);
1.定义一个类实现接口
ArrayClass ac=new ArrayClass();
int[] num={1,2,3,4,5,6,7};
absClass bc=new absClass();
ac.test(num,bc);
使用匿名类
ArrayClass ac=new ArrayClass();
int[] num={1,2,3,4,5,6,7};
ac.test(num, new Show() {
@Override
public void customShow(int element) {
System.out.println(element);
}
});
使用Lambda表达式
- 如果参数是一个接口类对象，且接口里面只有一个方法
- 可以省略方法名
ArrayClass ac=new ArrayClass();
int[] num={1,2,3,4,5,6,7};
ac.test(num,(int element)->{
System.out.println(element);
});
类
- 闭包enclusure 把函数作为一个方法的参数
class ArrayClass
{
public void test (int [] target,Show s){
for (int element:target)
{
s.customShow(element);
}
}
}
* 必须是接口 这个接口里面只有一个方法
interface Show
{
void customShow(int element);
}
class absClass implements Show
{
@Override
public void customShow(int element) {
System.out.println(element);
}
}
感悟：1.今天学习的东西，总的来说不难，就是有的东西比较绕，需要仔细理解。
2.对于我个人来说，在边听课的时候边打代码，有的时候听的不是很仔细，讲完了，一些细节不知道，就成了阻碍。
3.对于Java来说，我感觉学的东西很多，但是对于它还缺一个整体的布局了解，对于Java，有哪些部分，每个部分有哪些知识，我都不知道，只知道学了一大堆东西，但是却没有形成自己的知识体系。每个具体的知识的运用知道，但是如果让我写一个程序，我无法第一时间想到这个程序如何写，又用到哪些知识，而这就是因为知识体系没有建立。
