Java-10集合

最新推荐文章于 2022-07-13 15:30:26 发布

Jerry&Crj

最新推荐文章于 2022-07-13 15:30:26 发布

阅读量235

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/weixin_42348733/article/details/115816429

版权

Java 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

文章目录

Java-09集合

1.Java集合框架概述

Collection接口：单列数据，定义了存取一组对象的方法的集合
1. List：元素有序、可重复的集合
2. Set：元素无序、不可重复的集合
Map接口：双列数据，保存具有映射关系“key-value对”的集合

Collection接口继承树

Map接口继承树

2.`Collection`接口方法

方法	功能
`add(Object obj)`	添加
`addAll(Collection coll)`	添加
`int size()`	获取有效元素的个数
`void clear()`	清空集合
`boolean isEmpty()`	是否为空集合
`boolean contains(Object obj)`	判断当前集合中是否包含obj
`containsAll(Collection coll1)`	判断形参coll1中的所有元素是否都存在于当前集合中
`remove(Object obj)`	从当前集合中删除obj元素
`removeAll(Collection coll1)`	从当前集合中删除coll1中所有的元素；（差集）
`retainAll(Collection coll1)`	交集：获取当前集合和coll1集合的交集，并返回给当前集合
`equals(Object obj)`	要想返回true,需要当前集合和形参集合中的元素都相同，按顺序
`hashCode()`	返回当前对象的哈希值
`toArray():`	集合 --> 数组
`asList()`	数组—>集合

3.`Iterator`迭代器接口

3.1 注意

Iterator 仅用于遍历集合，Iterator 本身并不提供承装对象的能力。如果需要创建 Iterator 对象，则必须有一个被迭代的集合。
集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用，且下一条记录无效，直接调用it.next()会抛出NoSuchElementException异常。

Iterator iterator = coll.iterator();
//hasNext():判断是否还有下一个元素
while(iterator.hasNext()){
//next():①指针下移 ②将下移以后集合位置上的元素返回
System.out.println(iterator.next());
}

3.2 在迭代器中调用其`remove()`方法

Iterator可以删除集合的元素，但是是遍历过程中通过迭代器对象的remove方法，不是集合对象的remove方法。
如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，再调用remove都会报IllegalStateException。

4.`Collection`子接口一：`List`

4.1 初见

鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组
List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector。

4.2 方法

4.2.1 增

方法名	功能
`add(Object obj)`	list.add(123);
`void add(int index,E element)`	在列表的指定位置插入指定元素（可选操作）。将当前处于该位置的元素（如果有的话）和所有后续元素向右移动（在其索引中加 1）
`boolean addAll(int index, Collection eles)`	从index位置开始将eles中的所有元素添加进来

4.2.2 删

方法名	功能
`Object remove(int index)`	移除指定index位置的元素，并返回此元素

4.2.3 改

方法名	功能
`Object set(int index, Object ele)`	设置指定index位置的元素为ele

4.2.4 查

方法名	功能
`Object get(int index)`	获取指定index位置的元素

4.2.5 其他方法

方法名	功能
`int indexOf(Object obj)`	返回obj在集合中首次出现的位置
`int lastIndexOf(Object obj)`	返回obj在当前集合中末次出现的位置
`List subList(int fromIndex, int toIndex)`	返回从fromIndex到toIndex位置的子集合

Collection coll = new ArrayList();
        //add(Object e) :讲元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add("123");
        coll.add(new Date());

        //size():获取添加的元素的个数
        System.out.println(coll.size());//4


        //addAll():
        Collection coll1 = new ArrayList();
        coll1.add("456");
        coll1.addAll(coll);
        System.out.println(coll1.size());//5
        System.out.println(coll1.toString());//[456, AA, BB, 123, Tue Jan 26 17:33:59 CST 2021]

        //clear():清空集合元素
        coll.clear();

        //isEmpty():判断当前集合是否为空
        System.out.println(coll.isEmpty());

