Java基础知识集合容器List,ArrayList,LinkedList

容器|集合

容器|集合 : 存储多个数据
    数组 : 存储多个数据
        一段连续的内存空间

    数组的特点:
        1.引用数据类型
        2.定长,长度一旦确定不可改变
        3.存储数据的类型相同
        4.有序,有索引

    集合:
        存储任意引用类型数据
        集合的长度可变,可以根据需求动态的增删数据,长度随之改变

---

public class Class001_Container {
    public static void main(String[] args) {
        //容器对象
        ArrayList list = new ArrayList();
        //存储数据
        list.add("nihao");
        list.add(123);
        list.add(false);

        System.out.println(list);
        System.out.println(list.size());

        //删除数据
        list.remove(0);

        System.out.println(list);
        System.out.println(list.size());

        //修改数据
        list.set(1,true);

        System.out.println(list);
    }
}

---

Collection容器

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

/*
    容器中的接口层次结构
        Collection : 单个值的集合
            Set 无序不可重复
            List 有序可重复,有索引
        Map : 键值对的集合(KEY-VALUE)


    Collection 集合层次结构中的根接口。 集合表示一组对象，称为其元素 。
        常用方法
        遍历方式
            foreach
            iterator迭代器
 */
public class Class001_Collection {
    public static void main(String[] args) {
        //1.创建集合对象
        Collection collection = new ArrayList();
        Collection col = new ArrayList();
        //2)常用方法
        //boolean add(E e) 确保此集合包含指定的元素（可选操作）。
        collection.add(123);
        collection.add(false);
        collection.add("你好");
        collection.add('a');
        collection.add(null);
        collection.add(1.234);

        col.add("aaa");
        col.add("bbb");
        System.out.println(col.add("ccc"));
        System.out.println(collection);
        System.out.println(col);
        //boolean addAll(Collection<? extends E> c) 将指定集合中的所有元素添加到此集合中（可选操作）。
        collection.addAll(col);
        System.out.println(collection);
        System.out.println(col);

        //void clear() 从此集合中删除所有元素（可选操作）。
        //col.clear();
        //boolean isEmpty() 如果此集合不包含任何元素，则返回 true 。
        //System.out.println(col.isEmpty());

        //boolean contains(Object o) 如果此collection包含指定的元素，则返回 true 。
        System.out.println(collection.contains("你好"));
        //boolean containsAll(Collection<?> c) 如果此集合包含指定集合中的所有元素，则返回 true 。
        System.out.println(collection.containsAll(col));
        //boolean remove(Object o) 从此集合中移除指定元素的单个实例（如果存在）（可选操作）。
        System.out.println(collection.remove(123));
        System.out.println(collection);
        //boolean removeAll(Collection<?> c) 删除此集合的所有元素，这些元素也包含在指定的集合中（可选操作）。
        //boolean retainAll(Collection<?> c) 仅保留此集合中包含在指定集合中的元素（可选操作）。
        col.add("ddd");
        System.out.println(collection);
        System.out.println(col);
        //System.out.println(collection.retainAll(col));
        System.out.println(collection);
        //int size() 返回此集合中的元素数。
        //Object[] toArray() 返回包含此集合中所有元素的数组。
        //System.out.println(Arrays.toString(collection.toArray()));

        System.out.println("-----------foreach----------------");
        for(Object obj:collection){
            System.out.println(obj);
        }

        System.out.println("------------iterator迭代器-------------");
        //1)获取迭代器实例,用来遍历指定的集合
        //Iterator<E> iterator() 返回此集合中元素的迭代器。
        Iterator it = collection.iterator();

        //2)判断是否存在下一个数据
        while(it.hasNext()){
            //3)获取下一个数据
            System.out.println(it.next());
        }
    }
}

---

泛型

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

/*
    泛型:  jdk1.5
        参数化类型 : 数据类型作为参数传递
                    只能配置引用数据类型
        <>定义泛型
        泛型的行为发生在编译期间,运行期间发型配置的所有内容无效,泛型擦除
        要求先定义泛型,才能使用泛型
        泛型类 : 类型的后面定义泛型,在使用类型的时候可以通过泛型传递具体的类型,类中可以进行使用
        泛型方法

        泛型的优点:
            代码简单简洁
            增强程序健壮性,避免类型转换异常的出现
            增强稳定性与可读性
 */
