04.集合注解反射

集合:

ArrayList的特点:

1.List接口的实现类

2.通常可以根据下标进行操作

3.元素有下标,有序,可重复

4.底层结构是数组,内存空间是连续的

5.增删操作比较慢,查询操作比较快 ( 前提是数据量比较大时 )

6.初始容量为10,扩容以1.5倍扩容

ArrayList示例:

package cn.tedu.collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

/**本类用于ArrayList的相关测试*/
public class TestArrayList {
   
    public static void main(String[] args) {
   
        //1.创建对应的集合对象
        /*底层会自动帮我们们创建数组来存放对象,并且数组的初始容量是10*/
        ArrayList<Integer> list = new ArrayList<>();
        //2.向集合中添加元素,用于测试
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(300);
        list.add(400);
        System.out.println(list);
        //3.测试常用方法
//        list.clear();
//        System.out.println(list);//[]
        System.out.println(list.contains("100"));//false,"100"是String类型,是否包含指定元素"100"
        System.out.println();
        System.out.println(list.get(0));//100,取集合下标为0的元素
        System.out.println(list.indexOf(400));//3,判断元素第一次出现的下标
        System.out.println(list.lastIndexOf(400));//5.判断元素最后一次出现的下标

        /*下面的代码报错,数组下标越界,index:300  size:6
        * 主要是因为List中有两个重载的remove()方法,如果传入的是300
        * 会直接把这个300看作是int类型的index索引,所以如果想指定元素来删除数据
        * 需要把int类型的300手动装箱成Integer类型的300元素*/
        //System.out.println(list.remove(300));//报错,下标越界

        System.out.println(list);
        System.out.println(list.remove(Integer.valueOf(300)));//手动装箱,根据具体元素删除内容,参数为引用类型,int需要手动装箱
        System.out.println(list);
        System.out.println(list.remove(2));//根据下标删除元素
        System.out.println(list);
        System.out.println(list.set(2,777));//修改指定位置处的元素为777
        System.out.println(list);
        System.out.println(list.size());
        System.out.println(list);

        //测试集合间的操作
        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(1);
        list2.add(2);
        list2.add(3);
        list2.add(4);
        System.out.println(list2);//将list2集合中的所有元素添加到list集合的末尾
        list.addAll(list2);//[100,200,777,400,1,2,3,4]
        System.out.println(list);
        list.addAll(0,list2);//将list2集合中的所有元素从list集合的0号位置开始添加
        System.out.println(list);//[1,2,3,4,100,200,777,400,1,2,3,4]

        list.removeAll(list2);//删除list集合中所有属于list2集合的元素
        System.out.println(list);//[100,200,777,400]
        list.add(1);
        System.out.println(list.containsAll(list2));//list集合中是否包含list2的所有元素

        list.retainAll(list2);//取交集,保留list中属于list2的所有元素
        System.out.println(list);//[1]

        ArrayList<Integer> list3 = new ArrayList<>();
        list3.add(1);
        list3.add(2);
        list3.add(3);
        list3.add(4);

        //测试集合的迭代
        /*1.通过for循环
         * 2.高效for循环
         * 3.iterator
         * 4.listIterator*/
        //方式1:因为List集合是有序的,元素是有下标的,所以可以根据下标进行遍历
        //从哪开始:0   到哪结束:list.size()-1    如何变化:++
        for (int i = 0; i < list3.size(); i++) {
   
            System.out.println(list3.get(i));
        }
        System.out.println("========");

        //方式2:因为普通for循环遍历效率低,语法复杂,所以使用高效for循环来遍历
        //格式:for(每轮遍历到的元素的类型  元素名:要遍历的元素){循环体}
        for(Integer n:list3){
   
            System.out.println(n);
        }
        System.out.println("========");

        //方式3:从父接口Collection中继承过来的迭代器
        //1.获取要迭代的集合对应的迭代器
        Iterator<Integer> it = list3.iterator();
        //2.通过迭代器判断是否有下一个元素可以迭代
        while (it.hasNext()){
   
            //3.通过迭代器获取本轮迭代的元素
            System.out.println(it.next());
        }

        System.out.println("=======");
        /*方式4:ListIterator属于List接口独有的迭代器
        Iterator<E>---父接口,常用方法hasNext()和next()
        * ListIterator<E>----子接口---可以使用父接口的功能,除了父接口的功能
        之外还有自己的特有功能,比如逆序遍历,添加元素等,但注意,不常用
        public interface ListIterator<E> extends Iterator<E>*/
        ListIterator<Integer> it2 = list3.listIterator();
        while(it2.hasNext()){
   
            System.out.println(it2.next());
        }
        System.out.println("==========");
        for (int i = list3.size()-1; i >=0 ; i--) {
   
            System.out.println(list3.get(i));
        }

    }
}

LinkedList:

LinkedList的特点:
1.List接口的实现类

2.元素有下标,有序,可重复

3.底层的数据结构是链表,内存空间不连续的

4.通过进行首尾节点的操作比较多

5.增删操作比较快,查询操作比较慢[数据量比较大时]

注意:LinkedList的查询操作也不是都慢,首尾操作还是比较快的

