Java笔记026-集合/数组、Collection接口、ArrayList、Vector、LinkedList

集合

集合的理解和好处

保存多个数据使用的是数组，分析数组的弊端

数组

1、长度开始必须指定，而且一旦指定，不能更改

2、保存的必须为同一类型的元素

3、使用数组进行增加/删除元素的示意代码-比较麻烦

Person数组扩容示意代码

Person[] pers = new Person[1];//大小是1
pers[0] = new Person();
//增加新的Person对象
Person[] pers2 = new Person[pers.length + 1];//创建新数组
for(){}//拷贝pers数组的元素到pers2
pers2[pers2.length - 1] = new Person();//添加新的对象

集合

1、可以动态保存任意多个对象，使用比较方便！

2、提供了一系列方便的操作对象的方法：add、remove、set、get等

3、使用集合添加，删除新元素的示意代码-简洁

集合的框架体系

Java的集合类很多，主要分为两大类，如图：

package com14.collection_;import java.util.ArrayList;
import java.util.HashMap;/*** @author 甲柒* @version 1.0* @title Collection_* @package com14.collection_* @time 2023/1/13 17:53*/
public class Collection_ {@SuppressWarnings({"all"})public static void main(String[] args) {//解读//1.集合主要是两组(单列集合，双列集合)//2.Collection接口有两个重要的子接口 List Set，他们的实现子类都是单列集合//3.Map接口的实现子类是双列集合，存放的 K-V
//        Collection
//        MapArrayList arrayList = new ArrayList();arrayList.add("jack");arrayList.add("tom");HashMap hashMap = new HashMap();hashMap.put("NO1", "北京");hashMap.put("NO2", "上海");}
}

Collection接口和常用方法

Collection接口实现类的特点

public interface Collection<E> extends lterable<E>

1、Collection实现子类可以存放多个元素，每个元素可以是Object

2、有些Collection的实现类，可以存放重复的元素，有些不可以

3、有些Collection的实现类，有些是有序的(List)，有些不是有序(Set)

4、Collection接口没有直接的实现子类，是通过它的子接口Set和List来实现的

Collection接口和常用方法

1、add //添加单个元素

2、remove //删除指定元素

3、contains //查找元素是否存在

4、size //获取元素个数

5、isEmpty //判断是否为空

6、clear //清空

7、addAll //添加多个元素

8、containsAll //查找多个元素是否都存在

9、removeAll //删除多个元素

10、说明：以ArrayList实现类来演示

package com14.collection_;import java.util.ArrayList;/*** @author 甲柒* @version 1.0* @title CollectionMethod* @package com14.collection_* @time 2023/1/13 18:42*/
public class CollectionMethod {@SuppressWarnings({"all"})public static void main(String[] args) {ArrayList arrayList = new ArrayList();//1、add //添加单个元素arrayList.add("jack");arrayList.add(10);arrayList.add(true);System.out.println("arrayList=" + arrayList);//2、remove //删除指定元素
//        arrayList.remove(0);//删除第一个元素arrayList.remove(true);//指定删除某个元素System.out.println("arrayList=" + arrayList);//3、contains //查找元素是否存在System.out.println(arrayList.contains("jack"));//true//4、size //获取元素个数System.out.println(arrayList.size());//2//5、isEmpty //判断是否为空System.out.println(arrayList.isEmpty());//false//6、clear //清空arrayList.clear();System.out.println("arrayList=" + arrayList);//7、addAll //添加多个元素ArrayList arrayList1 = new ArrayList();arrayList1.add("西游记");arrayList1.add("三国演义");arrayList.addAll(arrayList1);System.out.println("arrayList=" + arrayList);//8、containsAll //查找多个元素是否都存在System.out.println(arrayList.containsAll(arrayList1));//true//9、removeAll //删除多个元素arrayList.add("鬼吹灯");arrayList.removeAll(arrayList1);System.out.println("arrayList=" + arrayList);//鬼吹灯//10、说明：以ArrayList实现类来演示}
}

Collection接口遍历元素方式1-使用Iterator(迭代器)

基本介绍

1、Iterator对象称为迭代器,主要用于遍历Collection集合中的元素。

2、所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了lterator接口的对象，即可以返回一个迭代器。

3、Iterator的结构。[图:]

4、Iterator仅用于遍历集合，Iterator本身并不存放对象。

迭代器的执行原理

Iterator iterator = coll.iterator();//得到一个集合的迭代器

//hasNext():判断是否还有下一个元素

while(iterator.hasNext()){

//next()作用:1.指针下移2.将下移以后集合位置上的元素返回

System.out.println(iterator.next());

}

Iterator接口的方法

注意：在调用iterator.next()方法之前必须要调用iterator.hasNext()进行检测。若不调用，且下一条记录无效，直接调用itterator.next()会抛出NoSuchElementException异常

package com14.collection_;import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;/*** @author 甲柒* @version 1.0* @title CollectionIterator* @package com14.collection_* @time 2023/1/28 17:44*/
public class CollectionIterator {@SuppressWarnings({"all"})public static void main(String[] args) {Collection collection = new ArrayList();collection.add(new Book("三国演义", "罗贯中", 49.9));collection.add(new Book("三体", "刘慈欣", 139.9));collection.add(new Book("流浪地球", "刘慈欣", 69.9));//        System.out.println("collection=" + collection);//现在希望能够遍历collection集合//1.先得到collection对应的迭代器Iterator iterator = collection.iterator();//2.使用while循环遍历
//        while (iterator.hasNext()) {//判断是否还有数据
//            //返回下一个元素，类型是Objext
//            Object obj = iterator.next();
//            System.out.println("obj=" + obj);
//        }//快捷键 快速生成while => itit//显示所有快捷键的快捷键 ctrl + jwhile (iterator.hasNext()) {Object next = iterator.next();System.out.println(next);}//3.当退出while循环后，这时iterator迭代器，指向最后的元素
//        iterator.next();//NoSuchElementException//4.如果希望再次遍历，需要重置迭代器iterator = collection.iterator();System.out.println("=====第2次遍历=====");while (iterator.hasNext()) {Object next = iterator.next();System.out.println(next);}}
}class Book {private String name;private String author;private double price;public Book(String name, String author, double price) {this.name = name;this.author = author;this.price = price;}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getAuthor() {return author;}public void setAuthor(String author) {this.author = author;}public double getPrice() {return price;}public void setPrice(double price) {this.price = price;}@Overridepublic String toString() {return "Book{" +"name='" + name + '\'' +", author='" + author + '\'' +", price=" + price +'}';}
}

Collection接口遍历对象方式2-for循环增强

增强for循环，可以代替iterator迭代器，特点：增强for就是简化版的iterator，本质一样 。只能用于遍历集合或数组。

基本语法

for(元素类型 元素名:集合名或数组名){访问元素
}

案例演示

package com14.collection_;import java.util.ArrayList;
import java.util.Collection;/*** @author 甲柒* @version 1.0* @title CollectionFor* @package com14.collection_* @time 2023/1/28 18:11*/
public class CollectionFor {@SuppressWarnings({"all"})public static void main(String[] args) {Collection collection = new ArrayList();collection.add(new Book("三国演义", "罗贯中", 49.9));collection.add(new Book("三体", "刘慈欣", 139.9));collection.add(new Book("流浪地球", "刘慈欣", 69.9));//解读//1.使用增强for，在Collection集合//2.增强for，底层仍然是迭代器//3.增强for，可以理解成就是简化版的 迭代器遍历for (Object book :collection) {System.out.println(book);}//增强for，也可以直接在数组使用
//        int[] nums = {1, 8, 10, 99};
//        for (int i : nums) {
//            System.out.println("i=" + i);
//        }}
}

练习题

请编写程序

1、创建3个 Dog {name, age} 对象，放入到 ArrayList中，赋给List 引用

2、用迭代器和增强for循环两种方式来遍历

3、重写Dog的toString方法，输出name和age

package com14.collection_;import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;/*** @author 甲柒* @version 1.0* @title CollectionExercise* @package com14.collection_* @time 2023/1/28 18:21*/
public class CollectionExercise {@SuppressWarnings({"all"})public static void main(String[] args) {List list = new ArrayList();list.add(new Dog("大黄", 5));list.add(new Dog("大白", 10));list.add(new Dog("大黑", 3));//先使用for增强for (Object dog : list) {System.out.println("dog=" + dog);}//使用迭代器System.out.println("=======使用迭代器=======");Iterator iterator = list.iterator();while (iterator.hasNext()) {Object dog = iterator.next();System.out.println("dog=" + dog);}}
}/*** 1、创建3个 Dog {name, age} 对象，放入到 ArrayList中，赋给List 引用* 2、用迭代器和增强for循环两种方式来遍历* 3、重写Dog的toString方法，输出name和age*/
class Dog {private String name;private int age;public Dog(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;}@Overridepublic String toString() {return "Dog{" +"name='" + name + '\'' +", age=" + age +'}';}
}

List接口和常用方法

List接口基本介绍

List接口是Collection接口的子接口

1. List集合类中的元素有序(即添加顺序和取出顺序一致)、且可重复

2. List集合中的每个元素都有其对应的顺序索引，即支持索引

3. List容器中的元素都对应一个整数类型的序号记载其在容器中的位置，可以根据序号存取容器中的元素

4. JDK API中List接口的实现类有：

package com14.list_;import java.util.ArrayList;
import java.util.List;/*** @author 甲柒* @version 1.0* @title List_* @package com14.list_* @time 2023/2/20 9:34*/
public class List_ {public static void main(String[] args) {//1.List集合类中元素有序(即添加顺序和取出顺序一致)、且可重复List list = new ArrayList();list.add("tom");list.add("jack");list.add("marry");list.add("lsp");list.add("lsp");System.out.println("list" + list);//2.List集合中的每个元素都有其对应的顺序索引，即支持索引System.out.println(list.get(2));}
}

List接口的常用方法

List集合里添加了一些根据索引来操作集合元素的方法

1. void add(int index, Object ele):在index位置插入ele元素

2. boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来

3. Object get(int index):获取指定index位置的元素

4. int indexOf(Object obj):返回obj在集合中首次出现的位置

5. int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置

6. Object remove(int index):移除指定index位置的元素，并返回此元素

7. Object set(int index, Object ele):设置指定index位置的元素为ele，相当于是替换

8. List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合

package com14.list_;import java.util.ArrayList;
import java.util.List;/*** @author 甲柒* @version 1.0* @title ListMethod* @package com14.list_* @time 2023/2/20 10:36*/
public class ListMethod {@SuppressWarnings({"all"})public static void main(String[] args) {List list = new ArrayList();list.add("渣渣辉");list.add("唐玄奘");
//        void add(int index, Object ele):在index位置插入ele元素//在index = 1的位置插入一个对象list.add(1, "甲柒");System.out.println("list=" + list);
//        boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来List list2 = new ArrayList();list2.add("jack");list2.add("tom");list.addAll(1, list2);System.out.println("list=" + list);
//        Object get(int index):获取指定index位置的元素System.out.println(list.get(2));
//        int indexOf(Object obj):返回obj在集合中首次出现的位置System.out.println(list.indexOf("tom"));
//        int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置list.add("甲柒");System.out.println("list=" + list);System.out.println(list.lastIndexOf("甲柒"));
//        Object remove(int index):移除指定index位置的元素，并返回此元素list.remove(0);System.out.println("list=" + list);
//        Object set(int index, Object ele):设置指定index位置的元素为ele，相当于是替换list.set(1, "沈腾");System.out.println("list=" + list);
//        List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合List list1 = list.subList(0, 2);System.out.println("list1=" + list1);}
}

List接口练习题1

添加10个以上的元素(比如String "hello")，在2号位插入一个元素"甲柒"，获得第5个元素，删除第6个元素，修改第7个元素，在使用迭代器遍历集合，要求：使用List的实现类ArrayList完成。

package com14.list_;import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;/*** @author 甲柒* @version 1.0* @title ListExercise* @package com14.list_* @time 2023/2/20 18:55*/
public class ListExercise {//    添加10个以上的元素(比如String "hello")，
//    在2号位插入一个元素"甲柒"，获得第5个元素，
//    删除第6个元素，修改第7个元素，在使用迭代器遍历集合，
//    要求：使用List的实现类ArrayList完成。@SuppressWarnings({"all"})public static void main(String[] args) {List list = new ArrayList();for (int i = 0; i < 12; i++) {list.add("hello" + i);}System.out.println("List=" + list);
//        在2号位插入一个元素"甲柒"list.add(1, "甲柒");System.out.println("List=" + list);
//        获得第5个元素，System.out.println("第五个元素=" + list.get(4));
//        删除第6个元素list.remove(5);System.out.println("List=" + list);
//        修改第7个元素list.set(6, "java");System.out.println("List=" + list);
//        在使用迭代器遍历集合Iterator iterator = list.iterator();while (iterator.hasNext()) {Object next = iterator.next();System.out.println("next=" + next);}}
}

List三种遍历方式[ArrayList、Linked、Vector]

package com14.list_;import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;/*** @author 甲柒* @version 1.0* @title ListFor* @package com14.list_* @time 2023/2/20 19:12*/
public class ListFor {@SuppressWarnings({"all"})public static void main(String[] args) {
//        List 接口的实现子类  LinkedList
//        List list = new ArrayList();
//        List list = new Vector();List list = new LinkedList();list.add("蟹老板");list.add("章鱼哥");list.add("海绵宝宝");list.add("派大星");//遍历//1.迭代器System.out.println("==========迭代器==========");Iterator iterator = list.iterator();while (iterator.hasNext()) {Object next = iterator.next();System.out.println(next);}System.out.println("==========增强for==========");//2.增强forfor (Object o : list) {System.out.println(o);}System.out.println("==========普通for==========");//3.普通forfor (int i = 0; i < list.size(); i++) {System.out.println(list.get(i));}}
}

List接口练习题2

使用List的实现类添加三本书，并遍历，打印效果如下

要求：

1. 按价格排序，从低到高(使用冒泡排序)

2. 使用ArrayList、LinkedList、Vector三种集合实现

package com14.list_;import java.util.LinkedList;
import java.util.List;/*** @author 甲柒* @version 1.0* @title ListExercise02* @package com14.list_* @time 2023/2/20 19:30*/
@SuppressWarnings({"all"})
public class ListExercise02 {public static void main(String[] args) {
//        List list = new ArrayList();List list = new LinkedList();
//        List list = new Vector();list.add(new Book("红楼梦", 39, "曹雪芹"));list.add(new Book("西游记", 100, "吴承恩"));list.add(new Book("水浒传", 9.9, "施耐庵"));list.add(new Book("三国演义", 88, "罗贯中"));
//        list.add(new Book("红楼梦","39","曹雪芹"));//遍历for (Object o : list) {System.out.println(o);}//冒泡排序sort(list);System.out.println("===排序后===");//遍历for (Object o : list) {System.out.println(o);}}//静态方法public static void sort(List list) {int listSize = list.size();for (int i = 0; i < listSize - 1; i++) {for (int j = 0; j < listSize - 1 - i; j++) {//取出对象BookBook book1 = (Book) list.get(j);Book book2 = (Book) list.get(j + 1);if (book1.getPrice() > book2.getPrice()) {list.set(j, book2);list.set(j + 1, book1);}}}}
}

ArryList的注意事项

1. permits all elements，including null，ArrayList可以加入null，并且多个

2. ArrayList是由数组来实现数据存储的

3. ArrayList基本等同于Vector，除了ArrayList是线程不安全(执行效率高)，在多线程情况下，不建议使用ArrayList

package com14.list_;import java.util.ArrayList;/*** @author 甲柒* @version 1.0* @title ArrayListDetail* @package com14.list_* @time 2023/2/21 19:46*/
@SuppressWarnings({"all"})
public class ArrayListDetail {public static void main(String[] args) {//ArrayList是线程不安全的，源码中没有synchronized/*public boolean add(E e) {ensureCapacityInternal(size + 1);  // Increments modCount!!elementData[size++] = e;return true;}*/ArrayList arrayList = new ArrayList();arrayList.add(null);arrayList.add("jack");arrayList.add(null);System.out.println(arrayList);}
}

ArrayList底层结构和源码分析

ArrayList的底层操作机制源码分析

1、ArrayList中维护了一个Object类型的数组elementData

transient Object[] elementData;//transient表示瞬间，短暂的，表示该属性不会被序列号

2、当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0，第1次添加，则扩容elementData为10，如需再次扩容，则扩容elementData为1.5倍

3、如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如需要扩容，则直接扩容elementData为1.5倍

package com14.list_;import java.util.ArrayList;/*** @author 甲柒* @version 1.0* @title ArrayListSource* @package com14.list_* @time 2023/2/21 21:41*/
@SuppressWarnings({"all"})
public class ArrayListSource {public static void main(String[] args) {//解读//使用无参构造器创建ArrayList对象ArrayList list = new ArrayList();//ArrayList list = new ArrayList(8);//使用for给list集合添加1-10数据for (int i = 1; i <= 10; i++) {list.add(i);}//使用for给list集合添加11-15数据for (int i = 11; i <= 15; i++) {list.add(i);}list.add(100);list.add(200);list.add(null);}
}

Vector底层结构和源码剖析

Vector的基本介绍

1、Vector类的定义说明

2、Vector底层也是一个对象数组，protected Object[] elementData

3、Vector是线程同步的，即线程安全，Vector类的操作方法带有synchronized

4、在开发中，需要线程同步安全时，考虑使用Vector

Vector底层结构和ArrayList的比较

Vector和ArrayList的比较

LinkedList底层结构

LiskedList的全面说明

1. LiskedList底层实现了双向链表和双端队列特点

2. 可以添加任意元素(元素可以重复)，包括null

3. 线程不安全，没有实现同步

LiskedList的底层操作机制

1. LinkedList底层维护了一个双向链表

2. LinkedList中维护了两个属性first和last分别指向首节点和尾节点

3. 每个节点(Node对象)，里又维护了prev、next、item三个属性，其中通过prev指向前一个节点，通过next指向后一个节点，最终实现双链表

4. 所以LinkedList的元素的添加和删除，不是通过数组完成的，相对来说效率较高

5. 模拟一个简单的双链表

package com14.list_;/*** @author 甲柒* @version 1.0* @title LinkedList* @package com14.list_* @time 2023/2/21 22:55*/
public class LinkedList {public static void main(String[] args) {//模拟一个简单的双向链表Node jack = new Node("jack");Node tom = new Node("tom");Node jerry = new Node("jerry");//连接三个结点，形成双向链表//jack -> tom -> jerryjack.next = tom;tom.next = jerry;//jerry -> tom -> jackjerry.pre = tom;tom.pre = jack;Node first = jack;//让first引用指向jack,就是双向链表的头结点Node last = jerry;//让last引用指向hsp,就是双向链表的尾结点//演示，从头到尾进行遍历System.out.println("===从头到尾进行遍历===");while (true) {if (first == null) {break;}//输出first 信息System.out.println(first);first = first.next;}//演示，从尾到头的遍历System.out.println("====从尾到头的遍历====");while (true) {if (last == null) {break;}//输出last 信息System.out.println(last);last = last.pre;}//演示链表的添加对象/数据，是多么的方便//要求，是在 tom --------- 老韩直接，插入一个对象 smith//1. 先创建一个 Node 结点，name 就是 smithNode smith = new Node("smith");//下面就把 smith 加入到双向链表了smith.next = jerry;smith.pre = tom;jerry.pre = smith;tom.next = smith;//让first 再次指向jackfirst = jack;//让first引用指向jack,就是双向链表的头结点System.out.println("===从头到尾进行遍历===");while (true) {if (first == null) {break;}//输出first 信息System.out.println(first);first = first.next;}last = jerry; //让last 重新指向最后一个结点//演示，从尾到头的遍历System.out.println("====从尾到头的遍历====");while (true) {if (last == null) {break;}//输出last 信息System.out.println(last);last = last.pre;}}
}//定义一个Node 类，Node 对象 表示双向链表的一个结点
class Node {public Object item; //真正存放数据public Node next; //指向后一个结点public Node pre; //指向前一个结点public Node(Object name) {this.item = name;}public String toString() {return "Node name=" + item;}
}

LinkedList的增删改查案例

package com14.list_;import java.util.Iterator;
import java.util.LinkedList;/*** @author 甲柒* @version 1.0* @title LInkedListCRUD* @package com14.list_* @time 2023/2/22 20:22*/
@SuppressWarnings({"all"})
public class LInkedListCRUD {public static void main(String[] args) {LinkedList linkedList = new LinkedList();linkedList.add(1);linkedList.add(2);linkedList.add(3);System.out.println("linkedList=" + linkedList);//演示一个删除结点的linkedList.remove(); // 这里默认删除的是第一个结点//linkedList.remove(2);System.out.println("linkedList=" + linkedList);//修改某个结点对象linkedList.set(1, 999);System.out.println("linkedList=" + linkedList);//得到某个结点对象//get(1) 是得到双向链表的第二个对象Object o = linkedList.get(1);System.out.println(o);//999//因为LinkedList 是 实现了List接口, 遍历方式System.out.println("===LinkedList遍历迭代器====");Iterator iterator = linkedList.iterator();while (iterator.hasNext()) {Object next = iterator.next();System.out.println("next=" + next);}System.out.println("===LinkedList遍历增强for====");for (Object o1 : linkedList) {System.out.println("o1=" + o1);}System.out.println("===LinkedList遍历普通for====");for (int i = 0; i < linkedList.size(); i++) {System.out.println(linkedList.get(i));}//源码阅读./* 1. LinkedList linkedList = new LinkedList();public LinkedList() {}2. 这时 linkedList 的属性 first = null  last = null3. 执行 添加public boolean add(E e) {linkLast(e);return true;}4.将新的结点，加入到双向链表的最后void linkLast(E e) {final Node<E> l = last;final Node<E> newNode = new Node<>(l, e, null);last = newNode;if (l == null)first = newNode;elsel.next = newNode;size++;modCount++;}*//*读源码 linkedList.remove(); // 这里默认删除的是第一个结点1. 执行 removeFirstpublic E remove() {return removeFirst();}2. 执行public E removeFirst() {final Node<E> f = first;if (f == null)throw new NoSuchElementException();return unlinkFirst(f);}3. 执行 unlinkFirst, 将 f 指向的双向链表的第一个结点拿掉private E unlinkFirst(Node<E> f) {// assert f == first && f != null;final E element = f.item;final Node<E> next = f.next;f.item = null;f.next = null; // help GCfirst = next;if (next == null)last = null;elsenext.prev = null;size--;modCount++;return element;}*/}
}

ArrayList和LinkedList比较

ArrayList和LinkedList比较

如何选择ArrayList和LinkedList：

1. 如果改查的操作多，选择ArrayList

2. 如果增删的操作多，选择LinkedList

3. 一般来说，在程序中，80%~90%都是查询，因此大部分情况下会选择ArrayList

4. 在一个项目中，根据业务灵活选择，也可以这样，一个模块使用的是ArrayList，另一个模块是LinkedList