@Test
public void test1(){
    ArrayList list = new ArrayList();
    list.add(123);
    list.add(456);
    list.add("AA");
    list.add(new Person("Tom",12));
    list.add(456);
    System.out.println(list);
    //void add(int index, Object ele):在index位置插入ele元素
    list.add(1,"guo");
    System.out.println(list);

    //boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
    List list1 = Arrays.asList(1,2,3);
    list.addAll(list1);
    System.out.println(list.size());//9

    //Object get(int index):获取指定index位置的元素
    System.out.println(list.get(1));
}
@Test
public void test2(){
    ArrayList list = new ArrayList();
    list.add(123);
    list.add(456);
    list.add("AA");
    list.add(new Person("Tom",12));
    list.add(456);
    System.out.println(list);

    //int indexOf(Object obj):返回obj在集合中首次出现的位置 没有找到就返回-1
    int index = list.indexOf(456);
    System.out.println(index);

    //int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
    int list1 = list.lastIndexOf(456);
    System.out.println(list1);

    //Object remove(int index):移除指定index位置的元素，并返回此元素
    Object obj = list.remove(0);
    System.out.println(obj);
    System.out.println(list);

    //Object set(int index, Object ele):设置指定index位置的元素为ele
    list.set(1,"CC");
    System.out.println(list);

    //List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
    List list2 = list.subList(2, 4);
    System.out.println(list);
    System.out.println(list2);
}

4.2.6 LinkedList

1.初见

LinkedList：双向链表，内部没有声明数组，而是定义了Node类型的first和last，用于记录首末元素。同时，定义内部类Node，作为LinkedList中保存数据的基本结构。Node除了保存数据，还定义了两个变量：

prev变量记录前一个元素的位置
next变量记录下一个元素的位置

private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}

2.方法(上面的方法也都还有，列举一些新加的方法)

方法	功能
`void addFirst(Object obj)`	在该列表开头插入指定的元素。
`void addLast(Object obj)`	将指定的元素追加到此列表的末尾。
`Object getFirst()`	返回此列表中的第一个元素。
`Object getLast()`	返回此列表中的最后一个元素。
`Object removeFirst()`	从此列表中删除并返回第一个元素。
`Object removeLast()`	从此列表中删除并返回最后一个元素。

4.2.7 Vector

1. 初见

Vector 是一个古老的集合，JDK1.0就有了。大多数操作与ArrayList 相同，区别之处在于Vector是线程安全的。
在各种list中，最好把ArrayList作为缺省选择。当插入、删除频繁时，使用LinkedList；Vector总是比ArrayList慢，所以尽量避免使用。

2. 方法(上面的方法也都还有，列举一些新加的方法)

方法	功能
`void addElement(Object obj)`	将指定的组件添加到此向量的末尾，将其大小增加1。
`void insertElementAt(Object obj,int index)`	在指定的index插入指定对象作为该向量中的一个 `index` 。
`void setElementAt(Object obj,int index)`	设置在指定的组件 `index`此向量的要指定的对象。
`void removeElement(Object obj)`	从此向量中删除参数的第一个（最低索引）出现次数。
`void removeAllElements()`	从该向量中删除所有组件，并将其大小设置为零。

5.`Collection`子接口一：`Set` 存储无序的、不可重复的数据

5.1 初见

Set接口是Collection的子接口，set接口没有提供额外的方法
Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败。
Set 判断两个对象是否相同不是使用 == 运算符，而是根据 equals() 方法

1.无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的

2.不可重复性：保证添加的元素按照equals()判断时，不能返回true，即相同的元素只能添加一个

5.2 HashSet

HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时都使用这个实现类。
HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存取、查找、删除性能。

5.2.1 特点

不能保证元素的排列顺序
HashSet 不是线程安全的
集合元素可以是 null

5.2.2 注意

HashSet 集合判断两个元素相等的标准：两个对象通过 hashCode() 方法比较相等，并且两个对象的 equals() 方法返回值也相等。
对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则。即：“相等的对象必须具有相等的散列码”。

5.3 LinkedHashSet

5.3.1 特点

LinkedHashSet 是 HashSet 的子类
LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。
LinkedHashSet插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。
LinkedHashSet 不允许集合元素重复。

