JAVA入门—————Collection集合 AND 子子接口ArrayList AND 数据结构

集合

• 定义：方便增删改查容器中的元素 是一种容器

数组和集合的区别

• 数组：

1. 长度固定
2. 存储基本数据类型和引用数据类型
3. 储存同类型数据

• 集合：

1. 长度可变
2. 存储引用数据类型
3. 可以存储不同类型数据

Collection集合

• 定义：是集合的顶层父接口
• 子接口：set 和 list

List 子接口：ArrayList LinkedList Vector
Set子接口：HashSet LinkedHashSet TreeSet

ArrayList：

• List接口的子接口

添加功能

boolean add(Object obj)——往集合中添加一个元素

eg：	Collection collection = new ArrayList();//父接收子
        collection.add("aaa");
        collection.add("123");
        System.out.println(collection);————输出：[aaa, 123]

boolean addAll(Collection c)——添加一个集合的元素 (给一个集合添加进另一个集合中的所有元素)

eg：	Collection c = new ArrayList();
        c.add("abc");
        c.add("def");
        Collection c1 = new ArrayList();
        c1.add("123"); //自动装箱
        c1.add("456");
        c1.add(Integer.valueOf(789));
        c.addAll(c1);   // 把c1集合放进c中
        System.out.println(c);————输出：[abc, def, 123, 456, 789]

boolean remove(Object o)——移除一个元素

eg:		......
		c.remove(789);
        System.out.println(c);

void clear()——移除所有元素

eg：	c.clear();
        System.out.println(c);————输出：[]

boolean removeAll(Collection c)——移除一个集合的元素

有交集可移除返回 true 没有交集不可移除 则删除失败 返回 false

eg：	Collection c = new ArrayList();
        c.add("abc");
        c.add("def");
        c.add("ghi");
        c.add("123");
        c.add("456");
        Collection c1 = new ArrayList();
        c1.add("123"); //自动装箱
        c1.add("456");
        c1.add(Integer.valueOf(789));
        boolean b = c.removeAll(c1);
        System.out.println(b);——————输出：true

boolean contains(Object o)——判断集合中是否包含指定的元素

eg：	......
 		boolean b1 = c.contains("abc");
        System.out.println(b1);————输出：true

boolean containsAll(Collection c)——判断集合中是否包含指定的集合元素(这个集合 包含 另一个集合中所有的元素才算包含 才返回true)

• [1,2,3] containsAll ([1,2,4]) ———— false
• [1, 2, 3,4] containsAll ([1, 2, 4]) ———— true

eg：	......
 		boolean b2 = c.containsAll(c1);
        System.out.println(b2);————输出：false

boolean isEmpty()——判断集合是否为空

eg：	......
 		c.clear();
 		boolean b = c.isEmpty();
        System.out.println(b);——————输出：true

int size():元素的个数

eg：	Collection c = new ArrayList();
        c.add("abc");
        c.add("def");
        c.add("ghi");
        c.add("123");
        c.add("456");
        c.add("我爱学习");
        int size = c.size();
        System.out.println(size);————输出：6

boolean retainAll(Collection c)———获取两个集合的交集元素(交集：两个集合都有的元素)

eg：	Collection c = new ArrayList();
        c.add("abc");
        c.add("def");
        c.add("ghi");
        c.add("123");
        c.add("456");
        Collection c1 = new ArrayList();
        c1.add("123"); 
        c1.add("456");
        c1.add(Integer.valueOf(789));
        boolean b = c.retainAll(c1);
        System.out.println(b);———-—返回true   c发生过变化
        System.out.println(c);——-——c变成c与c1的交集

boolean iterator——返回在此 collection 的元素上进行迭代的迭代器。

boolean hasNext ()——若集合中有元素可以迭代，则返回 true。

E next ()———返回迭代的下一个元素

• 遍历集合：需要一个迭代器

反向遍历前必须先正向遍历，使指针移到最后一个元素上

eg：	Collection c = new ArrayList();
        c.add(2000);
        c.add(2002);
        c.add(2004);
        c.add(2006);
        c.add(2008);
        c.add(2010);
        Iterator it = c.iterator();————c集合的迭代器
        while(it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);————元素遍历
        }
        System.out.println("================");
        while(li.hasPrevious()){ ——————元素反向遍历
            Object p = li.previous();
            System.out.println(p);
        }

Object[ ] toArray()———把集合转换为数组

