Java集合框架中的ArrayList和collection

集合的由来
  面向对象语言的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。
继承体系

数组与集合的区别
长度区别

• 数组的长度是固定的
• 集合的长度是可变的。

存储数据类型的区别

• 数组可以存储基本数据类型，也可以存储引用数据类型
• 集合只能存储引用数据类型

内容区别

• 数组只能存储同种类型的数据
• 集合可以存储不同类型的元素

Java中用于集合类的顶层父接口是Collection接口。
1.Collection
1.添加功能

• boolean add(Object obj):添加一个元素
• boolean addAll(Collection c):添加一个集合的元素 (给一个集合添加进另一个集合中的所有元素)

import java.util.ArrayList;
import java.util.Collection;

public class collectionMytest1 {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        //存储的是引用数据类型
        collection.add(100);
        collection.add(Integer.valueOf(10));
        //添加功能
        collection.add(1000);
        Collection collection1 = new ArrayList();
        collection1.add(1);
        collection1.add(2);
        collection1.add(Integer.valueOf(3));
        //给一个集合添加添加另一个集合的所有元素
        boolean b = collection.addAll(collection1);
        System.out.println(b);
        System.out.println(collection);
    }
}

运行结果为：

true
[100, 10, 1000, 1, 2, 3]

2.删除功能

• void clear():移除所有元素
• boolean remove(Object o):移除一个元素
• boolean removeAll(Collection c):移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素

import java.util.ArrayList;
import java.util.Collection;

public class collectionMytest2 {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add(1);
        collection.add(2);
        collection.add(3);
        collection.add(Integer.valueOf(23));
        //移除一个元素，返回的是是否删成功
        boolean b = collection.remove(23);
        System.out.println(b);
        System.out.println(collection);
        //移除所有元素
        collection.clear();
        System.out.println(collection);
    }
}

运行结果为：

true
[1, 2, 3]
[]

3.判断功能

• boolean contains(Object o)：判断集合中是否包含指定的元素
• boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(这个集合 包含 另一个集合中所有的元素才算包含 才返回true)
• boolean isEmpty()：判断集合是否为空

import java.util.ArrayList;
import java.util.Collection;

public class Mytest4 {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add(11);
        collection.add(Integer.valueOf(22));
        collection.add(33);
        //判断集合是否为空
        boolean b1 = collection.isEmpty();
        //判断集合中是否包含制定的元素
        boolean b = collection.contains(33);
        Collection collection1 = new ArrayList();
        collection1.add(11);
        collection1.add(22);
        //判断一个集合是否包含指定集合的所有元素，
        boolean b2 = collection.containsAll(collection1);
        System.out.println(b);
        System.out.println(b1);
        System.out.println(b2);
    }
}

运行结果为：

true
false
true

4.交集功能

• boolean retainAll(Collection c):获取两个集合的交集元素(交集：两个集合都有的元素) 注意 ：A集合对B集合取交集，获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化

import java.util.ArrayList;
import java.util.Collection;

public class Mytest5 {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add(100);
        collection.add(Integer.valueOf(200));
        collection.add(300);
        Collection collection1 = new ArrayList();
        collection1.add(200);
        collection1.add(Integer.valueOf(300));
        collection1.add(400);
        //A集合对B集合取交集，获取到的交集元素在A集合中。
        // //返回的布尔值表示的是A集合是否发生变化
        boolean b = collection.retainAll(collection1);
        System.out.println(b);
        System.out.println(collection);
        System.out.println(collection1);
    }
}

运行结果为：

true
[200, 300]
[200, 300, 400]

5.把集合转换为数组

• Object[] toArray()

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class Mytest5 {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add(100);
        collection.add(Integer.valueOf(200));
        collection.add(300);
        Object[] array = collection.toArray();
        System.out.println(Arrays.toString(array));
    }
}

运行结果为：

[100, 200, 300]

6.获取功能以及长度功能

• Iterator iterator()（获取功能）
• int size():元素的个数（长度功能）

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Mytest6 {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add(100);
        collection.add(Integer.valueOf(200));
        collection.add(300);
        collection.add(400);
        collection.add(Integer.valueOf(500));
        //元素的个数
        int size = collection.size();
        System.out.println(size );
        //获取一个迭代器
        //Iterator 对 collection 进行迭代的迭代器。
        //boolean hasNext ()
        //如果仍有元素可以迭代，则返回 true。
        // next ()
        //返回迭代的下一个元素。
        Iterator iterator = collection.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();//让指针下移
            System.out.println(next);
        }
    }
}

运行结果为

5
100
200
300
400
500

2.ArrayList
  1.底层数据结构是数组，初始容量为10，每次增长1.5倍，查询慢，增删快
  2.线程不安全（线程非同步），效率高
   3.在增删时候，需要数组的拷贝复制（native方法由c/c++实现）

功能

• int indexOf (Object o) 返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 - 1。
• int lastIndexOf (Object o) 返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 - 1。
• List subList ( int fromIndex, int toIndex) 根据起始索引和结束索引从集合中截取一段元素，放到一个新集合中
• void forEach (Consumer < ? super E > action) 执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常。

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class Mytest {
    public static void main(String[] args) {
        //ArrayList( int initialCapacity)
        //构造一个具有指定初始容量的空列表。
        ArrayList list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        list.add(7);
        list.add(8);
        list.add(9);

        //int indexOf (Object o)
        //返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 - 1。
        //int lastIndexOf (Object o)
        //返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 - 1。

        //List<E> subList ( int fromIndex, int toIndex)
        //返回一个视图之间的指定 fromIndex，包容，和 toIndex这份名单的部分，独家。


        //void forEach (Consumer < ? super E > action)
        //执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常。

        //根据起始索引和结束索引从集合中截取一段元素，放到一个新集合中
        //List list1 = list.subList(0, list.indexOf(200)+1);
        //System.out.println(list1);
        //
        //System.out.println(list);
        int i = list.indexOf(5);
        int i1 = list.lastIndexOf(6);
        List list1 = list.subList(2, 7);
        System.out.println(list1);
        list.forEach(new Consumer() {
            @Override
            public void accept(Object o) {

                System.out.println(o);
            }
        });
    }
}

3.forEach

public class Mytest2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(12);
        list.add(45);
        list.add(24);
        list.add(-2);
        list.add(78);
        list.add(39);
        //相当于遍历
        list.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });
    }
}

4.函数式接口
  接口中只有一个抽象方法，那么就可以使用 Lambda 表达式来简写匿名内部类。

import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Consumer;

public class Mytest2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(12);
        list.add(45);
        list.add(24);
        list.add(-2);
        list.add(78);
        list.add(39);
        //通过Lambda 表达式来简写匿名内部类
        //法一
        Consumer con = (obj) -> System.out.println(obj);
        //法二
        Consumer con2 = System.out::println;
        list.forEach(con2);
        list.forEach(System.out::println);

    }
}

5.排序集合中的元素

import java.util.ArrayList;
import java.util.Comparator;

public class Mytest2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(12);
        list.add(45);
        list.add(24);
        list.add(-2);
        list.add(78);
        //排序集合中的元素
        //ctrl+o 或ctrl+p可以提示方法中要的参数类型
        list.sort(new Comparator<Integer>(){
            @Override
            public int compare(Integer a, Integer b) {
                return(a-b);//正负以及0
            }
        });
        System.out.println(list);
    }
}

运行结果为：

[-2, 12, 24, 45, 78]