Java集合Collections

什么是集合？

       Java中用来保存数据的容器。

数组和集合的区别
    i.数组长度是固定的,集合的长度是可变的
    ii.数组中元素类型可以是基本类型,也可以是引用类型
        但是集合中元素类型必须只能是引用类型,如果想保持基本类型,要写该基本类型对应的包装类
  

 

Collection是List和Set的父接口

Collection:

增：boolean add(E e)

删：boolean remove(Object o)

改：无

查：无

其他：

    public boolean contains(Object obj); 判断集合中是否包含某个元素
    public void clear(); 清空集合(把集合的元素全部删除,不是把集合置为null)
    public boolean isEmpty(); 判断集合是否为空(是指集合中是否没有元素,并不是值集合是否为null)
    public int size(); 返回集合中元素的个数
    public Object[] toArray(); 将集合转成数组  

迭代器(iterator):
    用于遍历集合的对象(集合有无索引,均可使用迭代器来遍历,迭代器遍历集合时是不需要索引的!!!)

如何使用迭代器?
   i.获取要遍历的集合的迭代器对象
   ii.调用迭代器对象.hasNext();
   iii.调用迭代器对象.next();

public class Iterator{
    public static void main(Stirng[] args){
        Collection<String> clt = new ArrayList<>();//Collection是接口，不能创建对象，可以创建它的实现类
        clt.add("a");
        clt.add("b");
        clt.add("c");
        //获取迭代器
        Iterator<String> it=clt.iterator(); 
        while(it.hasNext()){//判断集合中是否有元素
            String s=it.next();//获取值
            System.out.println(s);
        }
    } 
}

List接口：

List继承Collection接口：子类继承父类后就会自动继承父类中的成员变量和成员方法

增: add(int index,E e)

删: remove(int index)

改: set(int index,E 新元素);

查: get(int index);

其他：

indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。 lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。 subList(int fromIndex, int toIndex)           返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。

特点：

1、有序

2、有索引

3、可重复

List的实现类

1、ArrayList是一个动态数组，它允许任何符合规则的元素插入甚至包括null，ArrayList初始容量为10，即数组的大小。

特点: 查询快,增删慢!!

方法：Collection中的＋List中的

2、LinkedList

LinkedList底层采用的数据结构是链表结构,特点:查询慢,增删快

方法：Collection中的＋List中的+特有方法

 特有方法:
        public void addFirst(E e);添加到集合首
        public void addLast(E e);添加到集合尾
        
        public E removeFirst(); 删除集合首元素,返回被删除的那个元素
        public E removeLast(); 删除集合尾元素,返回被删除的那个元素
        
        public E getFirst(); 获取集合首元素
        public E getLast(); 获取集合尾元素
        
        public E pop(); //删除集合的首元素,底层就是removeFirst
        public void push(E e); //向集合中添加首元素,底层就是addFirst

还有一些像:pollFirst();peekFirst();这类的与removeFist();addFist();差不多

看源码以pollFirst()与removeFist()为例

public E pollFirst() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }





 public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }

 

 3、Vector

与ArrayList相似，但是Vector是同步的。所以说Vector是线程安全的动态数组。它的操作与ArrayList几乎一样。

Set接口：

Set接口 继承 Collection接口
Set接口的特点:
    无序的(Java中无序是指存取顺序不保证一致,比如:存入2 1 3 打印集合3 2 1)
    无索引的
    元素唯一的    
   但是实际上严格来说 无序这个特点是不对的(实现类LinkedHashSet是有序的)    

Set中方法：与Collection中相同

Set的实现类

1、hashSet

a.HashSet他没有特有方法!!!
b.HashSet底层采用哈希表结构(数组结构+链表结构+红黑树结构)   
c.HashSet的使用(无序,无索引,元素唯一)

2、LinkedHashSet

a.LinkedHashSet也没有特有方法!!!
b.LinkedHashSet底层采用链表+哈希表结构   
c.LinkedHashSet使用(有序,无索引的,元素唯一)

3、TreeSet

a.TreeSet特点
    无序的(无序是存取顺序不保证一致,存入321 打印123,存入132 打印123 存入321 打印123)
         TreeSet是无序的,但是它无序中一种特殊的存在,有自然顺序!!
    无索引
    元素唯一      
b.TreeSet特有方法: 无!
C.TreeSet底层采用红黑树结构

Collections工具类：

shuffle(List<?> list)           使用默认随机源对指定列表进行置换。 sort(List<T> list, Comparator<? super T> c)           根据指定比较器产生的顺序对指定列表进行排序。 sort(List<T> list, Comparator<? super T> c)           根据指定比较器产生的顺序对指定列表进行排序。 swap(List<?> list, int i, int j)           在指定列表的指定位置处交换元素。 reverse(List<?> list)           反转指定列表中元素的顺序。 copy(List<? super T> dest, List<? extends T> src)           将所有元素从一个列表复制到另一个列表 addAll(Collection<? super T> c, T... elements)           将所有指定元素添加到指定 collection 中。

Collections.sort()方法：

public class Student {
    private String name;
    private Integer age;

    public Student() {
    }
    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +"name='" + name + '\'' +", age=" + age +'}';
    }

    public static void main(String[] args) {
        ArrayList<Student> stu=new ArrayList<>();
        stu.add(new Student("张三",18));
        stu.add(new Student("李四",38));
        stu.add(new Student("王五",28));

        Collections.sort(stu, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.age-o2.age;
            }
        });
        System.out.println(stu);
        //[Student{name='张三', age=18}, Student{name='王五', age=28}, Student{name='李四', age=38}]
    }
}