eg：	Collection c = new ArrayList();
        c.add(10);
        c.add(20);
        c.add(30);
        c.add(40);
        c.add(50);
        Object[] obj = c.toArray();//父类接收子类
        for (int i = 0; i < obj.length; i++) {   //遍历
            Integer in = (Integer) obj[i];//向下转型
            System.out.println(in.intValue());   // 以int类型返回改integer的值
        }

List

collection——父父接口
List———父接口

boolean hasPrevious ()——如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。——————————ListIterator特有的方法

E previous ()——返回列表中的前一个元素

void add(int index,E element): 在指定索引处添加元素

eg：	List l = new ArrayList();
        l.add(100);
        l.add(200);
        l.add(300);
        l.add(400);
        l.add(500);
        l.add(0,10);
        System.out.println(l);————输出：10  100  200 300 400 500

E remove(int index):移除指定索引处的元素 返回的是移除的元素

eg：	List l = new ArrayList();
        l.add(100);
        l.add(200);
        l.add(300);
        l.add(400);
        l.add(500);
        l.add(0,10);
        l.add(0,2);
        Object o = l.remove(2);————删除索引2
        System.out.println(o);———输出：100
        boolean b = l.remove(Integer.valueOf(2));————删除元素2
        System.out.println(b);————输出：true

E get(int index):获取指定索引处的元素

eg：	......
		Object o = l.get(l.size() - 1);
        System.out.println(o);——————输出：500

E set(int index,E element):更改指定索引处的元素 返回的是被替换的元素

eg:     ......
        Object o1 = l.set(0, 50);
        System.out.println(o1);————输出：10

E subList ( int fromIndex, int toIndex)——根据起始索引，终止索引，截取一段元素放到新集合中（含头不含尾）

eg：	List l1 = l.subList(2, 5);
        System.out.println(l1);————输出：[200, 300, 400]

遍历集合的四种方法

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class demo4 {
    public static void main(String[] args) {
        ———————遍历集合
        List l = new ArrayList();
        l.add(100);
        l.add(200);
        l.add(300);
        l.add(400);
        l.add(500);
        ————————————方法一：for循环
        for (int i = 0; i < l.size(); i++) {
            Object o = l.get(i);
            System.out.println(o);
        }
        System.out.println("================");
        ————————————方法二：toArray方法
        Object[] obj = l.toArray();
        for (int i = 0; i < obj.length; i++) {
            Integer in = (Integer) obj[i];
            System.out.println(in);
        }
        System.out.println("================");
        ————————————方法三：Collection的iterator方法
        Iterator iterator = l.iterator();
        while (iterator.hasNext()){
            Object o = iterator.next();
            System.out.println(o);
        }
        System.out.println("================");
        ————————————方法四：List独有的方法
        ListIterator listIterator = l.listIterator();
        while (listIterator.hasNext()){
            Object next = listIterator.next();
            System.out.println(next);
        }
        System.out.println("================");
    }
}

————使用迭代器对集合的元素进行迭代 在迭代途中增删集合中的元素会出现ConcurrentModificationException并发修改异常
————因为通过集合获取到这个迭代器之后 迭代器预先知道集合中的元素个数 会按照既定的元素个数进行迭代，在迭代途中增删元素，会打乱迭代器的迭代顺序，所以就会抛出并发修改异常

eg：	ArrayList l = new ArrayList();
        l.add("abc");
        l.add("def");
        l.add("xyz");
        l.add("java");
        //使用迭代器自带迭代增删元素的方法
        ListIterator li = l.listIterator();
        while(li.hasNext()){
            Object next = li.next();
            String ele = (String) next;
            if(ele.equals("java")){
                li.add("World");
            }
        }
        System.out.println(l);

int lastIndexOf (Object o)——返回此列表中最后一次出现的指定元素的索引，若此列表不包含索引，则返回 - 1

eg：	int index1 = l.lastIndexOf("xyz");
        System.out.println(index1);————输出：6

int indexOf (Object o)——返回此列表中首次出现的指定元素的索引，若此列表不包含元素，则返回 - 1

eg：	ArrayList l = new ArrayList();
        l.add("abc");
        l.add("def");
        l.add("xyz");
        l.add("java");
        l.add("123");
        l.add("456");
        l.add("xyz");
        int index = l.indexOf("xyz");
        System.out.println(index);————输出：2

void forEach (Consumer < ? super E > action)——遍历集合元素方法：执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常

Consumer ——接口

eg：	//遍历集合中的元素
        l.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });

数据结构

• 概念：数据结构其实就是存储数据的格式
• 分类： 栈 队列 数组 链表 树 哈希表
• 栈特点： 先进后出
• 队列特点： 先进先出
• 数组特点： 查询快 , 增删慢
• 链表特点： 查询慢 , 增删快