@Test
    public void test1(){
        Set set = new HashSet();
        set.add(456);
        set.add(123);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new User("Tom",12));
        set.add(new User("Tom",12));
        set.add(129);

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }


    }


    //LinkedHashSet的使用
    //LinkedHashSet作为HashSet的子类，在添加数据的同时，还维护了两个引用，记录此数据前一个数据和后一个数据
    //优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet

    @Test
    public void test2(){
        Set set = new LinkedHashSet();
        set.add(456);
        set.add(123);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new User("Tom",12));
        set.add(new User("Tom",12));
        set.add(129);

        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

5.4 TreeSet

TreeSet 是 SortedSet 接口的实现类，TreeSet 可以确保集合元素处于排序状态。
TreeSet底层使用红黑树结构存储数据

5.4.1 方法

方法名	功能
`Comparator comparator()`	返回用于对该集合中的元素进行排序的比较器，或`null，`
`Object first()`	返回此集合中当前的第一个（最低）元素。
`Object last()`	返回此集合中当前的最后（最高）元素。
`Object lower(Object e)`	返回这个集合中最大的元素严格小于给定的元素，如果没有这样的元素，则返回 `null` 。
`Object higher(Object e)`	返回严格大于给定元素的该集合中的最小元素，如果没有此元素则返回 `null` 。
`SortedSet subSet(fromElement, toElement)`	返回此集合的部分的视图，其元素的范围从 `fromElement` （含）到 `toElement` ，排他。
`SortedSet headSet(toElement)`	返回该集合的部分的视图，其元素小于（或等于，如果 `inclusive`为真） `toElement` 。
`SortedSet tailSet(fromElement)`	返回此组件的元素大于或等于 `fromElement`的部分的视图。

@Test
    public void test1(){
        TreeSet set = new TreeSet();
        //不能添加不同类的对象：java.lang.ClassCastException
//        set.add(123);
//        set.add(456);
//        set.add("AA");
//        set.add("BB");
        //举例一：
//        set.add(34);
//        set.add(1);
//        set.add(-9);
//        set.add(new User("Tom",20));

        //举例二：
        set.add(new User("Tom",12));
        set.add(new User("Jerry",32));
        set.add(new User("Jim",1));
        set.add(new User("Mike",562));
        set.add(new User("Jack",5));
        set.add(new User("Jack",12));

        System.out.println(set);
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
    @Test
    public void test2(){
        Comparator com = new Comparator() {
            //按照年龄从小到大排列
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User u1 = (User)o1;
                    User u2 = (User)o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }else {
                    throw new RuntimeException("类型不匹配");
                }
            }
        };
        TreeSet set = new TreeSet(com);
        set.add(new User("Tom",12));
        set.add(new User("Jerry",32));
        set.add(new User("Jim",1));
        set.add(new User("Mike",562));
        set.add(new User("Jack",5));
        set.add(new User("Jack",12));
    }

5.4.2 定制排序

public void test2(){
        Comparator com = new Comparator() {
            //按照年龄从小到大排列
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User u1 = (User)o1;
                    User u2 = (User)o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }else {
                    throw new RuntimeException("类型不匹配");
                }
            }
        };
        TreeSet set = new TreeSet(com);
        set.add(new User("Tom",12));
        set.add(new User("Jerry",32));
        set.add(new User("Jim",1));
        set.add(new User("Mike",562));
        set.add(new User("Jack",5));
        set.add(new User("Jack",12));
    }

6.`Map`接口

6.1 初见

Map与Collection并列存在。用于保存具有映射关系的数据:key-value
Map 中的 key 和 value 都可以是任何引用类型的数据
Map 中的 key 用Set来存放，不允许重复，即同一个 Map 对象所对应的类，须重写hashCode()和equals()方法
常用String类作为Map的“键”
key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value
Map接口的常用实现类：HashMap、TreeMap、LinkedHashMap和 Properties。其中，HashMap是 Map 接口使用频率最高的实现类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GLHvnjx0-1618705119655)(C:\Users\HP\AppData\Roaming\Typora\typora-user-images\image-20210410101418311.png)]

6.2 方法