package cn.tedu.collection;
import java.util.LinkedList;
/**本类用于LinkedList的相关测试*/
public class TestLinkedList {
   
    public static void main(String[] args) {
   
        //1.创建集合对象
        LinkedList<String> li = new LinkedList<>();
        //2.添加数据
        li.add("孙悟空");
        li.add("猪八戒");
        li.add("唐三藏");
        li.add("沙师弟");
        li.add("白龙马");
        System.out.println(li);

        //测试LinkedList的独有方法
        li.addFirst("蜘蛛精");//添加首元素
        li.addLast("玉兔精");//添加尾元素
        System.out.println(li);//[蜘蛛精, 孙悟空, 猪八戒, 唐三藏, 沙师弟, 白龙马, 玉兔精]

        System.out.println(li.getFirst());//获取首元素,蜘蛛精
        System.out.println(li.getLast());//获取尾元素,玉兔精
        System.out.println(li.removeFirst());//删除首元素
        System.out.println(li);//[孙悟空, 猪八戒, 唐三藏, 沙师弟, 白龙马, 玉兔精]
        System.out.println(li.removeLast());//删除尾元素
        System.out.println(li);//[孙悟空, 猪八戒, 唐三藏, 沙师弟, 白龙马]

        /*别名:查询系列*/
        System.out.println(li.element());//孙悟空,获取首元素
        System.out.println(li.peek());//孙悟空,获取首元素
        System.out.println(li.peekFirst());//孙悟空,获取首元素
        System.out.println(li.peekLast());//白龙马,获取尾元素

        /*别名:新增系列*/
        System.out.println(li.offer("海绵宝宝"));//添加尾元素
        System.out.println(li);
        System.out.println(li.offerFirst("派大星"));//添加首元素
        System.out.println(li);
        System.out.println(li.offerLast("蟹老板"));//添加尾元素
        System.out.println(li);

        /*别名:移除系列*/
        System.out.println(li.poll());//删除首元素
        System.out.println(li.pollFirst());//删除首元素
        System.out.println(li.pollLast());//删除尾元素
        System.out.println(li);

    }
}

Map集合:

1. Map可以根据键来提取对应的值
2. Map的键不允许重复,如果重复,对应的值会被覆盖
3. Map存放的都是无序的数据
4. Map的初始容量是16,默认的加载因子是0.75

常用方法:

void clear() 从此映射中移除所有映射关系（可选操作） boolean containsKey(Object key) 如果此映射包含指定键的映射关系，则返回 true
boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true
Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的 Set 视图
boolean equals(Object o) 比较指定的对象与此映射是否相等
V get(Object key) 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null
int hashCode() 返回此映射的哈希码值
boolean isEmpty() 如果此映射未包含键-值映射关系，则返回 true
Set keySet() 返回此映射中包含的键的 Set 视图
V put(K key, V value) 将指定的值与此映射中的指定键关联（可选操作）
void putAll(Map<? extends K,? extends V> m)从指定映射中将所有映射关系复制到此映射中（可选操作）
V remove(Object key) 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）
int size() 返回此映射中的键-值映射关系数
Collection values() 返回此映射中包含的值的 Collection 视图

Map的常用方法与迭代:

package cn.tedu.map;
import java.util.*;
/**本类用于测试Map接口*/
public class MapDemo {
   
    public static void main(String[] args) {
   
        //1.创建集合Map对象
        /*Map中的数据要符合映射规则,一定注意要同时指定K和V的数据类型
        * 至于这个K和V具体要设置成什么类型,取决于具体的业务需求*/
        Map<Integer,String> map = new HashMap<>();
        //2.向map集合存入数据,注意方法是put()方法,并且需要存入一对的<K,V>的值
        map.put(9527,"白骨精");
        map.put(9528,"黑熊精");
        map.put(9529,"锂鱼精");
        map.put(9530,"黄毛怪");
        map.put(9527,"女儿国国王");
        map.put(9531,"黑熊精");
        /*1.Map中的K不允许重复,如果重复,后面的value会把前面的value覆盖掉
        * 比如:女儿国国王和白骨精,的key都是9527,白骨精就被覆盖了
        * 2.Map中的value可以重复,比如我们有两个黑熊精*/
        System.out.println(map);

        //3.进行方法测试
        //map.clear();//清空数据
        //System.out.println(map);//{}
        System.out.println(map.isEmpty());//false,判断集合是否为空
        System.out.println(map.size());//获取集合中键值对的对数
        System.out.println(map.containsKey(9527));//true,判断集合是否包含9527的key
        System.out.println(map.containsValue("白骨精"));//false,判断集合是否包含指定的值value
        System.out.println(map);
        System.out.println(map.remove(9529));//根据key删除对应的这一对键值对
        Collection<String> c = map.values();//将Map中所有的value值取出,存入Collection中
        System.out.println(c);

        //4.map集合的迭代方式1
        /*Map的迭代方式1:
        * 遍历map中的数据,但是map本身没有迭代器,所以需要先转换成set集合
        * 用到的方法:keySet():把map中的所有key值存入到set集合中,返回值Set<Key>
        */