本文介绍了Java集合框架中的Collection接口及其子接口List的基本概念和特点，包括增删查改方法的使用，以及迭代器和增强for循环的遍历方式。还通过代码示例展示了如何操作ArrayList和HashMap，并提供了练习题来巩固知识。
目录
集合基本概念
Java集合的类型很多，主要分为两大类
Collection单列集合
Map双列集合
代码演示：
package idea.chapter14.collection_;
import java.util.ArrayList;
import java.util.HashMap;
/**
* 演示集合的基本介绍
*/
@SuppressWarnings({"all"})
public class Collection_ {
public static void main(String[] args) {
//1. 首先集合主要是分为两组(单列集合 , 双列集合)
//2. Collection 接口有两个重要的子接口 List Set , 他们的实现子类都是单列集合
//3. Map 接口的实现子类 是双列集合，存放的 K-V 也就是键值对
//Collection
//Map
ArrayList arrayList = new ArrayList();
arrayList.add("jack");
arrayList.add("tom");
HashMap hashMap = new HashMap();
hashMap.put("1", "北京");
hashMap.put("2", "上海");
}
}
集合的理解和好处
1)可以动态保存任意多个对象，使用比较方便！
2)提供了一系列方便的操作对象的方法：add、remove、set、get等
3)使用集合添加，删除新元素的示意代码-简洁
Collection接口实现类的特点
public interface Collection<E> extends Iterable<E>
1) collection实现子类可以存放多个元素，每个元素可以是Object
2)有些Collection的实现类，可以存放重复的元素，有些不可以
3)有些Collection的实现类，有些是有序的(List)，有些不是有序(Set)
4)Collection接口没有直接的实现子类，是通过它的子接口Set和List来实现的
Collection接口和常用方法
-
add:添加单个元素
-
remove:删除指定元素
-
contains:查找元素是否存在
-
size：获取元素个数
-
isEmpty:判断是否为空
-
clear：清空
-
addAll:添加多个元素
-
containsAll：查找多个元素是否都存在
-
removeAll：删除多个元素
住：使用ArrayList来演示
代码演示：
package idea.chapter14.collection_;
import java.util.ArrayList;
import java.util.List;
/**
* 演示Collection接口哦的一些常用方法
*/
@SuppressWarnings({"all"})
public class CollectionMethod {
public static void main(String[] args) {
//创建一个ArrayList集合
List list = new ArrayList();
// add:添加单个元素
//这就是集合的特点动态保存任意多个对象，这里我们添加了一个String对象 int 类型 布尔类型
list.add("jack");
list.add(1);
list.add(true);
System.out.println(list);
// remove:删除指定元素
list.remove("jack");
System.out.println(list);
// contains:查找元素是否存在
System.out.println(list.contains(1));//这里返回true因为1在集合中存在
// size：获取元素个数
System.out.println(list.size());//输出的结果是2，因为在上面我们已经删除过了一个元素
// isEmpty:判断是否为空
System.out.println(list.isEmpty());//返回false
// clear：清空
//list.clear();
// addAll:添加多个元素
ArrayList list1 = new ArrayList();
list1.add("tom");
list1.add(2);
list.addAll(list1);
System.out.println(list);
// containsAll：查找多个元素是否都存在
System.out.println(list.containsAll(list1));//这里返回true，因为我们加入的信息都存在
// removeAll：删除多个元素
list.removeAll(list1);
System.out.println(list);
}
}
迭代器
基本介绍
1)Iterator对象称为迭代器，主要用于遍历Collection集合中的元素。
2)所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了lterator接口的对象，即可以返回一个迭代器。
3.lterator 的结构.
4.Iterator 仅用于遍历集合，Iterator本身并不存放对象。
迭代器的执行原理
Iterator iterator = coll.iterator)://得到一个集合的迭代器
//hasNext(0：判断是否还有下一个元素while(iterator.hasNext())(
//next()：①指针下移②将下移以后集合位置上的元素返回
System.out.println(iterator.next());)
注意：在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用，且下一条记录无效，直接调用it.next()会抛出NoSuchElementException异常。
代码演示：
注意：如果我们要第二次遍历，我们要重置一个迭代器才可以。
package idea.chapter14.collection_;
import java.util.ArrayList;
import java.util.Iterator;
/**
* 演示迭代器的基本使用
*/
@SuppressWarnings({"all"})
public class CollectionIterator {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(new Book("三国演义", "罗贯中", 10.1));
list.add(new Book("小李飞刀", "古龙", 5.1));
list.add(new Book("红楼梦", "曹雪芹", 34.6));
//先获取到迭代器
Iterator iterator = list.iterator();
//使用while循环遍历
while (iterator.hasNext()) {//iterator.hasNext()这个方法会判断是否还有数据
Object obj = iterator.next();
System.out.println(obj);
}
//. 当退出while循环后 , 这时iterator迭代器，指向最后的元素
//注意：在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用，且下一条记录无效，直接调用it.next()会抛出NoSuchElementException异常。
// iterator.next();//NoSuchElementException
//4. 如果希望再次遍历，需要重置我们的迭代器
//相当于把我们的指向最后的元素，重新去指回第一个元素，接下来在遍历就可以了
iterator = list.iterator();
System.out.println("第二次遍历");
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;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", author='" + author + '\'' +
", price=" + price +
'}';
}
}for循环增强
Collection接口遍历对象方式2-for循环增强.
增强for循环，可以代替iterator迭代器，特点：增强for就是简化版的iterator，本质一样。只能用于遍历集合或数组。
增强for基本语法
for(元素类型 元素名：集合名或数组名) 访问元素
代码演示：
package idea.chapter14.collection_;
import java.util.ArrayList;
/**
* 演示增强for循环
*/
@SuppressWarnings({"all"})
public class CollectionFor {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(new Book("三国演义", "罗贯中", 10.1));
list.add(new Book("小李飞刀", "古龙", 5.1));
list.add(new Book("红楼梦", "曹雪芹", 34.6));
//2. 增强for， 底层仍然是迭代器
//3. 增强for可以理解成就是简化版本的 迭代器遍历
//4. 快捷键方式 I
for (Object o : list) {
System.out.println(o);
}
//增强for，也可以直接在数组使用
// int[] nums = {1, 8, 10, 90};
// for (int i : nums) {
// System.out.println("i=" + i);
// }
}
}
习题
代码演示：
package idea.chapter14.collection_;
import java.util.ArrayList;
import java.util.Iterator;
@SuppressWarnings({"all"})
public class CollectionExercise {
public static void main(String[] args) {
/*
Collection接口和常用方法
课堂练习
请编写程序CollectionExercise.java
1.创建 3个 Dog (name，age)对象，放入到ArrayList中，赋给 List引用
2.用迭代器和增强for循环两种方式来遍历
3.重写Dog的toString方法，输出name和age
*/
ArrayList list = new ArrayList();
list.add(new Dog("jack", 10));
list.add(new Dog("tom", 20));
list.add(new Dog("mary", 30));
System.out.println("使用迭代器遍历");
//使用迭代器遍历
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println(obj);
}
System.out.println("使用增强for循环遍历");
//使用增强for循环遍历
for (Object o : list) {
System.out.println(o);
}
}
}
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;
}
@Override
public String toString() {
return name + age;
}
}
List接口
List接口基本介绍
List接口是 Collection接口的子接口
1.List集合类中元素有序(即添加顺序和取出顺序一致)、且可重复
2.List集合中的每个元素都有其对应的顺序索引，即支持索引。
3.List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
4.JDK API中List接口的实现类有：常用的有：ArrayList、LinkedList和Vector。
代码演示：
package idea.chapter14.list_;
import java.util.ArrayList;
import java.util.List;
/**
* 演示List接口的基本使用
*/
@SuppressWarnings({"all"})
public class list {
public static void main(String[] args) {
// 1.List集合类中元素有序(即添加顺序和取出顺序一致)、且可重复
// 2.List集合中的每个元素都有其对应的顺序索引，即支持索引。
// 3.List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
//创建一个ArrayList
List list = new ArrayList();
list.add("jack");
list.add("tom");
list.add("mary");
list.add("tom");//这里我们添加了两个tom，因为List集合中的元素，允许重复
System.out.println(list);
//2. List集合中的每个元素都有其对应的顺序索引，即支持索引索引是从0开始的
System.out.println(list.get(3));//因为下标从0开始，所以输出的就是tom
}
}
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 lastlndexOf(Object obj):返回obj在当前集合中末次出现的位置
6.Object remove(int index):移除指定index位置的元素，并返回此元
7.Object set(int index,Object ele):设置指定index位置的元素为ele，相当于是替换.
8.List subList(int fromlndex,int tolndex):返回从fromlndex到tolndex位置的子集合
代码演示：
package idea.chapter14.list_;
import java.util.ArrayList;
import java.util.List;
/**
* 演示List的常用方法
*/
@SuppressWarnings({"all"})
public class ListMethod {
public static void main(String[] args) {
//创建一个集合
List list = new ArrayList();
// 1.void add(int index,Object ele):在index位置插入ele元素
list.add("jack");
list.add("tom");
//这里添加了两个元素
System.out.println(list);
//index,在指定的位置插入两个元素
list.add(1, "mary");
//此时我们在1的位置插入了一个many，那么原来位置的就会，往后移动，那么此时，在集合中，就有三个元素了
System.out.println(list);
// 2.boolean addAll(int index,Collection eles):从index位置开始将eles中的所有元素添加进来
List list1 = new ArrayList();
list1.add("hello");
list1.add("word");
list.add(1, list1);
System.out.println(list);
// 3.Object get(int index):获取指定index位置的元素
//获取下标为3的元素
System.out.println(list.get(3));
// 4.int indexOf(Object obj):返回obj在集合中首次出现的位置
System.out.println(list.indexOf("jack"));
// 5.int lastlndexOf(Object obj):返回obj在当前集合中末次出现的位置
System.out.println(list.lastIndexOf("tom"));
// 6.Object remove(int index):移除指定index位置的元素，并返回此元素
//此时已将将下标为1的元素，删除
System.out.println(list.remove(1));
System.out.println(list);
// 7.Object set(int index,Object ele):设置指定index位置的元素为ele，相当于是替换.
//此时就是将原来下标为1的元素，替换成hello
list.set(1, "hello");
System.out.println(list);
// 8.List subList(int fromlndex,int tolndex):返回从fromlndex到tolndex位置的子集合
//这里返回的就是，集合中所以的元素
//因为该方法，会返回一个子集合，所以，返回的就是从下标为0开始，到集合的最后一个元素，也就是返回整个集合
List list2 = list.subList(0, list.size());
for (Object o : list2) {
System.out.println(o);
}
}
}
List接口练习
第一题
代码演示;
package idea.chapter14.list_;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
@SuppressWarnings({"all"})
public class ListExercise {
public static void main(String[] args) {
/*
添加10个以上的元素(比如String "hello" )，在2号位插入一个元素"jack"，
获得第5个元素，删除第6个元素，修改第7个元素，在使用迭代器遍历集合，
要求:使用List的实现类ArrayList完成。
*/
//创建一个ArrayList集合
List list = new ArrayList();
for (int i = 0; i < 15; i++) {
list.add("hello" + i);
}
list.add(1, "jack");
System.out.println(list.get(5));
list.remove(6);
list.set(6, "many");
//得到迭代器
Iterator iterator = list.iterator();
//使用for循环遍历
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
}
}
第三题
代码演示;
注意这里要向下转型，否则无法使用子类的元素
注意这里在交换的时候，不用定义赋值变量，只需要使用set方法设置即可
package idea.chapter14.list_;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
public class ListExercise02 {
public static void main(String[] args) {
/*
使用list添加三本数对象，要求价格从低到高使用冒泡排序
使用ArrayList LinkedList Vector
*/
//List list = new ArrayList();
//List list = new LinkedList();
List list = new Vector();
list.add(new Book("红楼梦", 100, "曹雪芹"));
list.add(new Book("西游记", 10, "吴承恩"));
list.add(new Book("水浒传", 19, "施耐庵"));
list.add(new Book("三国", 80, "罗贯中"));
//使用冒泡排序
for (int i = 0; i < list.size() - 1; i++) {
for (int j = 0; j < list.size() - 1 - i; j++) {
//注意这里要向下转型，否则无法使用子类的元素
Book book1 = (Book) list.get(j);
Book book2 = (Book) list.get(j + 1);
if (book1.getPrice() > book2.getPrice()) {
//注意这里在交换的时候，不用定义赋值变量，只需要使用set方法设置即可
list.set(j, book2);
list.set(j + 1, book1);
}
}
}
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
}
}
class Book {
private String name;
private double price;
private String author;
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() {
return
"名称:" + name + "\t\t\t" +
"价格:" + price + "\t\t\t" +
"作者:" + author
;
}
}List的三种遍历方式
有三种分别是
迭代器
增强for循环
普通for循环
代码演示：
package idea.chapter14.list_;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* 演示List的三种遍历方式
*/
@SuppressWarnings({"all"})
public class ListFor {
public static void main(String[] args) {
List list = new ArrayList();
list.add("jack");
list.add("tom");
list.add("mary");
//第一种方式使用迭代器
System.out.println("使用迭代器进行遍历");
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
//第二种方式，使用增强for循环遍历，在底层使用的还是迭代器
System.out.println("使用增强for遍历");
for (Object o : list) {
System.out.println(o);
}
//第三种方式，使用普通for循环遍历
System.out.println("使用普通for循环遍历");
for (int i = 0; i < list.size() ; i++) {
System.out.println(list.get(i));
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