6.2.1 添加、修改

方法名	功能
`Object put(Object key,Object value)`	将指定key-value添加到(或修改)当前map对象中
`void putAll(Map m)`	将m中的所有key-value对存放到当前map中

6.2.2 删除

方法名	功能
`Object remove(Object key)`	移除指定key的key-value对，并返回value
`void clear()`	清空当前map中的所有数据

6.2.3 查询操作

方法名	功能
`Object get(Object key)`	获取指定key对应的value
`boolean containsKey(Object key)`	是否包含指定的key
`boolean containsValue(Object value)`	是否包含指定的value
`int size()`	返回map中key-value对的个数
`boolean isEmpty()`	判断当前map是否为空
`boolean equals(Object obj)`	判断当前map和参数对象obj是否相等

6.2.4 元视图操作

方法名	功能
`Set keySet()`	返回所有key构成的Set集合
`Collection values()`	返回所有value构成的Collection集合
`Set entrySet()`	返回所有key-value对构成的Set集合

方法名	功能
`Object put(Object key,Object value)`	将指定key-value添加到(或修改)当前map对象中
`void putAll(Map m)`	将m中的所有key-value对存放到当前map中

@Test
    public void test1(){

        Map map = new HashMap();
        //添加
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",56);
        //本质上成了修改了，相同的key了就修改了
        map.put("AA",87);
        System.out.println(map);

        Map map1 = new HashMap();
        map1.put("CC",123);
        map1.put("DD",123);
        map.putAll(map1);
        System.out.println(map);

        //remove(Object key)
        Object value = map.remove("CC");
        System.out.println(value);
        System.out.println(map);

        //void clear()：清空当前map中的所有数据
        map.clear();
        System.out.println(map);
        System.out.println(map.size());
    }



/*  元素查询的操作：
*  Object get(Object key)：获取指定key对应的value
*  boolean containsKey(Object key)：是否包含指定的key
*  boolean containsValue(Object value)：是否包含指定的value
*  int size()：返回map中key-value对的个数
*  boolean isEmpty()：判断当前map是否为空
*  boolean equals(Object obj)：判断当前map和参数对象obj是否相等
*/
    @Test
    public void test2(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",56);
        //Object get(Object key)：获取指定key对应的value
        System.out.println(map.get(45));

        // boolean containsKey(Object key)：是否包含指定的key
        boolean bb = map.containsKey("BB");
        System.out.println(bb);

        //boolean containsValue(Object value)：是否包含指定的value
        boolean b = map.containsValue(123);
        System.out.println(b);

        //boolean isEmpty()：判断当前map是否为空
        System.out.println(map.isEmpty());//本质看的是size(看源码中的HashMap)

        //boolean equals(Object obj)：判断当前map和参数对象obj是否相等    所有的内容都一样才是true
        Map map1 = new HashMap();
        map1.put("AA",123);
        map1.put(45,123);
        map1.put("BB",56);
        boolean b1 = map.equals(map1);
        System.out.println(b1);
    }

/*  元视图操作的方法：
*  Set keySet()：返回所有key构成的Set集合
*  Collection values()：返回所有value构成的Collection集合
*  Set entrySet()：返回所有key-value对构成的Set集合
*/
    @Test
    public void test3(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put(45,1234);
        map.put("BB",56);

        //遍历所有的key集
        Set set = map.keySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println();

        //遍历所有的value集
        Collection values = map.values();
        for (Object obj :
                values) {
            System.out.println(obj);
        }


        System.out.println();
        //遍历所有的key-value集 entrySet():
        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            //entrySet集合中的元素都是entry
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey()+":"+entry.getValue());

        }


//        方式二
        Set KeySet = map.keySet();
        Iterator iterator2 = KeySet.iterator();
        while (iterator2.hasNext()){
            Object key = iterator2.next();
            Object value = map.get(key);
            System.out.println(key + "::" + value);
        }
    }

6.3 HashMap

6.3.1 初见

