集合之Collection家族的 List接口+ 迭代器+泛型

你的名字 2024-04-09 02:46 32阅读 0赞

## 集合之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对象
    		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对象
    		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");
    		
    		//将newList1中所有的元素添加到list末尾
    		list.addAll(newList1);
    		
    		ArrayList<String> newList2 = new ArrayList<>();
    		
    		//利用集合工具类做批量添加
    		Collections.addAll(newList2, "xxx","yyy","zzz");
    		
    		//将newList2中所有的元素添加到list指定下标的位置
    		list.addAll(5, newList2);
    		
    		//清空集合中所有的元素
    		//list.clear();
    		
    		System.out.println("判断集合中是否包含指定元素：" + list.contains("李元芳"));
    		System.out.println("判断集合中是否包含子集合：" + list.containsAll(newList1));
    		
    		System.out.println("获取集合中元素第一次出现的下标：" + list.indexOf("不知火舞"));
    		System.out.println("获取集合中元素第一次出现的下标：" + list.lastIndexOf("不知火舞"));
    		
    		//(注意：不包含元素返回true，包含元素返回false)
    		System.out.println("判断集合中是否不包含元素：" + list.isEmpty());
    		
    		//根据下标删除元素
    		list.remove(4);
    		
    		//根据元素删除元素
    		list.remove("墨子");
    		
    		//去除交集(删除list中包含了newList1中所有的元素)
    		list.removeAll(newList1);
    		
    		//保留交集(保留list中包含了newList2中所有的元素)
    		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("---------------------");
    		
    		//遍历方式1 -- for循环
    		for (int i = 0; i < list.size(); i++) {
        
    			System.out.println(list.get(i));
    		}
    		
    		System.out.println("---------------------");
    		
    		//遍历方式2 -- foreach
    		for (String element : list) {
        
    			System.out.println(element);
    		}
    		
    		System.out.println("---------------------");
    		
    		//遍历方式3 -- Iterator
    		Iterator<String> iterator = list.iterator();
    		while (iterator.hasNext()) {
        
    			//判断是否有可迭代的元素
    			String next =  iterator.next();//返回下一个元素
    			System.out.println(next);
    			
    		}
    		
    		System.out.println("---------------------");
    		
    		//遍历方式4 -- ListIterator
    		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");
    	}
    }

/**
     * E - element - 元素
     * T - type - 类型 
     * R - return - 返回值
     */
    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) {
        
    		// TODO Auto-generated method stub
    		return 0;
    	}
    
    	@Override
    	public void expansion() {
        
    		// TODO Auto-generated method stub
    		
    	}
    
    	@Override
    	public int delete(Student t) {
        
    		// TODO Auto-generated method stub
    		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) {
        
    		// TODO Auto-generated method stub
    		return 0;
    	}
    
    	@Override
    	public void expansion() {
        
    		// TODO Auto-generated method stub
    		
    	}
    
    	@Override
    	public int delete(Book t) {
        
    		// TODO Auto-generated method stub
    		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<A> list = new ArrayList<>();
    		ArrayList<B> list = new ArrayList<>();
    		return list;
    	}
    	
    	//? extends A 表示A类型或A的子类
    	public static ArrayList<?> method02(){
        
    		
    		//	ArrayList<A> list = new ArrayList<>();
    			ArrayList<B> list = new ArrayList<>();
    			return list;
    		}
    	
    	//? super A 表示A类型或A的父类
    	public static ArrayList<? super A> method03(){
        
    //		ArrayList<A> list = new ArrayList<>();
    			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);
    		}
    		
    		//foreach的底层实现：
    		//String element;
    		//for(Iterator<String> it = list.iterator();it.hasNext();System.out.println(element)){
        
    		//	element = it.next();
    		//}
    	}
    }

#### 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("阿珂")) {
        
    				//注意：使用Iterator遍历集合，不要使用集合对象去删除元素
    				//list.remove(element);
    				
    				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);
    		}
    	}
    }