集合
集合的理解和好处
保存多个数据使用的是数组,分析数组的弊端
数组
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接口的子接口
List集合类中的元素有序(即添加顺序和取出顺序一致)、且可重复
List集合中的每个元素都有其对应的顺序索引,即支持索引
List容器中的元素都对应一个整数类型的序号记载其在容器中的位置,可以根据序号存取容器中的元素
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集合里添加了一些根据索引来操作集合元素的方法
void add(int index, Object ele):在index位置插入ele元素
boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
Object get(int index):获取指定index位置的元素
int indexOf(Object obj):返回obj在集合中首次出现的位置
int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
Object remove(int index):移除指定index位置的元素,并返回此元素
Object set(int index, Object ele):设置指定index位置的元素为ele,相当于是替换
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的实现类添加三本书,并遍历,打印效果如下
要求:
按价格排序,从低到高(使用冒泡排序)
使用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的注意事项
permits all elements,including null,ArrayList可以加入null,并且多个
ArrayList是由数组来实现数据存储的
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的全面说明
LiskedList底层实现了双向链表和双端队列特点
可以添加任意元素(元素可以重复),包括null
线程不安全,没有实现同步
LiskedList的底层操作机制
LinkedList底层维护了一个双向链表
LinkedList中维护了两个属性first和last分别指向首节点和尾节点
每个节点(Node对象),里又维护了prev、next、item三个属性,其中通过prev指向前一个节点,通过next指向后一个节点,最终实现双链表
所以LinkedList的元素的添加和删除,不是通过数组完成的,相对来说效率较高
模拟一个简单的双链表
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:
如果改查的操作多,选择ArrayList
如果增删的操作多,选择LinkedList
一般来说,在程序中,80%~90%都是查询,因此大部分情况下会选择ArrayList
在一个项目中,根据业务灵活选择,也可以这样,一个模块使用的是ArrayList,另一个模块是LinkedList