HashMap是 Map 接口使用频率最高的实现类。
允许使用null键和null值，与HashSet一样，不保证映射的顺序。
所有的key构成的集合是Set:无序的、不可重复的。所以，key所在的类要重写： equals()和hashCode()
所有的value构成的集合是Collection:无序的、可以重复的。所以，value所在的类要重写：equals()
一个key-value构成一个entry 所有的entry构成的集合是Set:无序的、不可重复的
HashMap 判断两个 key 相等的标准是：两个 key 通过 equals() 方法返回 true， hashCode 值也相等。
HashMap 判断两个 value相等的标准是：两个 value 通过 equals() 方法返回 true。

6.3.2 面试题：负载因子值的大小，对HashMap有什么影响

负载因子的大小决定了HashMap的数据密度。
负载因子越大密度越大，发生碰撞的几率越高，数组中的链表越容易长, 造成查询或插入时的比较次数增多，性能会下降。
负载因子越小，就越容易触发扩容，数据密度也越小，意味着发生碰撞的几率越小，数组中的链表也就越短，查询和插入时比较的次数也越小，性能会更高。但是会浪费一定的内容空间。而且经常扩容也会影响性能，建议初始化预设大一点的空间。
按照其他语言的参考及研究经验，会考虑将负载因子设置为0.7~0.75，此时平均检索长度接近于常数。

6.4 LinkedHashMap

6.4.1 初见

LinkedHashMap 是 HashMap 的子类
在HashMap存储结构的基础上，使用了一对双向链表来记录添加元素的顺序
与LinkedHashSet类似，LinkedHashMap 可以维护 Map 的迭代顺序：迭代顺序与 Key-Value 对的插入顺序一致

6.5 TreeMap

6.5.1 初见

TreeMap存储 Key-Value 对时，需要根据 key-value 对进行排序。 TreeMap 可以保证所有的 Key-Value 对处于有序状态。
TreeSet底层使用红黑树结构存储数据
TreeMap 的 Key 的排序：
- 自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException
- 定制排序：创建 TreeMap 时，传入一个 Comparator 对象，该对象负责对 TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现 Comparable 接口
TreeMap判断两个key相等的标准：两个key通过compareTo()方法或者compare()方法返回0。

  @Test
    public void test(){
        TreeMap map = new TreeMap();
        User u1 = new User("Tom",12);
        User u2 = new User("Jerry",22);
        User u3= new User("Jack",14);
        User u4= new User("Json",11);
        map.put(u1,"98");
        map.put(u2,"81");
        map.put(u3,"38");
        map.put(u4,"28");

        Set entrySet = map.entrySet();
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    //定制排序
    @Test
    public void test2(){
        TreeMap map = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User u1 = (User)o1;
                    User u2 = (User)o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }
                throw new RuntimeException("类型不一致");
            }
        });
        User u1 = new User("Tom",12);
        User u2 = new User("Jerry",22);
        User u3= new User("Jack",14);
        User u4= new User("Json",11);
        map.put(u1,"98");
        map.put(u2,"81");
        map.put(u3,"38");
        map.put(u4,"28");
        Set entrySet = map.entrySet();
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

6.6 Properties

6.6.1 初见

Properties 类是 Hashtable 的子类，该对象用于处理属性文件
由于属性文件里的 key、value 都是字符串类型，所以 Properties 里的 key 和 value 都是字符串类型
存取数据时，建议使用setProperty(String key,String value)方法和 getProperty(String key)方法

Properties pros = new Properties();
pros.load(new FileInputStream("jdbc.properties"));
String user = pros.getProperty("user");
System.out.println(user);

7.`Collection`工具类

7.1 初见

Collections 是一个操作 Set、List 和 Map 等集合的工具类
Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法

7.2 方法

7.2.1 排序操作

方法名	功能
`reverse(List)`	反转 List 中元素的顺序
`shuffle(List)`	对 List 集合元素进行随机排序
`sort(List)`	根据元素的自然顺序对指定 List 集合元素按升序排序
`sort(List，Comparator)`	根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
`swap(List，int， int)`	将指定 list 集合中的 i 处元素和 j 处元素进行交换``

7.2.2 查找、替换

