java 集合Collection使用解读

1.集合是什么？

Java集合类存放于 java.util 包中，是一个用来存放对象的容器。

注意：①、集合只能存放对象。比如存一个 int 型数据 1放入集合中，其实它是自动转换成 Integer 类后存入的，Java中每一种基本类型都有对应的引用类型。

②、集合存放的是多个对象的引用，对象本身还是放在堆内存中。

③、集合可以存放不同类型，不限数量的数据类型。集合的元素个数是可变的。

2.集合的类型

Collection抽象接口，集合类型主要有3种：set(集）、list(列表，数组）和map(映射)。

3.Collection接口方法

定义一个集合：

Collection<String> list = new ArrayList<>();

添加元素

//添加元素
list.add("jack");
list.add("merry");
System.out.println(list);

删除元素

list.remove("merry");
System.out.println(list);

获取元素个数

//获取元素个数
System.out.println(list.size());

判断是否包含某一个元素

if (list.contains("jack")){
        System.out.println("有jack");
} else{
        System.out.println("没有jack");
}

判读是否为空

if (list.isEmpty()){
      System.out.println("是空的");
} else {
      System.out.println("不是空的");
}

判断两个集合是否相同

       Collection<String> list2 = new ArrayList<>();
        list2.add("jack");
        list2.add("merry");
        if (list.equals(list2)){
            System.out.println("两个集合相同");
        } else {
            System.out.println("两个集合不相同");
        }

清空集合

list.clear();
System.out.println(list);

3.1集合的遍历

<1>.使用Iterator来遍历

hasNext 判断是否有元素
next 获取下一个对象
remove 删除当前遍历过的对象

Collection<String> list2 = new ArrayList<>();
Iterator iterator = list2.iterator();

while (iterator.hasNext()){
     System.out.println(iterator.next());
}

<2>.for-each 增强for循环快速循环

Collection<String> list2 = new ArrayList<>();
for (String obj: list2) {
    System.out.println(obj);
}

<3>.for-i循环

Collection<String> list2 = new ArrayList<>();
for (int i = 0; i < list2.size(); i++) {
   System.out.println(((ArrayList<String>) list2).get(i));
}

3.2、List（有序、可重复）

继承于Collection

List里存放的对象是有序的，同时也是可以重复的，List关注的是索引，拥有一系列和索引相关的方法，查询速度快。因为往list集合里插入或删除数据时，会伴随着后面数据的移动，所有插入删除数据速度慢。

ArrayList 是连续的内存空间
优点：访问方便。缺点：删除添加效率低

LinkedArrayList 内部使用链表实现，不一定连续（基本不连续）
优点：增加删除效率高。缺点：访问不方便

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> a2 = new ArrayList<>();
a2.add(1);
a2.add(2);
a2.add(3);

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(score.indexOf(1));//第一次出现的位置
System.out.println(score.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);

3.3 Lambda表达式

Lambda表达式，也可称为闭包，是一个匿名函数，即没有函数名的函数，它是推动java8 发布的最重要的新特性。

Lambda允许把函数作为一个方法参数（函数作为参数传递进方法中）。

使用Lambda表达式可以使代码变得更简洁紧凑。

举一个例子来使用一下。先定义一个数组，添加几个元素：

ArrayList<Integer> nums = new ArrayList<>();
nums.add(1);
nums.add(2);
nums.add(3);
nums.add(4);

使用如下：

方法一

 //Lambda表达式
nums.removeIf(obj -> obj % 2 == 0);

方法二

for (int i = 0; i < nums.size(); i++) {
    Integer obj = nums.get(i);
    if (obj % 2 == 0){
        nums.remove(obj);
         i--;
    }
}

System.out.println(nums);
//执行结果
[1, 3]

闭包 enclusure 把函数作为一个方法的参数

定义一个接口，这个接口里面只有一个方法。

interface Show{
    void customShow(int element);
}

定义一个类实现这个接口。

class YANClass implements Show{
    @Override
    public void customShow(int element) {
        System.out.println(element);
    }
}

定义一个类ArrayClass，写一个方法，其中一个参数为接口类型，并调用接口定义的方法。

//闭包 enclusure 把函数作为一个方法的参数
class ArrayClass{
    public void test(int[] target, Show s){
        for (int element: target){
            s.customShow(element);
        }
    }
}

1.使用方式：定义一个类实现接口

ArrayClass ac = new ArrayClass();
int[] num = {1,2,3,4,5,6};
YANClass yc = new YANClass();
ac.test(num, yc);

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));

3.4、Set（无序、不能重复）

Set里存放的对象是无序，不能重复的，集合中的对象不按特定的方式排序，只是简单地把对象加入集合中。

3.5、Map（键值对、键唯一、值不唯一，键不能相同，值可以相同）

Map集合中存储的是键值对，键不能重复，值可以重复。根据键得到值，对map集合遍历时先得到键的set集合，对set集合进行遍历，得到相应的值。

4.JAVA集合类型四种常见输出方式：

1、Iterator：迭代输出，是使用最多的输出方式。
2、ListIterator：是Iterator的子接口，专门用于输出List中的内容。
3、foreach输出：JDK1.5之后提供的新功能，可以输出数组或集合。
4、for循环。
代码示例如下：

for的形式：for（int i=0;i<arr.size();i++）{...}
foreach的形式： for（int　i：arr）{...}
iterator的形式：
Iterator it = arr.iterator();
while(it.hasNext()){ object o =it.next(); ...}