Java集合01¶
1.什么是集合？¶
前面我们保存数据使用的是数组，数组有不足的地方，我们来分析一下：
- 长度开始时必须指定，而且一但指定不能更改
- 保存的必须是同一类型的元素
-
使用数组进行增加/删除元素的很麻烦----重新创建一个数组，将旧数组的元素拷贝过来
-
集合的好处：
- 可以动态地保存任意多个对象，使用比较方便
- 提供了一系列方便的操作对象的方法：add、remove、set、get等
- 使用集合添加、删除新元素简单高效
1.1==集合的框架体系==¶
- 集合主要是两组（单列集合，双列集合）
- Collection接口有两个重要的子接口List和Set，它们的实现子类都是**单列集合**
- Map接口的实现子类 是**双列集合**，存放的是 K-V
例子
package li.collections;
import java.util.*;
public class CollectionsTest {
public static void main(String[] args) {
//Collection
//Map
ArrayList arrayList = new ArrayList();
arrayList.add("jack");//单列
arrayList.add("tony");
HashMap hashMap = new HashMap();
hashMap.put("No1","北京");//双列
hashMap.put("No2","上海");
}
}
2.Collection接口¶
- Collection接口实现类的特点
public interface Collecion<E> extends Iterable<E>
- Collection 实现子类可以存放多个元素，每个元素可以是Object
- Collection的实现类，有些可以存放重复的元素，有些不可以
- Collection的实现类，有些是有序的（List），有些是无序的（Set）
- Collection接口没有直接实现的子类，是通过它的子接口List和Set来实现的
2.1Collection方法¶
- add（）添加单个元素
- remove（）删除指定元素
- contains（）查找元素是否存在
- size（）获取元素个数
- isEmpty（）判断是否为空
- clear（）清空
- addAll（）添加多个元素
- containsAll（）查找多个元素是否都存在
- removeAll（）删除多个元素
例子1：Collection接口不能直接被实例化，因此以实现了接口的子类ArrayList来演示
package li.collections;
import java.util.*;
public class CollectionMethod {
public static void main(String[] args) {
List list = new ArrayList();
//1. add（）添加单个元素
list.add("jack");
list.add(10);//list.add(new Integer(10)); 自动装箱
list.add(true);
System.out.println("list="+list);//list=[jack, 10, true] 注意里面的元素都是对象，非基本数据类型
//2. remove（）删除指定元素
//list.remove(0);//指定删除的索引
//System.out.println("list="+list);//list=[10, true]
list.remove(true);//指定删除某个对象
System.out.println("list="+list);//list=[jack, 10]
//3. contains（）查找元素是否存在
System.out.println(list.contains("jack"));//true
//4. size（）获取元素个数
System.out.println(list.size());//2
//5. isEmpty（）判断是否为空
System.out.println(list.isEmpty());//false
//6. clear（）清空
list.clear();
System.out.println(list);//[] 空的集合
//7. addAll（）添加多个元素
ArrayList list2 =new ArrayList();
list2.add("红楼梦");
list2.add("三国演义");
list.addAll(list2);
System.out.println("list="+list);//list=[红楼梦, 三国演义]
//8. containsAll（）查找多个元素是否都存在
System.out.println(list.containsAll(list2));//true
//9. removeAll（）删除多个元素
list.add("聊斋志异");
list.removeAll(list2);
System.out.println("list="+list);//list=[聊斋志异]
}
}
3.迭代器遍历¶
-
迭代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续再判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式，专业术语称为迭代。
-
基本介绍：
-
Iterator对象称为迭代器，主要用于遍历Collection集合中的元素。
- 所有实现了Collection接口的集合类都有一个iterator（）方法，用以返回一个实现了Iterator接口的对象，即可以返回一个迭代器
-
Iterator仅用于遍历集合，Iterator本身并不存放对象
-
Iterator接口的常用方法如下：
- public E next（）：返回迭代的下一个元素。
- public boolean hasNext（）：如果仍有元素可以迭代，则返回 true。
- default void remove（）：
- 迭代器的执行原理：
PS：在调用iterator.next（）方法之前一定必须要调用iterator.hasNext（）方法来进行检测，若不调用且下一条记录无效则会抛出 NoSuchElementException 异常。
例子：
package li.collections;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionIterator {
@SuppressWarnings({"all"})
public static void main(String[] args) {
Collection col = new ArrayList();
col.add(new Book("三国演义","罗贯中",10.1));
col.add(new Book("小李飞刀","古龙",5.1));
col.add(new Book("红楼梦","曹雪芹",34.6));
System.out.println("col"+col);//col[Book{name='三国演义', author='罗贯中', price=10.1}, Book{name='小李飞刀', author='古龙', price=5.1}, Book{name='红楼梦', author='曹雪芹', price=34.6}]
//现在想要遍历这个col集合
//1.先得到col集合对应的迭代器
Iterator iterator = col.iterator();
//2.使用while循环遍历
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
//3.当退出while循环之后，这使得iterator迭代器指向最后的元素，
// 这时如果再执行iterator.next()就会出现NoSuchElementException异常
//4.如果想要再次遍历集合，则需要重置迭代器
//重置迭代器，这之后就可以再次遍历，实质上是重新创建了一个迭代器对象
iterator = col.iterator();
}
}
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;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", author='" + author + '\'' +
", price=" + price +
'}';
}
}
快捷键：itit
快捷键：Ctrl+j 显示所有快捷键
4.集合增强for¶
-
Collection接口遍历对象的方式1--迭代器遍历 2--for循环增强
-
增强for循环，可以代替iterator迭代器，特点：增强for循环就是简化版的iterator，本质一样。只能用于遍历集合或者数组。
-
基本语法：
for(元素类型 元素名：集合名或数组名){
访问元素
}
例子：
package li.collections;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionFor {
@SuppressWarnings({"all"})
public static void main(String[] args) {
Collection col = new ArrayList();
col.add(new Book("三国演义","罗贯中",10.1));
col.add(new Book("小李飞刀","古龙",5.1));
col.add(new Book("红楼梦","曹雪芹",34.6));
//增强for,用于集合
//增强for底层仍然是迭代器
//因此增强for可以理解成简化版的迭代器
for (Object book:col) {//元素类型 元素名：集合名或数组名
System.out.println("book="+book);
}
//使用增强for，不但可以适用于集合，还可以用于数组
int[] nums ={1,3,8,10};
for (int i:nums){
System.out.println("i="+i);
}
}
}
快捷键：集合名.for
5.List接口¶
List接口是Collection接口的子接口
- List集合类中的元素有序（即添加顺序和取出顺序一致），且可重复
- List集合中的每个元素都有其对应的顺序索引，即支持索引
- List容器中的元素都对应一个整数型序号记载在其容器中的位置，可以根据序号存取容器中的元素
- JDK API中List接口的实现子类有很多，常用的有ArrayList、LinkedList和Vector
5.1List接口的常用方法¶
-
boolean add(int index, E element) 将指定的元素插入此列表中的指定位置（可选操作）
-
boolean addAll(int index, Collection<? extends E> c) 将指定集合中的所有元素插入到此列表中的指定位置（可选操作）
- Obect get(int index) 返回此列表中指定位置的元素
- int indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
- int lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1
- Object remove(int index) 删除该列表中指定位置的元素,并返回此元素（可选操作）
- Object set(int index, E element) 用指定的元素（可选操作）替换此列表中指定位置的元素
- List subList(int fromIndex, int toIndex) 返回从 fromIndex(不含)到 toIndex(不含)位置的子集合：[fromIndex,toIndex)
例子：
package li.collections.list;
import java.util.ArrayList;
import java.util.List;
public class ListMethod {
@SuppressWarnings({"all"})
public static void main(String[] args) {
List list = new ArrayList();
list.add("张三丰");
list.add("贾宝玉");
//boolean add(int index, E element)
//将指定的元素插入此列表中的指定位置（可选操作）
list.add(1,"杨过");//在index=1的位置插入一个对象
System.out.println(list);//[张三丰, 杨过, 贾宝玉]
//boolean addAll(int index, Collection<? extends E> c)
//将指定集合中的所有元素插入到此列表中的指定位置（可选操作）
List list2 = new ArrayList();
list2.add("jack");
list2.add("tom");
list.addAll(1,list2);//在索引1位置插入list2集合的元素
System.out.println(list);//[张三丰, jack, tom, 杨过, 贾宝玉]
//Obect get(int index)
// 返回此列表中指定位置的元素。
//int indexOf(Object o)
//返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
System.out.println(list.indexOf("tom"));//2
//int lastIndexOf(Object o)
//返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1
list.add("杨过");
System.out.println(list);//[张三丰, jack, tom, 杨过, 贾宝玉, 杨过]
System.out.println(list.lastIndexOf("杨过"));//5
//Object remove(int index)
//删除该列表中指定位置的元素,并返回此元素（可选操作）
list.remove(3);
System.out.println(list);//[张三丰, jack, tom, 贾宝玉, 杨过]
//Object set(int index, E element)
//用指定的元素（可选操作）替换此列表中指定位置的元素
list.set(1,"马丽");
System.out.println(list);//[张三丰, 马丽, tom, 贾宝玉, 杨过]
//List subList(int fromIndex, int toIndex)
//返回从 fromIndex(不含)到 toIndex(不含)位置的子集合：[fromIndex,toIndex)
List returnList = list.subList(0,2);
System.out.println(returnList);//[张三丰, 马丽]
}
}
5.2List的三种遍历方式¶
List的三种遍历方式：
- 使用iterator迭代器
- 使用增强for循环
- 使用for循环
例子：
package li.collections.list;
import java.util.*;
public class ListFor {
@SuppressWarnings({"all"})
public static void main(String[] args) {
//List接口的实现子类 Vector LinkedList同理
//List list = new ArrayList();
//List list = new Vector();
List list = new LinkedList();
list.add("jack");
list.add("tom");
list.add("鱼香肉丝");
list.add("北京烤鸭");
//1.使用迭代器
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.print(obj);
}
//2.增强for循环
for (Object obj:list) {
System.out.print(obj);
}
//使用普通for循环
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i));
}
}
}
5.3List排序练习¶
使用List的实现类添加三本图书，并遍历，打印效果如下：
名称：XX 价格：xx 作者：xx
名称：XX 价格：xx 作者：xx
名称：XX 价格：xx 作者：xx
要求：
-
按价格排序，从低到高（使用冒泡排序）
-
要求使用ArrayList、LinkedList、Vector三种集合实现
使用冒泡实现集合的排序
package li.collections.list;
import java.util.ArrayList;
import java.util.List;
@SuppressWarnings("all")
public class ListExercise {
public static void main(String[] args) {
//使用ArrayList,LinkedList、Vector同理
List list = new ArrayList();
list.add(new Book("红楼梦", 65.5, "曹雪芹"));
list.add(new Book("西游记", 48.8, "吴承恩"));
list.add(new Book("三国演义", 55, "罗贯中"));
list.add(new Book("水浒传", 36, "施耐庵"));
System.out.println("====未排序前遍历====");
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();//获取集合的长度
Book book1;
Book book2;
for (int i = 0; i < listSize - 1; i++) {//轮数
for (int j = 0; j < listSize - 1 - i; j++) {//每轮的索引
book1 = (Book) list.get(j);
book2 = (Book) list.get(j + 1);
if (book1.getPrice() > book2.getPrice()) {
list.set(j, book2);
list.set(j + 1, book1);
}
}
}
}
}
class Book {
private String name;
private double price;
private String author;
public Book() {
}
public Book(String name, double price, String author) {
this.name = name;
this.price = price;
this.author = author;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
@Override
public String toString() {//按格式重写toString方法
return "名称：" + name + "\t\t" + "价格：" + price + "\t\t" + "作者：" + author;
}
}