方法名	功能
`Object max(Collection)`	根据元素的自然顺序，返回给定集合中的最大元素
`Object max(Collection，Comparator)`	根据 Comparator 指定的顺序，返回给定集合中的最大元素
`Object min(Collection)`
`Object min(Collection，Comparator)`
`int frequency(Collection，Object)`	返回指定集合中指定元素的出现次数
`void copy(List dest,List src)`	将src中的内容复制到dest中
`boolean replaceAll(List list，Object oldVal，Object newVal)`	使用新值替换 List 对象的所有旧值

 @Test
    public void test1(){
        List list = new ArrayList();
        list.add(123);
        list.add(43);
        list.add(765);
        list.add(765);
        list.add(765);
        list.add(-97);
        list.add(0);
        //swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
        Collections.swap(list,1,2);
        System.out.println(list);
        //reverse(List)：反转 List 中元素的顺序
        System.out.println(list);
        Collections.reverse(list);
        System.out.println(list);
        //shuffle(List)：对 List 集合元素进行随机排序
        Collections.shuffle(list);
        System.out.println(list);
        //sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
        Collections.sort(list);
        System.out.println(list);

        //int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
        int frequency = Collections.frequency(list, 765);
        System.out.println(frequency);



    }

    @Test
    public void test2(){
        //void copy(List dest,List src)：将src中的内容复制到dest中
        List list = new ArrayList();
        list.add(123);
        list.add(43);
        list.add(-97);
        list.add(0);
        //报异常了
//        List dest = new ArrayList();
//        Collections.copy(dest,list);
        //正确的
        List dest = Arrays.asList(new Object[list.size()]);
        Collections.copy(dest,list);
        System.out.println(dest);



          /*
        Collections 类中提供了多个 synchronizedXxx() 方法，
        该方法可使将指定集合包装成线程同步的集合，从而可以解决
        多线程并发访问集合时的线程安全问题

         */
        //返回的list1即为线程安全的List
        List list1 = Collections.synchronizedList(list);

    }

    @Test
    public void test3(){
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        System.out.println();
    }

反射

1.类加载器

1.1 定义：当程序要使用某个类时，如果该类还未加载到内存中，则系统会通过`加载`、`连接`、`初始化`三步来实现对这个1.2 类进行初始化

加载：
- 就是指将class文件读入内存，并为之创建一个Class对象;
- 任何类被使用时都会建立一个Class对象
连接：
- 验证：是否有正确的内部结构，并和其他类协调一致；
- 准备：负责为类的静态成员分配内存，并设置默认初始化值
- 解析：将类的二进制数据中的符号引用替换为直接引用
初始化：初始化的步骤

1.3 加载时机

创建类的实例
访问类的静态变量，或者为静态变量赋值
调用类的静态方法
使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
初始化某个类的子类
直接使用java.exe命令来运行某个主类

1.4 类加载器

1.4.1 作用

负责将class文件加载到内存中，并为之生成对应的Class对象。

1.4.2 组成

Bootstrap ClassLoader 根类加载器
- 也被称为引导类加载器，负责Java核心类的加载
  - 不如System String等，在JDK中JRE的lib目录下rt.jar文件中
Extension ClassLoader 扩展类加载器
- 负责JRE的扩展目录中jar包的加载
  - 在JDK中JRE的lib目录下ext目录
System ClassLoader 系统类加载器
- 负责在JVM启动时加载来自java命令的class文件(我们写的Java文件)，以及classpath环境变量所指定的jar包和类路径

2.反射

2.1 定义：

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
l要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.

2.2 获取class文件对象代码

package 复习01;

import org.junit.Test;
import 复习01.Domain.Person;

/**
 * Class类：
 *  成员变量    Field
 *  构造方法    Constructor
 *  成员方法    Method
 * 获取class文件对象的方式
 *  A：Object类的getClass()方法  
 *  B:数据类型的静态属性class
 *  Class类中的静态方法
 *
 */