public class Class002_Type {
    public static void main(String[] args) {
        Collection<String> col = new ArrayList<>();
        col.add("abc");
        col.add("bcd");
        col.add("dce");

        for(String str:col){

        }

        Iterator<String> it =  col.iterator();
        while(it.hasNext()){
            String s = it.next();
        }
    }
}

---

List集合

import java.util.ArrayList;
import java.util.List;

/*
    List : 有序,可重复
    Set : 无序,不可重复|唯一的

    List : 有序集合（也称为序列 ）。 该接口的用户可以精确控制列表中每个元素的插入位置。
    新增: 一些列根据索引操作的方法
    遍历方式 :
        for普通for循环
        foreach 增强for循环
        iterator迭代器
 */
public class Class001_List {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();

        //添加
        list.add(3);
        list.add(2);
        list.add(1);
        System.out.println(list);
        //void add(int index, E element) 将指定元素插入此列表中的指定位置（可选操作）。  --只能添加不能修改
        //boolean add(E e) 将指定的元素追加到此列表的末尾（可选操作）。
        list.add(3,6);
        list.add(4,2);
        System.out.println(list);
        list.add(2,100);
        System.out.println(list);

        //E set(int index, E element) 用指定的元素替换此列表中指定位置的元素（可选操作）。 --只能修改不能添加
        System.out.println(list.set(2,10));
        System.out.println(list);

        //boolean addAll(int index, Collection<? extends E> c) 将指定集合中的所有元素插入到指定位置的此列表中（可选操作）。

        //E get(int index) 返回此列表中指定位置的元素。
        System.out.println(list.get(2));

        //int indexOf(Object o) 返回此列表中第一次出现的指定元素的索引，如果此列表不包含该元素，则返回-1。
        System.out.println(list.indexOf(2));
        //int lastIndexOf(Object o) 返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回-1。
        System.out.println(list.lastIndexOf(2));

        //static <E> List<E> of(E... elements) 返回包含任意数量元素的不可修改列表。
        List<String> list2 = List.of("aaa","bbb","ccc");
        System.out.println(list2);
        //list2.set(1,"eee");  //java.lang.UnsupportedOperationException
        System.out.println(list2.get(1));

        //E remove(int index) 删除此列表中指定位置的元素（可选操作）。  -->优先识别
        //boolean remove(Object o) 从该列表中删除指定元素的第一个匹配项（如果存在）（可选操作）。
        System.out.println(list.remove(3));
        System.out.println(list);

        //List<E> subList(int fromIndex, int toIndex) 返回指定的 fromIndex （包含）和 toIndex （不包括）之间的此列表部分的视图。
        System.out.println(list.subList(1,3));;

        System.out.println("------------------ for普通for循环-----------------");
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
    }
}

---

ArrayList集合

import java.util.ArrayList;

/*
    有序,可重复的
     ArrayList : 实现所有可选列表操作，并允许所有元素，包括null 。
        底层结构: 数组  Object[] elementData;
        特点: 根据索引查询遍历效率较高,增删效率低
        应用场景: 适合应用在大量做查询,少量做增删的位置
        扩容问题:
            初始容量 : 默认初始容量为10 ,在第一次添加add的时候进行构建  private static final int DEFAULT_CAPACITY = 10;
            扩容机制 : 每次扩容原容量的1.5倍 int newCapacity = oldCapacity + (oldCapacity >> 1);
        新增功能: void forEach(Consumer<? super E> action)
        遍历 :
            普通for
            增强for
            iterator迭代器
            listIterator迭代器
     Vector :
        底层结构 : 数组
        特点 : 与ArrayList相同
        区别:
            1)  Vector是同步的|线程安全
                ArrayList不同步|线程不安全,相对效率较高
            2) Vector每次扩容原容量的2倍
               ArrayList每次扩容原容量的1.5倍,相对ArrayList更有利于节省内存

     总结 :  如果不需要线程安全实现，建议使用ArrayList代替Ve.1

    定义一个ArrayList存储javabean类型的数据,测试使用
    如果存储javabean类型的数据,在调用一些方法时候(indexOf..),默认调用equals方法进行判断,要求对javabean类型重写equals方法
 */
public class Class003_ArrayList {
    public static void main(String[] args) {
        ArrayList<Double> list = new ArrayList();
        list.add(1.1);
        list.add(2.2);
        list.add(3.3);
        list.add(null);
        list.add(null);

        System.out.println(list);
        //遍历集合中的每一个数据,输出打印
        list.forEach(System.out::println);
    }
}

