2021-04-20

一，泛型的通用性
–1，测试
package cn.tedu.util;
//测试 泛型的通用性
public class Test1 {
public static void main(String[] args) {
//1,打印数组里的数据
String[] a = {“杨幂”,“周笔畅”,“Anglelababa”,“迪丽热巴”,“刘沛霞”};
print(a);
Integer[] b = {1,2,3,4,5};
print(b);
}
//泛型方法:返回值前+参数里
public static void print(E[] x){
//高效for循环/foreach循环:两个使用场景:数组|Collection集合
//语法:for( 遍历得到的数据的类型 变量名 : 要遍历的是啥){循环体}
for( E s : x){
System.out.println(s);
}

	        //普通for循环
	        for (int i = 0; i < x.length; i++) {
	            System.out.println(x[i]);
	        }
	    }

	}

二,Collection接口
–1,概述
Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称 为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允 许。一些 collection 是有序的，而另一些则是无序的。
–2,常见方法
boolean add(E e)
确保此 collection 包含指定的元素（可选操作）。
boolean addAll(Collection<? extends E> c)
将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
void clear()
移除此 collection 中的所有元素（可选操作）。
boolean contains(Object o)
如果此 collection 包含指定的元素，则返回 true。
boolean containsAll(Collection<?> c)
如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean equals(Object o)
比较此 collection 与指定对象是否相等。
int hashCode()
返回此 collection 的哈希码值。
boolean isEmpty()
如果此 collection 不包含元素，则返回 true。
Iterator iterator()
返回在此 collection 的元素上进行迭代的迭代器。
boolean remove(Object o)
从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
boolean removeAll(Collection<?> c)
移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
boolean retainAll(Collection<?> c)
仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
int size()
返回此 collection 中的元素数。
Object[] toArray()
返回包含此 collection 中所有元素的数组。
–3,测试
package cn.tedu.util;

	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.Iterator;

	//测试 Collection接口
	public class Test2 {
	    public static void main(String[] args) {
	        //1,创建对象
	        Collection<Integer> c = new ArrayList<>();
	        //2,调用方法
	        c.add(100);//添加元素，要符合泛型类型的检查
	        c.add(200);//自动装箱
	        c.add(300);
	        System.out.println(c);
	//        c.clear();//清空集合
	        System.out.println( c.contains(200) );//判断c里是否包含200元素
	        System.out.println( c.equals("jack") );//判断c是否和"jack"相等
	        System.out.println( c.hashCode() );//获取哈希码值
	        System.out.println( c.isEmpty() );//判断c是否为空
	        System.out.println( c.remove(100) );//移除100元素
	        System.out.println( c.size() );//获取集合里元素的个数
	        //Object[]可以存的数据类型丰富，很通用
	        Object[] o =  c.toArray();//把c里的数据存入Object[]
	        System.out.println( Arrays.toString(o) );
	        Object[] o2 ={null,1,1.1,"jack"};
	        //迭代集合中的元素
	        // 方式1：Iterator<E> iterator()
	        Iterator<Integer> it = c.iterator();
	        while (it.hasNext()){//hasNext()判断有没有数据
	            Integer data = it.next();//获取数据
	            System.out.println(data);
	        }
	        // 方式2： foreach的使用场景：数组|Collection集合
	        for (Integer z : c) {
	            System.out.println(z);
	        }

	        //集合间的操作--了解
	        Collection<Integer> c2 = new ArrayList<>();
	        c2.add(100);
	        c2.add(200);
	        System.out.println( c.addAll(c2) );//把c2加到c里
	        System.out.println(c);//[200, 300, 100, 200, 300]
	        System.out.println( c.containsAll(c2) );//判断c里包含c2吗
	//        System.out.println( c.removeAll(c2) );//移除c和c2的交集
	        System.out.println( c.retainAll(c2) );//保留c和c2的交集
	    }
	}

三，List接口
–1，概述
有序，有索引，可以重复。
可以根据索引查询/插入/删除/修改
是一个Collection的子接口，可以用父接口的功能，也可以进行扩展。
–2，方法们
–继承自父接口Collection的
–自己扩展的
void add(int index, E element)
在列表的指定位置插入指定元素（可选操作）。
boolean addAll(int index, Collection<? extends E> c)
E get(int index)
返回列表中指定位置的元素。
int indexOf(Object o)
返回此列表中第一次出现的指定元素的索引
int lastIndexOf(Object o)
返回此列表中最后出现的指定元素的索引
ListIterator listIterator()
返回此列表元素的列表迭代器（按适当顺序）。
E remove(int index)
移除列表中指定位置的元素（可选操作）。
E set(int index, E element)
用指定元素替换列表中指定位置的元素（可选操作）。
List subList(int fromIndex, int toIndex)