public class Reflection01 {
    @Test
    public void test1() throws ClassNotFoundException {
        Person p = new Person();
        //方式一
        //c获取了p的字节码文件
        Class c= p.getClass();

        Person p2 = new Person();
        Class c2 = p2.getClass();

        System.out.println(p == p2);//false
        System.out.println(c == c2);//true

        //方式二
        Class c3 = Person.class;
        System.out.println(c == c3);//true
        //方式三
        Class c4 = Class.forName("com.Jerry.Person");
        System.out.println(c == c4);//true

    }
}

2.2 方法的使用情形

自己玩：任选一种，第二种比较方便
开发：第三种(全类名，带包名)，因为时字符产，不是具体的类名，可以配置到配置文件中

2.3 获取无参/带参构造方法代码

2.3.1 方法

方法名	简述
getConstructor	返回一个`Constructor`对象，该对象反映`Constructor`对象表示的类的指定的公共`类`函数。 `parameterTypes`参数是以声明顺序标识构造函数的形式参数类型的`类`对象的数组。如果此`类`对象表示在非静态上下文中声明的内部类，则形式参数类型将显式包围实例作为第一个参数。
getDeclaredClasses	返回的数组`类`对象反映声明此表示的类的成员的所有类和接口`类`对象。这包括public，protected，default（package）访问以及该类声明的私有类和接口，但不包括继承的类和接口。
getConstructors	回一个包含Constructor对象的数组，反映由此`Constructor`对象表示的类的所有公共`类`函数。
newInstance	使用由此`Constructor`对象表示的构造函数，使用指定的初始化参数创建和初始化构造函数的声明类的新实例。
setAccessible	将此对象的`accessible`标志设置为指示的布尔值。 `true`的值表示反射对象应该在使用时抑制Java语言访问检查。 `false`的值表示反映的对象应该强制执行Java语言访问检查。

访问获取单个多个无参，带参构造方法，

 Class<?> c1 = Class.forName("复习01.Domain.Person");
        //获取构造方法 getConstructors :获取某些构造方法（所有公共的构造方法）
        Constructor<?>[] cons = c1.getConstructors();
        for(Constructor con:cons){
            System.out.println(con);
        }
        //获取所有
        Constructor<?>[] cons1 = c1.getDeclaredConstructors();
        for(Constructor con :cons1){
            System.out.println(con);
        }

        //获取单个
        //参数表示时：要过去的构造方法的构造参数类型的class字节码文件对象
    	Constructor<?> con1 = c1.getConstructor();//返回的时构造方法对象
        //带参的
        Constructor<?> con2 = c1.getConstructor(String.class,int.class,String.class);//返回的时构造方法对象
        //使用此Constructor对象表示的构造方法来创建该构造方法的声明类的实例，并用指定的初始化参数初始化该实例，相当于 Person p = new Person();
        Object o = con1.newInstance();
        System.out.println(o);//

练习

Class<?> c1 = Class.forName("复习01.Domain.Person");
Constructor<?> con1 = c1.getConstructor(String.class, int.class, String.class);
Object obj = con1.newInstance("Tom", 22, "上海");
System.out.println(obj);//Person{name='Tom', age=22, address='上海'}

获取私有带参构造方法

        Class<?> c1 = Class.forName("复习01.Domain.Person");
        Constructor<?> con1 = c1.getDeclaredConstructor(String.class);
        //暴力访问，值为true：取消Java语言访问检查
        con1.setAccessible(true);
        Object aaa = con1.newInstance("aaa");
        System.out.println(aaa);

2.4 获取成员变量

2.4.1 方法

方法名	简述
`getField(String name)`	返回一个`Field`对象，它反映此表示的类或接口的指定公共成员字段`类`对象。 `name`参数是一个`String` ，指定所需字段的简单名称。
`getFields()`	返回包含一个数组`Field`对象反射由此表示的类或接口的所有可访问的公共字段`类`对象。
`getDeclaredField(String name)`	返回一个`Field`对象，它反映此表示的类或接口的指定已声明字段`类`对象。
`getDeclaredFields()`	返回的数组 `Field`对象反映此表示的类或接口声明的所有字段 `类`对象。

package 复习01;

import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