---

LinkedList集合

import java.util.LinkedList;
import java.util.Objects;

/*
    LinkedList: 实现所有可选列表操作，并允许所有元素（包括null ）。
        底层结构: 双向链表
        特点: 查询效率低,增删效率高
        应用场景:单个数据值的集合中,允许数据有序,且可重复,在大量做增删,销量做查询的时候时候适合使用链表
        新增功能: 新增了一些与链表头尾相关的方法

        注意: 请注意，此实现不同步。

        定义链表结构,存储javabean类型的数据,测试使用,遍历使用
        存储javabean类型数据时候,要求javabean类型重写equals方法,否则使用一些判断比较的方法时候回默认调用equals方法
 */
public class Class004_LinkedList {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList();
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        System.out.println(list);
        list.addFirst("aaa");
        list.addLast("ddd");
        list.addLast(null);
        System.out.println(list);

        LinkedList<Person> persons = new LinkedList();
        persons.add(new Person("zhangsan",18));
        persons.add(new Person("lisi",17));
        persons.add(new Person("wangwu",19));

        System.out.println(persons);

        System.out.println(persons.contains(new Person("zhangsan",18)));
    }
}

class Person{
    private String name;
    private int age;

    public Person() {
    }

    public Person(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 "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    /*@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }*/

}

---

手写LinkedList基本功能

import java.util.LinkedList;

//通过单向链表手写LinkedList : 了解
public class Class005_MyLinked {
    public static void main(String[] args) {
        MyLinkedList my = new MyLinkedList();
        my.add("nihao");
        System.out.println(my.size());
        System.out.println(my);
        my.add("1111");
        System.out.println(my);
        System.out.println(my.size());
        System.out.println(my.get(0));
        System.out.println(my.get(1));
        System.out.println(my);

        LinkedList list = new LinkedList();
        list.add("aaa");
        list.add("vvv");

        System.out.println(list);

    }
}

class MyLinkedList{
    //记录链表头节点
    private Node head;
    //数据的个数
    private int size;

    public MyLinkedList() {
    }

    //获取
    public Object get(int index){
        //校验索引
        if(index<0 || index>=size){
            throw new IndexOutOfBoundsException(index+"越界...");
        }

        //用作遍历链表使用
        Node temp = head;
        //遍历链表
        for(int i=0;i<size;i++){ //i作为索引存在
            if(i==index){
                return temp.getData();
            }
            temp= temp.getNext();
        }
        return null;
    }

    /**
     * 添加数据
     * @param value 要添加的数据
     */
    public void add(String value) {
        //创建新节点
        Node newNode = new Node(value,null);

        //判断原链表中是否存在节点
        if(head==null && size==0){
            //不存在节点,新节点就作为链表头节点
            head = newNode;
            //长度+1
            size++;
            return;
        }
        //temp 指向每一个节点,用来遍历
        Node temp = head;
        //存储节点,遍历原链表,找到最后一个节点
        while(temp.getNext()!=null){
            temp = temp.getNext();
        }

        //新节点挂上去
        temp.setNext(newNode);

        //长度+1
        size++;
    }

    //size
    public int size(){
        return this.size;
    }

    //重写toString,把链表中的每一个节点的数据获拼接一个字符串返回
    @Override
    public String toString() {
        //链表中不存在数据,直接返回[]
        if(size==0){
            return "[]";
        }
        //链表中存在数据
        Node temp = head;
        //sb做字符串的拼接
        StringBuilder sb = new StringBuilder("[");
        //遍历链表,获取到每一个节点的数据值,拼接完成字符串返回
        while(true){
            sb.append(temp.getData()).append(", ");
            //没有下一个节点,循环结束
            if(temp.getNext()==null){
                break;
            }
            //存在下一个节点,temp指向下一个节点
            temp= temp.getNext();
        }

        //去除最后多余的", "
        sb.delete(sb.length()-2,sb.length());

        return sb.append("]").toString();
    }
}

//节点
class Node{
    private Object data;
    private Node next;

    public Node(Object data, Node next) {
        this.data = data;
        this.next = next;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    @Override
    public String toString() {
        return "Node{" +
                "data=" + data +
                ", next=" + next +
                '}';
    }
}