Java学习笔记之集合Collection/List/ListIterator/LinkedList/栈与队列/数组与链表

1.集合体系结构

2.Collection集合的常用方法

(1).Collection集合概述:
是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素.
jdk不提供此接口的任何直接实现,它提供更具体的子接口(如set和list)实现.
(2).创建Collection集合的对象
多态的方式
具体的实现类ArrayList
代码实现:

Collection<String> c = new ArrayList<>();

(3).Collection集合的常用方法
boolean add(E e):添加元素
boolean remove(Object o):从集合中移除指定的元素
void clear():清空集合中的元素
boolean contains(Object o):判断集合中是否存在指定的元素
boolean isEmpty():判断集合是否为空
int size():集合的长度,也就是集合中元素的个数
代码实现:

Collection<String> c = new ArrayList<>();
c.add("hello");
c.add("world");
c.add("java");
System.out.println(c);
System.out.println(c.size());
System.out.println(c.remove("java"));
System.out.println(c);
System.out.println(c.contains("java"));
System.out.println(c.contains("hello"));
System.out.println(c.isEmpty());
c.clear();
System.out.println(c.isEmpty());

3.Collection集合存储自定义对象并遍历

(1).Iterator:迭代器,集合的专用遍历方法
Iteratoriterator():返回此集合中的元素的迭代器,通过集合的iterator()方法得到
迭代器是通过集合的iterator()方法得到的,所以我们说它是依赖于集合而存在的
(2).Iterator中的常用方法
E next():返回迭代器中的下一个元素
boolean hasNext():如果迭代具有更多元素,则返回true
代码实现:

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

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

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

public class StudentTest {
    public static void main(String[] args) {
		//创建集合对象
        Collection<Student> collection = new ArrayList<>();
		//为集合添加元素
        collection.add(new Student("叶凡",30));
        collection.add(new Student("猴子",31));
        collection.add(new Student("瑶溪",21));
		//创建迭代器对象
        Iterator<Student> iterator = collection.iterator();
		//遍历集合元素
        while (iterator.hasNext()) {
            Student next = iterator.next();
            System.out.println(next);
        }
    }
}

4.List集合的特有方法

(1).List集合概述和特点
有序集合(也称序列),用户可以精确控制列表中的每个元素的插入位置,用户可以通过整数索引访问元素,并搜索列表中的元素.
与Set集合不同,列表通常允许重复的元素
(2).List集合特点
有序:存储和取出的元素顺序一致
可重复:存储的元素可以重复
(3).List集合特有方法
void add(int index,E element):在此集合中的指定位置插入指定的元素.
E remove(int index):删除指定索引处的元素,返回被删除的元素
E set(int index,E element):修改指定索引处的元素,返回被修改的元素
E get(int index):返回指定索引处的元素
代码实现:

import java.util.ArrayList;
import java.util.List;
public class ListDemo {
    public static void main(String[] args) {
		//创建集合对象
        List<String> strList = new ArrayList<>();
		//给集合添加元素
        strList.add("剑圣");
        strList.add("蛮王");
        strList.add("小妮");
		//在此集合中的指定位置插入指定的元素
        strList.add(1,"刘邦");
        System.out.println(strList);
		//删除指定索引处的元素,返回被删除的元素
        strList.remove(1);
        System.out.println(strList);
		//修改指定索引处的元素,返回被修改的元素
        strList.set(1,"项羽");
        System.out.println(strList);
		//返回指定索引处的元素
        String s = strList.get(1);
        System.out.println(s);
    }
}

5.ListIterator

(1).ListIterator:列表迭代器
通过List集合的listIterator()方法得到,所以说它是List集合特有的迭代器
用于允许程序员沿任一方向遍历列表的列表迭代器,在迭代期间修改列表,并获取列表中迭代器的当前位置