--3，测试
	package cn.tedu.util;
	import java.util.ArrayList;
	import java.util.Iterator;
	import java.util.List;
	import java.util.ListIterator;

	//测试 List接口
	public class Test3 {
	    public static void main(String[] args) {
	        //1,创建对象
	        List<Integer> list = new ArrayList<>();
	        //2,调用方法
	            //继承自父接口Collection的
	//        boolean add(E e)
	        list.add(100);
	        list.add(200);
	        list.add(300);
	        list.add(100);
	        list.add(200);
	        list.add(null);
	        list.add(null);
	        //[100, 200, 300, 100, 200, null, null]
	        //特点:有序 + 可以重复 + 可以存多个null
	        System.out.println(list);
	//        void clear()
	//        boolean contains(Object o)
	//        boolean containsAll(Collection<?> c)
	//        boolean equals(Object o)
	//        int hashCode()
	//        boolean isEmpty()
	//        boolean remove(Object o)
	//        int size()
	//        Object[] toArray()
	//        Iterator<E> iterator()
	        //自己扩展的
	        list.add(0,10);//在指定下标位置添加新元素
	//[10, 100, 200, 300, 100, 200, null, null]
	        System.out.println( list.get(3) );//获取下标为3对应的元素
	        System.out.println( list.indexOf(200) );//获取200元素第一次出现的下标
	        System.out.println( list.lastIndexOf(200) );//获取200元素最后一次出现的下标
	        System.out.println( list.remove(1) );//移除1下标处的元素
	        System.out.println( list.set(5,666) );//把5下标处的元素换成666
	        List<Integer> list2 = list.subList(2,6);//从2开始到6结束,截取子List[2,6)

	        //移除指定的元素
	        //[10, 200, 300, 100, 200, 666, null]
	//      System.out.println( list.remove(2) );//按下标移除
	        //直接移除元素,传入基本类型的参数会当做下标用
	        System.out.println( list.remove(new Integer(300) ) );
	        //TODO 迭代List接口中元素的方式
	        //方式1:: 继承自父接口的方法Iterator<E> iterator()
	        System.out.println();
	        Iterator<Integer> it = list.iterator();
	        while (it.hasNext()){//判断有没有元素
	            Integer data = it.next();//获取元素
	            System.out.println(data);
	        }
	        //方式2:: List有下标,根据下标遍历for
	        for (int i = 0; i < list.size(); i++) {
	            Integer data = list.get(i);//根据下标获取
	            System.out.println(data);
	        }
	        //方式3:: foreach
	        for (Integer x : list) {
	            System.out.println(x);
	        }
	        //方式4:: List子接口的扩展方法ListIterator<E> listIterator()
	        ListIterator<Integer> it2 = list.listIterator();
	        //顺序遍历
	        while(it2.hasNext()){
	            Integer data = it2.next();
	            System.out.println(data);
	        }
	        //逆向遍历
	        while (it2.hasPrevious()){//判断前面有元素吗
	            Integer data = it2.previous();//获取前面的元素
	            System.out.println("data = " + data);
	        }
	        //TODO 面试题1： 数组 和集合 的区别
	        //TODO 面试题2： List接口的迭代方式
	        //TODO 面试题3： iterator()和listIterator()的区别
	        //前者是父接口Iterator提供的，后者是ListIterator子接口提供的
	        //ListIterator子接口可以使用父接口的所有功能也进行了扩展
	        //扩展了逆向遍历（必须先顺序遍历）
	    }
	}

四，ArrayList实现类
–1，概述
是List接口的实现类。拥有和List接口一样的特点。
底层是数组。
–2，创建对象
ArrayList()
构造一个初始容量为 10 的空列表。
–3，测试
package cn.tedu.util;

	import java.util.ArrayList;
	import java.util.Arrays;

	//测试 ArrayList接口
	public class Test4 {
	    public static void main(String[] args) {
	        //1,创建对象
	 //本质上底层会维护一个Object[] elementData,用来存放入ArrayList中的数据
	    //1,jdk1.6,当创建ArrayList对象时,底层会初始化一个数组,默认容量是10.
	        //数据多的时候,超过10个时,会自动扩容:旧容量+旧容量/2
	        //jdk1.8,但是,一开始是空数组.第一次添加数据时才开始扩充容量.
	        ArrayList<String> list = new ArrayList();
	//2,add被调用时,拿着数据,直接存入了Object[]中.
	        list.add("1");//存入数组里的0下标处
	        list.add("2");//存入数组里的1下标处....
	        list.add("3");
	        list.add("1");
	        list.add(null);
	        //特点::有序 + 有下标 + 可重复
	        System.out.println(list);
	        //2,调用方法
	            //继承自Collection接口的
	            //继承自List接口的

	        //TODO 模拟ArrayList
	        //创建对象时,会创建Object数组并初始化
	        Object[] elementData = {};//1.8的写法
	        elementData = new Object[10];//1.6的写法
	        //add()添加数据时,把数据存入数组里
	        elementData[0] = "1";
	        elementData[1] = "2";
	        elementData[2] = "3";
	        elementData[3] = "1";
	        //数据的长度<=10,不会扩容,>10时会自动扩容,是以前的1.5倍
	        elementData = Arrays.copyOf(elementData,15);
	        elementData = Arrays.copyOf(elementData,22);