public class Reflection02 {
    @Test
    public void test1() throws Exception{
        Class<?> c1 = Class.forName("复习01.Domain.Person");
//        c1.getField();
//        c1.getFields();
//        c1.getDeclaredField();
//        c1.getDeclaredFields();
        //获取公共的所有
//        Field[] fields = c1.getFields();
//        for(Field f : fields){
//            System.out.println(f);
//        }
        //获取所有
        Field[] fs = c1.getDeclaredFields();
        for(Field f : fs){
            System.out.println(f);
        }


        //获取单个
        Field address = c1.getField("address");
        //并赋值
        Constructor<?> con = c1.getConstructor();
        Object obj = con.newInstance();
        address.set(obj,"nihao");
        System.out.println(obj);

        //获取私有，并赋值
        Field name = c1.getDeclaredField("name");
        name.setAccessible(true);
        name.set(obj,"Jerry");
        System.out.println(obj);

        //Person{name='Jerry', age=23, address='nihao'}
        Field age = c1.getDeclaredField("age");
        age.setAccessible(true);
        age.set(obj,23);
        System.out.println(obj);

    }
}

2.5 获取方法

2.5.1 方法

方法名	简述
`getMethod(String name, 类<?>... parameterTypes)`	参数 `name` - 方法的名称 `parameterTypes` - 参数列表
`getMethods()`	返回包含一个数组 `方法`对象反射由此表示的类或接口的所有公共方法 `类`对象，包括那些由类或接口和那些从超类和超接口继承的声明。
`getDeclaredMethod(String name, 类<?>... parameterTypes)`	参数 `name` - 方法的名称 `parameterTypes` - 参数数组
`getDeclaredMethods()`	返回包含一个数组 `方法`对象反射的类或接口的所有声明的方法，通过此表示 `类`对象，包括公共，保护，默认（包）访问和私有方法，但不包括继承的方法。

package 复习01;

import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class Reflection03 {
    @Test
    public void test1() throws Exception{
        Class<?> c1 = Class.forName("复习01.Domain.Person");
        Method getString = c1.getMethod("getString",String.class,int.class);
        Constructor<?> con = c1.getConstructor();
        Object pMethod = con.newInstance();
        Object getStr = getString.invoke(pMethod, "hello", 100);//调用pMethod的getString方法
        System.out.println(getStr);

        //获取私有
        Method function = c1.getDeclaredMethod("function", int.class);
        Constructor<?> con1 = c1.getConstructor();
        Object pFunction = con1.newInstance();
        function.setAccessible(true);
        function.invoke(pFunction, 11);
    }

}

3.动态代理

定义：

动态代理：在程序运行过程中产生的这个对象

方法，通过此表示 类对象，包括公共，保护，默认（包）访问和私有方法，但不包括继承的方法。 |
| | |

package 复习01;

import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class Reflection03 {
    @Test
    public void test1() throws Exception{
        Class<?> c1 = Class.forName("复习01.Domain.Person");
        Method getString = c1.getMethod("getString",String.class,int.class);
        Constructor<?> con = c1.getConstructor();
        Object pMethod = con.newInstance();
        Object getStr = getString.invoke(pMethod, "hello", 100);//调用pMethod的getString方法
        System.out.println(getStr);

        //获取私有
        Method function = c1.getDeclaredMethod("function", int.class);
        Constructor<?> con1 = c1.getConstructor();
        Object pFunction = con1.newInstance();
        function.setAccessible(true);
        function.invoke(pFunction, 11);
    }

}

3.动态代理

定义：

动态代理：在程序运行过程中产生的这个对象
而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理

Jerry&Crj

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java-10集合

文章目录Java-09集合1.Java集合框架概述Collection接口继承树Map接口继承树2.`Collection`接口方法3.`Iterator`迭代器接口3.1 注意3.2 在迭代器中调用其`remove()`方法4.`Collection`子接口一：`List`4.1 初见4.2 方法4.2.1 增4.2.2 删4.2.3 改4.2.4 查4.2.5 其他方法4.2.6 LinkedList1.初见2.方法(上面的方法也都还有，列举一些新加的方法)4.2.7 Vector1. 初见2. 方法(
复制链接

扫一扫