关于java:Java-的-Collection-与-List-集合

相同点

都是容器, 能够存储多个数据
不同点
- 数组的长度是不可变的, 汇合的长度是可变的
- 数组能够存根本数据类型和援用数据类型
  
  汇合只能存援用数据类型, 如果要存根本数据类型, 须要存对应的包装类

Collection 汇合概述
- 是单例汇合的顶层接口, 它示意一组对象, 这些对象也称为 Collection 的元素
- JDK 不提供此接口的任何间接实现. 它提供更具体的子接口 (如 Set 和 List) 实现
创立 Collection 汇合的对象
- 多态的形式
- 具体的实现类 ArrayList

Collection 汇合罕用办法

办法名	阐明
boolean add(E e)	增加元素
boolean remove(Object o)	从汇合中移除指定的元素
boolean removeIf(Object o)	依据条件进行移除
void clear()	清空集合中的元素
boolean contains(Object o)	判断汇合中是否存在指定的元素
boolean isEmpty()	判断汇合是否为空
int size()	汇合的长度，也就是汇合中元素的个数

迭代器介绍
- 迭代器, 汇合的专用遍历形式
- Iterator<E> iterator(): 返回此汇合中元素的迭代器, 通过汇合对象的 iterator()办法失去
Iterator 中的罕用办法

boolean hasNext(): 判断以后地位是否有元素能够被取出
E next(): 获取以后地位的元素, 将迭代器对象移向下一个索引地位

Collection 汇合的遍历

public class IteratorDemo1 {public static void main(String[] args) {
        // 创立汇合对象
        Collection<String> c = new ArrayList<>();

        // 增加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        c.add("javaee");

        //Iterator<E> iterator()：返回此汇合中元素的迭代器，通过汇合的 iterator()办法失去
        Iterator<String> it = c.iterator();

        // 用 while 循环改良元素的判断和获取
        while (it.hasNext()) {String s = it.next();
            System.out.println(s);
        }
    }
}

迭代器中删除的办法

void remove(): 删除迭代器对象以后指向的元素

public class IteratorDemo2 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");

        Iterator<String> it = list.iterator();
        while(it.hasNext()){String s = it.next();
            if("b".equals(s)){
                // 指向谁, 那么此时就删除谁.
                it.remove();}
        }
        System.out.println(list);
    }
}

介绍
- 它是 JDK5 之后呈现的, 其外部原理是一个 Iterator 迭代器
- 实现 Iterable 接口的类才能够应用迭代器和加强 for
- 简化数组和 Collection 汇合的遍历
格局

for(汇合 / 数组中元素的数据类型变量名 : 汇合 / 数组名) {

// 曾经将以后遍历到的元素封装到变量中了, 间接应用变量即可

}

代码

public class MyCollectonDemo1 {public static void main(String[] args) {ArrayList<String> list =  new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        //1, 数据类型肯定是汇合或者数组中元素的类型
        //2,str 仅仅是一个变量名而已, 在循环的过程中, 顺次示意汇合或者数组中的每一个元素
        //3,list 就是要遍历的汇合或者数组
        for(String str : list){System.out.println(str);
        }
    }
}

List 汇合的概述
- 有序汇合, 这里的有序指的是存取程序
- 用户能够准确管制列表中每个元素的插入地位, 用户能够通过整数索引拜访元素, 并搜寻列表中的元素
- 与 Set 汇合不同, 列表通常容许反复的元素
List 汇合的特点
- 存取有序
- 能够反复
- 有索引

办法介绍

办法名	形容
void add(int index,E element)	在此汇合中的指定地位插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	批改指定索引处的元素，返回被批改的元素
E get(int index)	返回指定索引处的元素

示例代码

public class MyListDemo {public static void main(String[] args) {List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        //method1(list);
        //method2(list);
        //method3(list);
        //method4(list);
    }

    private static void method4(List<String> list) {//        E get(int index)        返回指定索引处的元素
        String s = list.get(0);
        System.out.println(s);
    }

    private static void method3(List<String> list) {//        E set(int index,E element)    批改指定索引处的元素，返回被批改的元素
        // 被替换的那个元素, 在汇合中就不存在了.
        String result = list.set(0, "qqq");
        System.out.println(result);
        System.out.println(list);
    }

    private static void method2(List<String> list) {//        E remove(int index)        删除指定索引处的元素，返回被删除的元素
        // 在 List 汇合中有两个删除的办法
        // 第一个 删除指定的元素, 返回值示意以后元素是否删除胜利
        // 第二个 删除指定索引的元素, 返回值示意理论删除的元素
        String s = list.remove(0);
        System.out.println(s);
        System.out.println(list);
    }

    private static void method1(List<String> list) {//        void add(int index,E element)    在此汇合中的指定地位插入指定的元素
        // 原来地位上的元素往后挪一个索引.
        list.add(0,"qqq");
        System.out.println(list);
    }
}

栈构造

先进后出
队列构造

先进先出

数组构造

查问快、增删慢
队列构造

查问慢、增删快

ArrayList 汇合

底层是数组构造实现，查问快、增删慢
LinkedList 汇合

底层是链表构造实现，查问慢、增删快

特有办法

办法名	阐明
public void addFirst(E e)	在该列表结尾插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的开端
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最初一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最初一个元素

示例代码

public class MyLinkedListDemo4 {public static void main(String[] args) {LinkedList<String> list = new LinkedList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
//        public void addFirst(E e)    在该列表结尾插入指定的元素
        //method1(list);

//        public void addLast(E e)    将指定的元素追加到此列表的开端
        //method2(list);

//        public E getFirst()        返回此列表中的第一个元素
//        public E getLast()        返回此列表中的最初一个元素
        //method3(list);

//        public E removeFirst()        从此列表中删除并返回第一个元素
//        public E removeLast()        从此列表中删除并返回最初一个元素
        //method4(list);
      
    }

    private static void method4(LinkedList<String> list) {String first = list.removeFirst();
        System.out.println(first);

        String last = list.removeLast();
        System.out.println(last);

        System.out.println(list);
    }

    private static void method3(LinkedList<String> list) {String first = list.getFirst();
        String last = list.getLast();
        System.out.println(first);
        System.out.println(last);
    }

    private static void method2(LinkedList<String> list) {list.addLast("www");
        System.out.println(list);
    }

    private static void method1(LinkedList<String> list) {list.addFirst("qqq");
        System.out.println(list);
    }
}

关于java:Java-的-Collection-与-List-集合

1.Collection 汇合

1.1 数组和汇合的区别

1.2 汇合类体系结构

1.3Collection 汇合概述和应用

1.4Collection 汇合的遍历

1.5 加强 for 循环

2.List 汇合

2.1List 汇合的概述和特点

2.2List 汇合的特有办法

3. 数据结构

3.1 数据结构之栈和队列

3.2 数据结构之数组和链表

4.List 汇合的实现类

4.1List 汇合子类的特点

4.2LinkedList 汇合的特有性能