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

数据结构

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

你可能感兴趣的:(JAVA入门—————Collection集合 AND 子子接口ArrayList AND 数据结构)