(2).ListIterator中的常用方法
E next():返回迭代器中的下一个元素
boolean hasNext():如果迭代具有更多元素,则返回true
E previous():返回列表中的上一个元素
boolean hasPrevious():如果此列表迭代器在相反方向遍历列表时具有更多元素,则返回true
void add(E e):将指定的元素插入列表
(3).增强for循环
增强for:简化数组和Collection集合的遍历
实现Iterable接口的类允许其实对象成为增强型for语句的目标
它是JDK5之后出现的,其内部原理是一个Iterator迭代器
(4).增强for的格式:

for(元素数据类型变量名:数组或者Collection集合){
	//在此处使用变量即可,该变量就是元素
}

范例:

int[] arr = {1,2,3,4,5};
for(int i : arr){
	System.out.println(i);
}

6.List集合子类特点

(1).List集合常用子类:ArrayList,LinkedList
Array:底层数据结构是数组,查询快,增删慢
LinkedList:底层数据结构是链表,查询慢,增删快
代码实现:

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class ListTest {
    public static void main(String[] args) {
        ArrayList<String> arrStr = new ArrayList<>();
        arrStr.add("孙悟空");
        arrStr.add("唐僧");
        arrStr.add("八戒");
        arrStr.add("悟净");
        for (String s : arrStr) {
            System.out.println(s);
        }
        System.out.println("-------------");
        for (int i = 0; i < arrStr.size(); i++) {
            String s =  arrStr.get(i);
            System.out.println(s);
        }
        System.out.println("-------------");
        Iterator<String> iterator = arrStr.iterator();
        while (iterator.hasNext()) {
            String s =  iterator.next();
            System.out.println(s);
        }
        System.out.println("-------------");
        
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("孙悟空");
        linkedList.add("唐僧");
        linkedList.add("八戒");
        linkedList.add("悟净");
        for (String s : linkedList) {
            System.out.println(s);
        }
        System.out.println("-------------");
        for (int i = 0; i < linkedList.size(); i++) {
            String s =  linkedList.get(i);
            System.out.println(s);
        }
        System.out.println("-------------");
        Iterator<String> iterator1 = linkedList.iterator();
        while (iterator1.hasNext()) {
            String s =  iterator1.next();
            System.out.println(s);
        }
    }
}

7.LinkedList集合的特有功能

代码实现:

import java.util.LinkedList;
public class LinkedListTest {
    public static void main(String[] args) {
		//创建集合对象
        LinkedList<String> linkedList = new LinkedList<>();
		//给集合添加元素
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");
		
        linkedList.addFirst("li");
        System.out.println(linkedList);
		
        linkedList.addLast("xiaolong");
        System.out.println(linkedList);
        System.out.println("----------");
		
        System.out.println(linkedList.getFirst());
        System.out.println(linkedList.getLast());
        System.out.println("----------");
		
        System.out.println(linkedList.removeFirst());
        System.out.println(linkedList.removeLast());
        System.out.println("----------");
		
        System.out.println(linkedList);
    }
}

8.栈与队列/数组与链表

(1)常见数据结构之栈
数据进入栈模型的过程称为:压/进栈
数据离开栈模型的过程称为:弹/出栈
最先进栈模型的元素称为栈低元素,最后进栈模型的元素称为栈顶元素
栈是一种数据先进后出的模型
(2)常见数据结构之队列
数据从后端进入队列模型的过程称为:入队列
数据从后端进入队列模型的过程称为:出队列
队列是一种数据先进先出的模型
(3)常见数据结构之数组
查询数据通过索引定位(自带索引),查询任意数据耗时相同,查询效率高
删除数据时,要将原始数据删除,同时后面每个数据前移,删除效率低
添加数据时,添加位置后的每个数据后移,再添加元素,添加效率极低
所以说数组是一种查询块,增删慢的模型
而链表是一种增删快的模型(对比数组)
而链表是一种查询慢的模型(对比数组),因为每一次查询都会从头开始查询.