集合之Collection家族的 List接口+ 迭代器+泛型
一、集合
1.含义
1.集合是Java API所提供的一系列类，可以用于动态存放多个对象 (集合只能存对象)
2.集合与数组的不同在于，集合是大小可变的序列，而且元素类型可以不受限定，只要是引用类型。(集合中不能放基本数据类型，但可以放基本数据类型的包装类)
3.集合类全部支持泛型，是一种数据安全的用法。
2.集合与数组的不同
数组：一旦初始化后长度不可变，元素类型受限定（String类型的数组只能装String的数据），数组可以存储基本数据类型
集合：长度可变的序列，元素类型不受限定（一个集合可以存储多个数据类型的元素），集合只能存储引用数据类型
3.集合框架图
1.Java的集合框架从整体上可以分为两大家族
1.Collection(接口)家族。该接口下的所有子孙均存储的是单一对象。 Add(s)
2.Map(接口)家族。该接口下的所有子孙均存储的是key-value(键值对)形式的数据。Put(key,value)
2.另外还有三个分支，均是为上述两大家族服务的
1.Iterator(迭代器)家族。主要用于遍历Colleciton接口的及其子类而设计
2.Comparator(比较器), 在集合中存储对象时候，用于对象之间的比较
3.Collecitons是工具类。注意该类名带个s，一般就表示工具类。里面提供了N多静态方法，来对Colleciton集合进行操作
二、Collection家族
List接口
1.特点：有序且可重复（因为List接口中添加了许多针对下标操作的方法）
2.ArrayList的使用
1.一个集合对象可以存储多个类型的元素
2.缺点：不方便管理
import java.util.ArrayList;
public class Test01 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add(100);
list.add(123.123);
list.add("abc");
System.out.println(list);
}
}
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.ListIterator;
public class Test02 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("高渐离");
list.add("诸葛亮");
list.add("墨子");
list.add("安吉拉");
list.add("甄姬");
list.add("不知火舞");
list.add("不知火舞");
list.set(3, "李元芳");
String str = list.get(4);
System.out.println("获取指定下标上的元素：" + str);
int size = list.size();
System.out.println("获取元素个数：" + size);
list.add(5,"典韦");
ArrayList<String> newList1 = new ArrayList<>();
Collections.addAll(newList1, "aaa","bbb","ccc");
list.addAll(newList1);
ArrayList<String> newList2 = new ArrayList<>();
Collections.addAll(newList2, "xxx","yyy","zzz");
list.addAll(5, newList2);
System.out.println("判断集合中是否包含指定元素：" + list.contains("李元芳"));
System.out.println("判断集合中是否包含子集合：" + list.containsAll(newList1));
System.out.println("获取集合中元素第一次出现的下标：" + list.indexOf("不知火舞"));
System.out.println("获取集合中元素第一次出现的下标：" + list.lastIndexOf("不知火舞"));
System.out.println("判断集合中是否不包含元素：" + list.isEmpty());
list.remove(4);
list.remove("墨子");
list.removeAll(newList1);
list.retainAll(newList2);
list.set(1, "后裔");
Object[] array = list.toArray();
System.out.println(Arrays.toString(array));
String[] ss = new String[list.size()];
list.toArray(ss);
System.out.println(Arrays.toString(ss));
System.out.println("---------------------");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("---------------------");
for (String element : list) {
System.out.println(element);
}
System.out.println("---------------------");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String next = iterator.next();
System.out.println(next);
}
System.out.println("---------------------");
ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
String next = listIterator.next();
System.out.println(next);
}
}
}
三、泛型
1.泛型的使用
2.注意：
1.泛型只能设置引用数据类型
2.泛型可以设置多个，用逗号隔开
3.需求：模拟ArrayList底层使用泛型的情况
import java.util.ArrayList;
public class Test01 {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<>();
list1.add(100);
ArrayList<String> list2 = new ArrayList<>();
list2.add("abc");
System.out.println("----------------------");
MyArrayList<Integer> myArrayList1 = new MyArrayList<>();
myArrayList1.add(100);
MyArrayList<String> myArrayList2 = new MyArrayList<>();
myArrayList2.add("abc");
System.out.println("-----------------------");
A<String,Integer> a = new A<>();
Integer xxx = a.xxx("abc");
}
}
public class MyArrayList <E>{
public void add(E e){}
}
public class A <T,R>{
public R xxx(T t){
return null;
}
}
4.需求：设置管理系统通用的接口
public class Test01 {
public static void main(String[] args) {
}
}
public class StudentManagerSystem implements IManagerSystem<Student>{
@Override
public int add(Student t) {
return 0;
}
@Override
public void expansion() {
}
@Override
public int delete(Student t) {
return 0;
}
}
public interface IManagerSystem<T> {
public int add(T t);
public void expansion();
public int delete(T t);
}
public class BookManagerSystem implements IManagerSystem<Book>{
@Override
public int add(Book t) {
return 0;
}
@Override
public void expansion() {
}
@Override
public int delete(Book t) {
return 0;
}
}
public interface IManagerSystem<T> {
public int add(T t);
public void expansion();
public int delete(T t);
}
public class Book {
}
5.泛型限定
? 表示任何类型
? extends A： 表示A类型或A的子类
? super A： 表示A类型或A的父类
import java.util.ArrayList;
public class Test01 {
public static void main(String[] args) {
}
public static ArrayList<?> method01(){
ArrayList<B> list = new ArrayList<>();
return list;
}
public static ArrayList<?> method02(){
ArrayList<B> list = new ArrayList<>();
return list;
}
public static ArrayList<? super A> method03(){
ArrayList<Object> list = new ArrayList<>();
return list;
}
}
public class A {
}
public class B extends A {
}
四、迭代器、
1.foreach的底层原理
注意：foreach底层就是使用迭代器去实现的遍历
import java.util.ArrayList;
import java.util.Iterator;
public class Test01 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("程咬金");
list.add("阿珂");
list.add("王昭君");
list.add("刘禅");
list.add("百里守约");
for (String element : list) {
System.out.println(element);
}
}
}
2.Iterator底层实现原理
import java.util.ArrayList;
import java.util.Iterator;
public class Test02 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("程咬金");
list.add("阿珂");
list.add("王昭君");
list.add("刘禅");
list.add("百里守约");
Iterator<String> it = list.iterator();
while (it.hasNext()) {
String element = it.next();
System.out.println(element);
}
}
}
3.使用Iterator遍历集合，在遍历时删除元素
注意：
1.Iterator遍历集合，删除元素必须使用it.remove()
2.Iterator遍历集合，不能添加元素
import java.util.ArrayList;
import java.util.Iterator;
public class Test03 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("程咬金");
list.add("阿珂");
list.add("王昭君");
list.add("刘禅");
list.add("百里守约");
Iterator<String> it = list.iterator();
while (it.hasNext()) {
String element = it.next();
if (element.equals("阿珂")) {
it.remove();
}
}
for (String element : list) {
System.out.println(element);
}
}
}
4.使用ListIterator遍历集合，在遍历时删除元素
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class Test04 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("程咬金");
list.add("阿珂");
list.add("王昭君");
list.add("刘禅");
list.add("百里守约");
ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
String next = listIterator.next();
if (next.equals("刘禅")) {
listIterator.remove();
}
}
for (String element : list) {
System.out.println(element);
}
}
}
5.使用ListIterator遍历集合，在遍历时添加元素
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class Test05 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("程咬金");
list.add("阿珂");
list.add("王昭君");
list.add("刘禅");
list.add("百里守约");
ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
String next = listIterator.next();
if (next.equals("王昭君")) {
listIterator.add("妲己");
}
}
for (String element : list) {
System.out.println(element);
}
}
}
6.使用ListIterator遍历集合，在遍历时替换元素
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class Test06 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("程咬金");
list.add("阿珂");
list.add("王昭君");
list.add("刘禅");
list.add("百里守约");
ListIterator<String> listIterator = list.listIterator();
while (listIterator.hasNext()) {
String next = listIterator.next();
if (next.equals("王昭君")) {
listIterator.set("兰陵王");
}
}
for (String element : list) {
System.out.println(element);
}
}
}
7.使用ListIterator从指定下标开始遍历集合
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class Test07 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("程咬金");
list.add("阿珂");
list.add("王昭君");
list.add("刘禅");
list.add("百里守约");
ListIterator<String> listIterator = list.listIterator(1);
while (listIterator.hasNext()) {
String next = listIterator.next();
System.out.println(next);
}
}
}
8.使用ListIterator倒叙遍历集合
import java.util.ArrayList;
import java.util.ListIterator;
public class Test08 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("程咬金");
list.add("阿珂");
list.add("王昭君");
list.add("刘禅");
list.add("百里守约");
ListIterator<String> listIterator = list.listIterator(list.size());
while (listIterator.hasPrevious()) {
String previous = listIterator.previous();
System.out.println(previous);
}
}
}
